@danielx/civet 0.7.29 → 0.7.31

package/dist/browser.js

@@ -492,20 +492,22 @@ ${body}`;
     }
   });
 
-  // source/main.civet
-  var main_exports = {};
-  __export(main_exports, {
+  // source/browser.civet
+  var browser_exports = {};
+  __export(browser_exports, {
     ParseError: () => import_lib3.ParseError,
     ParseErrors: () => ParseErrors,
     SourceMap: () => SourceMap2,
+    autoRunScripts: () => autoRunScripts,
     compile: () => compile,
-    default: () => main_default,
     generate: () => generate_default,
     isCompileError: () => isCompileError,
     lib: () => lib_exports,
     parse: () => parse,
     parseProgram: () => parseProgram,
     prune: () => prune,
+    runScript: () => runScript,
+    runScripts: () => runScripts,
     sourcemap: () => sourcemap_exports
   });
 
@@ -685,7 +687,7 @@ ${body}`;
     "ForStatement",
     "IfStatement",
     "IterationStatement",
-    "LabeledStatement",
+    "LabelledStatement",
     "ReturnStatement",
     "SwitchStatement",
     "ThrowStatement",
@@ -730,13 +732,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 +1107,7 @@ ${body}`;
     }
     return ["(", type, ")"];
   }
-  function wrapIIFE(expressions, asyncFlag) {
+  function wrapIIFE(expressions, asyncFlag, generator) {
     let prefix;
     const async = [];
     if (asyncFlag) {
@@ -1128,23 +1133,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 +1796,7 @@ ${body}`;
       ({ type } = exp);
     }
     let ref4;
-    switch (exp.type) {
+    switch (type) {
       case "BreakStatement":
       case "ContinueStatement":
       case "DebuggerStatement":
@@ -1986,6 +2017,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 +2084,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 +2180,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 +2209,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 +2271,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 +2305,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 +2326,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 +3587,7 @@ ${body}`;
     const blockStatement = ["", statementExp];
     let ref;
     if (statementExp.type === "IterationExpression") {
-      if (statementExp.async) {
+      if (statementExp.async || statementExp.generator) {
         return;
       }
       const statement2 = statementExp.statement;
@@ -4515,7 +4645,7 @@ ${body}`;
     scopes.pop();
   }
 
-  // source/browser.civet
+  // source/browser-shim.civet
   function dirname(path) {
     return path.replace(/[^]*\//, "");
   }
@@ -4529,7 +4659,7 @@ ${body}`;
       );
     };
   }
-  var browser_default = {
+  var browser_shim_default = {
     dirname,
     resolve,
     createRequire
@@ -4672,12 +4802,12 @@ ${body}`;
       }
       let output, context, contextGlobal;
       try {
-        context = browser_default.createContext?.() ?? globalThis;
+        context = browser_shim_default.createContext?.() ?? globalThis;
         const filename2 = context.__filename = resolve(getFilename() ?? "");
         context.__dirname = dirname(filename2);
         context.require = createRequire(filename2);
-        if (browser_default.runInContext != null) {
-          contextGlobal = browser_default.runInContext("globalThis", context);
+        if (browser_shim_default.runInContext != null) {
+          contextGlobal = browser_shim_default.runInContext("globalThis", context);
           const builtins = new Set(Object.getOwnPropertyNames(contextGlobal));
           for (const name of Object.getOwnPropertyNames(globalThis)) {
             if (builtins.has(name)) {
@@ -4688,9 +4818,9 @@ ${body}`;
               ...Object.getOwnPropertyDescriptor(globalThis, name)
             });
           }
-          output = browser_default.runInContext(js, context, {
+          output = browser_shim_default.runInContext(js, context, {
             filename: filename2,
-            importModuleDynamically: browser_default.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER
+            importModuleDynamically: browser_shim_default.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER
           });
         } else {
           output = eval?.(js);
@@ -6020,7 +6150,8 @@ ${js}`
           type: "IterationExpression",
           children: [statement],
           block: statement.block,
-          statement
+          statement,
+          generator: statement.generator
         };
       }
       case "IfStatement": {
@@ -6547,6 +6678,7 @@ ${js}`
     ReservedBinary,
     ArgumentsWithTrailingMemberExpressions,
     TrailingMemberExpressions,
+    IndentedTrailingMemberExpression,
     AllowedTrailingMemberExpressions,
     TrailingCallExpressions,
     AllowedTrailingCallExpressions,
@@ -6815,6 +6947,7 @@ ${js}`
     BlockStatement,
     LabelledStatement,
     Label,
+    LabelIdentifier,
     LabelledItem,
     IfStatement,
     ElseClause,
@@ -7874,7 +8007,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 +8048,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 +12605,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 +12679,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 +12791,8 @@ ${js}`
       children: [statement],
       block: statement.block,
       statement,
-      async
+      async,
+      generator: statement.generator
     };
   });
   function IterationExpression(ctx, state2) {
@@ -12664,8 +12811,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 +12828,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 +12897,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 +12911,7 @@ ${js}`
       subtype: kind.token,
       children: [kind, ws, condition],
       condition,
+      generator,
       negated: kind.negated
     };
   });
@@ -12773,16 +12931,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 +13709,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 +13733,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;
@@ -17716,19 +17896,6 @@ ${js}`
       }
     });
     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);
@@ -17930,6 +18097,15 @@ ${js}`
       }
     }
   });
