@danielx/civet 0.6.37 → 0.6.39

package/README.md

@@ -26,7 +26,7 @@ The modern way to write TypeScript.
   [Gulp](integration/gulp),
   [ESM module resolution](source/esm.civet),
   [CJS](register.js),
-  [Bun](source/bun-civet.coffee)
+  [Bun](source/bun-civet.civet)
 - Starter templates for [Solid](https://github.com/orenelbaum/solid-civet-template) and [Solid Start](https://github.com/orenelbaum/solid-start-civet-template)
 
 Quickstart Guide

package/dist/browser.js

@@ -7,7 +7,14 @@ var Civet = (() => {
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __commonJS = (cb, mod) => function __require() {
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw new Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
@@ -893,6 +900,28 @@ ${input.slice(result.pos)}
         }
         return expandedOps;
       }
+      function handleThisPrivateShorthands(value) {
+        if (value.privateShorthand) {
+          value = value.children[1].children[1];
+          return [value, false];
+        }
+        if (value.type === "MemberExpression" || value.type === "CallExpression") {
+          let suppressPrefix = value.thisShorthand;
+          value = {
+            ...value,
+            children: value.children.map((c, i) => {
+              if (i === 0) {
+                let s;
+                [c, s] = handleThisPrivateShorthands(c);
+                suppressPrefix || (suppressPrefix = s);
+              }
+              return c;
+            })
+          };
+          return [value, suppressPrefix];
+        }
+        return [value, value.thisShorthand];
+      }
       function processCallMemberExpression(node) {
         const { children } = node;
         for (let i = 0; i < children.length; i++) {
@@ -920,11 +949,15 @@ ${input.slice(result.pos)}
                 throw new Error("Glob pattern cannot have method definition");
               }
               if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
-                throw new Error("Glob pattern must have call or member expression value");
+                throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
               }
+              let suppressPrefix = false;
               let value = part.value ?? part.name;
               const wValue = getTrimmingSpace(part.value);
-              value = prefix.concat(insertTrimmingSpace(value, ""));
+              [value, suppressPrefix] = handleThisPrivateShorthands(value);
+              if (!suppressPrefix) {
+                value = prefix.concat(insertTrimmingSpace(value, ""));
+              }
               if (wValue)
                 value.unshift(wValue);
               if (part.type === "SpreadProperty") {
@@ -1138,14 +1171,14 @@ ${input.slice(result.pos)}
             chains.push(i);
           } else if (lowerPrecedenceOps.includes(op.token)) {
             processChains(op);
-            first = [];
+            first = void 0;
           }
           i++;
         }
         processChains(op);
         return results;
         function processChains(op2) {
-          if (isRelationalOp(op2)) {
+          if (first && isRelationalOp(op2)) {
             first = expandExistence(first);
           }
           if (chains.length > 1) {
@@ -1154,7 +1187,7 @@ ${input.slice(result.pos)}
                 results.push(" ", "&&", " ");
               }
               const binop = binops[index];
-              let [pre, op3, post, exp] = binop;
+              let [, , , exp] = binop;
               exp = binop[3] = expandExistence(exp);
               let endIndex;
               if (k < chains.length - 1) {
@@ -1167,10 +1200,13 @@ ${input.slice(result.pos)}
               return start = endIndex;
             });
           } else {
-            results.push(first, ...binops.slice(start, i + 1).flat());
+            if (first) {
+              results.push(first);
+            }
+            results.push(...binops.slice(start, i + 1).flat());
             start = i + 1;
           }
-          return chains.length = 0;
+          chains.length = 0;
         }
         function expandExistence(exp) {
           const existence = isExistence(exp);
@@ -1252,6 +1288,23 @@ ${input.slice(result.pos)}
           }
         }
       }
