@danielx/civet 0.6.87 → 0.6.89

package/dist/civet

@@ -6,6 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,8 +26,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // source/cli.civet
+var cli_exports = {};
+__export(cli_exports, {
+  cli: () => cli,
+  parseArgs: () => parseArgs,
+  repl: () => repl,
+  version: () => version
+});
+module.exports = __toCommonJS(cli_exports);
 var import_main = require("./main.js");
 var import_config = require("./config.js");
 var import_unplugin = require("./unplugin");
@@ -244,6 +257,33 @@ async function* readFiles(filenames) {
   return results1;
 }
 async function repl(options) {
+  const vm = await import("vm");
+  let importModuleDynamically = vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER;
+  if (!importModuleDynamically) {
+    if (vm.SourceTextModule != null) {
+      const { pathToFileURL } = await import("url");
+      importModuleDynamically = (specifier) => {
+        if (/^\.\.?[/\\]/.test(specifier)) {
+          return import(pathToFileURL(import_path.default.join(process.cwd(), specifier)));
+        } else {
+          return import(specifier);
+        }
+      };
+    } else {
+      const execArgv = ["--experimental-vm-modules"];
+      const { register } = await import("module");
+      if (process.env.NODE_OPTIONS) {
+        execArgv.push(process.env.NODE_OPTIONS);
+      }
+      const { fork } = await import("child_process");
+      fork(__filename, process.argv.slice(2), {
+        execArgv,
+        stdio: "inherit"
+      });
+      return;
+    }
+  }
+  require("../register.js");
   console.log(`Civet ${version()} REPL.  Enter a blank line to ${(() => {
     switch (false) {
       case !options.ast: {
@@ -259,7 +299,6 @@ async function repl(options) {
   })()} code.`);
   global.quit = global.exit = () => process.exit(0);
   const nodeRepl = await import("repl");
-  const vm = await import("vm");
   const r = nodeRepl.start({
     prompt: (() => {
       switch (false) {
@@ -288,28 +327,76 @@ async function repl(options) {
         return "";
       }
     } : void 0,
-    eval: function(input, context, filename, callback) {
+    eval: async function(input, context, filename, callback) {
       if (input === "\n") {
         return callback(null, void 0);
       } else if (input in ["quit\n", "exit\n", "quit()\n", "exit()\n"]) {
         return process.exit(0);
       } else if (input.endsWith("\n\n")) {
         let output;
+        if (options.compile || options.ast) {
+          try {
+            output = (0, import_main.compile)(input, { ...options, filename });
+          } catch (error) {
+            console.error(error);
+            return callback(null, void 0);
+          }
+          return callback(null, output);
+        }
+        let ast = (0, import_main.compile)(input, { ...options, filename, ast: true });
+        const topLevelAwait = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast);
+        if (topLevelAwait) {
+          const [prologue, rest] = (0, import_main.parse)(input, { startRule: "ProloguePrefix" });
+          const prefix = input.slice(0, -rest.length);
+          const coffee = prologue.some((p) => p.type === "CivetPrologue" && (p.config.coffeeCompat || p.config.coffeeDo));
+          ast = (0, import_main.compile)(
+            prefix + (coffee ? "(do ->\n" : "async do\n") + rest.replace(/^/gm, " ") + (coffee ? ")" : ""),
+            { ...options, filename, ast: true }
+          );
+          import_main.lib.gatherRecursive(ast, ($) => $.type === "BlockStatement").forEach((topBlock) => {
+            return import_main.lib.gatherRecursiveWithinFunction(topBlock, ($1) => $1.type === "Declaration").forEach((decl) => {
+              const type = decl.children.shift();
+              if (!Array.isArray(ast)) {
+                ast = [ast];
+              }
+              return ast.unshift(`var ${decl.names.join(",")};`);
+            });
+          });
+        }
+        const errors = [];
         try {
-          output = (0, import_main.compile)(input, { ...options, filename });
+          output = (0, import_main.generate)(ast, { errors });
         } catch (error) {
           console.error(error);
           return callback(null, void 0);
         }
-        if (options.compile || options.ast) {
-          return callback(null, output);
-        } else {
-          let result;
+        if (errors.length) {
+          console.error(`Parse errors: ${errors.map(($2) => $2.message).join("\n")}`);
+          return callback(null, void 0);
+        }
+        let result;
+        try {
+          result = vm.runInContext(output, context, {
+            filename,
+            importModuleDynamically
+          });
+        } catch (error) {
+          return callback(error, void 0);
+        }
+        if (topLevelAwait) {
+          let threw = false;
           try {
-            result = vm.runInContext(output, context, { filename });
+            result = await result;
           } catch (error) {
-            return callback(error, void 0);
+            threw = true;
+            callback(error, void 0);
           }
+          if (!threw) {
+            return callback(null, result);
+          }
+          ;
+          return;
+        } else {
           return callback(null, result);
         }
       } else {
@@ -451,7 +538,20 @@ async function cli() {
           }
         }
         const { fork } = await import("child_process");
-        const execArgv = ["--loader", "@danielx/civet/esm"];
+        const { register } = await import("module");
+        let execArgv;
+        if (register) {
+          execArgv = ["--import", "@danielx/civet/register"];
+        } else {
+          execArgv = [
+            "--loader",
+            "@danielx/civet/esm",
+            // ESM
+            "--require",
+            "@danielx/civet/register"
+            // CJS
+          ];
+        }
         const debugRe = /--debug|--inspect/;
         const isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS ?? "");
         if (process.env.NODE_OPTIONS) {
@@ -516,3 +616,10 @@ async function cli() {
 if (require.main === module) {
   cli();
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli,
+  parseArgs,
+  repl,
+  version
+});

package/dist/esm.mjs

@@ -1,6 +1,5 @@
 // source/esm.civet
 import { readFileSync } from "fs";
-import { createRequire } from "module";
 import { pathToFileURL, fileURLToPath } from "url";
 import sourceMapSupport from "@cspotcode/source-map-support";
 import Civet from "./main.js";
@@ -72,16 +71,6 @@ async function load(url, context, next) {
   }
   return next(url, context);
 }
-var require2 = createRequire(import.meta.url);
-require2.extensions[".civet"] = function(m, filename) {
-  const source = readFileSync(filename, "utf8");
-  const code = compile(source, {
-    filename,
-    inlineMap: true,
-    js: true
-  });
-  return m._compile(code, filename);
-};
 export {
   load,
   resolve