starlight-cannoli-plugins 1.2.18 → 2.0.0

package/README.md

@@ -48,7 +48,7 @@ export default defineConfig({
 });
 ```
 
-### Starlight LaTeX Compile
+### LaTeX Compile
 
 Automatically compiles fenced `tex compile` and `latex compile` code blocks to SVG diagrams during the build process. Uses `pdflatex` and `dvisvgm` for high-quality, cached SVG output.
 
@@ -58,7 +58,7 @@ Automatically compiles fenced `tex compile` and `latex compile` code blocks to S
 - Caches compiled SVGs by content hash (no recompilation if unchanged)
 - Comprehensive error reporting with line numbers and formatted LaTeX source
 - Supports custom preamble via `% ===` separator in code blocks
-- Works seamlessly with Starlight's content pipeline
+- Works with Starlight and plain Astro projects
 - Requires `svgOutputDir` configuration (no defaults)
 
 **System Requirements:**
@@ -75,24 +75,26 @@ pdflatex --version
 dvisvgm --version
 ```
 
+**Options:**
+
+- `svgOutputDir` (required): Directory where compiled SVG files are written. Must be inside `public/` so Astro serves them as static assets.
+- `removeOrphanedSvgs` (optional, default: `false`): When `true`, SVG files that are no longer referenced by any `tex compile` block are deleted automatically. In dev mode, stale SVGs are removed immediately when a block is edited. On build, any remaining orphans are swept at the end.
+
 **Usage:**
 
 ```ts
 // astro.config.mjs
 import { defineConfig } from "astro/config";
 import starlight from "@astrojs/starlight";
-import { starlightLatexCompile } from "cannoli-starlight-plugins";
+import { astroLatexCompile } from "cannoli-starlight-plugins";
 
 export default defineConfig({
   integrations: [
-    starlight({
-      title: "My Docs",
-      plugins: [
-        starlightLatexCompile({
-          svgOutputDir: "public/static/tex-svgs",
-        }),
-      ],
+    astroLatexCompile({
+      svgOutputDir: "public/static/tex-svgs",
+      removeOrphanedSvgs: true, // optional
     }),
+    starlight({ title: "My Docs" }),
   ],
 });
 ```
@@ -174,16 +176,9 @@ Add custom CSS classes the `tex compile` code block to have them applied to the
 
 The img element will have classes: `tex-compiled bg-white rounded-1` (note: the `tex-compiled` class is always included by default).
 
-### Remark LaTeX Compile
-
-The underlying remark plugin that powers `starlightLatexCompile`. Use this directly in Astro projects that don't use Starlight.
-
-**System Requirements:**
+### Remark LaTeX Compile (low-level)
 
-Same as `starlightLatexCompile`:
-
-- **`pdflatex`** — LaTeX compiler that produces PDF output
-- **`dvisvgm`** — Converts PDF to SVG format
+The underlying remark plugin used by `astroLatexCompile`. Use this directly if you need to wire the transformer into a custom pipeline — most users should use `astroLatexCompile` instead.
 
 **Usage:**
 
@@ -195,18 +190,13 @@ import { remarkLatexCompile } from "cannoli-starlight-plugins/remark-latex-compi
 export default defineConfig({
   markdown: {
     remarkPlugins: [
-      [
-        remarkLatexCompile,
-        {
-          svgOutputDir: "public/static/tex-svgs",
-        },
-      ],
+      [remarkLatexCompile, { svgOutputDir: "public/static/tex-svgs" }],
     ],
   },
 });
 ```
 
-The plugin works identically to `starlightLatexCompile` but is configured directly in the Astro markdown pipeline.
+Note: when used directly (without `astroLatexCompile`), the Starlight content layer cache is not cleared automatically, so SVGs may not recompile on repeat builds in Starlight projects.
 
 ### Rehype Validate Links
 
@@ -288,7 +278,7 @@ export default defineConfig({
 });
 ```
 
-### Starlight Sync Docs to Public
+### Sync Docs to Public
 
 Syncs `src/content/docs/` to `public/` so local files (e.g., PDFs, images) referenced in markdown are served by the dev server and included in builds. In dev mode, it watches for file changes and re-syncs automatically — no restart needed.
 
@@ -305,18 +295,12 @@ Syncs `src/content/docs/` to `public/` so local files (e.g., PDFs, images) refer
 // astro.config.mjs
 import { defineConfig } from "astro/config";
 import starlight from "@astrojs/starlight";
