@cristianormazabal/triton-latex 0.1.13 → 0.1.15

package/README.md

@@ -104,6 +104,8 @@ by any character (here `|`) and an optional `\includegraphics` key list:
 | `\tritonsetup{<opts>}` | Default `\includegraphics` options (default `width=\linewidth`). |
 | `\tritoncli{<cmd>}` | CLI invocation (default `triton-latex`). |
 | `\tritontheme{<name>}` | Theme preset passed to the CLI for inline renders. |
+| `\tritonthemefile{<path>}` | Load an external `.triton-theme.json` by file path. |
+| `\tritonthemesdir{<dir>}` | Scan a directory for `*.triton-theme.json` files. |
 | `\tritonscale{<n>}` | Scale passed to the CLI (default `1`). |
 | `\tritoncachedir{<dir>}` | Render cache directory (default `\jobname.triton-cache`). |
 | `\triton[<opts>]{<name>}` | **Precompile fallback:** `\includegraphics` of `<dir>/<name>.pdf`. |
@@ -148,6 +150,49 @@ node dist/cli.cjs render diagram.mmd -o out.pdf --theme executive --scale 2
 
 Installed as the `triton-latex` bin when the package is linked.
 
+## External themes
+
+Use a `.triton-theme.json` file to apply a custom colour palette and typography
+to every inline diagram in your document.
+
+### `.sty` macros
+
+```latex
+\tritonthemefile{.triton/themes/my-brand.triton-theme.json}
+% — OR —
+\tritonthemesdir{.triton/themes}   % scan a directory, then use \tritontheme{name}
+```
+
+`\tritonthemefile{<path>}` passes `--theme-file <path>` to the CLI for every
+inline `\begin{triton}` render in the document. `\tritonthemesdir{<dir>}` passes
+`--themes-dir <dir>`; combine it with `\tritontheme{<name>}` to select a theme by
+name from the discovered registry.
+
+### CLI flags
+
+```sh
+# Load a specific theme file
+node dist/cli.cjs render diagram.mmd -o out.pdf \
+  --theme-file .triton/themes/my-brand.triton-theme.json
+
+# Scan a directory and select by name
+node dist/cli.cjs render diagram.mmd -o out.pdf \
+  --themes-dir .triton/themes --theme my-brand
+```
+
+### ⚠️ Cache caveat
+
+The cache key includes the theme-file **path**, not its **content**. After editing
+a `.triton-theme.json` in place, clear the cache before recompiling:
+
+```sh
+latexmk -C          # preferred
+rm -r <jobname>.triton-cache  # or manually
+```
+
+See [docs/external-themes.md](../docs/external-themes.md) for the full format
+reference, field list, built-in preset names, and cross-host worked example.
+
 ## Overleaf / no-shell-escape fallback
 
 Overleaf (and any compile with shell-escape disabled) can't run the CLI, so render

package/dist/cli.cjs

