@danielx/civet 0.7.3 → 0.7.5

package/dist/main.mjs

@@ -28,9 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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;
@@ -416,14 +416,14 @@ var require_machine = __commonJS({
         }, [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)}
 `);
@@ -435,11 +435,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) {
@@ -463,11 +463,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;
@@ -531,6 +531,7 @@ __export(lib_exports, {
   processCoffeeInterpolation: () => processCoffeeInterpolation,
   processForInOf: () => processForInOf,
   processProgram: () => processProgram,
+  processProgramAsync: () => processProgramAsync,
   processUnaryExpression: () => processUnaryExpression,
   quoteString: () => quoteString,
   reorderBindingRestProperty: () => reorderBindingRestProperty,
@@ -1153,14 +1154,12 @@ function processParams(f) {
   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");
@@ -1245,7 +1244,7 @@ function blockWithPrefix(prefixStatements, block) {
   return block;
 }
 function braceBlock(block) {
-  if (block.bare) {
+  if (block.bare && !block.root) {
     if (block.children === block.expressions) {
       block.children = [block.expressions];
     }
@@ -1297,8 +1296,8 @@ function makeBlockFragment() {
 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;
@@ -1359,9 +1358,9 @@ function processBlocks(statements) {
 }
 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];
@@ -1379,8 +1378,8 @@ function needsPrecedingSemicolon(exp) {
     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;
       }
@@ -1422,6 +1421,9 @@ function needsPrecedingSemicolon(exp) {
 }
 
 // source/parser/util.civet
+function len(arr, length) {
+  return arr.length === length;
+}
 var assert = {
   equal(a, b, msg) {
     if (a !== b) {
@@ -1441,9 +1443,12 @@ function addParentPointers(node, parent) {
     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);
     }
   }
@@ -1453,10 +1458,9 @@ function clone(node) {
   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);
@@ -1500,7 +1504,7 @@ function isEmptyBareBlock(node) {
   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;
@@ -1548,8 +1552,8 @@ function isExit(node) {
   if (!(node != null)) {
     return false;
   }
-  let ref1;
   let ref2;
+  let ref3;
   switch (node.type) {
     case "ReturnStatement":
     case "ThrowStatement":
@@ -1558,10 +1562,10 @@ function isExit(node) {
       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(
@@ -1857,8 +1861,8 @@ function updateParentPointers(node, parent, depth = 1) {
     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;
@@ -1868,8 +1872,8 @@ function updateParentPointers(node, parent, depth = 1) {
     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);
     }
   }
@@ -1999,9 +2003,9 @@ function wrapWithReturn(expression) {
 }
 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);
     }
@@ -2022,7 +2026,7 @@ function findChildIndex(parent, child) {
   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)) {
@@ -2052,8 +2056,9 @@ function findAncestor(node, predicate, stopPredicate) {
   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));
   }
@@ -2061,24 +2066,30 @@ function gatherNodes(node, predicate) {
     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 [];
@@ -2088,8 +2099,9 @@ function gatherRecursive(node, predicate, skipPredicate) {
   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));
   }
@@ -2129,7 +2141,7 @@ var precedenceOrder = [
   ["**"]
 ];
 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++) {
@@ -2240,7 +2252,7 @@ function processBinaryOpExpression($0) {
         } 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 };
@@ -2345,7 +2357,7 @@ function expandChainedComparisons([first, binops]) {
   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)) {
@@ -2955,7 +2967,7 @@ function aliasBinding(p, ref) {
 }
 
 // source/parser/declaration.civet
-function len(arr, length) {
+function len2(arr, length) {
   return arr.length === length;
 }
 function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
@@ -3138,9 +3150,12 @@ function processDeclarationCondition(condition, rootCondition, parent) {
   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);
   });
 }
@@ -3150,7 +3165,7 @@ function processDeclarationConditionStatement(s) {
     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;
@@ -3159,7 +3174,7 @@ function processDeclarationConditionStatement(s) {
   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 {
@@ -4076,36 +4091,79 @@ function processComptime(statements) {
   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) {
@@ -4213,7 +4271,7 @@ function serialize(value) {
         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) {
@@ -4302,7 +4360,7 @@ function getIndentLevel(str, tab) {
 }
 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) {
@@ -4384,7 +4442,7 @@ function dedentBlockSubstitutions($0, tab) {
   ;
   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) {
@@ -4514,9 +4572,8 @@ function isExpression(node) {
   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;
@@ -4615,7 +4672,7 @@ function handleThisPrivateShorthands(value) {
 }
 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];
@@ -4709,14 +4766,14 @@ function processCallMemberExpression(node) {
           });
         }
       }
-      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,
@@ -4768,7 +4825,7 @@ function replaceNode(node, newNode, parent) {
     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) {
@@ -4858,8 +4915,8 @@ function convertNamedImportsToObject(node, pattern) {
       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,
@@ -4869,7 +4926,7 @@ function convertNamedImportsToObject(node, pattern) {
       };
     }
   });
-  let ref4;
+  let ref3;
   return {
     type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
     names: node.names,
@@ -4878,7 +4935,7 @@ function convertNamedImportsToObject(node, pattern) {
       node.children[0],
       // {
       properties,
-      (ref4 = node.children)[ref4.length - 1]
+      (ref3 = node.children)[ref3.length - 1]
       // }
     ]
   };
@@ -5055,17 +5112,17 @@ function processAssignments(statements) {
     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;
@@ -5095,7 +5152,7 @@ function processAssignments(statements) {
         }
       }
       let wrapped = false;
-      while (i < len2) {
+      while (i < len3) {
         const lastAssignment = $1[i++];
         const [, lhs, , op] = lastAssignment;
         if (op.token !== "=")
@@ -5108,7 +5165,7 @@ function processAssignments(statements) {
           }
         }
       }
-      i = len2 - 1;
+      i = len3 - 1;
       while (i >= 0) {
         const lastAssignment = $1[i];
         if (lastAssignment[3].token === "=") {
@@ -5144,14 +5201,14 @@ function processAssignments(statements) {
         }
         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];
           });
@@ -5233,9 +5290,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     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,
@@ -5272,8 +5329,8 @@ function processTypes(node) {
   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++;
     }
@@ -5307,11 +5364,11 @@ function processStatementExpressions(statements) {
   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);
@@ -5319,7 +5376,8 @@ function processStatementExpressions(statements) {
       }
       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,
@@ -5397,7 +5455,13 @@ function processProgram(root) {
   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");
@@ -5521,8 +5585,8 @@ function processPlaceholders(statements) {
     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);
@@ -5553,9 +5617,9 @@ function processPlaceholders(statements) {
       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);
     }
@@ -5600,8 +5664,8 @@ function reorderBindingRestProperty(props) {
         }
       ];
     }
-    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];
     }
@@ -6799,15 +6863,20 @@ var $R92 = (0, import_lib2.$R)(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
 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);
@@ -7246,8 +7315,8 @@ var SingleLineBinaryOpRHS$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impor
 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$$);
@@ -8405,11 +8474,11 @@ var PropertyAccess$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(AccessStart, (0,
   var dot = $1;
   var neg = $2;
   var num = $3;
-  const len2 = {
+  const len3 = {
     children: []
   }, children = [
     adjustIndexAccess(dot),
-    len2,
+    len3,
     neg,
     num,
     "]"
@@ -8417,7 +8486,7 @@ var PropertyAccess$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(AccessStart, (0,
   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) {
@@ -13503,7 +13572,7 @@ var Comma$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L25, 'Comma ","'),
 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) {
@@ -16089,26 +16158,29 @@ var parser = function() {
       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() {
@@ -16153,6 +16225,21 @@ Object.defineProperties(state, {
     }
   }
 });
+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 = {};
@@ -16579,15 +16666,15 @@ var uncacheable = /* @__PURE__ */ new Set([
   "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;
@@ -16599,21 +16686,18 @@ var compile = function(src, options) {
     });
   }
   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"));
@@ -16642,28 +16726,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;
@@ -16730,7 +16831,7 @@ var isCompileError = function(err) {
   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 };
 export {
   compile,
   main_default as default,
@@ -16738,6 +16839,7 @@ export {
   isCompileError,
   lib_exports as lib,
   parse,
+  parseProgram,
   prune,
   util_exports as util
 };