+      function replaceBlockExpression(node, child, replacement) {
+        let found = false;
+        const { expressions } = node;
+        for (let i = 0, l = expressions.length; i < l; i++) {
+          const statement = expressions[i];
+          const [, s] = statement;
+          if (s === child) {
+            statement[1] = replacement;
+            replacement.parent = node;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          throw new Error("Could not find child to replace");
+        }
+      }
       function findChildIndex(parent, child) {
         const children = Array.isArray(parent) ? parent : parent.children;
         const len = children.length;
@@ -2138,12 +2191,12 @@ ${input.slice(result.pos)}
       }
       function processDeclarationConditions(node) {
         gatherRecursiveAll(node, (n) => {
-          return n.type === "IfStatement" || n.type === "IterationStatement";
+          return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
         }).forEach(processDeclarationConditionStatement);
       }
       function processDeclarationConditionStatement(s) {
         const { condition } = s;
-        if (!condition) {
+        if (!condition?.expression) {
           return;
         }
         processDeclarationCondition(condition.expression);
@@ -2184,6 +2237,27 @@ ${input.slice(result.pos)}
             updateParentPointers(newBlock, s);
             break;
           }
+          case "SwitchStatement": {
+            const { blockPrefix, ref: ref2 } = condition.expression;
+            if (!blockPrefix) {
+              return;
+            }
+            s.condition = {
+              type: "ParenthesizedExpression",
+              children: ["(", ref2, ")"],
+              expression: ref2,
+              parent: s
+            };
+            s.children[1] = s.condition;
+            const block = blockWithPrefix([["", [{
+              type: "Declaration",
+              children: ["let ", ...condition.expression.children]
+            }], ";"], ...blockPrefix], makeEmptyBlock());
+            replaceBlockExpression(s.parent, s, block);
+            block.expressions.push(["", s]);
+            s.parent = block;
+            break;
+          }
         }
       }
       function implicitFunctionBlock(f) {
@@ -2632,12 +2706,12 @@ ${input.slice(result.pos)}
           }
           if (errors || !isPattern)
             return;
-          let { expression } = s;
-          if (expression.type === "ParenthesizedExpression") {
-            expression = expression.expression;
+          let { condition } = s;
+          if (condition.type === "ParenthesizedExpression") {
+            condition = condition.expression;
           }
-          let hoistDec, refAssignment = [], ref = maybeRef(expression, "m");
-          if (ref !== expression) {
+          let hoistDec, refAssignment = [], ref = maybeRef(condition, "m");
+          if (ref !== condition) {
             hoistDec = {
               type: "Declaration",
               children: ["let ", ref],
@@ -2645,7 +2719,7 @@ ${input.slice(result.pos)}
             };
             refAssignment = [{
               type: "AssignmentExpression",
-              children: [ref, " = ", expression]
+              children: [ref, " = ", condition]
             }, ","];
           }
           let prev = [], root = prev;
@@ -2673,7 +2747,7 @@ ${input.slice(result.pos)}
                 return conditionArray;
               return [" || ", ...conditionArray];
             });
-            const condition = {
+            const condition2 = {
               type: "ParenthesizedExpression",
               children: ["(", ...refAssignment, conditionExpression, ")"],
               expression: conditionExpression
@@ -2708,7 +2782,7 @@ ${input.slice(result.pos)}
               next.push("\n", "else ");
             prev.push(["", {
               type: "IfStatement",
-              children: ["if", condition, block, next],
+              children: ["if", condition2, block, next],
               then: block,
               else: next,
               hoistDec
@@ -5361,7 +5435,8 @@ ${input.slice(result.pos)}
             type: "PropertyAccess",
             name: id,
             children: [".", id]
-          }]
+          }],
+          thisShorthand: true
         };
       });
       var ThisLiteral$2 = AtThis;
@@ -5382,7 +5457,8 @@ ${input.slice(result.pos)}
             type: "PropertyAccess",
             name: id.name,
             children: [".", id]
-          }]
+          }],
+          privateShorthand: true
         };
       });
       var PrivateThis$$ = [PrivateThis$0, PrivateThis$1];
@@ -7050,7 +7126,7 @@ ${input.slice(result.pos)}
           names: exp.names
         };
       });
