@danielx/civet 0.7.5 → 0.7.6

package/dist/browser.js

@@ -38,9 +38,9 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // node_modules/@danielx/hera/dist/machine.js
+  // ../Hera/dist/machine.js
   var require_machine = __commonJS({
-    "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
+    "../Hera/dist/machine.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty;
       var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -489,6 +489,7 @@ ${input.slice(result.pos)}
   // source/main.civet
   var main_exports = {};
   __export(main_exports, {
+    ParseErrors: () => ParseErrors,
     compile: () => compile,
     default: () => main_default,
     generate: () => generate_default,
@@ -970,6 +971,9 @@ ${input.slice(result.pos)}
         wrapIterationReturningResults(exp, outer, collect);
         return;
       case "BlockStatement":
+        if (node.expressions.some(isExit)) {
+          return;
+        }
         assignResults(exp.expressions[exp.expressions.length - 1], collect);
         return;
       case "IfStatement":
@@ -1004,6 +1008,9 @@ ${input.slice(result.pos)}
     switch (node.type) {
       case "BlockStatement":
         if (node.expressions.length) {
+          if (node.expressions.some(([, exp2]) => isExit(exp2))) {
+            return;
+          }
           const last = node.expressions[node.expressions.length - 1];
           insertReturn(last);
         } else {
@@ -1249,12 +1256,6 @@ ${input.slice(result.pos)}
   // source/parser/block.civet
   function blockWithPrefix(prefixStatements, block) {
     if (prefixStatements && prefixStatements.length) {
-      const indent = getIndent(block.expressions[0]);
-      if (indent) {
-        prefixStatements = prefixStatements.map((statement) => {
-          return [indent, ...statement.slice(1)];
-        });
-      }
       const expressions = [...prefixStatements, ...block.expressions];
       updateParentPointers(prefixStatements, block);
       block = {
@@ -2612,6 +2613,11 @@ ${input.slice(result.pos)}
     declareHelper[base](ref);
     return state.helperRefs[base] = ref;
   }
+  function extractPreludeFor(node) {
+    let helpers = new Set(Object.values(state.helperRefs));
+    helpers = new Set(gatherRecursive(node, helpers.has.bind(helpers)));
+    return state.prelude.filter((s) => gatherRecursive(s, helpers.has.bind(helpers)).length);
+  }
 
   // source/parser/pattern-matching.civet
   function processPatternTest(lhs, patterns) {
@@ -4030,6 +4036,26 @@ ${input.slice(result.pos)}
     scopes.pop();
   }
 
+  // source/browser.civet
+  function dirname(path) {
+    return path.replace(/[^]*\//, "");
+  }
+  function resolve(path) {
+    return path;
+  }
+  function createRequire(path) {
+    return (id) => {
+      throw new ReferenceError(
+        "Civet comptime does not support 'require' on this platform"
+      );
+    };
+  }
+  var browser_default = {
+    dirname,
+    resolve,
+    createRequire
+  };
+
   // source/generate.civet
   function stringify(node) {
     try {
@@ -4115,32 +4141,18 @@ ${input.slice(result.pos)}
     if (!getInitialConfig()?.comptime) {
       return;
     }
-    let prepareEval = () => {
-    };
+    const promises = runComptime(statements);
     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;
-          }
+          await Promise.all(promises);
         }
-      })().then(async () => {
-        await Promise.all(runComptime(statements, prepareEval));
-      });
+      })();
     }
   }
-  function runComptime(statements, prepareEval) {
+  function runComptime(statements) {
     const sync2 = getSync();
     return gatherRecursive(
       statements,
@@ -4148,20 +4160,77 @@ ${input.slice(result.pos)}
         return node.type === "ComptimeStatement" || node.type === "ComptimeExpression";
       }
     ).map((exp) => {
-      const content = exp.type === "ComptimeStatement" ? exp.block : exp.expression;
+      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;
       }
-      prepareEval();
-      let output = eval?.(`"use strict";${js}`);
+      let output, context;
+      try {
+        context = browser_default.createContext?.() ?? globalThis;
+        const filename2 = context.__filename = resolve(getFilename() ?? "");
+        context.__dirname = dirname(filename2);
+        context.require = createRequire(filename2);
+        if (browser_default.runInContext != null) {
+          for (const global of [
+            "RegExp",
+            "Date",
+            "Set",
+            "Map",
+            "URL",
+            "Int8Array",
+            "Uint8Array",
+            "Int16Array",
+            "Uint16Array",
+            "Int32Array",
+            "Uint32Array",
+            "Float32Array",
+            "Float64Array",
+            "Uint8ClampedArray",
+            "BigInt64Array",
+            "BigUint64Array",
+            "Buffer"
+          ]) {
+            context[global] = globalThis[global];
+          }
+          context.Object2 = Object;
+          output = browser_default.runInContext(js, context, {
+            filename: filename2,
+            importModuleDynamically: browser_default.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER
+          });
+        } else {
+          output = eval?.(js);
+        }
+      } catch (e) {
+        exp.children = [
+          {
+            type: "Error",
+            message: `comptime block failed to execute: ${e}
+${js}`
+          }
+        ];
+        return;
+      }
       let promise;
       if (exp.type === "ComptimeExpression") {
         const finish = () => {
           let string;
           try {
-            string = serialize(output);
+            if (browser_default.runInContext != null) {
+              context.output = output;
+              string = browser_default.runInContext(
+                `${serialize(serialize)}serialize(output)`,
+                context
+              );
+            } else {
+              string = serialize(output);
+            }
           } catch (e) {
             exp.children = [
               {
@@ -4288,11 +4357,8 @@ ${input.slice(result.pos)}
             })().join(",") + "])";
             break;
           }
-          case Array.prototype: {
-            ref1 = `[${val.map(recurse).join(",")}]`;
-            break;
-          }
-          case Object.prototype: {
+          case Object.prototype:
+          case globalThis.Object2?.prototype: {
             let objStr = "{";
             let descStr = "";
             for (let ref2 = Object.getOwnPropertyNames(val).concat(Object.getOwnPropertySymbols(val)), i = 0, len3 = ref2.length; i < len3; i++) {
@@ -4357,7 +4423,11 @@ ${input.slice(result.pos)}
             break;
           }
           default: {
-            throw new TypeError(`cannot serialize object with prototype ${Object.getPrototypeOf(val)}`);
+            if (Array.isArray(val)) {
+              ref1 = `[${val.map(recurse).join(",")}]`;
+            } else {
+              throw new TypeError(`cannot serialize object with prototype ${val.constructor?.name ?? Object.getPrototypeOf(val)}`);
+            }
           }
         }
         ;
@@ -4743,11 +4813,23 @@ ${input.slice(result.pos)}
         }
         prefix = prefix.concat(glob.dot);
         for (const part of glob.object.properties) {
+          if (part.type === "Error") {
+            parts.push(part);
+            continue;
+          }
           if (part.type === "MethodDefinition") {
-            throw new Error("Glob pattern cannot have method definition");
+            parts.push({
+              type: "Error",
+              message: "Glob pattern cannot have method definition"
+            });
+            continue;
           }
           if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
-            throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
+            parts.push({
+              type: "Error",
+              message: `Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`
+            });
+            continue;
           }
           let suppressPrefix = false;
           let name = part.name;
@@ -4896,6 +4978,10 @@ ${input.slice(result.pos)}
     }
     let children, i;
     do {
+      if (!(exp.children != null)) {
+        return;
+      }
+      ;
       ({ children } = exp);
       i = children.length - 1;
       while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional"))
@@ -11000,6 +11086,7 @@ ${input.slice(result.pos)}
     if (!state.operators.has(id.name))
       return $skip;
     return {
+      token: id.name,
       call: id,
       special: true,
       ...state.operators.get(id.name)
@@ -11010,6 +11097,7 @@ ${input.slice(result.pos)}
     if (!state.operators.has(id.name))
       return $skip;
     return {
+      token: id.name,
       call: id,
       special: true,
       negated: true,
@@ -16651,6 +16739,21 @@ ${input.slice(result.pos)}
 
   // source/main.civet
   var { SourceMap: SourceMap2 } = util_exports;
+  var ParseErrors = class extends Error {
+    name = "ParseErrors";
+    filename;
+    line;
+    column;
+    offset;
+    constructor(message, filename1, line1, column1, offset1) {
+      super(message);
+      this.filename = filename1;
+      this.line = line1;
+      this.column = column1;
+      this.offset = offset1;
+      this.message = message;
+    }
+  };
   var uncacheable = /* @__PURE__ */ new Set([
     // Meta
     "DebugHere",
@@ -16760,7 +16863,7 @@ ${counts}`;
       }
       function checkErrors() {
         if (options.errors?.length) {
-          throw new Error(`Parse errors: ${options.errors.map(($) => $.message).join("\n")} `);
+          throw new ParseErrors(options.errors.map(($) => $.message).join("\n"));
         }
         ;
         return;

package/dist/civet

@@ -228,7 +228,7 @@ async function* readFiles(filenames) {
         }
         if (process.stdin.isTTY) {
           const lines = [];
-          const rl = (await import("readline")).createInterface(process.stdin, process.stdout);
+          const rl = (await import("node:readline")).createInterface(process.stdin, process.stdout);
           rl.on("line", (buffer) => lines.push(buffer + "\n"));
           content = await new Promise((resolve, reject) => {
             rl.on("SIGINT", () => {
@@ -259,11 +259,11 @@ async function* readFiles(filenames) {
   return results1;
 }
 async function repl(options) {
-  const vm = await import("vm");
+  const vm = await import("node:vm");
   let importModuleDynamically = vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER;
   if (!importModuleDynamically) {
     if (vm.SourceTextModule != null) {
-      const { pathToFileURL } = await import("url");
+      const { pathToFileURL } = await import("node:url");
       importModuleDynamically = (specifier) => {
         if (/^\.\.?[/\\]/.test(specifier)) {
           return import(pathToFileURL(import_path.default.join(process.cwd(), specifier)));
@@ -273,11 +273,11 @@ async function repl(options) {
       };
     } else {
       const execArgv = ["--experimental-vm-modules"];
-      const { register } = await import("module");
+      const { register } = await import("node:module");
       if (process.env.NODE_OPTIONS) {
         execArgv.push(process.env.NODE_OPTIONS);
       }
-      const { fork } = await import("child_process");
+      const { fork } = await import("node:child_process");
       fork(__filename, process.argv.slice(2), {
         execArgv,
         stdio: "inherit"
@@ -300,7 +300,7 @@ async function repl(options) {
     }
   })()} code.`);
   global.quit = global.exit = () => process.exit(0);
-  const nodeRepl = await import("repl");
+  const nodeRepl = await import("node:repl");
   const r = nodeRepl.start({
     prompt: (() => {
       switch (false) {
@@ -500,6 +500,14 @@ async function cli() {
       errors++;
       continue;
     }
+    process.stdout.on("error", (e) => {
+      if (["EPIPE", "EOF"].includes(e.code)) {
+        return process.exit(0);
+      } else {
+        console.error(e);
+        return process.exit(1);
+      }
+    });
     if (options.ast) {
       process.stdout.write(JSON.stringify(output, null, 2));
     } else if (options.compile) {
@@ -547,8 +555,8 @@ async function cli() {
             process.exit(1);
           }
         }
-        const { fork } = await import("child_process");
-        const { register } = await import("module");
+        const { fork } = await import("node:child_process");
+        const { register } = await import("node:module");
         let execArgv;
         if (register) {
           execArgv = ["--import", "@danielx/civet/register"];

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;
@@ -481,6 +481,7 @@ ${input.slice(result.pos)}
 // source/main.civet
 var main_exports = {};
 __export(main_exports, {
+  ParseErrors: () => ParseErrors,
   compile: () => compile,
   default: () => main_default,
   generate: () => generate_default,
@@ -963,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":
@@ -997,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 {
@@ -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 = {
@@ -2605,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) {
@@ -4023,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 {
@@ -4108,32 +4119,18 @@ function processComptime(statements) {
   if (!getInitialConfig()?.comptime) {
     return;
   }
-  let prepareEval = () => {
-  };
+  const promises = runComptime(statements);
   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;
-        }
+        await Promise.all(promises);
       }
-    })().then(async () => {
-      await Promise.all(runComptime(statements, prepareEval));
-    });
+    })();
   }
 }
-function runComptime(statements, prepareEval) {
+function runComptime(statements) {
   const sync2 = getSync();
   return gatherRecursive(
     statements,
@@ -4141,20 +4138,77 @@ function runComptime(statements, prepareEval) {
       return node.type === "ComptimeStatement" || node.type === "ComptimeExpression";
     }
   ).map((exp) => {
-    const content = exp.type === "ComptimeStatement" ? exp.block : exp.expression;
+    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;
     }
-    prepareEval();
-    let 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") {
       const finish = () => {
         let string;
         try {
-          string = serialize(output);
+          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 = [
             {
@@ -4281,11 +4335,8 @@ 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, len3 = ref2.length; i < len3; i++) {
@@ -4350,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)}`);
+          }
         }
       }
       ;
@@ -4736,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;
@@ -4889,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"))
@@ -10993,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)
@@ -11003,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,
@@ -16644,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",
@@ -16753,7 +16841,7 @@ ${counts}`;
     }
     function checkErrors() {
       if (options.errors?.length) {
-        throw new Error(`Parse errors: ${options.errors.map(($) => $.message).join("\n")} `);
+        throw new ParseErrors(options.errors.map(($) => $.message).join("\n"));
       }
       ;
       return;
@@ -16851,6 +16939,7 @@ var isCompileError = function(err) {
 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,

package/dist/main.mjs

@@ -28,9 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/@danielx/hera/dist/machine.js
+// ../Hera/dist/machine.js
 var require_machine = __commonJS({
-  "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
+  "../Hera/dist/machine.js"(exports, module) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -946,6 +946,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":
@@ -980,6 +983,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 {
@@ -1225,12 +1231,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 = {
@@ -2588,6 +2588,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) {
@@ -4006,6 +4011,11 @@ function createVarDecs(block, scopes, pushVar) {
   scopes.pop();
 }
 
+// source/parser/comptime.civet
+import { resolve, dirname } from "node:path";
+import { createRequire } from "node:module";
+import vm from "node:vm";
+
 // source/generate.civet
 function stringify(node) {
   try {
@@ -4091,32 +4101,18 @@ function processComptime(statements) {
   if (!getInitialConfig()?.comptime) {
     return;
   }
-  let prepareEval = () => {
-  };
+  const promises = runComptime(statements);
   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;
-        }
+        await Promise.all(promises);
       }
-    })().then(async () => {
-      await Promise.all(runComptime(statements, prepareEval));
-    });
+    })();
   }
 }
-function runComptime(statements, prepareEval) {
+function runComptime(statements) {
   const sync2 = getSync();
   return gatherRecursive(
     statements,
@@ -4124,20 +4120,77 @@ function runComptime(statements, prepareEval) {
       return node.type === "ComptimeStatement" || node.type === "ComptimeExpression";
     }
   ).map((exp) => {
-    const content = exp.type === "ComptimeStatement" ? exp.block : exp.expression;
+    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;
     }
-    prepareEval();
-    let output = eval?.(`"use strict";${js}`);
+    let output, context;
+    try {
+      context = vm.createContext?.() ?? globalThis;
+      const filename2 = context.__filename = resolve(getFilename() ?? "");
+      context.__dirname = dirname(filename2);
+      context.require = createRequire(filename2);
+      if (vm.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 = vm.runInContext(js, context, {
+          filename: filename2,
+          importModuleDynamically: vm.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") {
       const finish = () => {
         let string;
         try {
-          string = serialize(output);
+          if (vm.runInContext != null) {
+            context.output = output;
+            string = vm.runInContext(
+              `${serialize(serialize)}serialize(output)`,
+              context
+            );
+          } else {
+            string = serialize(output);
+          }
         } catch (e) {
           exp.children = [
             {
@@ -4264,11 +4317,8 @@ 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, len3 = ref2.length; i < len3; i++) {
@@ -4333,7 +4383,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)}`);
+          }
         }
       }
       ;
@@ -4719,11 +4773,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;
@@ -4872,6 +4938,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"))
@@ -10976,6 +11046,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)
@@ -10986,6 +11057,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,
@@ -16627,6 +16699,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",
@@ -16736,7 +16823,7 @@ ${counts}`;
     }
     function checkErrors() {
       if (options.errors?.length) {
-        throw new Error(`Parse errors: ${options.errors.map(($) => $.message).join("\n")} `);
+        throw new ParseErrors(options.errors.map(($) => $.message).join("\n"));
       }
       ;
       return;
@@ -16833,6 +16920,7 @@ var isCompileError = function(err) {
 };
 var main_default = { parse, parseProgram, generate: generate_default, util: util_exports, compile, isCompileError };
 export {
+  ParseErrors,
   compile,
   main_default as default,
   generate_default as generate,

package/dist/types.d.ts

@@ -82,6 +82,7 @@ declare module "@danielx/civet" {
   export function generate(ast: CivetAST, options?: CompileOptions): string
 
   const Civet: {
+    version: string
     compile: typeof compile
     isCompileError: typeof isCompileError
     parse: typeof parse

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielx/civet",
   "type": "commonjs",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",
@@ -89,7 +89,7 @@
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0",
     "tsup": "^7.2.0",
-    "typescript": "^5.2.2",
+    "typescript": "^5.4.5",
     "vite": "^4.4.12",
     "vitepress": "^1.0.0-alpha.35",
     "vscode-languageserver": "^8.1.0",