@@ -24,8 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_node_url = require("node:url");
 
 // ../src/contracts/animations.ts
 var CONNECTOR_ANIMATIONS = [
@@ -44097,6 +44098,211 @@ var svgRenderer = {
   render: renderSVG
 };
 
+// ../src/theme/validate.ts
+function isBuiltinThemeName(name) {
+  return themePresetNames.includes(name);
+}
+var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "base",
+  "palette",
+  "typography",
+  "spacing",
+  "edges",
+  "panel"
+]);
+var PALETTE_KEYS = /* @__PURE__ */ new Set([
+  "primary",
+  "secondary",
+  "background",
+  "surface",
+  "border",
+  "text",
+  "textMuted",
+  "success",
+  "warning",
+  "error"
+]);
+var TYPOGRAPHY_KEYS = /* @__PURE__ */ new Set([
+  "fontFamily",
+  "monoFamily",
+  "baseFontSize",
+  "titleFontSize",
+  "smallFontSize",
+  "lineHeight"
+]);
+var SPACING_KEYS = /* @__PURE__ */ new Set([
+  "unit",
+  "nodePadding",
+  "nodeGap",
+  "diagramMargin"
+]);
+var EDGES_KEYS = /* @__PURE__ */ new Set([
+  "strokeWidth",
+  "arrowSize",
+  "labelFontSize",
+  "curveTension"
+]);
+var PANEL_KEYS = /* @__PURE__ */ new Set([
+  "titleAlign",
+  "titlePosition",
+  "titleChrome"
+]);
+var HEX_COLOR = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var SLUG = /^[a-z0-9-]+$/;
+var CSS_INJECTION = /url\s*\(|expression\s*\(/i;
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function fail(message) {
+  return err("THEME_VALIDATION_ERROR", message);
+}
+function validatePalette(obj) {
+  if (!isPlainObject(obj)) return fail('"palette" must be a plain object');
+  for (const key of Object.keys(obj)) {
+    if (!PALETTE_KEYS.has(key)) return fail(`Unknown key in palette: "${key}"`);
+  }
+  for (const key of Object.keys(obj)) {
+    const val = obj[key];
+    if (typeof val !== "string" || !HEX_COLOR.test(val)) {
+      return fail(`palette.${key} must be a CSS hex color (e.g. "#RGB" or "#RRGGBB"), got ${JSON.stringify(val)}`);
+    }
+  }
+  return ok(obj);
+}
+function validateTypography(obj) {
+  if (!isPlainObject(obj)) return fail('"typography" must be a plain object');
+  for (const key of Object.keys(obj)) {
+    if (!TYPOGRAPHY_KEYS.has(key)) return fail(`Unknown key in typography: "${key}"`);
+  }
+  const stringFields = ["fontFamily", "monoFamily"];
+  for (const key of stringFields) {
+    if (key in obj) {
+      const val = obj[key];
+      if (typeof val !== "string") return fail(`typography.${key} must be a string`);
+      if (CSS_INJECTION.test(val)) return fail(`typography.${key} contains disallowed CSS expression`);
+    }
+  }
+  const positiveFields = ["baseFontSize", "titleFontSize", "smallFontSize", "lineHeight"];
+  for (const key of positiveFields) {
+    if (key in obj) {
+      const val = obj[key];
+      if (typeof val !== "number" || val <= 0) {
+        return fail(`typography.${key} must be a positive number, got ${JSON.stringify(val)}`);
+      }
+    }
+  }
+  return ok(obj);
+}
+function validateSpacing(obj) {
+  if (!isPlainObject(obj)) return fail('"spacing" must be a plain object');
+  for (const key of Object.keys(obj)) {
+    if (!SPACING_KEYS.has(key)) return fail(`Unknown key in spacing: "${key}"`);
+  }
+  for (const key of Object.keys(obj)) {
+    const val = obj[key];
+    if (typeof val !== "number" || val < 0) {
+      return fail(`spacing.${key} must be a non-negative number, got ${JSON.stringify(val)}`);
+    }
+  }
+  return ok(obj);
+}
+function validateEdges(obj) {
+  if (!isPlainObject(obj)) return fail('"edges" must be a plain object');
+  for (const key of Object.keys(obj)) {
+    if (!EDGES_KEYS.has(key)) return fail(`Unknown key in edges: "${key}"`);
+  }
+  const nonNegativeFields = ["strokeWidth", "arrowSize", "labelFontSize"];
+  for (const key of nonNegativeFields) {
+    if (key in obj) {
+      const val = obj[key];
+      if (typeof val !== "number" || val < 0) {
+        return fail(`edges.${key} must be a non-negative number, got ${JSON.stringify(val)}`);
+      }
+    }
+  }
+  if ("curveTension" in obj) {
+    const val = obj["curveTension"];
+    if (typeof val !== "number" || val < 0 || val > 1) {
+      return fail(`edges.curveTension must be a number between 0 and 1, got ${JSON.stringify(val)}`);
+    }
+  }
+  return ok(obj);
+}
+function validatePanel(obj) {
+  if (!isPlainObject(obj)) return fail('"panel" must be a plain object');
+  for (const key of Object.keys(obj)) {
+    if (!PANEL_KEYS.has(key)) return fail(`Unknown key in panel: "${key}"`);
+  }
+  if ("titleAlign" in obj) {
+    const val = obj["titleAlign"];
+    if (val !== "left" && val !== "center" && val !== "right") {
+      return fail(`panel.titleAlign must be "left", "center", or "right", got ${JSON.stringify(val)}`);
+    }
+  }
+  if ("titlePosition" in obj) {
+    const val = obj["titlePosition"];
+    if (val !== "inside" && val !== "on-border" && val !== "above") {
+      return fail(`panel.titlePosition must be "inside", "on-border", or "above", got ${JSON.stringify(val)}`);
+    }
+  }
+  if ("titleChrome" in obj) {
+    const val = obj["titleChrome"];
+    if (val !== "none" && val !== "box" && val !== "pill") {
+      return fail(`panel.titleChrome must be "none", "box", or "pill", got ${JSON.stringify(val)}`);
+    }
+  }
+  return ok(obj);
+}
+function validateThemeInput(json) {
+  if (!isPlainObject(json)) {
+    return fail(`ThemeInput must be a non-null plain object, got ${json === null ? "null" : Array.isArray(json) ? "array" : typeof json}`);
+  }
+  for (const key of Object.keys(json)) {
+    if (!TOP_LEVEL_KEYS.has(key)) return fail(`Unknown top-level key: "${key}"`);
+  }
+  const result = {};
+  if ("name" in json) {
+    const v = json["name"];
+    if (typeof v !== "string") return fail(`"name" must be a string, got ${JSON.stringify(v)}`);
+    if (v.length < 1 || v.length > 64) return fail(`"name" must be 1\u201364 characters, got length ${v.length}`);
+    if (!SLUG.test(v)) return fail(`"name" must match ^[a-z0-9-]+$, got ${JSON.stringify(v)}`);
+    result["name"] = v;
+  }
+  if ("base" in json) {
+    const v = json["base"];
+    if (typeof v !== "string") return fail(`"base" must be a string, got ${JSON.stringify(v)}`);
+    if (!isBuiltinThemeName(v)) return fail(`"base" must be a built-in preset name; "${v}" is not recognised`);
+    result["base"] = v;
+  }
+  if ("palette" in json) {
+    const r = validatePalette(json["palette"]);
+    if (!r.ok) return r;
+    result["palette"] = r.value;
+  }
+  if ("typography" in json) {
+    const r = validateTypography(json["typography"]);
+    if (!r.ok) return r;
+    result["typography"] = r.value;
+  }
+  if ("spacing" in json) {
+    const r = validateSpacing(json["spacing"]);
+    if (!r.ok) return r;
+    result["spacing"] = r.value;
+  }
+  if ("edges" in json) {
+    const r = validateEdges(json["edges"]);
+    if (!r.ok) return r;
+    result["edges"] = r.value;
+  }
+  if ("panel" in json) {
+    const r = validatePanel(json["panel"]);
+    if (!r.ok) return r;
+    result["panel"] = r.value;
+  }
+  return ok(result);
+}
+
 // ../src/frontend/index.ts
 registerDiagram("flowchart", flowchart);
 registerDiagram("timeline", timeline);
@@ -44229,11 +44435,144 @@ function svgToPdf(svg, opts2 = {}) {
   });
 }
 
