@danielx/civet 0.6.68 → 0.6.70

package/dist/civet

@@ -28,15 +28,9 @@ var import_main = require("./main.js");
 var import_config = require("./config.js");
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
-var version;
-var parseArgs;
-var readFiles;
-var repl;
-var cli;
-var indexOf = [].indexOf;
-version = function() {
+function version() {
   return require("../package.json").version;
-};
+}
 if (process.argv.includes("--version")) {
   console.log(version());
   process.exit(0);
@@ -80,37 +74,35 @@ You can use - to read from stdin or (prefixed by -o) write to stdout.
   process.exit(0);
 }
 var encoding = "utf8";
-parseArgs = function(args) {
-  var options, filenames, scriptArgs, i, endOfArgs, arg;
-  options = {};
+function parseArgs(args) {
+  const options = {};
   Object.defineProperty(options, "run", {
     get: function() {
       return !(this.ast || this.compile);
     }
   });
-  filenames = [];
-  scriptArgs = null;
-  i = 0;
-  endOfArgs = function(j) {
+  const filenames = [];
+  let scriptArgs = [];
+  let i = 0;
+  function endOfArgs(j) {
     i = args.length;
     if (j >= args.length) {
       return;
     }
     if (options.run) {
       filenames.push(args[j]);
-      return scriptArgs = args.slice(j + 1);
+      scriptArgs = args.slice(j + 1);
     } else {
-      return filenames.push(...args.slice(j));
+      filenames.push(...args.slice(j));
     }
-  };
+  }
   while (i < args.length) {
-    arg = args[i];
+    const arg = args[i];
     if (/^-\w{2,}$/.test(arg)) {
       args.splice(i, 1 + i - i, ...(() => {
-        var char;
         const results = [];
         for (let ref = arg.slice(1), i1 = 0, len = ref.length; i1 < len; i1++) {
-          char = ref[i1];
+          const char = ref[i1];
           results.push(`-${char}`);
         }
         return results;
@@ -178,14 +170,14 @@ parseArgs = function(args) {
     i++;
   }
   return { filenames, scriptArgs, options };
-};
-readFiles = async function* (filenames, options) {
-  var filename, stdin, lines, rl, content;
+}
+async function* readFiles(filenames) {
   const results1 = [];
   for (let i2 = 0, len1 = filenames.length; i2 < len1; i2++) {
-    filename = filenames[i2];
-    stdin = filename === "-";
+    let filename = filenames[i2];
+    const stdin = filename === "-";
     try {
+      let content;
       if (stdin) {
         process.stdin.setEncoding(encoding);
         filename = "<stdin>";
@@ -194,24 +186,21 @@ readFiles = async function* (filenames, options) {
         } catch (e) {
         }
         if (process.stdin.isTTY) {
-          lines = [];
-          rl = require("readline").createInterface(process.stdin, process.stdout);
-          rl.on("line", function(buffer) {
-            return lines.push(buffer + "\n");
-          });
-          content = await new Promise(function(resolve, reject) {
-            rl.on("SIGINT", function() {
+          const lines = [];
+          const rl = (await import("readline")).createInterface(process.stdin, process.stdout);
+          rl.on("line", (buffer) => lines.push(buffer + "\n"));
+          content = await new Promise((resolve, reject) => {
+            rl.on("SIGINT", () => {
               return reject("^C");
             });
-            return rl.on("close", function() {
+            return rl.on("close", () => {
               return resolve(lines.join(""));
             });
           });
         } else {
           content = (await (async () => {
-            var chunk;
             const results2 = [];
-            for await (chunk of process.stdin) {
+            for await (const chunk of process.stdin) {
               results2.push(chunk);
             }
             return results2;
@@ -227,9 +216,8 @@ readFiles = async function* (filenames, options) {
   }
   ;
   return results1;
-};
-repl = function(options) {
-  var nodeRepl, vm, r;
+}
+async function repl(options) {
   console.log(`Civet ${version()} REPL.  Enter a blank line to ${(() => {
     switch (false) {
       case !options.ast: {
@@ -243,12 +231,10 @@ repl = function(options) {
       }
     }
   })()} code.`);
-  global.quit = global.exit = function() {
-    return process.exit(0);
-  };
-  nodeRepl = require("repl");
-  vm = require("vm");
-  return r = nodeRepl.start({
+  global.quit = global.exit = () => process.exit(0);
+  const nodeRepl = await import("repl");
+  const vm = await import("vm");
+  const r = nodeRepl.start({
     prompt: (() => {
       switch (false) {
         case !options.ast: {
@@ -262,53 +248,54 @@ repl = function(options) {
         }
       }
     })(),
-    writer: options.ast ? function(obj) {
+    writer: options.ast ? (obj) => {
       try {
         return JSON.stringify(obj, null, 2);
       } catch (e) {
         console.log(`Failed to stringify: ${e}`);
-        return obj;
+        return "";
       }
-    } : options.compile ? function(obj) {
+    } : options.compile ? (obj) => {
       if (typeof obj === "string") {
         return obj?.replace(/\n*$/, "");
       } else {
-        return obj;
+        return "";
       }
     } : void 0,
     eval: function(input, context, filename, callback) {
-      var output, result;
       if (input === "\n") {
-        return callback(null);
-      } else if (indexOf.call(["quit\n", "exit\n", "quit()\n", "exit()\n"], input) >= 0) {
+        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;
         try {
           output = (0, import_main.compile)(input, { ...options, filename });
         } catch (error) {
           console.error(error);
-          return callback("");
+          return callback(null, void 0);
         }
         if (options.compile || options.ast) {
           return callback(null, output);
         } else {
+          let result;
           try {
             result = vm.runInContext(output, context, { filename });
           } catch (error) {
-            return callback(error);
+            return callback(error, void 0);
           }
           return callback(null, result);
         }
       } else {
-        return callback(new nodeRepl.Recoverable("Enter a blank line to execute code."));
+        return callback(new nodeRepl.Recoverable(new Error("Enter a blank line to execute code.")), null);
       }
     }
   });
-};
-cli = async function() {
-  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, execArgv, debugRe, isDebug, child;
-  argv = process.argv;
-  ({ filenames, scriptArgs, options } = parseArgs(argv.slice(2)));
+  return r;
+}
+async function cli() {
+  const argv = process.argv;
+  let { filenames, scriptArgs, options } = parseArgs(argv.slice(2));
   if (options.config !== false) {
     options.config ??= await (0, import_config.findConfig)(process.cwd());
   }
@@ -334,12 +321,13 @@ cli = async function() {
     return repl(options);
   }
   const results3 = [];
-  for await ({ filename, error, content, stdin } of readFiles(filenames, options)) {
+  for await (const { filename, error, content, stdin } of readFiles(filenames)) {
     if (error) {
       console.error(`${filename} failed to load:`);
       console.error(error);
       continue;
     }
+    let output;
     try {
       output = (0, import_main.compile)(content, { ...options, filename });
     } catch (error2) {
@@ -352,7 +340,7 @@ cli = async function() {
       if (stdin && !options.output || options.output === "-") {
         results3.push(process.stdout.write(output));
       } else {
-        outputPath = import_path.default.parse(filename);
+        let outputPath = import_path.default.parse(filename);
         delete outputPath.base;
         if (options.js) {
           outputPath.ext += ".jsx";
@@ -360,7 +348,8 @@ cli = async function() {
           outputPath.ext += ".tsx";
         }
         if (options.output) {
-          optionsPath = import_path.default.parse(options.output);
+          const optionsPath = import_path.default.parse(options.output);
+          let stat;
           try {
             stat = await import_promises.default.stat(options.output);
           } catch {
@@ -380,7 +369,7 @@ cli = async function() {
         if (outputPath.dir) {
           import_promises.default.mkdir(outputPath.dir, { recursive: true });
         }
-        outputFilename = import_path.default.format(outputPath);
+        const outputFilename = import_path.default.format(outputPath);
         try {
           results3.push(await import_promises.default.writeFile(outputFilename, output));
         } catch (error2) {
@@ -389,35 +378,35 @@ cli = async function() {
         }
       }
     } else {
-      esm = /^\s*(import|export)\b/m.test(output);
+      const esm = /^\s*(import|export)\b/m.test(output);
       if (esm) {
         if (stdin) {
-          filename = `.stdin-${process.pid}.civet`;
+          const filename2 = `.stdin-${process.pid}.civet`;
           try {
-            await import_promises.default.writeFile(filename, content, { encoding });
+            await import_promises.default.writeFile(filename2, content, { encoding });
           } catch (e) {
-            console.error(`Could not write ${filename} for Civet ESM mode:`);
+            console.error(`Could not write ${filename2} for Civet ESM mode:`);
             console.error(e);
             process.exit(1);
           }
         }
         const { fork } = await import("child_process");
-        execArgv = ["--loader", "@danielx/civet/esm"];
-        debugRe = /--debug|--inspect/;
-        isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS);
+        const execArgv = ["--loader", "@danielx/civet/esm"];
+        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) {
           execArgv.push(process.env.NODE_OPTIONS);
         }
         if (isDebug) {
           execArgv.push("--inspect=" + (process.debugPort + 1));
         }
-        child = fork(filename, [
+        const child = fork(filename, [
           ...scriptArgs
         ], {
           execArgv,
           stdio: "inherit"
         });
-        results3.push(child.on("exit", async function(code) {
+        results3.push(child.on("exit", async (code) => {
           if (stdin) {
             await import_promises.default.unlink(filename);
           }
@@ -444,7 +433,7 @@ cli = async function() {
   }
   ;
   return results3;
-};
+}
 if (require.main === module) {
   cli();
 }