-import { starlightSyncDocsToPublic } from "cannoli-starlight-plugins";
+import { syncDocsToPublic } from "cannoli-starlight-plugins";
 
 export default defineConfig({
   integrations: [
-    starlight({
-      title: "My Docs",
-      plugins: [
-        starlightSyncDocsToPublic({
-          preserveDirs: ["static"],
-        }),
-      ],
-    }),
+    syncDocsToPublic({ preserveDirs: ["static"] }),
+    starlight({ title: "My Docs" }),
   ],
 });
 ```
@@ -327,7 +311,7 @@ export default defineConfig({
 - `ignorePatterns` (optional): Glob patterns for files to exclude from syncing. Patterns are matched against paths relative to `src/content/docs/`.
 
 ```ts
-starlightSyncDocsToPublic({
+syncDocsToPublic({
   preserveDirs: ["static"],
   ignorePatterns: ["**/*.txt", "**/drafts/**"],
 });
@@ -337,7 +321,9 @@ starlightSyncDocsToPublic({
 
 ### cannoli-latex-cleanup
 
-A cleanup utility for the LaTeX compile plugin. Scans your markdown source files for all `tex compile` code blocks, hashes them, and identifies orphaned SVG files in the output directory that are no longer referenced by any code block.
+A manual cleanup utility for the LaTeX compile plugin. Scans your markdown source files for all `tex compile` code blocks, hashes them, and identifies orphaned SVG files in the output directory that are no longer referenced by any code block.
+
+> **Note:** If you use `removeOrphanedSvgs: true` in your `astroLatexCompile` config, this CLI is generally not needed — orphaned SVGs are cleaned up automatically during both dev and build.
 
 **Usage:**
 
@@ -361,7 +347,7 @@ npx cannoli-latex-cleanup --svg-dir public/static/tex-svgs --docs-dir ./src/cont
 
 **Options:**
 
-- `--svg-dir` (required): Path to the SVG output directory configured in `starlightLatexCompile`
+- `--svg-dir` (required): Path to the SVG output directory configured in `astroLatexCompile`
 - `--docs-dir` (optional, default: `src/content/docs`): Path to markdown source directory
 - `--check`: List orphaned SVGs without deleting
 - `--delete`: Delete orphaned SVGs

package/dist/chunk-3OL3VUEB.js

@@ -0,0 +1,143 @@
+import {
+  parseFrontmatter
+} from "./chunk-3ATSZG6H.js";
+
+// src/plugins/starlight-sync-docs-to-public.ts
+import { cp, mkdir, readdir, readFile, writeFile, rm, stat } from "fs/promises";
+import { resolve, relative } from "path";
+import { minimatch } from "minimatch";
+var DEFAULT_SRC_DIR = "src/content/docs";
+var DEFAULT_PUBLIC_DIR = "public";
+async function fullSync(srcDir, publicDir, preserveDirs, ignorePatterns) {
+  await mkdir(publicDir, { recursive: true });
+  const items = await readdir(publicDir, { withFileTypes: true });
+  await Promise.all(
+    items.filter((item) => item.isDirectory() && !preserveDirs.includes(item.name)).map((item) => rm(resolve(publicDir, item.name), { recursive: true, force: true }))
+  );
+  await copyWithRetry(srcDir, publicDir, ignorePatterns);
+  console.log(
+    `[starlight-sync-docs-to-public] Synced ${DEFAULT_SRC_DIR}/ \u2192 ${DEFAULT_PUBLIC_DIR}/ (full sync)`
+  );
+}
+async function incrementalSync(changedFilePath, srcDir, publicDir, ignorePatterns) {
+  const rel = relative(srcDir, changedFilePath);
+  if (ignorePatterns.some((pattern) => minimatch(rel, pattern, { dot: true }))) {
+    return;
+  }
+  if (changedFilePath.endsWith(".md") || changedFilePath.endsWith(".mdx")) {
+    try {
+      const frontmatter = parseFrontmatter(changedFilePath);
+      if (frontmatter.draft === true) return;
+    } catch {
+      return;
+    }
+  }
+  const destPath = resolve(publicDir, rel);
+  let srcStat;
+  try {
+    srcStat = await stat(changedFilePath);
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      await rm(destPath, { recursive: true, force: true });
+      return;
+    }
+    throw err;
+  }
+  if (srcStat.isDirectory()) {
+    await mkdir(destPath, { recursive: true });
+    const files = await readdir(changedFilePath);
+    await Promise.all(
+      files.map(
+        (file) => incrementalSync(resolve(changedFilePath, file), srcDir, publicDir, ignorePatterns)
+      )
+    );
+  } else {
+    await mkdir(resolve(destPath, ".."), { recursive: true });
+    const content = await readFile(changedFilePath);
+    await writeFile(destPath, content);
+  }
+  console.log(`[starlight-sync-docs-to-public] Synced ${rel}`);
+}
+async function copyWithRetry(srcDir, publicDir, ignorePatterns) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await cp(srcDir, publicDir, {
+        recursive: true,
+        force: true,
+        filter: (src) => {
+          const rel = relative(srcDir, src);
+          if (rel === "") return true;
+          if (ignorePatterns.some((pattern) => minimatch(rel, pattern, { dot: true }))) {
+            return false;
+          }
+          if (src.endsWith(".md") || src.endsWith(".mdx")) {
+            try {
+              const frontmatter = parseFrontmatter(src);
+              if (frontmatter.draft === true) return false;
+            } catch {
+              return false;
+            }
+          }
+          return true;
+        }
+      });
+      return;
+    } catch (err) {
+      const code = err?.code;
+      if (code !== "EEXIST" && code !== "ENOENT") throw err;
+      if (attempt < 2) await new Promise((r) => setTimeout(r, 10 * (attempt + 1)));
+    }
+  }
+}
+function syncDocsToPublic(options) {
+  const srcDir = resolve(DEFAULT_SRC_DIR);
+  const publicDir = resolve(DEFAULT_PUBLIC_DIR);
+  const { preserveDirs, ignorePatterns = [] } = options;
+  return {
+    name: "astro-sync-docs-to-public",
+    hooks: {
+      "astro:build:start": async () => {
+        await fullSync(srcDir, publicDir, preserveDirs, ignorePatterns);
+      },
+      "astro:server:setup": ({ server }) => {
+        const pendingPaths = /* @__PURE__ */ new Set();
+        let isSyncing = false;
+        let debounceTimer = null;
+        const performSync = async () => {
+          if (isSyncing) return;
+          isSyncing = true;
+          try {
+            while (pendingPaths.size > 0) {
+              const paths = [...pendingPaths];
+              pendingPaths.clear();
+              await Promise.all(
+                paths.map(
+                  (p) => incrementalSync(p, srcDir, publicDir, ignorePatterns).catch((err) => {
+                    console.error(`[starlight-sync-docs-to-public] Error syncing ${p}:`, err);
+                  })
+                )
+              );
+            }
+          } finally {
+            isSyncing = false;
+            if (pendingPaths.size > 0) void performSync();
+          }
+        };
+        fullSync(srcDir, publicDir, preserveDirs, ignorePatterns).catch(console.error);
+        server.watcher.add(srcDir);
+        server.watcher.on("all", (_event, filePath) => {
+          if (!filePath.startsWith(srcDir)) return;
+          pendingPaths.add(filePath);
+          if (debounceTimer) clearTimeout(debounceTimer);
+          debounceTimer = setTimeout(performSync, 100);
+        });
+      }
+    }
+  };
+}
+var starlightSyncDocsToPublic = syncDocsToPublic;
+
+export {
+  syncDocsToPublic,
+  starlightSyncDocsToPublic
+};

