@danielx/civet 0.7.4 → 0.7.6

package/dist/browser.js

@@ -38,9 +38,9 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // node_modules/@danielx/hera/dist/machine.js
+  // ../Hera/dist/machine.js
   var require_machine = __commonJS({
-    "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
+    "../Hera/dist/machine.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty;
       var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -426,14 +426,14 @@ var Civet = (() => {
           }, [1, 1]);
           return [line, column];
         }
-        function validate(input, result, { filename }) {
+        function validate(input, result, { filename: filename2 }) {
           if (result && result.pos === input.length)
             return result.value;
           const expectations = Array.from(new Set(failExpected.slice(0, failIndex)));
           let l = location(input, maxFailPos), [line, column] = l;
           if (result && result.pos > maxFailPos) {
             l = location(input, result.pos);
-            throw new Error(`${filename}:${line}:${column} Unconsumed input at #{l}
+            throw new Error(`${filename2}:${line}:${column} Unconsumed input at #{l}
 
 ${input.slice(result.pos)}
 `);
@@ -445,11 +445,11 @@ ${input.slice(result.pos)}
               hint = JSON.stringify(hint);
             else
               hint = "EOF";
-            const error = new ParseError(`${filename}:${line}:${column} Failed to parse
+            const error = new ParseError(`${filename2}:${line}:${column} Failed to parse
 Expected:
 	${expectations.join("\n	")}
 Found: ${hint}
-`, "ParseError", filename, line, column, maxFailPos);
+`, "ParseError", filename2, line, column, maxFailPos);
             throw error;
           }
           if (result) {
@@ -473,11 +473,11 @@ ${input.slice(result.pos)}
         };
       }
       var ParseError = class extends Error {
-        constructor(message, name, filename, line, column, offset) {
+        constructor(message, name, filename2, line, column, offset) {
           super(message);
           this.message = message;
           this.name = name;
-          this.filename = filename;
+          this.filename = filename2;
           this.line = line;
           this.column = column;
           this.offset = offset;
@@ -489,12 +489,14 @@ ${input.slice(result.pos)}
   // source/main.civet
   var main_exports = {};
   __export(main_exports, {
+    ParseErrors: () => ParseErrors,
     compile: () => compile,
     default: () => main_default,
     generate: () => generate_default,
     isCompileError: () => isCompileError,
     lib: () => lib_exports,
     parse: () => parse,
+    parseProgram: () => parseProgram,
     prune: () => prune,
     util: () => util_exports
   });
@@ -554,6 +556,7 @@ ${input.slice(result.pos)}
     processCoffeeInterpolation: () => processCoffeeInterpolation,
     processForInOf: () => processForInOf,
     processProgram: () => processProgram,
+    processProgramAsync: () => processProgramAsync,
     processUnaryExpression: () => processUnaryExpression,
     quoteString: () => quoteString,
     reorderBindingRestProperty: () => reorderBindingRestProperty,
@@ -968,6 +971,9 @@ ${input.slice(result.pos)}
         wrapIterationReturningResults(exp, outer, collect);
         return;
       case "BlockStatement":
+        if (node.expressions.some(isExit)) {
+          return;
+        }
         assignResults(exp.expressions[exp.expressions.length - 1], collect);
         return;
       case "IfStatement":
@@ -1002,6 +1008,9 @@ ${input.slice(result.pos)}
     switch (node.type) {
       case "BlockStatement":
         if (node.expressions.length) {
+          if (node.expressions.some(([, exp2]) => isExit(exp2))) {
+            return;
+          }
           const last = node.expressions[node.expressions.length - 1];
           insertReturn(last);
         } else {
@@ -1176,14 +1185,12 @@ ${input.slice(result.pos)}
     if (!prefix.length)
       return;
     if (isConstructor) {
-      const superCalls = gatherNodes(expressions, (exp) => {
-        return exp.type === "CallExpression" && exp.children[0]?.token === "super";
-      });
+      const superCalls = gatherNodes(
+        expressions,
+        (a) => typeof a === "object" && a != null && "type" in a && a.type === "CallExpression" && "children" in a && Array.isArray(a.children) && a.children.length >= 1 && typeof a.children[0] === "object" && a.children[0] != null && "token" in a.children[0] && a.children[0].token === "super"
+      );
       if (superCalls.length) {
-        const { child } = findAncestor(
-          superCalls[0],
-          (ancestor) => ancestor === block
-        );
+        const { child } = findAncestor(superCalls[0], (a1) => a1 === block);
         const index = findChildIndex(expressions, child);
         if (index < 0) {
           throw new Error("Could not find super call within top-level expressions");
@@ -1249,12 +1256,6 @@ ${input.slice(result.pos)}
   // source/parser/block.civet
   function blockWithPrefix(prefixStatements, block) {
     if (prefixStatements && prefixStatements.length) {
-      const indent = getIndent(block.expressions[0]);
-      if (indent) {
-        prefixStatements = prefixStatements.map((statement) => {
-          return [indent, ...statement.slice(1)];
-        });
-      }
       const expressions = [...prefixStatements, ...block.expressions];
       updateParentPointers(prefixStatements, block);
       block = {
@@ -1268,7 +1269,7 @@ ${input.slice(result.pos)}
     return block;
   }
   function braceBlock(block) {
-    if (block.bare) {
+    if (block.bare && !block.root) {
       if (block.children === block.expressions) {
         block.children = [block.expressions];
       }
@@ -1320,7 +1321,7 @@ ${input.slice(result.pos)}
   function replaceBlockExpression(node, child, replacement) {
     let found = false;
     const { expressions } = node;
-    for (let i1 = 0, len2 = expressions.length; i1 < len2; i1++) {
+    for (let i1 = 0, len3 = expressions.length; i1 < len3; i1++) {
       const statement = expressions[i1];
       const [, s] = statement;
       if (s === child) {
@@ -1402,7 +1403,7 @@ ${input.slice(result.pos)}
       return false;
     }
     if (Array.isArray(exp)) {
-      for (let i3 = 0, len2 = exp.length; i3 < len2; i3++) {
+      for (let i3 = 0, len22 = exp.length; i3 < len22; i3++) {
         const child = exp[i3];
         if (!(child != null)) {
           continue;
@@ -1445,6 +1446,9 @@ ${input.slice(result.pos)}
   }
 
   // source/parser/util.civet
+  function len(arr, length) {
+    return arr.length === length;
+  }
   var assert = {
     equal(a, b, msg) {
       if (a !== b) {
@@ -1468,7 +1472,7 @@ ${input.slice(result.pos)}
       node.parent = parent;
     }
     if (node.children) {
-      for (let ref1 = node.children, i1 = 0, len2 = ref1.length; i1 < len2; i1++) {
+      for (let ref1 = node.children, i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
         const child = ref1[i1];
         addParentPointers(child, node);
       }
@@ -1525,8 +1529,7 @@ ${input.slice(result.pos)}
     if (node?.type !== "BlockStatement")
       return false;
     const { bare, expressions } = node;
-    return bare && //expressions is like [], [, {type: "EmptyStatement"}]
-    (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
+    return bare && (Array.isArray(expressions) && len(expressions, 0) || Array.isArray(expressions) && len(expressions, 1) && Array.isArray(expressions[0]) && expressions[0].length >= 2 && typeof expressions[0][1] === "object" && expressions[0][1] != null && "type" in expressions[0][1] && expressions[0][1].type === "EmptyStatement");
   }
   function isFunction(node) {
     const { type } = node;
@@ -1883,7 +1886,7 @@ ${input.slice(result.pos)}
       return;
     }
     if (Array.isArray(node)) {
-      for (let i2 = 0, len1 = node.length; i2 < len1; i2++) {
+      for (let i2 = 0, len22 = node.length; i2 < len22; i2++) {
         const child = node[i2];
         updateParentPointers(child, parent, depth);
       }
@@ -1894,7 +1897,7 @@ ${input.slice(result.pos)}
       node.parent = parent;
     }
     if (depth && isParent(node)) {
-      for (let ref4 = node.children, i3 = 0, len2 = ref4.length; i3 < len2; i3++) {
+      for (let ref4 = node.children, i3 = 0, len3 = ref4.length; i3 < len3; i3++) {
         const child = ref4[i3];
         updateParentPointers(child, node, depth - 1);
       }
@@ -2025,7 +2028,7 @@ ${input.slice(result.pos)}
   }
   function flatJoin(array, separator) {
     const result = [];
-    for (let i4 = 0, len3 = array.length; i4 < len3; i4++) {
+    for (let i4 = 0, len4 = array.length; i4 < len4; i4++) {
       const i = i4;
       const items = array[i4];
       if (i) {
@@ -2048,7 +2051,7 @@ ${input.slice(result.pos)}
     if (!(children != null)) {
       return -1;
     }
-    for (let i1 = 0, len2 = children.length; i1 < len2; i1++) {
+    for (let i1 = 0, len3 = children.length; i1 < len3; i1++) {
       const i = i1;
       const c = children[i1];
       if (c === child || Array.isArray(c) && arrayRecurse(c)) {
@@ -2163,7 +2166,7 @@ ${input.slice(result.pos)}
     ["**"]
   ];
   var precedenceMap = /* @__PURE__ */ new Map();
-  for (let i1 = 0, len2 = precedenceOrder.length; i1 < len2; i1++) {
+  for (let i1 = 0, len3 = precedenceOrder.length; i1 < len3; i1++) {
     const prec = i1;
     const ops = precedenceOrder[i1];
     for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
@@ -2274,7 +2277,7 @@ ${input.slice(result.pos)}
           } else {
             b = recurse(b);
           }
-          if (op.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
+          if (op.token === "instanceof" && (typeof b === "object" && b != null && "type" in b && b.type === "Literal" && "children" in b && Array.isArray(b.children) && b.children.length >= 1 && typeof b.children[0] === "object" && b.children[0] != null && "type" in b.children[0] && b.children[0].type === "StringLiteral")) {
             a = ["typeof ", makeLeftHandSideExpression(a)];
             if (op.negated) {
               op = { ...op, token: "!==", negated: false };
@@ -2379,7 +2382,7 @@ ${input.slice(result.pos)}
     let start = 0;
     const chains = [];
     var i = 0;
-    for (let i3 = 0, len2 = binops.length; i3 < len2; i3++) {
+    for (let i3 = 0, len22 = binops.length; i3 < len22; i3++) {
       var i = i3;
       var [, op] = binops[i3];
       if (isRelationalOp(op)) {
@@ -2610,6 +2613,11 @@ ${input.slice(result.pos)}
     declareHelper[base](ref);
     return state.helperRefs[base] = ref;
   }
+  function extractPreludeFor(node) {
+    let helpers = new Set(Object.values(state.helperRefs));
+    helpers = new Set(gatherRecursive(node, helpers.has.bind(helpers)));
+    return state.prelude.filter((s) => gatherRecursive(s, helpers.has.bind(helpers)).length);
+  }
 
   // source/parser/pattern-matching.civet
   function processPatternTest(lhs, patterns) {
@@ -2989,7 +2997,7 @@ ${input.slice(result.pos)}
   }
 
   // source/parser/declaration.civet
-  function len(arr, length) {
+  function len2(arr, length) {
     return arr.length === length;
   }
   function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
@@ -3187,7 +3195,7 @@ ${input.slice(result.pos)}
       return;
     }
     let { expression } = condition;
-    if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && len(expression.children, 2) && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
+    if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && len2(expression.children, 2) && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
       const { type: type1, children: [, { type: type2, expression: expression2 }] } = expression;
       const type = [type1, type2];
       expression = expression2;
@@ -3196,7 +3204,7 @@ ${input.slice(result.pos)}
     const { ref, pattern } = expression;
     if (pattern) {
       const conditions = getPatternConditions(pattern, ref).filter((c) => {
-        if (Array.isArray(c) && len(c, 2) && c[0] === ref && c[1] === " != null") {
+        if (Array.isArray(c) && len2(c, 2) && c[0] === ref && c[1] === " != null") {
           const [,] = c;
           return false;
         } else {
@@ -4028,6 +4036,26 @@ ${input.slice(result.pos)}
     scopes.pop();
   }
 
+  // source/browser.civet
+  function dirname(path) {
+    return path.replace(/[^]*\//, "");
+  }
+  function resolve(path) {
+    return path;
+  }
+  function createRequire(path) {
+    return (id) => {
+      throw new ReferenceError(
+        "Civet comptime does not support 'require' on this platform"
+      );
+    };
+  }
+  var browser_default = {
+    dirname,
+    resolve,
+    createRequire
+  };
+
   // source/generate.civet
   function stringify(node) {
     try {
@@ -4113,36 +4141,122 @@ ${input.slice(result.pos)}
     if (!getInitialConfig()?.comptime) {
       return;
     }
-    gatherRecursive(
+    const promises = runComptime(statements);
+    if (getSync()) {
+      return;
+    } else {
+      return (async () => {
+        {
+          await Promise.all(promises);
+        }
+      })();
+    }
+  }
+  function runComptime(statements) {
+    const sync2 = getSync();
+    return gatherRecursive(
       statements,
       (node) => {
         return node.type === "ComptimeStatement" || node.type === "ComptimeExpression";
       }
-    ).forEach((exp) => {
-      const content = exp.type === "ComptimeStatement" ? exp.block : exp.expression;
+    ).map((exp) => {
+      let content = exp.type === "ComptimeStatement" ? exp.block : exp.expression;
+      content = [
+        ...extractPreludeFor(content),
+        content
+      ];
       const options = { js: true };
-      const js = generate_default(prune(content), options);
+      let js = generate_default(prune(content), options);
+      js = `"use strict";${js}`;
       if (options.errors != null) {
         return;
       }
-      const output = eval?.(`"use strict";${js}`);
+      let output, context;
+      try {
+        context = browser_default.createContext?.() ?? globalThis;
+        const filename2 = context.__filename = resolve(getFilename() ?? "");
+        context.__dirname = dirname(filename2);
+        context.require = createRequire(filename2);
+        if (browser_default.runInContext != null) {
+          for (const global of [
+            "RegExp",
+            "Date",
+            "Set",
+            "Map",
+            "URL",
+            "Int8Array",
+            "Uint8Array",
+            "Int16Array",
+            "Uint16Array",
+            "Int32Array",
+            "Uint32Array",
+            "Float32Array",
+            "Float64Array",
+            "Uint8ClampedArray",
+            "BigInt64Array",
+            "BigUint64Array",
+            "Buffer"
+          ]) {
+            context[global] = globalThis[global];
+          }
+          context.Object2 = Object;
+          output = browser_default.runInContext(js, context, {
+            filename: filename2,
+            importModuleDynamically: browser_default.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER
+          });
+        } else {
+          output = eval?.(js);
+        }
+      } catch (e) {
+        exp.children = [
+          {
+            type: "Error",
+            message: `comptime block failed to execute: ${e}
+${js}`
+          }
+        ];
+        return;
+      }
+      let promise;
       if (exp.type === "ComptimeExpression") {
-        let string;
-        try {
-          string = serialize(output);
-        } catch (e) {
-          exp.children = [
+        const finish = () => {
+          let string;
+          try {
+            if (browser_default.runInContext != null) {
+              context.output = output;
+              string = browser_default.runInContext(
+                `${serialize(serialize)}serialize(output)`,
+                context
+              );
+            } else {
+              string = serialize(output);
+            }
+          } catch (e) {
+            exp.children = [
+              {
+                type: "Error",
+                message: `comptime result ${output} not serializable: ${e}`
+              }
+            ];
+            return;
+          }
+          return exp.children = [string];
+        };
+        if (sync2) {
+          finish();
+        } else {
+          promise = (async () => {
             {
-              type: "Error",
-              message: `comptime result ${output} not JSON serializable: ${e}`
+              output = await output;
+              return finish();
             }
-          ];
-          return;
+          })();
         }
-        return exp.children = [string];
       } else {
-        return exp.children = [];
+        promise = output;
+        exp.children = [];
       }
+      return promise;
     });
   }
   function serialize(value) {
@@ -4243,14 +4357,11 @@ ${input.slice(result.pos)}
             })().join(",") + "])";
             break;
           }
-          case Array.prototype: {
-            ref1 = `[${val.map(recurse).join(",")}]`;
-            break;
-          }
-          case Object.prototype: {
+          case Object.prototype:
+          case globalThis.Object2?.prototype: {
             let objStr = "{";
             let descStr = "";
-            for (let ref2 = Object.getOwnPropertyNames(val).concat(Object.getOwnPropertySymbols(val)), i = 0, len2 = ref2.length; i < len2; i++) {
+            for (let ref2 = Object.getOwnPropertyNames(val).concat(Object.getOwnPropertySymbols(val)), i = 0, len3 = ref2.length; i < len3; i++) {
               const prop = ref2[i];
               const desc = Object.getOwnPropertyDescriptor(val, prop);
               if (desc.enumerable && desc.configurable && desc.writable) {
@@ -4312,7 +4423,11 @@ ${input.slice(result.pos)}
             break;
           }
           default: {
-            throw new TypeError(`cannot serialize object with prototype ${Object.getPrototypeOf(val)}`);
+            if (Array.isArray(val)) {
+              ref1 = `[${val.map(recurse).join(",")}]`;
+            } else {
+              throw new TypeError(`cannot serialize object with prototype ${val.constructor?.name ?? Object.getPrototypeOf(val)}`);
+            }
           }
         }
         ;
@@ -4339,7 +4454,7 @@ ${input.slice(result.pos)}
   }
   function reduceIndentLevel(str, dedent, tab) {
     if (tab != null && tab != 1) {
-      for (let i1 = 0, len2 = str.length; i1 < len2; i1++) {
+      for (let i1 = 0, len3 = str.length; i1 < len3; i1++) {
         const i = i1;
         const char = str[i1];
         if (!dedent) {
@@ -4421,7 +4536,7 @@ ${input.slice(result.pos)}
     ;
     const dedent = ref1;
     let results = [s];
-    for (let i3 = 0, len2 = strWithSubstitutions.length; i3 < len2; i3++) {
+    for (let i3 = 0, len22 = strWithSubstitutions.length; i3 < len22; i3++) {
       const i = i3;
       let part = strWithSubstitutions[i3];
       if (part.token != null) {
@@ -4551,9 +4666,8 @@ ${input.slice(result.pos)}
     return true;
   }
   function expressionizeBlock(blockOrExpression) {
-    let ref1;
-    if ((ref1 = blockOrExpression) && "expressions" in ref1) {
-      const { expressions } = ref1;
+    if (blockOrExpression && typeof blockOrExpression === "object" && "expressions" in blockOrExpression) {
+      const { expressions } = blockOrExpression;
       const l = expressions.length;
       const results = [];
       let i1 = 0;
@@ -4652,7 +4766,7 @@ ${input.slice(result.pos)}
   }
   function processCallMemberExpression(node) {
     const { children } = node;
-    if (children[0]?.parenthesizedOp?.token && children[1]?.type === "Call") {
+    if (Array.isArray(children) && children.length >= 2 && typeof children[0] === "object" && children[0] != null && "parenthesizedOp" in children[0] && typeof children[0].parenthesizedOp === "object" && children[0].parenthesizedOp != null && "token" in children[0].parenthesizedOp && typeof children[1] === "object" && children[1] != null && "type" in children[1] && children[1].type === "Call") {
       const op = children[0].parenthesizedOp;
       let call = children[1];
       const args = [...call.args];
@@ -4699,11 +4813,23 @@ ${input.slice(result.pos)}
         }
         prefix = prefix.concat(glob.dot);
         for (const part of glob.object.properties) {
+          if (part.type === "Error") {
+            parts.push(part);
+            continue;
+          }
           if (part.type === "MethodDefinition") {
-            throw new Error("Glob pattern cannot have method definition");
+            parts.push({
+              type: "Error",
+              message: "Glob pattern cannot have method definition"
+            });
+            continue;
           }
           if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
-            throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
+            parts.push({
+              type: "Error",
+              message: `Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`
+            });
+            continue;
           }
           let suppressPrefix = false;
           let name = part.name;
@@ -4746,14 +4872,14 @@ ${input.slice(result.pos)}
             });
           }
         }
-        let ref2;
+        let ref1;
         let object = {
           type: "ObjectExpression",
           children: [
             glob.object.children[0],
             // {
             ...parts,
-            (ref2 = glob.object.children)[ref2.length - 1]
+            (ref1 = glob.object.children)[ref1.length - 1]
             // whitespace and }
           ],
           properties: parts,
@@ -4805,7 +4931,7 @@ ${input.slice(result.pos)}
       throw new Error("replaceNode failed: node has no parent");
     }
     function recurse(children) {
-      for (let i3 = 0, len2 = children.length; i3 < len2; i3++) {
+      for (let i3 = 0, len22 = children.length; i3 < len22; i3++) {
         const i = i3;
         const child = children[i3];
         if (child === node) {
@@ -4852,6 +4978,10 @@ ${input.slice(result.pos)}
     }
     let children, i;
     do {
+      if (!(exp.children != null)) {
+        return;
+      }
+      ;
       ({ children } = exp);
       i = children.length - 1;
       while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional"))
@@ -4895,8 +5025,8 @@ ${input.slice(result.pos)}
         return { type: "Error", message: "cannot use `type` in dynamic import" };
       } else {
         const { source, binding } = specifier;
-        let ref3;
-        const delim = (ref3 = specifier.children)[ref3.length - 1];
+        let ref2;
+        const delim = (ref2 = specifier.children)[ref2.length - 1];
         return {
           type: pattern ? "BindingProperty" : "Property",
           name: source,
@@ -4906,7 +5036,7 @@ ${input.slice(result.pos)}
         };
       }
     });
-    let ref4;
+    let ref3;
     return {
       type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
       names: node.names,
@@ -4915,7 +5045,7 @@ ${input.slice(result.pos)}
         node.children[0],
         // {
         properties,
-        (ref4 = node.children)[ref4.length - 1]
+        (ref3 = node.children)[ref3.length - 1]
         // }
       ]
     };
@@ -5092,17 +5222,17 @@ ${input.slice(result.pos)}
       statements,
       (n) => n.type === "AssignmentExpression" && n.names === null,
       (exp) => {
-        let { lhs: $1, expression: $2 } = exp, tail = [], i = 0, len2 = $1.length;
+        let { lhs: $1, expression: $2 } = exp, tail = [], i = 0, len3 = $1.length;
         let block;
-        let ref5;
-        if (exp.parent?.type === "BlockStatement" && !(ref5 = $1[$1.length - 1])?.[ref5.length - 1]?.special) {
+        let ref4;
+        if (exp.parent?.type === "BlockStatement" && !(ref4 = $1[$1.length - 1])?.[ref4.length - 1]?.special) {
           block = makeBlockFragment();
-          let ref6;
-          if (ref6 = prependStatementExpressionBlock(
+          let ref5;
+          if (ref5 = prependStatementExpressionBlock(
             { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
             block
           )) {
-            const ref = ref6;
+            const ref = ref5;
             exp.children = exp.children.map(function(c) {
               if (c === $2)
                 return ref;
@@ -5132,7 +5262,7 @@ ${input.slice(result.pos)}
           }
         }
         let wrapped = false;
-        while (i < len2) {
+        while (i < len3) {
           const lastAssignment = $1[i++];
           const [, lhs, , op] = lastAssignment;
           if (op.token !== "=")
@@ -5145,7 +5275,7 @@ ${input.slice(result.pos)}
             }
           }
         }
-        i = len2 - 1;
+        i = len3 - 1;
         while (i >= 0) {
           const lastAssignment = $1[i];
           if (lastAssignment[3].token === "=") {
@@ -5181,14 +5311,14 @@ ${input.slice(result.pos)}
           }
           i--;
         }
-        i = len2 - 1;
+        i = len3 - 1;
         const optionalChainRef = makeRef();
         while (i >= 0) {
           const assignment = $1[i];
           const [ws1, lhs, ws2, op] = assignment;
           if (lhs.type === "MemberExpression" || lhs.type === "CallExpression") {
             const newMemberExp = unchainOptionalMemberExpression(lhs, optionalChainRef, (children) => {
-              const assigns = $1.splice(i + 1, len2 - 1 - i);
+              const assigns = $1.splice(i + 1, len3 - 1 - i);
               $1.pop();
               return [ws1, ...children, ws2, op, ...assigns, $2];
             });
@@ -5270,9 +5400,9 @@ ${input.slice(result.pos)}
       }
       j++;
     }
-    let ref7;
-    if (ref7 = conditions.length) {
-      const l = ref7;
+    let ref6;
+    if (ref6 = conditions.length) {
+      const l = ref6;
       const cs = flatJoin(conditions, " && ");
       return {
         ...exp,
@@ -5309,8 +5439,8 @@ ${input.slice(result.pos)}
     return gatherRecursiveAll(node, (n) => n.type === "UnaryType").forEach((unary) => {
       let last;
       let count = 0;
-      let ref8;
-      while (unary.suffix.length && (ref8 = unary.suffix)[ref8.length - 1]?.token === "?") {
+      let ref7;
+      while (unary.suffix.length && (ref7 = unary.suffix)[ref7.length - 1]?.token === "?") {
         last = unary.suffix.pop();
         count++;
       }
@@ -5344,11 +5474,11 @@ ${input.slice(result.pos)}
     gatherRecursiveAll(statements, ($) => $.type === "StatementExpression").forEach((_exp) => {
       const exp = _exp;
       const { statement } = exp;
-      let ref9;
+      let ref8;
       switch (statement.type) {
         case "IfStatement": {
-          if (ref9 = expressionizeIfStatement(statement)) {
-            const expression = ref9;
+          if (ref8 = expressionizeIfStatement(statement)) {
+            const expression = ref8;
             return replaceNode(statement, expression, exp);
           } else {
             return replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -5356,7 +5486,8 @@ ${input.slice(result.pos)}
         }
         case "IterationExpression": {
           if (statement.subtype === "ComptimeStatement") {
-            const expression = wrapIIFE(statement.statement.block.expressions);
+            const { expressions } = statement.statement.block;
+            const expression = wrapIIFE(expressions, hasAwait(expressions));
             return replaceNode(statement, makeNode({
               type: "ComptimeExpression",
               expression,
@@ -5434,7 +5565,13 @@ ${input.slice(result.pos)}
     processBlocks(statements);
     populateRefs(statements);
     adjustAtBindings(statements);
-    processComptime(statements);
+    if (getSync()) {
+      processComptime(statements);
+    }
+  }
+  async function processProgramAsync(root) {
+    const { expressions: statements } = root;
+    await processComptime(statements);
   }
   function populateRefs(statements) {
     const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
@@ -5558,8 +5695,8 @@ ${input.slice(result.pos)}
       for (let i4 = 0, len3 = placeholders.length; i4 < len3; i4++) {
         const placeholder = placeholders[i4];
         typeSuffix ??= placeholder.typeSuffix;
-        let ref10;
-        replaceNode((ref10 = placeholder.children)[ref10.length - 1], ref);
+        let ref9;
+        replaceNode((ref9 = placeholder.children)[ref9.length - 1], ref);
       }
       const { parent } = ancestor;
       const body = maybeUnwrap(ancestor);
@@ -5590,9 +5727,9 @@ ${input.slice(result.pos)}
         fnExp = makeLeftHandSideExpression(fnExp);
       }
       replaceNode(ancestor, fnExp, parent);
-      let ref11;
-      if (ref11 = getTrimmingSpace(body)) {
-        const ws = ref11;
+      let ref10;
+      if (ref10 = getTrimmingSpace(body)) {
+        const ws = ref10;
         inplaceInsertTrimmingSpace(body, "");
         inplacePrepend(ws, fnExp);
       }
@@ -5637,8 +5774,8 @@ ${input.slice(result.pos)}
           }
         ];
       }
-      let ref12;
-      if (Array.isArray(rest.delim) && (ref12 = rest.delim)[ref12.length - 1]?.token === ",") {
+      let ref11;
+      if (Array.isArray(rest.delim) && (ref11 = rest.delim)[ref11.length - 1]?.token === ",") {
         rest.delim = rest.delim.slice(0, -1);
         rest.children = [...rest.children.slice(0, -1), rest.delim];
       }
@@ -6836,15 +6973,20 @@ ${input.slice(result.pos)}
   var $R93 = (0, import_lib2.$R)(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
   var $R94 = (0, import_lib2.$R)(new RegExp("[^]*", "suy"));
   var Program$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Reset, Init, (0, import_lib2.$E)(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var reset = $1;
+    var init = $2;
+    var ws1 = $3;
     var statements = $4;
-    processProgram({
+    var ws2 = $5;
+    const program = {
       type: "BlockStatement",
       expressions: statements,
-      children: [statements],
+      children: [reset, init, ws1, statements, ws2],
       bare: true,
       root: true
-    }, ReservedWord);
-    return $0;
+    };
+    processProgram(program);
+    return program;
   });
   function Program(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "Program", Program$0);
@@ -8442,11 +8584,11 @@ ${input.slice(result.pos)}
     var dot = $1;
     var neg = $2;
     var num = $3;
-    const len2 = {
+    const len3 = {
       children: []
     }, children = [
       adjustIndexAccess(dot),
-      len2,
+      len3,
       neg,
       num,
       "]"
@@ -8454,7 +8596,7 @@ ${input.slice(result.pos)}
     return {
       type: "NegativeIndex",
       children,
-      len: len2
+      len: len3
     };
   });
   var PropertyAccess$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(AccessStart, (0, import_lib2.$Q)(InlineComment), (0, import_lib2.$C)(IdentifierName, PrivateIdentifier, LengthShorthand)), function($skip, $loc, $0, $1, $2, $3) {
@@ -10944,6 +11086,7 @@ ${input.slice(result.pos)}
     if (!state.operators.has(id.name))
       return $skip;
     return {
+      token: id.name,
       call: id,
       special: true,
       ...state.operators.get(id.name)
@@ -10954,6 +11097,7 @@ ${input.slice(result.pos)}
     if (!state.operators.has(id.name))
       return $skip;
     return {
+      token: id.name,
       call: id,
       special: true,
       negated: true,
@@ -16126,26 +16270,29 @@ ${input.slice(result.pos)}
         const parser2 = options.startRule != null ? grammar[options.startRule] : Object.values(grammar)[0];
         if (!parser2)
           throw new Error(`Could not find rule with name '${options.startRule}'`);
-        const filename = options.filename || "<anonymous>";
+        const filename2 = options.filename || "<anonymous>";
         reset();
         Object.assign(ctx, { ...options.events, tokenize: options.tokenize });
         return validate(input, parser2(ctx, {
           input,
           pos: 0
         }), {
-          filename
+          filename: filename2
         });
       }
     };
   }();
   var { parse } = parser;
+  var filename;
   var initialConfig;
   var config;
+  var sync;
   var state = {};
   var getState = () => state;
   var getConfig = () => config;
   var getInitialConfig = () => initialConfig;
-  var setInitialConfig = (c) => initialConfig = c;
+  var getFilename = () => filename;
+  var getSync = () => sync;
   Object.defineProperties(state, {
     currentIndent: {
       get() {
@@ -16190,6 +16337,21 @@ ${input.slice(result.pos)}
       }
     }
   });
+  function parseProgram(input, options) {
+    filename = options?.filename;
+    initialConfig = options?.parseOptions;
+    sync = options?.sync;
+    const root = parse(input, options);
+    if (sync) {
+      filename = initialConfig = sync = null;
+      return root;
+    } else {
+      return processProgramAsync(root).then(() => {
+        filename = initialConfig = sync = null;
+        return root;
+      });
+    }
+  }
 
   // source/util.civet
   var util_exports = {};
@@ -16577,6 +16739,21 @@ ${input.slice(result.pos)}
 
   // source/main.civet
   var { SourceMap: SourceMap2 } = util_exports;
+  var ParseErrors = class extends Error {
+    name = "ParseErrors";
+    filename;
+    line;
+    column;
+    offset;
+    constructor(message, filename1, line1, column1, offset1) {
+      super(message);
+      this.filename = filename1;
+      this.line = line1;
+      this.column = column1;
+      this.offset = offset1;
+      this.message = message;
+    }
+  };
   var uncacheable = /* @__PURE__ */ new Set([
     // Meta
     "DebugHere",
@@ -16616,15 +16793,15 @@ ${input.slice(result.pos)}
     "RestoreTrailingMemberProperty",
     "RestoreNewlineBinaryOp"
   ]);
-  var compile = function(src, options) {
+  function compile(src, options) {
     if (!options) {
       options = {};
     } else {
       options = { ...options };
     }
     options.parseOptions = { ...options.parseOptions };
-    const filename = options.filename || "unknown";
-    if (filename.endsWith(".coffee") && !/^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test(src)) {
+    const filename2 = options.filename || "unknown";
+    if (filename2.endsWith(".coffee") && !/^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test(src)) {
       options.parseOptions.coffeeCompat = true;
     }
     const { hits, trace, noCache } = options;
@@ -16636,21 +16813,18 @@ ${input.slice(result.pos)}
       });
     }
     let ast;
-    setInitialConfig(options.parseOptions);
     try {
-      ast = parse(src, {
-        filename,
+      ast = parseProgram(src, {
+        parseOptions: options.parseOptions,
+        sync: options.sync,
+        filename: filename2,
         events
       });
-      if (!(options.ast === "raw")) {
-        ast = prune(ast);
-      }
     } finally {
-      setInitialConfig(void 0);
       if (hits || trace) {
-        import("fs").then(function({ writeFileSync }) {
+        import("node:fs").then(function({ writeFileSync }) {
           let ref;
-          if ((ref = events?.meta) && "logs" in ref) {
+          if ((ref = events?.meta) && typeof ref === "object" && "logs" in ref) {
             const { logs } = ref;
             if (trace) {
               writeFileSync(trace, logs.join("\n"));
@@ -16679,34 +16853,45 @@ ${counts}`;
         });
       }
     }
-    if (options.ast) {
-      return ast;
-    }
-    function checkErrors() {
-      if (options.errors?.length) {
-        throw new Error(`Parse errors: ${options.errors.map(($) => $.message).join("\n")} `);
+    function rest(ast2) {
+      options = options;
+      if (!(options.ast === "raw")) {
+        ast2 = prune(ast2);
       }
-      ;
-      return;
-    }
-    if (options.sourceMap || options.inlineMap) {
-      const sm = SourceMap2(src);
-      options.updateSourceMap = sm.updateSourceMap;
-      const code = generate_default(ast, options);
-      checkErrors();
-      if (options.inlineMap) {
-        return SourceMap2.remap(code, sm, filename, filename + ".tsx");
-      } else {
-        return {
-          code,
-          sourceMap: sm
-        };
+      if (options.ast) {
+        return ast2;
       }
+      function checkErrors() {
+        if (options.errors?.length) {
+          throw new ParseErrors(options.errors.map(($) => $.message).join("\n"));
+        }
+        ;
+        return;
+      }
+      if (options.sourceMap || options.inlineMap) {
+        const sm = SourceMap2(src);
+        options.updateSourceMap = sm.updateSourceMap;
+        const code = generate_default(ast2, options);
+        checkErrors();
+        if (options.inlineMap) {
+          return SourceMap2.remap(code, sm, filename2, filename2 + ".tsx");
+        } else {
+          return {
+            code,
+            sourceMap: sm
+          };
+        }
+      }
+      const result = generate_default(ast2, options);
+      checkErrors();
+      return result;
     }
-    const result = generate_default(ast, options);
-    checkErrors();
-    return result;
-  };
+    if (ast.then != null) {
+      return ast.then(rest);
+    } else {
+      return rest(ast);
+    }
+  }
   var makeCache = function({ hits, trace } = {}) {
     const meta = {};
     let hitCount;
@@ -16773,6 +16958,6 @@ ${counts}`;
     return err instanceof Error && //@ts-ignore
     [err.message, err.name, err.filename, err.line, err.column, err.offset].every(($1) => $1 !== void 0);
   };
-  var main_default = { parse, generate: generate_default, util: util_exports, compile, isCompileError };
+  var main_default = { parse, parseProgram, generate: generate_default, util: util_exports, compile, isCompileError };
   return __toCommonJS(main_exports);
 })();