@danielx/civet 0.7.3 → 0.7.5

package/dist/browser.js

@@ -38,9 +38,9 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // ../Hera/dist/machine.js
+  // node_modules/@danielx/hera/dist/machine.js
   var require_machine = __commonJS({
-    "../Hera/dist/machine.js"(exports, module) {
+    "node_modules/@danielx/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;
@@ -495,6 +495,7 @@ ${input.slice(result.pos)}
     isCompileError: () => isCompileError,
     lib: () => lib_exports,
     parse: () => parse,
+    parseProgram: () => parseProgram,
     prune: () => prune,
     util: () => util_exports
   });
@@ -554,6 +555,7 @@ ${input.slice(result.pos)}
     processCoffeeInterpolation: () => processCoffeeInterpolation,
     processForInOf: () => processForInOf,
     processProgram: () => processProgram,
+    processProgramAsync: () => processProgramAsync,
     processUnaryExpression: () => processUnaryExpression,
     quoteString: () => quoteString,
     reorderBindingRestProperty: () => reorderBindingRestProperty,
@@ -1176,14 +1178,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");
@@ -1268,7 +1268,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,8 +1320,8 @@ ${input.slice(result.pos)}
   function replaceBlockExpression(node, child, replacement) {
     let found = false;
     const { expressions } = node;
-    for (let i = 0, l = expressions.length; i < l; i++) {
-      const statement = expressions[i];
+    for (let i1 = 0, len3 = expressions.length; i1 < len3; i1++) {
+      const statement = expressions[i1];
       const [, s] = statement;
       if (s === child) {
         statement[1] = replacement;
@@ -1382,9 +1382,9 @@ ${input.slice(result.pos)}
   }
   function insertSemicolon(statements) {
     const l = statements.length;
-    for (let i1 = 0, len2 = statements.length; i1 < len2; i1++) {
-      const i = i1;
-      const s = statements[i1];
+    for (let i2 = 0, len1 = statements.length; i2 < len1; i2++) {
+      const i = i2;
+      const s = statements[i2];
       if (i < l - 1) {
         if (needsPrecedingSemicolon(statements[i + 1][1])) {
           const delim = s[2];
@@ -1402,8 +1402,8 @@ ${input.slice(result.pos)}
       return false;
     }
     if (Array.isArray(exp)) {
-      for (let i2 = 0, len1 = exp.length; i2 < len1; i2++) {
-        const child = exp[i2];
+      for (let i3 = 0, len22 = exp.length; i3 < len22; i3++) {
+        const child = exp[i3];
         if (!(child != null)) {
           continue;
         }
@@ -1445,6 +1445,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) {
@@ -1464,9 +1467,12 @@ ${input.slice(result.pos)}
       return;
     }
     node = node;
-    node.parent = parent;
+    if (parent != null) {
+      node.parent = parent;
+    }
     if (node.children) {
-      for (const child of node.children) {
+      for (let ref1 = node.children, i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
+        const child = ref1[i1];
         addParentPointers(child, node);
       }
     }
@@ -1476,10 +1482,9 @@ ${input.slice(result.pos)}
     return deepCopy(node);
   }
   function removeParentPointers(node) {
-    if (node == null)
-      return;
-    if (typeof node !== "object")
+    if (!(node != null && typeof node === "object")) {
       return;
+    }
     if (Array.isArray(node)) {
       for (const child of node) {
         removeParentPointers(child);
@@ -1523,7 +1528,7 @@ ${input.slice(result.pos)}
     if (node?.type !== "BlockStatement")
       return false;
     const { bare, expressions } = node;
-    return bare && (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;
@@ -1571,8 +1576,8 @@ ${input.slice(result.pos)}
     if (!(node != null)) {
       return false;
     }
-    let ref1;
     let ref2;
+    let ref3;
     switch (node.type) {
       case "ReturnStatement":
       case "ThrowStatement":
@@ -1581,10 +1586,10 @@ ${input.slice(result.pos)}
         return true;
       }
       case "IfStatement": {
-        return isExit(node.then) && isExit((ref1 = node.else)?.[ref1.length - 1]);
+        return isExit(node.then) && isExit((ref2 = node.else)?.[ref2.length - 1]);
       }
       case "BlockStatement": {
-        return isExit((ref2 = node.expressions)[ref2.length - 1]?.[1]);
+        return isExit((ref3 = node.expressions)[ref3.length - 1]?.[1]);
       }
       case "IterationStatement": {
         return node.condition?.type === "ParenthesizedExpression" && node.condition.expression?.type === "Literal" && node.condition.expression?.raw === "true" && gatherRecursiveWithinFunction(
@@ -1880,8 +1885,8 @@ ${input.slice(result.pos)}
       return;
     }
     if (Array.isArray(node)) {
-      for (let i1 = 0, len2 = node.length; i1 < len2; i1++) {
-        const child = node[i1];
+      for (let i2 = 0, len22 = node.length; i2 < len22; i2++) {
+        const child = node[i2];
         updateParentPointers(child, parent, depth);
       }
       return;
@@ -1891,8 +1896,8 @@ ${input.slice(result.pos)}
       node.parent = parent;
     }
     if (depth && isParent(node)) {
-      for (let ref3 = node.children, i2 = 0, len1 = ref3.length; i2 < len1; i2++) {
-        const child = ref3[i2];
+      for (let ref4 = node.children, i3 = 0, len3 = ref4.length; i3 < len3; i3++) {
+        const child = ref4[i3];
         updateParentPointers(child, node, depth - 1);
       }
     }
@@ -2022,9 +2027,9 @@ ${input.slice(result.pos)}
   }
   function flatJoin(array, separator) {
     const result = [];
-    for (let i3 = 0, len2 = array.length; i3 < len2; i3++) {
-      const i = i3;
-      const items = array[i3];
+    for (let i4 = 0, len4 = array.length; i4 < len4; i4++) {
+      const i = i4;
+      const items = array[i4];
       if (i) {
         result.push(separator);
       }
@@ -2045,7 +2050,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)) {
@@ -2075,8 +2080,9 @@ ${input.slice(result.pos)}
     return { ancestor: void 0, child: node };
   }
   function gatherNodes(node, predicate) {
-    if (node == null)
+    if (node == null || typeof node === "string") {
       return [];
+    }
     if (Array.isArray(node)) {
       return node.flatMap((n) => gatherNodes(n, predicate));
     }
@@ -2084,24 +2090,30 @@ ${input.slice(result.pos)}
       return [node];
     }
     switch (node.type) {
-      case "BlockStatement":
+      case "BlockStatement": {
         return [];
-      case "ForStatement":
+      }
+      case "ForStatement": {
         const isDec = node.declaration?.type === "Declaration";
         return node.children.flatMap((n) => {
-          if (isDec && n === node.declaration)
+          if (isDec && n === node.declaration) {
             return [];
-          return gatherNodes(n, predicate);
+          } else {
+            return gatherNodes(n, predicate);
+          }
         });
-      default:
+      }
+      default: {
         return gatherNodes(node.children, predicate);
+      }
     }
   }
   function gatherRecursive(node, predicate, skipPredicate) {
-    if (node == null)
+    if (node == null || typeof node === "string") {
       return [];
+    }
     if (Array.isArray(node)) {
-      return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
+      return node.flatMap(($) => gatherRecursive($, predicate, skipPredicate));
     }
     if (skipPredicate?.(node))
       return [];
@@ -2111,8 +2123,9 @@ ${input.slice(result.pos)}
     return gatherRecursive(node.children, predicate, skipPredicate);
   }
   function gatherRecursiveAll(node, predicate) {
-    if (node == null)
+    if (node == null || typeof node === "string") {
       return [];
+    }
     if (Array.isArray(node)) {
       return node.flatMap((n) => gatherRecursiveAll(n, predicate));
     }
@@ -2152,7 +2165,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++) {
@@ -2263,7 +2276,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 };
@@ -2368,7 +2381,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)) {
@@ -2978,7 +2991,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) {
@@ -3161,9 +3174,12 @@ ${input.slice(result.pos)}
     rootCondition.blockPrefix = getPatternBlockPrefix(pattern, ref, decl, suffix);
   }
   function processDeclarationConditions(node) {
-    gatherRecursiveAll(node, (n) => {
-      return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
-    }).forEach((s) => {
+    gatherRecursiveAll(
+      node,
+      (n) => {
+        return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
+      }
+    ).forEach((s) => {
       return processDeclarationConditionStatement(s);
     });
   }
@@ -3173,7 +3189,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;
@@ -3182,7 +3198,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 {
@@ -4099,36 +4115,79 @@ ${input.slice(result.pos)}
     if (!getInitialConfig()?.comptime) {
       return;
     }
-    gatherRecursive(
+    let prepareEval = () => {
+    };
+    if (getSync()) {
+      runComptime(statements, prepareEval);
+      return;
+    } else {
+      return (async () => {
+        {
+          try {
+            const path = (await import("node:path")).default;
+            const { createRequire } = await import("node:module");
+            return prepareEval = () => {
+              global.__filename = path.resolve(getFilename() ?? "");
+              global.__dirname = path.dirname(global.__filename);
+              return global.require = createRequire(global.__filename);
+            };
+          } catch (e) {
+            return;
+          }
+        }
+      })().then(async () => {
+        await Promise.all(runComptime(statements, prepareEval));
+      });
+    }
+  }
+  function runComptime(statements, prepareEval) {
+    const sync2 = getSync();
+    return gatherRecursive(
       statements,
       (node) => {
         return node.type === "ComptimeStatement" || node.type === "ComptimeExpression";
       }
-    ).forEach((exp) => {
+    ).map((exp) => {
       const content = exp.type === "ComptimeStatement" ? exp.block : exp.expression;
       const options = { js: true };
       const js = generate_default(prune(content), options);
       if (options.errors != null) {
         return;
       }
-      const output = eval?.(`"use strict";${js}`);
+      prepareEval();
+      let output = eval?.(`"use strict";${js}`);
+      let promise;
       if (exp.type === "ComptimeExpression") {
-        let string;
-        try {
-          string = serialize(output);
-        } catch (e) {
-          exp.children = [
+        const finish = () => {
+          let string;
+          try {
+            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) {
@@ -4236,7 +4295,7 @@ ${input.slice(result.pos)}
           case Object.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) {
@@ -4325,7 +4384,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) {
@@ -4407,7 +4466,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) {
@@ -4537,9 +4596,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;
@@ -4638,7 +4696,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];
@@ -4732,14 +4790,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,
@@ -4791,7 +4849,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) {
@@ -4881,8 +4939,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,
@@ -4892,7 +4950,7 @@ ${input.slice(result.pos)}
         };
       }
     });
-    let ref4;
+    let ref3;
     return {
       type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
       names: node.names,
@@ -4901,7 +4959,7 @@ ${input.slice(result.pos)}
         node.children[0],
         // {
         properties,
-        (ref4 = node.children)[ref4.length - 1]
+        (ref3 = node.children)[ref3.length - 1]
         // }
       ]
     };
@@ -5078,17 +5136,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;
@@ -5118,7 +5176,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 !== "=")
@@ -5131,7 +5189,7 @@ ${input.slice(result.pos)}
             }
           }
         }
-        i = len2 - 1;
+        i = len3 - 1;
         while (i >= 0) {
           const lastAssignment = $1[i];
           if (lastAssignment[3].token === "=") {
@@ -5167,14 +5225,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];
             });
@@ -5256,9 +5314,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,
@@ -5295,8 +5353,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++;
       }
@@ -5330,11 +5388,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);
@@ -5342,7 +5400,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,
@@ -5420,7 +5479,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");
@@ -5544,8 +5609,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);
@@ -5576,9 +5641,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);
       }
@@ -5623,8 +5688,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];
       }
@@ -6822,15 +6887,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);
@@ -7269,8 +7339,8 @@ ${input.slice(result.pos)}
   function SingleLineBinaryOpRHS(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "SingleLineBinaryOpRHS", SingleLineBinaryOpRHS$0);
   }
-  var RHS$0 = UnaryExpression;
-  var RHS$1 = ExpressionizedStatementWithTrailingCallExpressions;
+  var RHS$0 = ExpressionizedStatementWithTrailingCallExpressions;
+  var RHS$1 = UnaryExpression;
   var RHS$$ = [RHS$0, RHS$1];
   function RHS(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "RHS", RHS$$);
@@ -8428,11 +8498,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,
       "]"
@@ -8440,7 +8510,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) {
@@ -13526,7 +13596,7 @@ ${input.slice(result.pos)}
   function Comma(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "Comma", Comma$0);
   }
-  var Comptime$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L138, 'Comptime "comptime"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+  var Comptime$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L138, 'Comptime "comptime"'), NonIdContinue, (0, import_lib2.$N)((0, import_lib2.$EXPECT)($L15, 'Comptime ":"'))), function($skip, $loc, $0, $1, $2, $3) {
     return { $loc, token: $1 };
   });
   function Comptime(ctx, state2) {
@@ -16112,26 +16182,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() {
@@ -16176,6 +16249,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 = {};
@@ -16602,15 +16690,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;
@@ -16622,21 +16710,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"));
@@ -16665,28 +16750,45 @@ ${counts}`;
         });
       }
     }
-    if (options.ast) {
-      return ast;
-    }
-    if (options.sourceMap || options.inlineMap) {
-      const sm = SourceMap2(src);
-      options.updateSourceMap = sm.updateSourceMap;
-      const code = generate_default(ast, options);
-      if (options.inlineMap) {
-        return SourceMap2.remap(code, sm, filename, filename + ".tsx");
-      } else {
-        return {
-          code,
-          sourceMap: sm
-        };
+    function rest(ast2) {
+      options = options;
+      if (!(options.ast === "raw")) {
+        ast2 = prune(ast2);
+      }
+      if (options.ast) {
+        return ast2;
+      }
+      function checkErrors() {
+        if (options.errors?.length) {
+          throw new Error(`Parse errors: ${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);
-    if (options.errors?.length) {
-      throw new Error(`Parse errors: ${options.errors.map(($) => $.message).join("\n")} `);
+    if (ast.then != null) {
+      return ast.then(rest);
+    } else {
+      return rest(ast);
     }
-    return result;
-  };
+  }
   var makeCache = function({ hits, trace } = {}) {
     const meta = {};
     let hitCount;
@@ -16753,6 +16855,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);
 })();