@danielx/civet 0.7.4 → 0.7.6

package/dist/main.js

@@ -30,9 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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"(exports2, module2) {
+  "../Hera/dist/machine.js"(exports2, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -418,14 +418,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)}
 `);
@@ -437,11 +437,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) {
@@ -465,11 +465,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;
@@ -481,12 +481,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
 });
@@ -547,6 +549,7 @@ __export(lib_exports, {
   processCoffeeInterpolation: () => processCoffeeInterpolation,
   processForInOf: () => processForInOf,
   processProgram: () => processProgram,
+  processProgramAsync: () => processProgramAsync,
   processUnaryExpression: () => processUnaryExpression,
   quoteString: () => quoteString,
   reorderBindingRestProperty: () => reorderBindingRestProperty,
@@ -961,6 +964,9 @@ function assignResults(node, collect) {
       wrapIterationReturningResults(exp, outer, collect);
       return;
     case "BlockStatement":
+      if (node.expressions.some(isExit)) {
+        return;
+      }
       assignResults(exp.expressions[exp.expressions.length - 1], collect);
       return;
     case "IfStatement":
@@ -995,6 +1001,9 @@ function insertReturn(node, outerNode = node) {
   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 {
@@ -1169,14 +1178,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");
@@ -1242,12 +1249,6 @@ function skipImplicitArguments(args) {
 // 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 = {
@@ -1261,7 +1262,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];
     }
@@ -1313,7 +1314,7 @@ function makeBlockFragment() {
 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) {
@@ -1395,7 +1396,7 @@ function needsPrecedingSemicolon(exp) {
     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;
@@ -1438,6 +1439,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) {
@@ -1461,7 +1465,7 @@ function addParentPointers(node, parent) {
     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);
     }
@@ -1518,8 +1522,7 @@ function isEmptyBareBlock(node) {
   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;
@@ -1876,7 +1879,7 @@ function updateParentPointers(node, parent, depth = 1) {
     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);
     }
@@ -1887,7 +1890,7 @@ function updateParentPointers(node, parent, depth = 1) {
     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);
     }
@@ -2018,7 +2021,7 @@ function wrapWithReturn(expression) {
 }
 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) {
@@ -2041,7 +2044,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)) {
@@ -2156,7 +2159,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++) {
@@ -2267,7 +2270,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 };
@@ -2372,7 +2375,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)) {
@@ -2603,6 +2606,11 @@ function getHelperRef(base) {
   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) {
@@ -2982,7 +2990,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) {
@@ -3180,7 +3188,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;
@@ -3189,7 +3197,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 {
@@ -4021,6 +4029,11 @@ function createVarDecs(block, scopes, pushVar) {
   scopes.pop();
 }
 
+// source/parser/comptime.civet
+var import_node_path = require("node:path");
+var import_node_module = require("node:module");
+var import_node_vm = __toESM(require("node:vm"));
+
 // source/generate.civet
 function stringify(node) {
   try {
@@ -4106,36 +4119,122 @@ function processComptime(statements) {
   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 = import_node_vm.default.createContext?.() ?? globalThis;
+      const filename2 = context.__filename = (0, import_node_path.resolve)(getFilename() ?? "");
+      context.__dirname = (0, import_node_path.dirname)(filename2);
+      context.require = (0, import_node_module.createRequire)(filename2);
+      if (import_node_vm.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 = import_node_vm.default.runInContext(js, context, {
+          filename: filename2,
+          importModuleDynamically: import_node_vm.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 (import_node_vm.default.runInContext != null) {
+            context.output = output;
+            string = import_node_vm.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) {
@@ -4236,14 +4335,11 @@ function serialize(value) {
           })().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) {
@@ -4305,7 +4401,11 @@ function serialize(value) {
           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)}`);
+          }
         }
       }
       ;
@@ -4332,7 +4432,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) {
@@ -4414,7 +4514,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) {
@@ -4544,9 +4644,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;
@@ -4645,7 +4744,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];
@@ -4692,11 +4791,23 @@ function processCallMemberExpression(node) {
       }
       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;
@@ -4739,14 +4850,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,
@@ -4798,7 +4909,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) {
@@ -4845,6 +4956,10 @@ function lastAccessInCallExpression(exp) {
   }
   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"))
@@ -4888,8 +5003,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,
@@ -4899,7 +5014,7 @@ function convertNamedImportsToObject(node, pattern) {
       };
     }
   });
-  let ref4;
+  let ref3;
   return {
     type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
     names: node.names,
@@ -4908,7 +5023,7 @@ function convertNamedImportsToObject(node, pattern) {
       node.children[0],
       // {
       properties,
-      (ref4 = node.children)[ref4.length - 1]
+      (ref3 = node.children)[ref3.length - 1]
       // }
     ]
   };
@@ -5085,17 +5200,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;
@@ -5125,7 +5240,7 @@ function processAssignments(statements) {
         }
       }
       let wrapped = false;
-      while (i < len2) {
+      while (i < len3) {
         const lastAssignment = $1[i++];
         const [, lhs, , op] = lastAssignment;
         if (op.token !== "=")
@@ -5138,7 +5253,7 @@ function processAssignments(statements) {
           }
         }
       }
-      i = len2 - 1;
+      i = len3 - 1;
       while (i >= 0) {
         const lastAssignment = $1[i];
         if (lastAssignment[3].token === "=") {
@@ -5174,14 +5289,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];
           });
@@ -5263,9 +5378,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,
@@ -5302,8 +5417,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++;
     }
@@ -5337,11 +5452,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);
@@ -5349,7 +5464,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,
@@ -5427,7 +5543,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");
@@ -5551,8 +5673,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);
@@ -5583,9 +5705,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);
     }
@@ -5630,8 +5752,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];
     }
@@ -6829,15 +6951,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);
@@ -8435,11 +8562,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,
     "]"
@@ -8447,7 +8574,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) {
@@ -10937,6 +11064,7 @@ var _BinaryOp$1 = (0, import_lib2.$TV)(Identifier, function($skip, $loc, $0, $1)
   if (!state.operators.has(id.name))
     return $skip;
   return {
+    token: id.name,
     call: id,
     special: true,
     ...state.operators.get(id.name)
@@ -10947,6 +11075,7 @@ var _BinaryOp$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OmittedNegation, __,
   if (!state.operators.has(id.name))
     return $skip;
   return {
+    token: id.name,
     call: id,
     special: true,
     negated: true,
@@ -16119,26 +16248,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() {
@@ -16183,6 +16315,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 = {};
@@ -16570,6 +16717,21 @@ var StateCache = class {
 
 // 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",
@@ -16609,15 +16771,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;
@@ -16629,21 +16791,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"));
@@ -16672,34 +16831,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;
@@ -16766,14 +16936,16 @@ 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 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ParseErrors,
   compile,
   generate,
   isCompileError,
   lib,
   parse,
+  parseProgram,
   prune,
   util
 });