@danielx/civet 0.7.16 → 0.7.18

package/README.md

@@ -16,13 +16,14 @@ The modern way to write TypeScript.
 - [Civet VSCode Extension](https://marketplace.visualstudio.com/items?itemName=DanielX.civet)
 - [Discord Server](https://discord.gg/xkrW9GebBc)
 - Plugins for
-  [Vite, esbuild, Astro, Rollup, Webpack, Rspack](integration/unplugin)
+  [Vite, esbuild, Astro, Rollup, Webpack, Rspack](source/unplugin),
   <!--
   [esbuild](source/esbuild-plugin.civet),
   [Vite](https://github.com/edemaine/vite-plugin-civet),
   -->
   [ESM/CJS loader](source/esm.civet),
   [Babel](source/babel-plugin.mjs),
+  [Jest](https://github.com/DanielXMoore/Civet/blob/main/integration/jest),
   [Gulp](integration/gulp),
   [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)

package/dist/browser.js

@@ -5653,6 +5653,7 @@ ${js}`
             }
           }
         }
+        const refsToDeclare = /* @__PURE__ */ new Set();
         i = len3 - 1;
         while (i >= 0) {
           const lastAssignment = $1[i];
@@ -5686,6 +5687,7 @@ ${js}`
               }
             } else if (m2 = lhs.type, m2 === "ObjectBindingPattern" || m2 === "ArrayBindingPattern") {
               processBindingPatternLHS(lhs, tail);
+              gatherRecursiveAll(lhs, ($5) => $5.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare));
             }
           }
           i--;