-      var ArrayElementExpression$2 = $TS($S($E($S($E($S(__, DotDotDot, __)), ExtendedExpression)), $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2) {
+      var ArrayElementExpression$2 = $TS($S($E($S($E($S(__, DotDotDot, __)), PostfixedExpression)), $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2) {
         var expMaybeSpread = $1;
         if (expMaybeSpread) {
           const [spread, exp] = expMaybeSpread;
@@ -7234,20 +7310,7 @@ ${input.slice(result.pos)}
       function ObjectPropertyDelimiter(ctx, state) {
         return $EVENT_C(ctx, state, "ObjectPropertyDelimiter", ObjectPropertyDelimiter$$);
       }
-      var PropertyDefinition$0 = $TS($S($E(_), AtThis, IdentifierReference), function($skip, $loc, $0, $1, $2, $3) {
-        var ws = $1;
-        var at = $2;
-        var id = $3;
-        const value = [at, ".", id];
-        return {
-          type: "Property",
-          children: [ws, id, ": ", ...value],
-          name: id,
-          names: id.names,
-          value
-        };
-      });
-      var PropertyDefinition$1 = $TS($S($E(_), NamedProperty), function($skip, $loc, $0, $1, $2) {
+      var PropertyDefinition$0 = $TS($S($E(_), NamedProperty), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var prop = $2;
         return {
@@ -7255,7 +7318,7 @@ ${input.slice(result.pos)}
           children: [ws, ...prop.children]
         };
       });
-      var PropertyDefinition$2 = $TS($S($E(_), $TEXT($EXPECT($R6, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R6, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var toggle = $2;
         var id = $3;
@@ -7268,7 +7331,7 @@ ${input.slice(result.pos)}
           value
         };
       });
-      var PropertyDefinition$3 = $TS($S($E(_), MethodDefinition), function($skip, $loc, $0, $1, $2) {
+      var PropertyDefinition$2 = $TS($S($E(_), MethodDefinition), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var def = $2;
         if (!def.block || def.block.empty)
@@ -7278,7 +7341,7 @@ ${input.slice(result.pos)}
           children: [ws, ...def.children]
         };
       });
-      var PropertyDefinition$4 = $TS($S($E(_), DotDotDot, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$3 = $TS($S($E(_), DotDotDot, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var dots = $2;
         var exp = $3;
@@ -7290,7 +7353,7 @@ ${input.slice(result.pos)}
           value: exp
         };
       });
-      var PropertyDefinition$5 = $TS($S($E(_), $N(EOS), CallExpression), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$4 = $TS($S($E(_), $N(EOS), CallExpression), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var value = $3;
         switch (value.type) {
@@ -7349,16 +7412,18 @@ ${input.slice(result.pos)}
           if (!name)
             return $skip;
         }
+        if (name[0] === "#")
+          name = name.slice(1);
         return {
           type: "Property",
           children: [ws, name, ": ", value],
           name,
-          value,
           names: [],
+          value,
           hoistDec
         };
       });
-      var PropertyDefinition$$ = [PropertyDefinition$0, PropertyDefinition$1, PropertyDefinition$2, PropertyDefinition$3, PropertyDefinition$4, PropertyDefinition$5];
+      var PropertyDefinition$$ = [PropertyDefinition$0, PropertyDefinition$1, PropertyDefinition$2, PropertyDefinition$3, PropertyDefinition$4];
       function PropertyDefinition(ctx, state) {
         return $EVENT_C(ctx, state, "PropertyDefinition", PropertyDefinition$$);
       }
@@ -8615,7 +8680,7 @@ ${input.slice(result.pos)}
           children: $0
         };
       });
-      var ForStatementParameters$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var ForStatementParameters$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         var declaration = $3;
         return {
           declaration,
@@ -8722,7 +8787,7 @@ ${input.slice(result.pos)}
         return {
           type: "SwitchStatement",
           children: $0,
-          expression: condition,
+          condition,
           caseBlock
         };
       });
@@ -13418,6 +13483,7 @@ ${input.slice(result.pos)}
     generate: () => generate_default,
     isCompileError: () => isCompileError,
     parse: () => parse,
+    prune: () => prune,
     util: () => util_exports
   });
   var import_parser = __toESM(require_parser());
@@ -13585,7 +13651,10 @@ ${input.slice(result.pos)}
           sources: [srcFileName],
           mappings: this.renderMappings(),
           names: [],
-          sourcesContent: [sourceString]
+          sourcesContent: [sourceString],
+          toString: function() {
+            return JSON.stringify(this);
+          }
         };
       },
       updateSourceMap: function(outputStr, inputPos) {
@@ -13929,15 +13998,55 @@ ${input.slice(result.pos)}
     if (filename.endsWith(".coffee") && !/^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test(src)) {
       options.parseOptions.coffeeCompat = true;
     }
+    ;
+    const { hits, trace, noCache } = options;
     let events;
-    if (!options.noCache) {
-      events = makeCache();
+    if (!noCache) {
+      events = makeCache({
+        hits: !!hits,
+        trace: !!trace
+      });
+    }
+    let ast;
+    try {
+      parse.config = options.parseOptions || {};
+      ast = prune(parse(src, {
+        filename,
+        events
+      }));
+    } finally {
+      if (hits || trace) {
+        import("fs").then(function({ writeFileSync }) {
+          let ref;
+          if ((ref = events?.meta) && "logs" in ref) {
+            const { logs } = ref;
+            if (trace) {
+              writeFileSync(trace, logs.join("\n"));
+            }
+          }
+          if (hits) {
+            let ref1;
+            if (ref1 = events?.meta.hits) {
+              const hitData = ref1;
+              let total = 0;
+              const data = [...hitData.entries()];
+              const counts = data.sort(([, a], [, b]) => b - a).map(([k, v]) => {
+                total += v;
+                return `${k}: ${v}`;
+              }).join("\n");
+              const hitSummary = `Total: ${total}
+
+${counts}`;
+              return writeFileSync(hits, hitSummary);
+            }
+            ;
+            return;
+          }
+          ;
+          return;
+        });
+      }
     }
-    parse.config = options.parseOptions || {};
-    const ast = prune(parse(src, {
-      filename,
-      events
-    }));
     if (options.ast) {
       return ast;
     }
@@ -13960,22 +14069,45 @@ ${input.slice(result.pos)}
     }
     return result;
   }