+  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;
@@ -18156,7 +18332,11 @@ ${js}`
     })();
   };
   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+/";
@@ -18460,7 +18640,6 @@ ${counts}`;
       meta.logs = logs;
     }
     const stateCache = new StateCache();
-    let getStateKey = null;
     const stack = [];
     const events = {
       meta,
@@ -18489,14 +18668,12 @@ ${counts}`;
         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}`);
         }
@@ -18512,6 +18689,71 @@ ${counts}`;
   var isCompileError = function(err) {
     return err instanceof import_lib3.ParseError || err instanceof ParseErrors;
   };
-  var main_default = { parse, parseProgram, ParseError: import_lib3.ParseError, ParseErrors, generate: generate_default, sourcemap: sourcemap_exports, SourceMap: SourceMap2, compile, isCompileError };
-  return __toCommonJS(main_exports);
+
+  // source/browser.civet
+  async function runScripts(type = "text/civet") {
+    const scripts = window.document.querySelectorAll(`script[type=${JSON.stringify(type)}]`);
+    for (let i1 = 0, len3 = scripts.length; i1 < len3; i1++) {
+      const i = i1;
+      const script = scripts[i1];
+      runScript(script, `<script>${i}`);
+    }
+  }
+  async function runScript(script, name = "<script>") {
+    const options = {
+      inlineMap: true,
+      js: true
+    };
+    let code;
+    let ref;
+    if (ref = script.src || script.getAttribute("data-src")) {
+      const source = ref;
+      options.filename = source;
+      code = await (await fetch(source)).text();
+    } else {
+      options.filename = script.id || name;
+      code = script.innerHTML;
+    }
+    const js = await compile(code, options);
+    return window.eval(js);
+  }
+  function autoRunScripts(roots, options = {}) {
+    const observer = new MutationObserver(async (mutations) => {
+      for (let i2 = 0, len1 = mutations.length; i2 < len1; i2++) {
+        const mutation = mutations[i2];
+        if (!(mutation.type === "childList")) {
+          continue;
+        }
+        for (let ref1 = mutation.addedNodes, i3 = 0, len22 = ref1.length; i3 < len22; i3++) {
+          const node = ref1[i3];
+          if (node.nodeType === 1 && node.tagName === "SCRIPT" && node.type === "text/civet") {
+            await runScript(node);
+          }
+        }
+      }
+    });
+    options = { ...options, childList: true };
+    for (let i4 = 0, len3 = roots.length; i4 < len3; i4++) {
+      const root = roots[i4];
+      observer.observe(root, options);
+    }
+    return observer;
+  }
+  if (!(typeof window === "undefined")) {
+    const { currentScript } = document;
+    window?.addEventListener?.("DOMContentLoaded", () => {
+      if (currentScript?.hasAttribute("data-no-scripts")) {
+        return;
+      }
+      if (!currentScript?.hasAttribute("data-no-start-scripts")) {
+        runScripts();
+      }
+      if (!currentScript?.hasAttribute("data-no-auto-scripts")) {
+        return autoRunScripts([document.head, document.body]);
+      }
+      ;
+      return;
+    });
+  }
+  return __toCommonJS(browser_exports);
 })();