@danielx/civet 0.7.9 → 0.7.11

package/dist/civet

@@ -46,11 +46,11 @@ var unplugin;
 function version() {
   return require("../package.json").version;
 }
-if (process.argv.includes("--version")) {
+if (process.argv.some((a) => a === "--version" || a === "-version" || a === "-v")) {
   console.log(version());
   process.exit(0);
 }
-if (process.argv.includes("--help")) {
+if (process.argv.some((a1) => a1 === "--help" || a1 === "-help" || a1 === "-h")) {
   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    (,-.\`._,'(       |\\\`-/|
@@ -106,6 +106,7 @@ function parseArgs(args) {
   const filenames = [];
   let scriptArgs = [];
   let i = 0;
+  let errors = 0;
   function endOfArgs(j) {
     i = args.length;
     if (j >= args.length) {
@@ -121,6 +122,12 @@ function parseArgs(args) {
   while (i < args.length) {
     const arg = args[i];
     if (/^-\w{2,}$/.test(arg)) {
+      const results = [];
+      for (let ref = arg.slice(1), i1 = 0, len = ref.length; i1 < len; i1++) {
+        const char = ref[i1];
+        results.push(`-${char}`);
+      }
+      ;
       args.splice(i, 1 + i - i, ...results);
       continue;
     }
@@ -199,9 +206,9 @@ function parseArgs(args) {
       }
       default: {
         if (arg.startsWith("-") && arg !== "-") {
-          throw new Error(`Invalid command-line argument ${arg}`);
-        }
-        if (options.run) {
+          console.error(`Invalid command-line argument: ${arg}`);
+          errors++;
+        } else if (options.run) {
           endOfArgs(i);
         } else {
           filenames.push(arg);
@@ -210,12 +217,15 @@ function parseArgs(args) {
     }
     i++;
   }
+  if (errors) {
+    process.exit(Math.min(255, errors));
+  }
   return { filenames, scriptArgs, options };
 }
 async function* readFiles(filenames) {
   const results1 = [];
-  for (let i1 = 0, len = filenames.length; i1 < len; i1++) {
-    let filename = filenames[i1];
+  for (let i2 = 0, len1 = filenames.length; i2 < len1; i2++) {
+    let filename = filenames[i2];
     const stdin = filename === "-";
     try {
       let content;
@@ -273,7 +283,6 @@ async function repl(options) {
       };
     } else {
       const execArgv = ["--experimental-vm-modules"];
-      const { register } = await import("node:module");
       if (process.env.NODE_OPTIONS) {
         execArgv.push(process.env.NODE_OPTIONS);
       }
@@ -343,17 +352,36 @@ async function repl(options) {
       } else if (input in ["quit\n", "exit\n", "quit()\n", "exit()\n"]) {
         return process.exit(0);
       } else if (input.endsWith("\n\n")) {
+        let showError2 = function(error) {
+          console.error("Error while parsing Civet code:");
+          if ((0, import_main.isCompileError)(error)) {
+            if (error.errors != null) {
+              error = error.errors[0];
+            }
+            return console.log(`${input.split("\n").slice(0, error.line).join("\n")}
+${" ".repeat(error.column - 1)}^ ${error.header}`);
+          } else {
+            return console.error(error);
+          }
+        };
+        var showError = showError2;
         let output;
         if (options.compile || options.ast) {
           try {
             output = await (0, import_main.compile)(input, { ...options, filename });
           } catch (error) {
-            console.error(error);
+            showError2(error);
             return callback(null, void 0);
           }
           return callback(null, output);
         }
-        let ast = await (0, import_main.compile)(input, { ...options, filename, ast: true });
+        let ast;
+        try {
+          ast = await (0, import_main.compile)(input, { ...options, filename, ast: true });
+        } catch (error) {
+          showError2(error);
+          return callback(null, void 0);
+        }
         const topLevelAwait = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast);
         if (topLevelAwait) {
           const [prologue, rest] = (0, import_main.parse)(input, { startRule: "ProloguePrefix" });
@@ -373,7 +401,7 @@ async function repl(options) {
             });
           });
         }
-        const errors = [];
+        let errors = [];
         try {
           output = (0, import_main.generate)(ast, { errors });
         } catch (error) {
@@ -381,7 +409,9 @@ async function repl(options) {
           return callback(null, void 0);
         }
         if (errors.length) {
-          console.error(`Parse errors: ${errors.map(($2) => $2.message).join("\n")}`);
+          errors = [];
+          (0, import_main.generate)(ast, { errors, sourceMap: (0, import_main.SourceMap)(input) });
+          showError2(errors[0]);
           return callback(null, void 0);
         }
         let result;
@@ -394,18 +424,17 @@ async function repl(options) {
           return callback(error, void 0);
         }
         if (topLevelAwait) {
-          let threw = false;
+          let ok = true;
           try {
-            result = await result;
+            return result = await result;
           } catch (error) {
-            threw = true;
-            callback(error, void 0);
-          }
-          if (!threw) {
-            return callback(null, result);
+            ok = false;
+            return callback(error, void 0);
+          } finally {
+            if (ok) {
+              callback(null, result);
+            }
           }
-          ;
-          return;
         } else {
           return callback(null, result);
         }
@@ -531,7 +560,7 @@ async function cli() {
           targetPath = outputPath;
         }
         if (targetPath.dir) {
-          import_promises.default.mkdir(targetPath.dir, { recursive: true });
+          await import_promises.default.mkdir(targetPath.dir, { recursive: true });
         }
         const targetFilename = import_path.default.format(targetPath);
         try {
@@ -618,9 +647,9 @@ async function cli() {
         }
       });
     } catch (error) {
-      let ref;
-      if (ref = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
-        const match = ref;
+      let ref1;
+      if (ref1 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
+        const match = ref1;
         return process.exitCode = Math.min(255, errors + +match[1]);
       } else {
         process.exitCode = 1;

package/dist/esm.mjs

@@ -1,40 +1,10 @@
 // source/esm.civet
 import { readFileSync } from "fs";
 import { pathToFileURL, fileURLToPath } from "url";
-import sourceMapSupport from "@cspotcode/source-map-support";
 import Civet from "./main.js";
-var { compile, util } = Civet;
-var { SourceMap } = util;
+var { compile, SourceMap } = Civet;
 var baseURL = pathToFileURL(process.cwd() + "/").href;
 var extensionsRegex = /\.civet$/;
-var registered = false;
-var outputCache = /* @__PURE__ */ new Map();
-var directorySeparator = "/";
-var backslashRegExp = /\\/g;
-function normalizeSlashes(value) {
-  return value.replace(backslashRegExp, directorySeparator);
-}
-var ensureRegister = function() {
-  if (registered) {
-    return;
-  }
-  const installation = {
-    environment: "node",
-    retrieveFile(pathOrUrl) {
-      let path = pathOrUrl;
-      if (path.startsWith("file:")) {
-        try {
-          path = fileURLToPath(path);
-        } catch (e) {
-        }
-      }
-      path = normalizeSlashes(path);
-      return outputCache.get(path);
-    }
-  };
-  sourceMapSupport.install(installation);
-  return registered = true;
-};
 function resolve(specifier, context, next) {
   const { parentURL = baseURL } = context;
   if (extensionsRegex.test(specifier)) {
@@ -63,10 +33,8 @@ async function load(url, context, next) {
       // NOTE: Setting the source in the context makes it available when ts-node uses defaultLoad
       source: tsSource
     });
-    ensureRegister();
     result.responseURL = (result.responseURL ?? transpiledUrl).replace(/.tsx$/, "");
     result.source = SourceMap.remap(result.source, sourceMap, url, result.responseURL);
-    outputCache.set(normalizeSlashes(path), result.source);
     return result;
   }
   return next(url, context);