+// src/theme-resolve.ts
+var import_node_path2 = require("node:path");
+
+// ../src/theme/discover.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var THEME_SUFFIX = ".triton-theme.json";
+var SLUG2 = /^[a-z0-9-]+$/;
+function deriveNameFromFilename(filename) {
+  return (0, import_node_path.basename)(filename, THEME_SUFFIX);
+}
+function loadThemeFile(filePath) {
+  let raw;
+  try {
+    raw = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  } catch (cause) {
+    return err("THEME_VALIDATION_ERROR", `Cannot read theme file "${filePath}": ${String(cause)}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    return err("THEME_VALIDATION_ERROR", `Invalid JSON in theme file "${filePath}": ${String(cause)}`, cause);
+  }
+  const validated = validateThemeInput(parsed);
+  if (!validated.ok) {
+    return err(
+      "THEME_VALIDATION_ERROR",
+      `Theme file "${filePath}" failed validation: ${validated.error.message}`,
+      validated.error
+    );
+  }
+  const input = validated.value;
+  const baseName = parsed["base"] ?? "default";
+  const base = getThemePreset(baseName);
+  const resolved = resolveTheme(input, base);
+  return ok(resolved);
+}
+function discoverThemes(dir) {
+  const themes = /* @__PURE__ */ new Map();
+  const warnings = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch (cause) {
+    warnings.push(`Cannot read themes directory "${dir}": ${String(cause)}`);
+    return { themes, warnings };
+  }
+  const themeFiles = entries.filter((e) => e.endsWith(THEME_SUFFIX));
+  for (const filename of themeFiles) {
+    const filePath = (0, import_node_path.join)(dir, filename);
+    const result = loadThemeFile(filePath);
+    if (!result.ok) {
+      warnings.push(result.error.message);
+      continue;
+    }
+    const resolved = result.value;
+    const name = extractNameFromFile(filePath) ?? deriveNameFromFilename(filename);
+    if (!SLUG2.test(name)) {
+      warnings.push(`Theme file "${filename}": derived name "${name}" is not a valid slug (^[a-z0-9-]+$); skipped`);
+      continue;
+    }
+    if (isBuiltinThemeName(name)) {
+      warnings.push(`Theme "${name}" shadows a built-in preset; skipped`);
+      continue;
+    }
+    if (themes.has(name)) {
+      warnings.push(`Duplicate theme name "${name}": "${filename}" overrides an earlier definition`);
+    }
+    themes.set(name, resolved);
+  }
+  return { themes, warnings };
+}
+function extractNameFromFile(filePath) {
+  try {
+    const raw = (0, import_node_fs.readFileSync)(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed["name"] === "string" ? parsed["name"] : null;
+  } catch {
+    return null;
+  }
+}
+function findTritonThemesDir(startDir) {
+  const MAX_LEVELS = 10;
+  let current = (0, import_node_path.resolve)(startDir);
+  for (let level = 0; level < MAX_LEVELS; level++) {
+    const candidate = (0, import_node_path.join)(current, ".triton", "themes");
+    try {
+      if ((0, import_node_fs.existsSync)(candidate) && (0, import_node_fs.statSync)(candidate).isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+    const parent = (0, import_node_path.resolve)((0, import_node_path.join)(current, ".."));
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+
+// src/theme-resolve.ts
+function resolveCliTheme(args, inputDir) {
+  if (args.themeFile) {
+    const result = loadThemeFile((0, import_node_path2.resolve)(args.themeFile));
+    if (!result.ok) {
+      throw new Error(`--theme-file: ${result.error.message}`);
+    }
+    return result.value;
+  }
+  const registry4 = /* @__PURE__ */ new Map();
+  const autoDir = findTritonThemesDir(inputDir);
+  if (autoDir) {
+    const { themes, warnings } = discoverThemes(autoDir);
+    for (const [name, theme] of themes) registry4.set(name, theme);
+    for (const w of warnings) console.error(`warning: ${w}`);
+  }
+  if (args.themesDir) {
+    const { themes, warnings } = discoverThemes((0, import_node_path2.resolve)(args.themesDir));
+    for (const [name, theme] of themes) registry4.set(name, theme);
+    for (const w of warnings) console.error(`warning: ${w}`);
+  }
+  if (args.theme) {
+    if (registry4.has(args.theme)) {
+      return registry4.get(args.theme);
+    }
+    return getThemePreset(args.theme);
+  }
+  return void 0;
+}
+
 // src/cli.ts
+var import_meta = {};
 function parseArgs(argv) {
   const positionals = [];
   let out;
   let theme;
+  let themeFile;
+  let themesDir;
   let scale = 1;
   let help = false;
   for (let i = 0; i < argv.length; i++) {
@@ -44246,6 +44585,12 @@ function parseArgs(argv) {
       case "--theme":
         theme = argv[++i];
         break;
+      case "--theme-file":
+        themeFile = argv[++i];
+        break;
+      case "--themes-dir":
+        themesDir = argv[++i];
+        break;
       case "--scale":
         scale = Number(argv[++i]) || 1;
         break;
@@ -44257,7 +44602,7 @@ function parseArgs(argv) {
         positionals.push(a);
     }
   }
-  return { command: positionals.shift(), positionals, out, theme, scale, help };
+  return { command: positionals.shift(), positionals, out, theme, themeFile, themesDir, scale, help };
 }
 var USAGE = `triton-latex \u2014 render Triton diagrams to vector PDF for LaTeX.
 
@@ -44266,50 +44611,63 @@ Usage:
   triton-latex render-dir <srcDir> -o <outDir> [options]
 
 Options:
-  -o, --out <path>   Output file (render) or output directory (render-dir).
-  --theme <name>     Theme preset (default, executive, minimal, \u2026).
-  --scale <number>   Uniform scale for the PDF page box (default 1).
-  -h, --help         Show this help.
+  -o, --out <path>          Output file (render) or output directory (render-dir).
+  --theme <name>            Theme preset name (default, executive, minimal, \u2026) or
+                            a name from the discovered/loaded custom theme registry.
+  --theme-file <path>       Path to a .triton-theme.json file. Takes precedence over
+                            --theme and --themes-dir. Fails loudly on load error.
+  --themes-dir <dir>        Directory of .triton-theme.json files to register; merged
+                            on top of auto-discovered .triton/themes/ (overrides on
+                            name collision). Use with --theme <name>.
+  --scale <number>          Uniform scale for the PDF page box (default 1).
+  -h, --help                Show this help.
+
+Theme resolution order:
+  1. --theme-file <path>    \u2192 load that exact file (errors are fatal)
+  2. --themes-dir + auto-discovery (.triton/themes/ ancestor walk) \u2192 build registry
+     --theme <name>          \u2192 look up name in registry, then fall back to built-in preset
+  3. No theme flags          \u2192 core uses diagram frontmatter / default preset
 
 Examples:
   triton-latex render diagram.mmd -o figures/diagram.pdf
-  triton-latex render diagram.mmd -o diagram.svg          # SVG pass-through
-  triton-latex render-dir diagrams/ -o figures/           # batch \u2192 *.pdf
+  triton-latex render diagram.mmd -o diagram.svg                        # SVG pass-through
+  triton-latex render diagram.mmd -o out.pdf --theme-file my.triton-theme.json
+  triton-latex render diagram.mmd -o out.pdf --themes-dir .triton/themes --theme acme
+  triton-latex render-dir diagrams/ -o figures/                         # batch \u2192 *.pdf
 `;
 var DIAGRAM_EXTS = /* @__PURE__ */ new Set([".triton", ".mmd"]);
-function renderToSvg(source, themeName) {
-  const themeInput = themeName ? getThemePreset(themeName) : void 0;
+function renderToSvg(source, themeInput) {
   const result = renderSync(source, themeInput);
   if (!result.ok) {
     throw new Error(`${result.error.code}: ${result.error.message}`);
   }
   return result.value;
 }
-async function renderFile(inputPath, outPath, themeName, scale) {
-  const source = (0, import_node_fs.readFileSync)(inputPath, "utf8");
-  const svg = renderToSvg(source, themeName);
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)((0, import_node_path.resolve)(outPath)), { recursive: true });
-  if ((0, import_node_path.extname)(outPath).toLowerCase() === ".svg") {
-    (0, import_node_fs.writeFileSync)(outPath, svg, "utf8");
+async function renderFile(inputPath, outPath, themeInput, scale) {
+  const source = (0, import_node_fs2.readFileSync)(inputPath, "utf8");
+  const svg = renderToSvg(source, themeInput);
+  (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)((0, import_node_path3.resolve)(outPath)), { recursive: true });
+  if ((0, import_node_path3.extname)(outPath).toLowerCase() === ".svg") {
+    (0, import_node_fs2.writeFileSync)(outPath, svg, "utf8");
     return;
   }
   const pdf = await svgToPdf(svg, { scale });
-  (0, import_node_fs.writeFileSync)(outPath, pdf);
+  (0, import_node_fs2.writeFileSync)(outPath, pdf);
 }
-async function renderDir(srcDir, outDir, themeName, scale) {
-  (0, import_node_fs.mkdirSync)(outDir, { recursive: true });
-  const entries = (0, import_node_fs.readdirSync)(srcDir).filter((f2) => {
-    const full = (0, import_node_path.join)(srcDir, f2);
-    return (0, import_node_fs.statSync)(full).isFile() && DIAGRAM_EXTS.has((0, import_node_path.extname)(f2).toLowerCase());
+async function renderDir(srcDir, outDir, themeInput, scale) {
+  (0, import_node_fs2.mkdirSync)(outDir, { recursive: true });
+  const entries = (0, import_node_fs2.readdirSync)(srcDir).filter((f2) => {
+    const full = (0, import_node_path3.join)(srcDir, f2);
+    return (0, import_node_fs2.statSync)(full).isFile() && DIAGRAM_EXTS.has((0, import_node_path3.extname)(f2).toLowerCase());
   });
   let rendered = 0;
   const failed = [];
   for (const file of entries) {
-    const inputPath = (0, import_node_path.join)(srcDir, file);
-    const name = (0, import_node_path.basename)(file, (0, import_node_path.extname)(file));
-    const outPath = (0, import_node_path.join)(outDir, `${name}.pdf`);
+    const inputPath = (0, import_node_path3.join)(srcDir, file);
+    const name = (0, import_node_path3.basename)(file, (0, import_node_path3.extname)(file));
+    const outPath = (0, import_node_path3.join)(outDir, `${name}.pdf`);
     try {
-      await renderFile(inputPath, outPath, themeName, scale);
+      await renderFile(inputPath, outPath, themeInput, scale);
       console.log(`  \u2713 ${file} \u2192 ${name}.pdf`);
       rendered++;
     } catch (cause) {
@@ -44333,7 +44691,15 @@ async function main() {
       console.error(USAGE);
       return 1;
     }
-    await renderFile((0, import_node_path.resolve)(input), (0, import_node_path.resolve)(args.out), args.theme, args.scale);
+    const inputPath = (0, import_node_path3.resolve)(input);
+    let themeInput;
+    try {
+      themeInput = resolveCliTheme(args, (0, import_node_path3.dirname)(inputPath));
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      return 1;
+    }
+    await renderFile(inputPath, (0, import_node_path3.resolve)(args.out), themeInput, args.scale);
     console.log(`\u2713 ${input} \u2192 ${args.out}`);
     return 0;
   }
@@ -44344,10 +44710,18 @@ async function main() {
       console.error(USAGE);
       return 1;
     }
+    const resolvedSrcDir = (0, import_node_path3.resolve)(srcDir);
+    let themeInput;
+    try {
+      themeInput = resolveCliTheme(args, resolvedSrcDir);
+    } catch (e) {
+      console.error(`error: ${e.message}`);
+      return 1;
+    }
     const { rendered, failed } = await renderDir(
-      (0, import_node_path.resolve)(srcDir),
-      (0, import_node_path.resolve)(args.out),
-      args.theme,
+      resolvedSrcDir,
+      (0, import_node_path3.resolve)(args.out),
+      themeInput,
       args.scale
     );
     console.log(`
@@ -44359,9 +44733,11 @@ ${rendered} rendered, ${failed.length} failed.`);
   console.error(USAGE);
   return 1;
 }
-main().then((code) => process.exit(code)).catch((cause) => {
-  const message = cause instanceof Error ? cause.message : String(cause);
-  console.error(`error: ${message}`);
-  process.exit(1);
-});
+if (process.argv[1] === (0, import_node_url.fileURLToPath)(import_meta.url)) {
+  main().then((code) => process.exit(code)).catch((cause) => {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    console.error(`error: ${message}`);
+    process.exit(1);
+  });
+}
 //# sourceMappingURL=cli.cjs.map