package/dist/{chunk-KQM5EAEK.js → chunk-47X5MKFJ.js}

@@ -1,6 +1,6 @@
-// src/plugins/remark-latex-compile/compile.ts
+// src/plugins/remark-latex-compile/utils.ts
 import { createHash } from "crypto";
-import { spawnSync } from "child_process";
+import { spawn } from "child_process";
 import {
   existsSync,
   mkdirSync,
@@ -161,7 +161,7 @@ ${formattedSource}
 `;
 }
 
-// src/plugins/remark-latex-compile/compile.ts
+// src/plugins/remark-latex-compile/utils.ts
 var LATEX_BLOCK_REGEX = /```(?:tex|latex)\s+compile[^\r\n]*\r?\n([\s\S]*?)\r?\n```/g;
 function hashLatexCode(code) {
   const normalized = code.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("%")).filter(Boolean).join("\n").trim();
@@ -188,7 +188,26 @@ function buildLatexSource(latexCode) {
     "\\end{document}"
   ].join("\n");
 }
-function compileLatexToSvg(latexCode, svgOutputDir) {
+function execProcess(command, args) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const proc = spawn(command, args);
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      resolve({ status: code ?? 1, stdout, stderr });
+    });
+  });
+}
+async function compileLatexToSvg(latexCode, svgOutputDir) {
   const hash = hashLatexCode(latexCode);
   const svgPath = join(svgOutputDir, `${hash}.svg`);
   if (existsSync(svgPath)) {
@@ -201,41 +220,47 @@ function compileLatexToSvg(latexCode, svgOutputDir) {
   const latexSource = buildLatexSource(latexCode);
   try {
     writeFileSync(texFile, latexSource, "utf-8");
-    const latexResult = spawnSync("pdflatex", [
-      "-interaction=nonstopmode",
-      "-output-directory",
-      workDir,
-      texFile
-    ]);
-    if (latexResult.error) {
-      const code = latexResult.error.code;
+    let result;
+    try {
+      result = await execProcess("pdflatex", [
+        "-interaction=nonstopmode",
+        "-output-directory",
+        workDir,
+        texFile
+      ]);
+    } catch (err) {
+      const code = err.code;
       throw new Error(
-        `[remark-latex-compile] pdflatex not found on PATH (${code}).`
+        `[remark-latex-compile] pdflatex not found on PATH (${code}).`,
+        { cause: err }
       );
     }
-    if (latexResult.status !== 0) {
-      const errorOutput = latexResult.stderr?.toString() || latexResult.stdout?.toString() || "";
+    if (result.status !== 0) {
+      const errorOutput = result.stderr || result.stdout || "";
       const userMessage = createCompilationErrorMessage(
         latexSource,
         errorOutput
       );
       throw new Error(userMessage);
     }
-    const dvisvgmResult = spawnSync("dvisvgm", [
-      "--pdf",
-      "--bbox=dvi",
-      pdfFile,
-      "-o",
-      svgPath
-    ]);
-    if (dvisvgmResult.error) {
-      const code = dvisvgmResult.error.code;
+    let svgResult;
+    try {
+      svgResult = await execProcess("dvisvgm", [
+        "--pdf",
+        "--bbox=dvi",
+        pdfFile,
+        "-o",
+        svgPath
+      ]);
+    } catch (err) {
+      const code = err.code;
       throw new Error(
-        `[remark-latex-compile] dvisvgm not found on PATH (${code}).`
+        `[remark-latex-compile] dvisvgm not found on PATH (${code}).`,
+        { cause: err }
       );
     }
-    if (dvisvgmResult.status !== 0) {
-      const errorOutput = dvisvgmResult.stderr?.toString() || dvisvgmResult.stdout?.toString() || "";
+    if (svgResult.status !== 0) {
+      const errorOutput = svgResult.stderr || svgResult.stdout || "";
       throw new Error(
         `[remark-latex-compile] PDF to SVG conversion failed (hash: ${hash}).
 Error: ${errorOutput}`

package/dist/chunk-AZPHBHBE.js

@@ -0,0 +1,71 @@
+// src/plugins/astro-normalize-paths.ts
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { glob } from "glob";
+import { dirname, resolve } from "path";
+function astroNormalizePaths() {
+  return {
+    name: "astro-normalize-paths",
+    hooks: {
+      "astro:build:done": async ({ dir }) => {
+        const htmlFiles = await glob(`${dir.pathname}/**/*.html`);
+        await Promise.all(
+          htmlFiles.map(async (htmlFile) => {
+            let content = await readFile(htmlFile, "utf-8");
+            const originalContent = content;
+            const imgRegex = /<img([^>]*?)src=["']([^"']+)["']/g;
+            let match;
+            while ((match = imgRegex.exec(content)) !== null) {
+              const attrs = match[1];
+              const src = match[2];
+              const normalized = normalizeAssetPath(src, htmlFile, dir.pathname);
+              if (normalized && src !== normalized) {
+                console.log(`[astro-normalize-paths] Img path resolution:`);
+                console.log(`  Original: ${src}`);
+                console.log(`  HTML file: ${htmlFile}`);
+                console.log(`  Normalized: ${normalized}`);
+                content = content.replace(`<img${attrs}src="${src}"`, `<img${attrs}src="${normalized}"`);
+              }
+            }
+            const anchorRegex = /<a([^>]*?)href=["']([^"']+)["']/g;
+            while ((match = anchorRegex.exec(content)) !== null) {
+              const attrs = match[1];
+              const href = match[2];
+              const normalized = normalizeAssetPath(href, htmlFile, dir.pathname);
+              if (normalized && href !== normalized) {
+                content = content.replace(`<a${attrs}href="${href}"`, `<a${attrs}href="${normalized}"`);
+              }
+            }
+            if (content !== originalContent) {
+              await writeFile(htmlFile, content, "utf-8");
+            }
+          })
+        );
+      }
+    }
+  };
+}
+function normalizeAssetPath(path, htmlFile, siteRootPath) {
+  if (path.startsWith("http") || path.startsWith("data:") || path.startsWith("/")) {
+    return null;
+  }
+  const htmlDir = dirname(htmlFile);
+  const resolvedPath = resolve(htmlDir, path);
+  const siteRoot = resolve(siteRootPath);
+  let absolutePath = resolvedPath.slice(siteRoot.length).replace(/\\/g, "/");
+  if (!existsSync(resolvedPath)) {
+    const parentDir = dirname(htmlDir);
+    const alternativePath = resolve(parentDir, path);
+    if (existsSync(alternativePath)) {
+      absolutePath = alternativePath.slice(siteRoot.length).replace(/\\/g, "/");
+    }
+  }
+  const finalPath = "/" + absolutePath.replace(/^\/+/, "");
+  return finalPath;
+}
+var astro_normalize_paths_default = astroNormalizePaths;
+
+export {
+  astroNormalizePaths,
+  astro_normalize_paths_default
+};

package/dist/{chunk-HRUZQZ5L.js → chunk-FQLJMU2J.js}

@@ -72,24 +72,17 @@ function validateLink(link) {
   if (project_absolute_href.includes(".{md,mdx}")) {
     const matches = globSync(project_absolute_href);
     if (matches.length === 0) {
-      throw new Error(
-        `Link validation error: No matching file found for: ${link.original_href} (pattern: ${project_absolute_href})`
-      );
+      return `No matching file found for: ${link.original_href} (pattern: ${project_absolute_href})`;
     }
     if (matches.length > 1) {
-      throw new Error(
-        `Link validation error: Multiple matching files found: ${matches.join(
-          ", "
-        )} (from link: ${link.original_href})`
-      );
+      return `Multiple matching files found: ${matches.join(", ")} (from link: ${link.original_href})`;
     }
   } else {
     if (!existsSync(project_absolute_href)) {
-      throw new Error(
-        `Link validation error: File not found: ${project_absolute_href} (from link: ${link.original_href})`
-      );
+      return `File not found: ${project_absolute_href} (from link: ${link.original_href})`;
     }
   }
+  return null;
 }
 function rehypeValidateLinks(options) {
   return (tree, file) => {
@@ -100,6 +93,7 @@ function rehypeValidateLinks(options) {
       );
       return;
     }
+    const errors = [];
     visit(tree, "element", (node) => {
       if (node.tagName !== "a") return;
       const href = node.properties?.href;
@@ -108,9 +102,17 @@ function rehypeValidateLinks(options) {
       if (!link) return;
       if (link.skipValidation) return;
       if (node.properties?.["data-no-link-check"] !== void 0) return;
-      if (matchesSkipPattern(link.site_absolute_href, options?.skipPatterns)) return;
-      validateLink(link);
+      if (matchesSkipPattern(link.site_absolute_href, options?.skipPatterns))
+        return;
+      const error = validateLink(link);
+      if (error) errors.push(error);
     });
+    if (errors.length > 0) {
+      throw new Error(
+        `Link validation errors in ${filePath}:
+` + errors.map((e) => `  - ${e}`).join("\n")
+      );
+    }
   };
 }
 var rehype_validate_links_default = rehypeValidateLinks;

package/dist/chunk-S4YMC25A.js

@@ -0,0 +1,149 @@
+import {
+  compileLatexToSvg,
+  hashLatexCode
+} from "./chunk-47X5MKFJ.js";
+
+// src/plugins/remark-latex-compile/index.ts
+import { rm } from "fs/promises";
+import { join, resolve } from "path";
+import { visit as visit2, SKIP } from "unist-util-visit";
+
+// src/plugins/remark-latex-compile/rehype-converter.ts
+import { visit } from "unist-util-visit";
+function rehypeLatexCompile() {
+  return (tree, _file) => {
+    visit(tree, "element", (node, index, parent) => {
+      if (node.tagName !== "pre") return;
+      const codeChild = node.children?.[0];
+      if (!codeChild || codeChild.tagName !== "code") return;
+      const classes = Array.isArray(codeChild.properties?.className) ? codeChild.properties.className : [];
+      if (!classes.includes("language-tex") && !classes.includes("language-latex")) {
+        return;
+      }
+      const codeContent = codeChild.children?.map(
+        (child) => typeof child === "string" ? child : child.value || ""
+      ).join("").trim();
+      if (!codeContent) return;
+      const dataAttribute = codeChild.properties?.["data-meta"];
+      const isCompileBlock = dataAttribute && dataAttribute.includes("compile") || codeContent.includes("compile");
+      if (!isCompileBlock) return;
+      try {
+        const hash = hashLatexCode(codeContent);
+        const svgPath = `/static/tex-svgs/${hash}.svg`;
+        const imgElement = {
+          type: "element",
+          tagName: "img",
+          properties: {
+            src: svgPath,
+            alt: "LaTeX diagram",
+            className: ["tex-compiled"]
+          },
+          children: []
+        };
+        const paragraphElement = {
+          type: "element",
+          tagName: "p",
+          properties: {},
+          children: [imgElement]
+        };
+        if (parent && typeof index === "number") {
+          parent.children[index] = paragraphElement;
+        }
+      } catch (err) {
+        console.error(
+          `[rehype-latex-compile] Error processing code block:`,
+          err
+        );
+      }
+    });
+  };
+}
+
+// src/plugins/remark-latex-compile/index.ts
+function extractClassesFromMeta(meta) {
+  const classMatch = meta.match(/class="([^"]+)"/);
+  if (classMatch?.[1]) {
+    return classMatch[1].split(/\s+/).filter(Boolean);
+  }
+  return [];
+}
+function remarkLatexCompile(options) {
+  const svgOutputDir = resolve(options.svgOutputDir);
+  return async function transformer(tree, file) {
+    const nodes = [];
+    visit2(tree, "code", (node, index, parent) => {
+      if ((node.lang === "tex" || node.lang === "latex") && node.meta?.includes("compile") && parent && index !== void 0) {
+        nodes.push({ node, index, parent });
+      }
+      return SKIP;
+    });
+    if (nodes.length === 0) return;
+    const filePath = file.path || "unknown";
+    const results = await Promise.all(
+      nodes.map(async ({ node, index, parent }) => {
+        const lineNumber = node.position?.start.line ?? "?";
+        try {
+          const result = await compileLatexToSvg(node.value, svgOutputDir);
+          if (result.wasCompiled) {
+            console.log(
+              `[remark-latex-compile] ${filePath}:${lineNumber}: compiled ${result.hash}.svg`
+            );
+          }
+          options._referencedHashes?.add(result.hash);
+          return { index, parent, result, error: null, hash: result.hash };
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          const match = errorMsg.match(/\n\n([\s\S]+)/);
+          const details = match ? match[1] : errorMsg;
+          console.error(
+            `[remark-latex-compile] ${filePath}:${lineNumber}
+${details}`
+          );
+          return { index, parent, result: null, error: err, hash: null };
+        }
+      })
+    );
+    if (options._fileHashMap) {
+      const newHashes = new Set(
+        results.map((r) => r.hash).filter(Boolean)
+      );
+      const oldHashes = options._fileHashMap.get(filePath) ?? /* @__PURE__ */ new Set();
+      const staleHashes = [...oldHashes].filter((h) => !newHashes.has(h));
+      for (const staleHash of staleHashes) {
+        console.warn(
+          `[remark-latex-compile] Removing orphaned svg: ${staleHash}.svg`
+        );
+      }
+      await Promise.all(
+        staleHashes.map(
+          (h) => rm(join(svgOutputDir, `${h}.svg`), { force: true })
+        )
+      );
+      options._fileHashMap.set(filePath, newHashes);
+    }
+    for (let i = results.length - 1; i >= 0; i--) {
+      const { index, parent, result } = results[i];
+      const { node } = nodes[i];
+      if (!result) continue;
+      const customClasses = extractClassesFromMeta(node.meta ?? "");
+      const imageNode = {
+        type: "image",
+        url: `/static/tex-svgs/${result.hash}.svg`,
+        alt: "LaTeX diagram",
+        data: {
+          hProperties: { className: ["tex-compiled", ...customClasses] }
+        }
+      };
+      const paragraph = {
+        type: "paragraph",
+        children: [imageNode]
+      };
+      parent.children.splice(index, 1, paragraph);
+    }
+  };
+}
+
+export {
+  rehypeLatexCompile,
+  remarkLatexCompile
+};