@@ -5716,6 +5718,17 @@ ${js}`
           }
           i--;
         }
+        if (refsToDeclare.size) {
+          if (exp.hoistDec) {
+            exp.hoistDec.children.push([...refsToDeclare].map(($6) => [",", $6]));
+          } else {
+            exp.hoistDec = {
+              type: "Declaration",
+              children: ["let ", [...refsToDeclare].map((r, i2) => i2 ? [",", r] : r)],
+              names: []
+            };
+          }
+        }
         exp.names = $1.flatMap(([, l]) => l.names || []);
         if (tail.length) {
           const index = exp.children.indexOf($2);
@@ -5852,7 +5865,7 @@ ${js}`
     });
   }
   function processStatementExpressions(statements) {
-    gatherRecursiveAll(statements, ($5) => $5.type === "StatementExpression").forEach((_exp) => {
+    gatherRecursiveAll(statements, ($7) => $7.type === "StatementExpression").forEach((_exp) => {
       const exp = _exp;
       const { statement } = exp;
       let ref11;
@@ -5982,11 +5995,11 @@ ${js}`
   function processPlaceholders(statements) {
     const placeholderMap = /* @__PURE__ */ new Map();
     const liftedIfs = /* @__PURE__ */ new Set();
-    gatherRecursiveAll(statements, ($6) => $6.type === "Placeholder").forEach((_exp) => {
+    gatherRecursiveAll(statements, ($8) => $8.type === "Placeholder").forEach((_exp) => {
       const exp = _exp;
       let ancestor;
       if (exp.subtype === ".") {
-        ({ ancestor } = findAncestor(exp, ($7) => $7.type === "Call"));
+        ({ ancestor } = findAncestor(exp, ($9) => $9.type === "Call"));
         ancestor = ancestor?.parent;
         while (ancestor?.parent?.type === "UnaryExpression" || ancestor?.parent?.type === "NewExpression") {
           ancestor = ancestor.parent;
@@ -7108,8 +7121,8 @@ ${js}`
   var $L61 = (0, import_lib3.$L)("?=");
   var $L62 = (0, import_lib3.$L)("and=");
   var $L63 = (0, import_lib3.$L)("or=");
-  var $L64 = (0, import_lib3.$L)("**");
-  var $L65 = (0, import_lib3.$L)("*");
+  var $L64 = (0, import_lib3.$L)("*");
+  var $L65 = (0, import_lib3.$L)("**");
   var $L66 = (0, import_lib3.$L)("/");
   var $L67 = (0, import_lib3.$L)("%%");
   var $L68 = (0, import_lib3.$L)("%");
@@ -8147,13 +8160,15 @@ ${js}`
   function TernaryRest(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "TernaryRest", TernaryRest$$);
   }
-  var NestedTernaryRest$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(PushIndent, (0, import_lib3.$E)((0, import_lib3.$S)(Nested, QuestionMark, MaybeNestedExtendedExpression, Nested, Colon, MaybeNestedExtendedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+  var NestedTernaryRest$0 = (0, import_lib3.$S)(Nested, QuestionMark, MaybeNestedExtendedExpression, Nested, Colon, MaybeNestedExtendedExpression);
+  var NestedTernaryRest$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(PushIndent, (0, import_lib3.$E)((0, import_lib3.$S)(Nested, QuestionMark, MaybeNestedExtendedExpression, Nested, Colon, MaybeNestedExtendedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
     if ($2)
       return $2;
     return $skip;
   });
+  var NestedTernaryRest$$ = [NestedTernaryRest$0, NestedTernaryRest$1];
   function NestedTernaryRest(ctx, state2) {
-    return (0, import_lib3.$EVENT)(ctx, state2, "NestedTernaryRest", NestedTernaryRest$0);
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "NestedTernaryRest", NestedTernaryRest$$);
   }
   var ShortCircuitExpression$0 = BinaryOpExpression;
   function ShortCircuitExpression(ctx, state2) {
@@ -11501,11 +11516,12 @@ ${js}`
       ws.push(...$2);
     return [ws, $3];
   });
-  var NotDedentedBinaryOp$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Nested, (0, import_lib3.$E)(_), (0, import_lib3.$N)(Identifier), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var NotDedentedBinaryOp$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Nested, (0, import_lib3.$E)(_), (0, import_lib3.$N)(Identifier), (0, import_lib3.$C)((0, import_lib3.$N)((0, import_lib3.$EXPECT)($L64, 'NotDedentedBinaryOp "*"')), (0, import_lib3.$N)(ImportDeclaration)), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var op = $5;
     const ws = [...$1];
     if ($2)
       ws.push(...$2);
-    return [ws, $4];
+    return [ws, op];
   });
   var NotDedentedBinaryOp$$ = [NotDedentedBinaryOp$0, NotDedentedBinaryOp$1];
   function NotDedentedBinaryOp(ctx, state2) {
@@ -11559,8 +11575,8 @@ ${js}`
   function _BinaryOp(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "_BinaryOp", _BinaryOp$$);
   }
-  var BinaryOpSymbol$0 = (0, import_lib3.$EXPECT)($L64, 'BinaryOpSymbol "**"');
-  var BinaryOpSymbol$1 = (0, import_lib3.$EXPECT)($L65, 'BinaryOpSymbol "*"');
+  var BinaryOpSymbol$0 = (0, import_lib3.$EXPECT)($L65, 'BinaryOpSymbol "**"');
+  var BinaryOpSymbol$1 = (0, import_lib3.$EXPECT)($L64, 'BinaryOpSymbol "*"');
   var BinaryOpSymbol$2 = (0, import_lib3.$EXPECT)($L66, 'BinaryOpSymbol "/"');
   var BinaryOpSymbol$3 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L67, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
     return {
@@ -14495,7 +14511,7 @@ ${js}`
   function SingleQuote(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "SingleQuote", SingleQuote$0);
   }
-  var Star$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L65, 'Star "*"'), function($skip, $loc, $0, $1) {
+  var Star$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L64, 'Star "*"'), function($skip, $loc, $0, $1) {
     return { $loc, token: $1 };
   });
   function Star(ctx, state2) {

package/dist/civet

@@ -39,68 +39,34 @@ __export(cli_exports, {
 module.exports = __toCommonJS(cli_exports);
 var import_main = require("./main.js");
 var import_config = require("./config.js");
-var import_unplugin = require("./unplugin");
+var import_unplugin = require("./unplugin/unplugin.js");
 var import_promises = __toESM(require("node:fs/promises"));
 var import_node_path = __toESM(require("node:path"));
+var import_meta = {};
 var unplugin;
-function version() {
-  return require("../package.json").version;
-}
-if (process.argv.some((a) => a === "--version" || a === "-version" || a === "-v")) {
-  console.log(version());
-  process.exit(0);
-}
-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    (,-.\`._,'(       |\\\`-/|
-      \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:
-
-    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 .)
-  --civet XX       Specify civet compiler flag, as in "civet XX" prologue
-  --comptime       Enable execution of code during compilation via comptime
-  --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)
-  --typecheck      Run TypeScript and output diagnostics
-  --emit-declaration  Run TypeScript and emit .d.ts files (if no errors)
-
-You can use - to read from stdin or (prefixed by -o) write to stdout.
-
-By default, .civet imports get rewritten to use the output extension.
-You can override this behavior via: --civet rewriteCivetImports=.ext
-
-`);
-  process.exit(0);
+async function version() {
+  if (import_meta.url) {
+    const { createRequire } = await import("node:module");
+    return createRequire(import_meta.url)("../package.json").version;
+  } else {
+    return require("../package.json").version;
+  }
 }
 var encoding = "utf8";
-function parseArgs(args) {
+async function parseArgs(args, isTTY = process.stdin.isTTY) {
   const options = {};
   const isRun = () => !(options.ast || options.compile || options.typecheck || options.emitDeclaration);
   let filenames = [];
   let scriptArgs = [];
+  if (args.includes("-version")) {
+    options.version = true;
+  }
+  if (args.includes("-help")) {
+    options.help = true;
+  }
+  if (options.version || options.help) {
+    return { filenames, scriptArgs, options };
+  }
   let i = 0;
   let errors = 0;
   function endOfArgs(j) {
@@ -128,6 +94,16 @@ function parseArgs(args) {
       continue;
     }
     switch (arg) {
+      case "-v":
+      case "--version": {
+        options.version = true;
+        break;
+      }
+      case "-h":
+      case "--help": {
+        options.help = true;
+        break;
+      }
       case "-c":
       case "--compile": {
         options.compile = true;
@@ -150,7 +126,13 @@ function parseArgs(args) {
         Object.assign(
           options.parseOptions ??= {},
           (0, import_main.parse)(`civet ${args[++i]}`, {
-            startRule: "CivetPrologueContent"
+            startRule: "CivetPrologueContent",
+            filename: "--civet argument",
+            events: {
+              // remove cache in case we've compiled Civet before
+              enter: void 0,
+              exit: void 0
+            }
           }).config
         );
         break;
@@ -213,9 +195,11 @@ function parseArgs(args) {
     }
     i++;
   }
-  options.typescript = Boolean(options.typecheck || options.emitDeclaration);
+  if (options.typecheck || options.emitDeclaration) {
+    options.typescript = true;
+  }
   if (!(filenames.length || options.typescript)) {
-    if (process.stdin.isTTY) {
+    if (isTTY) {
       options.repl = true;
     } else {
       options.compile = true;
@@ -223,6 +207,28 @@ function parseArgs(args) {
       filenames = ["-"];
     }
   }
+  if (options.output && options.output !== "-") {
+    const optionsPath = import_node_path.default.parse(options.output);
+    let stat;
+    try {
+      stat = await import_promises.default.stat(options.output);
+    } catch {
+      stat = null;
+    }
+    if (stat?.isDirectory() || options.output.endsWith(import_node_path.default.sep) || options.output.endsWith("/")) {
+      options.outputDir = options.output;
+    } else if (/^(\.[^]+)+$/.test(optionsPath.base)) {
+      options.outputExt = optionsPath.base;
+      if (optionsPath.dir) {
+        options.outputDir = optionsPath.dir;
+      }
+    } else {
+      options.outputPath = optionsPath;
+      options.outputExt = optionsPath.ext;
+    }
+  }
+  ;
+  (options.parseOptions ??= {}).rewriteCivetImports ??= options.outputExt ?? ".civet.jsx";
   if (errors) {
     process.exit(Math.min(255, errors));
   }
@@ -275,7 +281,7 @@ async function* readFiles(filenames) {
   ;
   return results1;
 }
-async function repl(options) {
+async function repl(args, options) {
   const vm = await import("node:vm");
   let importModuleDynamically = vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER;
   if (!importModuleDynamically) {
@@ -294,15 +300,15 @@ async function repl(options) {
         execArgv.push(process.env.NODE_OPTIONS);
       }
       const { fork } = await import("node:child_process");
-      fork(__filename, process.argv.slice(2), {
+      fork(__filename, args, {
         execArgv,
         stdio: "inherit"
       });
       return;
     }
   }
-  require("../register.js");
-  console.log(`Civet ${version()} REPL.  Enter a blank line to ${(() => {
+  await import("../register.js");
+  console.log(`Civet ${await version()} REPL.  Enter a blank line to ${(() => {
     switch (false) {
       case !options.ast: {
         return "parse";
@@ -391,7 +397,10 @@ ${" ".repeat(error.column - 1)}^ ${error.header}`);
         }
         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 [prologue, rest] = (0, import_main.parse)(input, {
+            startRule: "ProloguePrefix",
+            filename: "--civet argument"
+          });
           const prefix = input.slice(0, -rest.length);
           const coffee = prologue.some((p) => p.type === "CivetPrologue" && (p.config.coffeeCompat || p.config.coffeeDo));
           ast = await (0, import_main.compile)(
@@ -452,17 +461,72 @@ ${" ".repeat(error.column - 1)}^ ${error.header}`);
   });
   return r;
 }
-async function cli() {
-  const argv = process.argv;
-  let { filenames, scriptArgs, options } = parseArgs(argv.slice(2));
+async function cli(args = process.argv.slice(2)) {
+  let { filenames, scriptArgs, options } = await parseArgs(args);
+  if (options.version) {
+    console.log(await version());
+    process.exit(0);
+  }
+  if (options.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               \`-    \\\`_\`"'-
+
+
+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
+
+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 .)
+  --civet XX       Specify civet compiler flag, as in "civet XX" prologue
+  --comptime       Enable execution of code during compilation via comptime
+  --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)
+  --typecheck      Run TypeScript and output diagnostics
+  --emit-declaration  Run TypeScript and emit .d.ts files (if no errors)
+
+You can use - to read from stdin or (prefixed by -o) write to stdout.
+
+By default, .civet imports get rewritten to use the output extension.
+You can override this behavior via: --civet rewriteCivetImports=.ext
+
+`);
+    process.exit(0);
+  }
   if (options.config !== false) {
     options.config ??= await (0, import_config.findConfig)(process.cwd());
   }
   if (options.config) {
+    const parsed = await (0, import_config.loadConfig)(options.config);
     options = {
-      ...await (0, import_config.loadConfig)(options.config),
+      ...parsed,
       ...options
     };
+    if (parsed.parseOptions && options.parseOptions) {
+      options.parseOptions = {
+        ...parsed.parseOptions,
+        ...options.parseOptions
+      };
+    }
   }
   if (options.typescript) {
     const unpluginOptions = {
@@ -479,30 +543,7 @@ async function cli() {
     options.inlineMap = true;
   }
   if (options.repl) {
-    return repl(options);
-  }
-  let outputDir, outputExt, outputPath;
-  if (options.output) {
-    const optionsPath = import_node_path.default.parse(options.output);
-    let stat;
-    try {
-      stat = await import_promises.default.stat(options.output);
-    } catch {
-      stat = null;
-    }
-    if (stat?.isDirectory() || options.output.endsWith(import_node_path.default.sep) || options.output.endsWith("/")) {
-      outputDir = options.output;
-    } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
-      outputExt = optionsPath.base;
-      if (optionsPath.dir) {
-        outputDir = optionsPath.dir;
-      }
-    } else {
-      outputPath = optionsPath;
-    }
-    if (options.output !== "-") {
-      (options.parseOptions ??= {}).rewriteCivetImports ??= outputExt ?? ".civet" + (options.js ? ".jsx" : ".tsx");
-    }
+    return repl(args, options);
   }
   let errors = 0;
   for await (const { filename, error, content, stdin } of readFiles(filenames)) {
@@ -549,14 +590,14 @@ async function cli() {
         } else {
           targetPath.ext += ".tsx";
         }
-        if (outputDir != null) {
-          targetPath.dir = outputDir;
+        if (options.outputDir != null) {
+          targetPath.dir = options.outputDir;
         }
-        if (outputExt != null) {
-          targetPath.ext = outputExt;
+        if (options.outputExt != null) {
+          targetPath.ext = options.outputExt;
         }
-        if (outputPath != null) {
-          targetPath = outputPath;
+        if (options.outputPath != null) {
+          targetPath = options.outputPath;
         }
         if (targetPath.dir) {
           await import_promises.default.mkdir(targetPath.dir, { recursive: true });
@@ -619,14 +660,14 @@ async function cli() {
           return process.exit(code ?? 1);
         });
       } else {
-        require("../register.js");
+        await import("../register.js");
         try {
           module.filename = await import_promises.default.realpath(filename);
         } catch {
           module.filename = filename;
         }
         process.argv = ["civet", module.filename, ...scriptArgs];
-        module.paths = require("module")._nodeModulePaths(import_node_path.default.dirname(module.filename));
+        module.paths = (await import("node:module"))._nodeModulePaths(import_node_path.default.dirname(module.filename));
         try {
           module._compile(output, module.filename);
         } catch (error2) {
@@ -659,9 +700,6 @@ async function cli() {
   ;
   return;
 }
-if (require.main === module) {
-  cli();
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   cli,
@@ -669,3 +707,4 @@ if (require.main === module) {
   repl,
   version
 });
+cli()

package/dist/config.d.mts

@@ -0,0 +1 @@
+/// <reference path="./types.d.ts" />

package/dist/config.d.ts

@@ -0,0 +1 @@
+/// <reference path="./types.d.ts" />

package/dist/config.mjs

@@ -0,0 +1,122 @@
+// source/config.civet
+import path from "path";
+import fs from "fs/promises";
+import { compile } from "./main.mjs";
+var configNames = [
+  "\u{1F408}",
+  "civetconfig",
+  "civet.config",
+  "package"
+];
+var configExtensions = [
+  ".civet",
+  ".js",
+  ".yaml",
+  ".yml",
+  ".json"
+];
+var configDir = ".config";
+async function findInDir(dirPath) {
+  const entries = new Set(await fs.readdir(dirPath));
+  const pathFor = (name) => path.join(dirPath, name);
+  if (entries.has(configDir) && await (async () => {
+    try {
+      return (await fs.stat(pathFor(configDir))).isDirectory();
+    } catch (e) {
+      return;
+    }
+  })()) {
+    const found = await findInDir(pathFor(configDir));
+    if (found) {
+      return found;
+    }
+  }
+  for (let i = 0, len = configNames.length; i < len; i++) {
+    const configName = configNames[i];
+    for (let i1 = 0, len1 = configExtensions.length; i1 < len1; i1++) {
+      const extension = configExtensions[i1];
+      for (let ref = ["." + configName + extension, configName + extension], i2 = 0, len2 = ref.length; i2 < len2; i2++) {
+        const entry = ref[i2];
+        if (entries.has(entry) && await (async () => {
+          try {
+            return (await fs.stat(pathFor(entry))).isFile();
+          } catch (e) {
+            return;
+          }
+        })()) {
+          return pathFor(entry);
+        }
+      }
+    }
+  }
+  return;
+}
+async function findConfig(startDir) {
+  let curr = startDir;
+  let parent = path.dirname(curr);
+  while (curr !== parent) {
+    const configPath = await findInDir(curr);
+    if (configPath) {
+      return configPath;
+    }
+    curr = parent;
+    parent = path.dirname(curr);
+  }
+  return;
+}
+async function loadConfig(pathname) {
+  const config = await fs.readFile(pathname, "utf8");
+  let data = {};
+  if (pathname.endsWith(".json")) {
+    let json;
+    try {
+      json = JSON.parse(config);
+    } catch (e) {
+      throw new Error(`Error parsing JSON config file ${pathname}: ${e}`);
+    }
+    if ("civetConfig" in json) {
+      data = json.civetConfig;
+    } else if (path.basename(pathname).startsWith("package")) {
+      return {};
+    } else {
+      data = json;
+    }
+  } else if (/\.ya?ml$/.test(pathname)) {
+    try {
+      const { default: YAML } = await import("yaml");
+      const yaml = YAML.parse(config);
+      data = yaml.civetConfig ?? yaml;
+    } catch (e) {
+      throw new Error(`Error parsing YAML config file ${pathname}: ${e}`);
+    }
+  } else {
+    let js;
+    if (pathname.endsWith(".civet")) {
+      try {
+        js = await compile(config, {
+          js: true
+        });
+      } catch (e) {
+        throw new Error(`Error compiling Civet config file ${pathname}: ${e}`);
+      }
+    } else {
+      js = config;
+    }
+    try {
+      const exports = await import(`data:text/javascript,${encodeURIComponent(js)}`);
+      data = exports?.default;
+    } catch (e) {
+      throw new Error(`Error running Civet config file ${pathname}: ${e}`);
+    }
+  }
+  if (!(data != null && typeof data === "object" && !Array.isArray(data))) {
+    throw new Error(`Civet config file must export an object, not ${Array.isArray(data) ? "array" : data != null ? typeof data : "null"}`);
+  }
+  delete data?.parseOptions?.comptime;
+  return data;
+}
+export {
+  findConfig,
+  findInDir,
+  loadConfig
+};

package/dist/esm.mjs

@@ -1,7 +1,7 @@
 // source/esm.civet
 import { readFileSync } from "fs";
 import { pathToFileURL, fileURLToPath } from "url";
-import Civet from "./main.js";
+import Civet from "./main.mjs";
 var { compile, SourceMap } = Civet;
 var baseURL = pathToFileURL(process.cwd() + "/").href;
 var extensionsRegex = /\.civet$/;