@danielx/civet 0.6.25 → 0.6.27

package/dist/bun-civet.mjs

@@ -1,16 +1,10 @@
-import {
-  plugin
-} from "bun";
+import { plugin } from "bun";
 await plugin({
   name: "Civet loader",
   setup: async function(builder) {
-    var compile, readFileSync;
     ({ compile } = await import("./main.mjs"));
     ({ readFileSync } = await import("fs"));
-    return builder.onLoad({
-      filter: /\.civet$/
-    }, function({ path }) {
-      var contents, source;
+    return builder.onLoad({ filter: /\.civet$/ }, function({ path }) {
       source = readFileSync(path, "utf8");
       contents = compile(source);
       return {

package/dist/civet

@@ -1,8 +1,19 @@
 #!/usr/bin/env node
 "use strict";
-var import_main = require("./main");
-var import_config = require("./config");
-var cli, encoding, fs, parseArgs, path, prune, readFiles, repl, version, splice = [].splice;
+
+// source/cli.civet
+var import_main = require("./main.js");
+var import_config = require("./config.js");
+var prune;
+var version;
+var encoding;
+var fs;
+var path;
+var parseArgs;
+var readFiles;
+var repl;
+var cli;
+var indexOf = [].indexOf;
 ({ prune } = import_main.generate);
 version = function() {
   return require("../package.json").version;
@@ -12,39 +23,39 @@ if (process.argv.includes("--version")) {
   process.exit(0);
 }
 if (process.argv.includes("--help")) {
-  process.stderr.write(`       \u2584\u2584\xB7 \u25AA   \u258C \u2590\xB7\u2584\u2584\u2584 .\u2584\u2584\u2584\u2584\u2584
-      \u2590\u2588 \u258C\u25AA\u2588\u2588 \u25AA\u2588\xB7\u2588\u258C\u2580\u2584.\u2580\xB7\u2022\u2588\u2588       _._     _,-'""\`-._
-      \u2588\u2588 \u2584\u2584\u2590\u2588\xB7\u2590\u2588\u2590\u2588\u2022\u2590\u2580\u2580\u25AA\u2584 \u2590\u2588.\u25AA    (,-.\`._,'(       |\\\`-/|
-      \u2590\u2588\u2588\u2588\u258C\u2590\u2588\u258C \u2588\u2588\u2588 \u2590\u2588\u2584\u2584\u258C \u2590\u2588\u258C\xB7        \`-.-' \\ )-\`( , o o)
-      \xB7\u2580\u2580\u2580 \u2580\u2580\u2580. \u2580   \u2580\u2580\u2580  \u2580\u2580\u2580               \`-    \\\`_\`"'-
+  process.stderr.write(`\u2584\u2584\xB7 \u25AA   \u258C \u2590\xB7\u2584\u2584\u2584 .\u2584\u2584\u2584\u2584\u2584
+          \u2590\u2588 \u258C\u25AA\u2588\u2588 \u25AA\u2588\xB7\u2588\u258C\u2580\u2584.\u2580\xB7\u2022\u2588\u2588       _._     _,-'""\`-._
+          \u2588\u2588 \u2584\u2584\u2590\u2588\xB7\u2590\u2588\u2590\u2588\u2022\u2590\u2580\u2580\u25AA\u2584 \u2590\u2588.\u25AA    (,-.\`._,'(       |\\\`-/|
+          \u2590\u2588\u2588\u2588\u258C\u2590\u2588\u258C \u2588\u2588\u2588 \u2590\u2588\u2584\u2584\u258C \u2590\u2588\u258C\xB7        \`-.-' \\ )-\`( , o o)
+          \xB7\u2580\u2580\u2580 \u2580\u2580\u2580. \u2580   \u2580\u2580\u2580  \u2580\u2580\u2580               \`-    \\\`_\`"'-
 
 
-Usage:
+    Usage:
 
-    civet                                        # REPL for executing code
-    civet -c                                     # REPL for transpiling code
-    civet --ast                                  # REPL for parsing code
-    civet [options] input.civet                  # run input.civet
-    civet [options] -c input.civet               # -> input.civet.tsx
-    civet [options] -c input.civet -o .ts        # -> input.ts
-    civet [options] -c input.civet -o dir        # -> dir/input.civet.tsx
-    civet [options] -c input.civet -o dir/.ts    # -> dir/input.ts
-    civet [options] -c input.civet -o output.ts  # -> output.ts
-    civet [options] < input.civet > output.ts    # pipe form
+        civet                                        # REPL for executing code
+        civet -c                                     # REPL for transpiling code
+        civet --ast                                  # REPL for parsing code
+        civet [options] input.civet                  # run input.civet
+        civet [options] -c input.civet               # -> input.civet.tsx
+        civet [options] -c input.civet -o .ts        # -> input.ts
+        civet [options] -c input.civet -o dir        # -> dir/input.civet.tsx
+        civet [options] -c input.civet -o dir/.ts    # -> dir/input.ts
+        civet [options] -c input.civet -o output.ts  # -> output.ts
+        civet [options] < input.civet > output.ts    # pipe form
 
-Options:
-  --help           Show this help message
-  --version        Show the version number
-  -o / --output XX Specify output directory and/or extension, or filename
-  -c / --compile   Compile input files to TypeScript (or JavaScript)
-  --config XX      Specify a config file (default scans for a config.civet, civet.json, civetconfig.civet or civetconfig.json file, optionally in a .config directory, or starting with a .)
-  --no-config      Don't scan for a config file
-  --js             Strip out all type annotations; default to .jsx extension
-  --ast            Print the AST instead of the compiled code
-  --inline-map     Generate a sourcemap
-  --no-cache       Disable compiler caching (slow, for debugging)
+    Options:
+      --help           Show this help message
+      --version        Show the version number
+      -o / --output XX Specify output directory and/or extension, or filename
+      -c / --compile   Compile input files to TypeScript (or JavaScript)
+      --config XX      Specify a config file (default scans for a config.civet, civet.json, civetconfig.civet or civetconfig.json file, optionally in a .config directory, or starting with a .)
+      --no-config      Don't scan for a config file
+      --js             Strip out all type annotations; default to .jsx extension
+      --ast            Print the AST instead of the compiled code
+      --inline-map     Generate a sourcemap
+      --no-cache       Disable compiler caching (slow, for debugging)
 
-You can use - to read from stdin or (prefixed by -o) write to stdout.
+    You can use - to read from stdin or (prefixed by -o) write to stdout.
 
 `);
   process.exit(0);
@@ -53,7 +64,7 @@ encoding = "utf8";
 fs = require("fs/promises");
 path = require("path");
 parseArgs = function(args) {
-  var arg, char, endOfArgs, filenames, i, options, ref, scriptArgs;
+  var options, filenames, scriptArgs, i, endOfArgs, arg, char;
   options = {};
   Object.defineProperty(options, "run", {
     get: function() {
@@ -78,49 +89,57 @@ parseArgs = function(args) {
   while (i < args.length) {
     arg = args[i];
     if (/^-\w{2,}$/.test(arg)) {
-      splice.apply(args, [i, i - i + 1].concat(ref = function() {
-        var k, len, ref1, results;
-        ref1 = arg.slice(1);
-        results = [];
-        for (k = 0, len = ref1.length; k < len; k++) {
-          char = ref1[k];
+      args.splice(i, 1 + i - i, ...(() => {
+        const results = [];
+        for (let ref = arg.slice(1), i1 = 0, len = ref.length; i1 < len; i1++) {
+          char = ref[i1];
           results.push(`-${char}`);
         }
+        ;
         return results;
-      }())), ref;
+      })());
       continue;
     }
     switch (arg) {
       case "-c":
-      case "--compile":
+      case "--compile": {
         options.compile = true;
         break;
+      }
       case "-o":
-      case "--output":
+      case "--output": {
         options.output = args[++i];
         break;
-      case "--config":
+      }
+      case "--config": {
         options.config = args[++i];
         break;
-      case "--no-config":
+      }
+      case "--no-config": {
         options.config = false;
         break;
-      case "--ast":
+      }
+      case "--ast": {
         options.ast = true;
         break;
-      case "--no-cache":
+      }
+      case "--no-cache": {
         options.noCache = true;
         break;
-      case "--inline-map":
+      }
+      case "--inline-map": {
         options.inlineMap = true;
         break;
-      case "--js":
+      }
+      case "--js": {
         options.js = true;
         break;
-      case "--":
+      }
+      case "--": {
         endOfArgs(++i);
         break;
-      default:
+      }
+      default: {
         if (arg.startsWith("-") && arg !== "-") {
           throw new Error(`Invalid command-line argument ${arg}`);
         }
@@ -129,16 +148,18 @@ parseArgs = function(args) {
         } else {
           filenames.push(arg);
         }
+      }
     }
     i++;
   }
+  ;
   return { filenames, scriptArgs, options };
 };
 readFiles = async function* (filenames, options) {
-  var chunk, content, error, filename, k, len, lines, results, rl, stdin;
-  results = [];
-  for (k = 0, len = filenames.length; k < len; k++) {
-    filename = filenames[k];
+  var filename, stdin, lines, rl, content, chunk;
+  const results1 = [];
+  for (let i2 = 0, len1 = filenames.length; i2 < len1; i2++) {
+    filename = filenames[i2];
     stdin = filename === "-";
     try {
       if (stdin) {
@@ -146,7 +167,7 @@ readFiles = async function* (filenames, options) {
         filename = "<stdin>";
         try {
           filename = await fs.realpath("/dev/stdin");
-        } catch (error1) {
+        } catch (e) {
         }
         if (process.stdin.isTTY) {
           lines = [];
@@ -163,82 +184,84 @@ readFiles = async function* (filenames, options) {
             });
           });
         } else {
-          content = (await async function() {
-            var ref, results1;
-            ref = process.stdin;
-            results1 = [];
-            for await (chunk of ref) {
-              results1.push(chunk);
+          content = (await (async () => {
+            const results2 = [];
+            for await (chunk of process.stdin) {
+              results2.push(chunk);
             }
-            return results1;
-          }()).join("");
+            ;
+            return results2;
+          })()).join("");
         }
       } else {
         content = await fs.readFile(filename, { encoding });
       }
-      results.push(yield { filename, content, stdin });
-    } catch (error1) {
-      error = error1;
-      results.push(yield { filename, error, stdin });
+      results1.push(yield { filename, content, stdin });
+    } catch (error) {
+      results1.push(yield { filename, error, stdin });
     }
   }
-  return results;
+  ;
+  return results1;
 };
 repl = function(options) {
-  var nodeRepl, r, vm;
-  console.log(`Civet ${version()} REPL.  Enter a blank line to ${function() {
+  var nodeRepl, vm, r;
+  console.log(`Civet ${version()} REPL.  Enter a blank line to ${(() => {
     switch (false) {
-      case !options.ast:
+      case !options.ast: {
         return "parse";
-      case !options.compile:
+      }
+      case !options.compile: {
         return "transpile";
-      default:
+      }
+      default: {
         return "execute";
+      }
     }
-  }()} code.`);
+  })()} code.`);
   global.quit = global.exit = function() {
     return process.exit(0);
   };
   nodeRepl = require("repl");
   vm = require("vm");
   return r = nodeRepl.start({
-    prompt: function() {
+    prompt: (() => {
       switch (false) {
-        case !options.ast:
+        case !options.ast: {
           return "\u{1F332}> ";
-        case !options.compile:
+        }
+        case !options.compile: {
           return "\u{1F408}> ";
-        default:
+        }
+        default: {
           return "\u{1F431}> ";
+        }
       }
-    }(),
+    })(),
     writer: options.ast ? function(obj) {
-      var e;
       try {
         return JSON.stringify(obj, null, 2);
-      } catch (error1) {
-        e = error1;
+      } catch (e) {
         console.log(`Failed to stringify: ${e}`);
         return obj;
       }
     } : options.compile ? function(obj) {
       if (typeof obj === "string") {
-        return obj != null ? obj.replace(/\n*$/, "") : void 0;
+        return obj?.replace(/\n*$/, "");
       } else {
         return obj;
       }
     } : void 0,
     eval: function(input, context, filename, callback) {
-      var error, output, result;
+      var output, result;
       if (input === "\n") {
         return callback(null);
-      } else if (input === "quit\n" || input === "exit\n" || input === "quit()\n" || input === "exit()\n") {
+      } else if (indexOf.call(["quit\n", "exit\n", "quit()\n", "exit()\n"], input) >= 0) {
         return process.exit(0);
       } else if (input.endsWith("\n\n")) {
         try {
           output = (0, import_main.compile)(input, { ...options, filename });
-        } catch (error1) {
-          error = error1;
+        } catch (error) {
           console.error(error);
           return callback("");
         }
@@ -247,8 +270,7 @@ repl = function(options) {
         } else {
           try {
             result = vm.runInContext(output, context, { filename });
-          } catch (error1) {
-            error = error1;
+          } catch (error) {
             return callback(error);
           }
           return callback(null, result);
@@ -260,16 +282,17 @@ repl = function(options) {
   });
 };
 cli = async function() {
-  var argv, child, content, e, error, esm, filename, filenames, options, optionsPath, output, outputFilename, outputPath, ref, results, scriptArgs, stat, stdin, x;
+  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, child;
   argv = process.argv;
   ({ filenames, scriptArgs, options } = parseArgs(argv.slice(2)));
   if (options.config !== false) {
-    if (options.config == null) {
-      options.config = await (0, import_config.findConfig)(process.cwd());
-    }
+    options.config ?? (options.config = await (0, import_config.findConfig)(process.cwd()));
   }
   if (options.config) {
-    options = { ...await (0, import_config.loadConfig)(options.config), ...options };
+    options = {
+      ...await (0, import_config.loadConfig)(options.config),
+      ...options
+    };
   }
   if (!filenames.length) {
     if (process.stdin.isTTY) {
@@ -286,10 +309,8 @@ cli = async function() {
   if (options.repl) {
     return repl(options);
   }
-  ref = readFiles(filenames, options);
-  results = [];
-  for await (x of ref) {
-    ({ filename, error, content, stdin } = x);
+  const results3 = [];
+  for await ({ filename, error, content, stdin } of readFiles(filenames, options)) {
     if (error) {
       console.error(`${filename} failed to load:`);
       console.error(error);
@@ -297,16 +318,15 @@ cli = async function() {
     }
     try {
       output = (0, import_main.compile)(content, { ...options, filename });
-    } catch (error1) {
-      error = error1;
-      console.error(error);
+    } catch (error2) {
+      console.error(error2);
       continue;
     }
     if (options.ast) {
-      results.push(process.stdout.write(JSON.stringify(output, null, 2)));
+      results3.push(process.stdout.write(JSON.stringify(output, null, 2)));
     } else if (options.compile) {
       if (stdin && !options.output || options.output === "-") {
-        results.push(process.stdout.write(output));
+        results3.push(process.stdout.write(output));
       } else {
         outputPath = path.parse(filename);
         delete outputPath.base;
@@ -319,10 +339,10 @@ cli = async function() {
           optionsPath = path.parse(options.output);
           try {
             stat = await fs.stat(options.output);
-          } catch (error1) {
+          } catch {
             stat = null;
           }
-          if ((stat != null ? stat.isDirectory() : void 0) || options.output.endsWith(path.sep) || options.output.endsWith("/")) {
+          if (stat?.isDirectory() || options.output.endsWith(path.sep) || options.output.endsWith("/")) {
             outputPath.dir = options.output;
           } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
             outputPath.ext = optionsPath.base;
@@ -334,17 +354,14 @@ cli = async function() {
           }
         }
         if (outputPath.dir) {
-          fs.mkdir(outputPath.dir, {
-            recursive: true
-          });
+          fs.mkdir(outputPath.dir, { recursive: true });
         }
         outputFilename = path.format(outputPath);
         try {
-          results.push(await fs.writeFile(outputFilename, output));
-        } catch (error1) {
-          error = error1;
+          results3.push(await fs.writeFile(outputFilename, output));
+        } catch (error2) {
           console.error(`${outputFilename} failed to write:`);
-          results.push(console.error(error));
+          results3.push(console.error(error2));
         }
       }
     } else {
@@ -354,41 +371,43 @@ cli = async function() {
           filename = `.stdin-${process.pid}.civet`;
           try {
             await fs.writeFile(filename, content, { encoding });
-          } catch (error1) {
-            e = error1;
+          } catch (e) {
             console.error(`Could not write ${filename} for Civet ESM mode:`);
             console.error(e);
             process.exit(1);
           }
         }
-        child = require("child_process").spawnSync(argv[0], ["--loader", "@danielx/civet/esm", filename, ...scriptArgs], {
-          stdio: "inherit"
-        });
+        child = require("child_process").spawnSync(argv[0], [
+          "--loader",
+          "@danielx/civet/esm",
+          filename,
+          ...scriptArgs
+        ], { stdio: "inherit" });
         if (stdin) {
           await fs.unlink(filename);
         }
-        results.push(process.exit(child.status));
+        results3.push(process.exit(child.status));
       } else {
         require("../register.js");
         try {
           module.filename = await fs.realpath(filename);
-        } catch (error1) {
+        } catch {
           module.filename = filename;
         }
         process.argv = ["civet", module.filename, ...scriptArgs];
         module.paths = require("module")._nodeModulePaths(path.dirname(module.filename));
         try {
-          results.push(module._compile(output, module.filename));
-        } catch (error1) {
-          error = error1;
+          results3.push(module._compile(output, module.filename));
+        } catch (error2) {
           console.error(`${filename} crashed while running in CJS mode:`);
-          console.error(error);
-          results.push(process.exit(1));
+          console.error(error2);
+          results3.push(process.exit(1));
         }
       }
     }
   }
-  return results;
+  ;
+  return results3;
 };
 if (require.main === module) {
   cli();

package/dist/config.js

@@ -22,6 +22,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// source/config.civet
 var config_exports = {};
 __export(config_exports, {
   findConfig: () => findConfig,
@@ -30,60 +32,64 @@ __export(config_exports, {
 module.exports = __toCommonJS(config_exports);
 var import_path = __toESM(require("path"));
 var import_promises = __toESM(require("fs/promises"));
-var import_main = require("./main");
-var import_url = require("url");
-var findInDir;
-findInDir = async function(dirPath) {
-  var dir, entry, name;
-  dir = await import_promises.default.opendir(dirPath);
-  for await (entry of dir) {
+var import_main = require("./main.js");
+var configFileNames = /* @__PURE__ */ new Set([
+  "\u{1F408}.json",
+  "\u{1F408}.civet",
+  "civetconfig.json",
+  "civetconfig.civet"
+]);
+async function findInDir(dirPath) {
+  const dir = await import_promises.default.opendir(dirPath);
+  for await (const entry of dir) {
     if (entry.isDirectory() && entry.name === ".config") {
-      return findInDir(import_path.default.join(dirPath, entry.name));
+      const found = await findInDir(
+        import_path.default.join(dirPath, entry.name)
+      );
+      if (found) {
+        return found;
+      }
     }
     if (entry.isFile()) {
-      name = entry.name.replace(/^\./, "");
-      if (name === "config.civet" || name === "civet.json" || name === "civetconfig.civet" || name === "civetconfig.json") {
+      const name = entry.name.replace(/^\./, "");
+      if (configFileNames.has(name)) {
         return import_path.default.join(dirPath, entry.name);
       }
     }
   }
-  return null;
-};
-var findConfig = async function(startDir) {
-  var configPath, curr, parent;
-  curr = startDir;
-  parent = import_path.default.dirname(curr);
+  return;
+}
+async function findConfig(startDir) {
+  let curr = startDir;
+  let parent = import_path.default.dirname(curr);
   while (curr !== parent) {
-    if (configPath = await findInDir(curr)) {
+    const configPath = await findInDir(curr);
+    if (configPath) {
       return configPath;
     }
     curr = parent;
     parent = import_path.default.dirname(curr);
   }
-  return null;
-};
-var loadConfig = async function(path2) {
-  var config, exports, js, tmpPath;
-  config = await import_promises.default.readFile(path2, "utf8");
+  return;
+}
+async function loadConfig(path2) {
+  const config = await import_promises.default.readFile(path2, "utf8");
   if (path2.endsWith(".json")) {
     return JSON.parse(config);
   } else {
-    js = (0, import_main.compile)(config, {
-      js: true
-    });
-    tmpPath = path2 + `.civet-tmp-${Date.now()}.mjs`;
-    await import_promises.default.writeFile(tmpPath, js);
+    const js = (0, import_main.compile)(config, { js: true });
+    let exports;
     try {
-      exports = await import((0, import_url.pathToFileURL)(tmpPath));
-    } finally {
-      await import_promises.default.unlink(tmpPath);
+      exports = await import(`data:text/javascript,${js}`);
+    } catch (e) {
+      console.error("Error loading config file", path2, e);
     }
     if (typeof exports.default !== "object" || exports.default === null) {
       throw new Error("civet config file must export an object");
     }
     return exports.default;
   }
-};
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   findConfig,