-  function makeCache() {
+  function makeCache({ hits, trace } = {}) {
+    const meta = {};
+    let hitCount;
+    if (hits) {
+      hitCount = /* @__PURE__ */ new Map();
+      meta.hits = hitCount;
+    }
+    let logs;
+    if (trace) {
+      logs = [];
+      meta.logs = logs;
+    }
     const stateCache = new StateCache();
     let getStateKey = null;
+    const stack = [];
     const events = {
+      meta,
       enter: function(ruleName, state) {
+        if (hits) {
+          hitCount.set(ruleName, (hitCount.get(ruleName) || 0) + 1);
+        }
         if (uncacheable.has(ruleName)) {
           return;
         }
         ;
         const key = [ruleName, state.pos, ...getStateKey()];
         if (stateCache.has(key)) {
+          if (trace) {
+            logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u{1F4B0}");
+          }
           const result = stateCache.get(key);
           return {
             cache: result ? { ...result } : void 0
           };
         }
+        if (trace) {
+          logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u2192");
+          stack.push(ruleName);
+        }
         return;
       },
       exit: function(ruleName, state, result) {
@@ -13993,6 +14125,10 @@ ${input.slice(result.pos)}
         if (parse.config.verbose && result) {
           console.log(`Parsed ${JSON.stringify(state.input.slice(state.pos, result.pos))} [pos ${state.pos}-${result.pos}] as ${ruleName}`);
         }
+        if (trace) {
+          stack.pop();
+          logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + " " + (result ? "\u2705" : "\u274C"));
+        }
         return;
       }
     };

package/dist/civet

@@ -1,20 +1,39 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // source/cli.civet
 var import_main = require("./main.js");
 var import_config = require("./config.js");
-var prune;
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
 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;
 };
@@ -60,9 +79,7 @@ if (process.argv.includes("--help")) {
 `);
   process.exit(0);
 }
-encoding = "utf8";
-fs = require("fs/promises");
-path = require("path");
+var encoding = "utf8";
 parseArgs = function(args) {
   var options, filenames, scriptArgs, i, endOfArgs, arg;
   options = {};
@@ -136,6 +153,14 @@ parseArgs = function(args) {
         options.js = true;
         break;
       }
+      case "--hits": {
+        options.hits = args[++i];
+        break;
+      }
+      case "--trace": {
+        options.trace = args[++i];
+        break;
+      }
       case "--": {
         endOfArgs(++i);
         break;
@@ -167,7 +192,7 @@ readFiles = async function* (filenames, options) {
         process.stdin.setEncoding(encoding);
         filename = "<stdin>";
         try {
-          filename = await fs.realpath("/dev/stdin");
+          filename = await import_promises.default.realpath("/dev/stdin");
         } catch (e) {
         }
         if (process.stdin.isTTY) {
@@ -196,7 +221,7 @@ readFiles = async function* (filenames, options) {
           })()).join("");
         }
       } else {
-        content = await fs.readFile(filename, { encoding });
+        content = await import_promises.default.readFile(filename, { encoding });
       }
       results1.push(yield { filename, content, stdin });
     } catch (error) {
@@ -284,7 +309,7 @@ repl = function(options) {
   });
 };
 cli = async function() {
-  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, child;
+  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)));
   if (options.config !== false) {
@@ -330,7 +355,7 @@ cli = async function() {
       if (stdin && !options.output || options.output === "-") {
         results3.push(process.stdout.write(output));
       } else {
-        outputPath = path.parse(filename);
+        outputPath = import_path.default.parse(filename);
         delete outputPath.base;
         if (options.js) {
           outputPath.ext += ".jsx";
@@ -338,13 +363,13 @@ cli = async function() {
           outputPath.ext += ".tsx";
         }
         if (options.output) {
-          optionsPath = path.parse(options.output);
+          optionsPath = import_path.default.parse(options.output);
           try {
-            stat = await fs.stat(options.output);
+            stat = await import_promises.default.stat(options.output);
           } catch {
             stat = null;
           }
-          if (stat?.isDirectory() || options.output.endsWith(path.sep) || options.output.endsWith("/")) {
+          if (stat?.isDirectory() || options.output.endsWith(import_path.default.sep) || options.output.endsWith("/")) {
             outputPath.dir = options.output;
           } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
             outputPath.ext = optionsPath.base;
@@ -356,11 +381,11 @@ cli = async function() {
           }
         }
         if (outputPath.dir) {
-          fs.mkdir(outputPath.dir, { recursive: true });
+          import_promises.default.mkdir(outputPath.dir, { recursive: true });
         }
-        outputFilename = path.format(outputPath);
+        outputFilename = import_path.default.format(outputPath);
         try {
-          results3.push(await fs.writeFile(outputFilename, output));
+          results3.push(await import_promises.default.writeFile(outputFilename, output));
         } catch (error2) {
           console.error(`${outputFilename} failed to write:`);
           results3.push(console.error(error2));
@@ -372,32 +397,45 @@ cli = async function() {
         if (stdin) {
           filename = `.stdin-${process.pid}.civet`;
           try {
-            await fs.writeFile(filename, content, { encoding });
+            await import_promises.default.writeFile(filename, content, { encoding });
           } 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" });
-        if (stdin) {
-          await fs.unlink(filename);
+        ;
+        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);
+        if (process.env.NODE_OPTIONS) {
+          execArgv.push(process.env.NODE_OPTIONS);
         }
-        results3.push(process.exit(child.status));
+        if (isDebug) {
+          execArgv.push("--inspect=" + (process.debugPort + 1));
+        }
+        child = fork(filename, [
+          ...scriptArgs
+        ], {
+          execArgv,
+          stdio: "inherit"
+        });
+        results3.push(child.on("exit", async function(code) {
+          if (stdin) {
+            await import_promises.default.unlink(filename);
+          }
+          return process.exit(code ?? 1);
+        }));
       } else {
         require("../register.js");
         try {
-          module.filename = await fs.realpath(filename);
+          module.filename = await import_promises.default.realpath(filename);
         } catch {
           module.filename = filename;
         }
         process.argv = ["civet", module.filename, ...scriptArgs];
-        module.paths = require("module")._nodeModulePaths(path.dirname(module.filename));
+        module.paths = require("module")._nodeModulePaths(import_path.default.dirname(module.filename));
         try {
           results3.push(module._compile(output, module.filename));
         } catch (error2) {

package/dist/config.js

@@ -84,7 +84,7 @@ async function loadConfig(path2) {
     const js = (0, import_main.compile)(config, { js: true });
     let exports;
     try {
-      exports = await import(`data:text/javascript,${js}`);
+      exports = await import(`data:text/javascript,${encodeURIComponent(js)}`);
     } catch (e) {
       console.error("Error loading config file", path2, e);
     }