starlight-cannoli-plugins 1.2.8 → 1.2.9

package/dist/chunk-QZUB4DOG.js

@@ -0,0 +1,255 @@
+// src/plugins/remark-latex-compile/compile.ts
+import { createHash } from "crypto";
+import { spawnSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  mkdtempSync
+} from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// src/plugins/remark-latex-compile/error-parser.ts
+function parseLatexError(latexOutput) {
+  const lines = latexOutput.split("\n");
+  const errors = [];
+  const seenMessages = /* @__PURE__ */ new Set();
+  let hasFatal = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("!")) {
+      const message = line.substring(1).trim();
+      if (seenMessages.has(message)) continue;
+      seenMessages.add(message);
+      const context = [];
+      let lineNum;
+      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+        const contextLine = lines[j];
+        if (contextLine.trim()) {
+          context.push(contextLine);
+        }
+        if (contextLine.startsWith("l.")) {
+          const lineMatch = contextLine.match(/^l\.(\d+)/);
+          if (lineMatch) {
+            lineNum = parseInt(lineMatch[1], 10);
+          }
+          break;
+        }
+      }
+      errors.push({
+        message,
+        line: lineNum,
+        context: context.slice(0, 3),
+        severity: "error"
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("Overfull") || line.includes("Underfull")) {
+      const msg = line.trim();
+      if (!seenMessages.has(msg)) {
+        seenMessages.add(msg);
+        errors.push({
+          message: msg,
+          context: [],
+          severity: "warning"
+        });
+      }
+    }
+  }
+  for (const line of lines) {
+    if (line.toLowerCase().includes("emergency stop") || line.toLowerCase().includes("fatal error") || line.toLowerCase().includes("not found")) {
+      hasFatal = true;
+      break;
+    }
+  }
+  if (errors.length === 0 && latexOutput.length > 0) {
+    for (const line of lines) {
+      if (line.includes("error") || line.includes("Error") || line.includes("Misplaced") || line.includes("Missing")) {
+        const msg = line.trim();
+        if (!seenMessages.has(msg)) {
+          seenMessages.add(msg);
+          errors.push({
+            message: msg,
+            context: [],
+            severity: "error"
+          });
+        }
+        break;
+      }
+    }
+  }
+  if (errors.length === 0) {
+    errors.push({
+      message: "Unknown LaTeX compilation error",
+      context: [],
+      severity: "error"
+    });
+  }
+  return { errors, hasFatal };
+}
+function formatLatexError(parsed) {
+  const RED = "\x1B[31m";
+  const YELLOW = "\x1B[33m";
+  const RESET = "\x1B[0m";
+  const errorCount = parsed.errors.filter((e) => e.severity === "error").length;
+  const warningCount = parsed.errors.filter(
+    (e) => e.severity === "warning"
+  ).length;
+  let output = `${RED}[remark-latex-compile] LaTeX compilation failed${RESET}
+`;
+  output += `${RED}${errorCount} error${errorCount !== 1 ? "s" : ""}${RESET}`;
+  if (warningCount > 0) {
+    output += `, ${YELLOW}${warningCount} warning${warningCount !== 1 ? "s" : ""}${RESET}`;
+  }
+  output += "\n\n";
+  const errorsByType = parsed.errors.reduce(
+    (acc, e) => {
+      if (!acc[e.severity]) acc[e.severity] = [];
+      acc[e.severity].push(e);
+      return acc;
+    },
+    {}
+  );
+  for (const err of errorsByType["error"] || []) {
+    output += `${RED}Error${RESET}`;
+    if (err.line) output += ` (line ${err.line})`;
+    output += `: ${err.message}
+`;
+    if (err.context.length > 0) {
+      output += `  Context: ${err.context[0]}
+`;
+    }
+  }
+  for (const warn of errorsByType["warning"] || []) {
+    output += `${YELLOW}Warning${RESET}: ${warn.message}
+`;
+  }
+  return output;
+}
+function formatLatexSourceWithLineNumbers(latexSource, errors) {
+  const RED = "\x1B[31m";
+  const RESET = "\x1B[0m";
+  const lines = latexSource.split("\n");
+  const maxLineNum = lines.length;
+  const lineNumWidth = String(maxLineNum).length;
+  const errorLineNumbers = new Set(errors.map((e) => e.line).filter(Boolean));
+  const formattedLines = lines.map((line, index) => {
+    const lineNum = index + 1;
+    const lineNumStr = String(lineNum);
+    const padding = lineNumStr.length < lineNumWidth ? " " : "";
+    if (errorLineNumbers.has(lineNum)) {
+      return `${padding}${RED}[${lineNumStr}]:${RESET} ${line}`;
+    }
+    return `${padding}[${lineNumStr}]: ${line}`;
+  }).join("\n");
+  return formattedLines;
+}
+function createCompilationErrorMessage(latexSource, rawError) {
+  const parsed = parseLatexError(rawError);
+  const formatted = formatLatexError(parsed);
+  const formattedSource = formatLatexSourceWithLineNumbers(
+    latexSource,
+    parsed.errors
+  );
+  return `${formatted}
+LaTeX source:
+${formattedSource}
+`;
+}
+
+// src/plugins/remark-latex-compile/compile.ts
+function hashLatexCode(code) {
+  const normalized = code.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("%")).filter(Boolean).join("\n").trim();
+  return createHash("md5").update(normalized).digest("hex").slice(0, 16);
+}
+function buildLatexSource(latexCode) {
+  if (latexCode.includes("\\documentclass") && latexCode.includes("\\begin{document}")) {
+    return latexCode.trim();
+  }
+  const separatorRegex = /%[ \t]*===/;
+  const parts = latexCode.split(separatorRegex);
+  let preamble = "";
+  let content = latexCode.trim();
+  if (parts.length === 2) {
+    preamble = parts[0].trim();
+    content = parts[1].trim();
+  }
+  return [
+    "\\documentclass[border=5pt]{standalone}",
+    preamble,
+    "\\begin{document}",
+    "\\Large",
+    content,
+    "\\end{document}"
+  ].join("\n");
+}
+function compileLatexToSvg(latexCode, svgOutputDir) {
+  const hash = hashLatexCode(latexCode);
+  const svgPath = join(svgOutputDir, `${hash}.svg`);
+  if (existsSync(svgPath)) {
+    return { hash, svgPath, wasCompiled: false };
+  }
+  mkdirSync(svgOutputDir, { recursive: true });
+  const workDir = mkdtempSync(join(tmpdir(), "latex-compile-"));
+  const texFile = join(workDir, "diagram.tex");
+  const pdfFile = join(workDir, "diagram.pdf");
+  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;
+      throw new Error(
+        `[remark-latex-compile] pdflatex not found on PATH (${code}).`
+      );
+    }
+    if (latexResult.status !== 0) {
+      const errorOutput = latexResult.stderr?.toString() || latexResult.stdout?.toString() || "";
+      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;
+      throw new Error(
+        `[remark-latex-compile] dvisvgm not found on PATH (${code}).`
+      );
+    }
+    if (dvisvgmResult.status !== 0) {
+      const errorOutput = dvisvgmResult.stderr?.toString() || dvisvgmResult.stdout?.toString() || "";
+      throw new Error(
+        `[remark-latex-compile] PDF to SVG conversion failed (hash: ${hash}).
+Error: ${errorOutput}`
+      );
+    }
+  } finally {
+    try {
+      rmSync(workDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return { hash, svgPath, wasCompiled: true };
+}
+
+export {
+  hashLatexCode,
+  compileLatexToSvg
+};

package/dist/chunk-UMYD2SJL.js

@@ -0,0 +1,233 @@
+import {
+  compileLatexToSvg
+} from "./chunk-QZUB4DOG.js";
+
+// src/plugins/remark-latex-compile/index.ts
+import { resolve } from "path";
+function extractClassesFromMeta(meta) {
+  const classMatch = meta.match(/class="([^"]+)"/);
+  if (classMatch && classMatch[1]) {
+    return classMatch[1].split(/\s+/).filter(Boolean);
+  }
+  return [];
+}
+function traverseTree(node, svgOutputDir, filePath, depth = 0) {
+  if (!node) return;
+  const children = node.children;
+  if (Array.isArray(children)) {
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type === "code" && (child.lang === "tex" || child.lang === "latex") && String(child.meta || "").includes("compile")) {
+        try {
+          const result = compileLatexToSvg(String(child.value), svgOutputDir);
+          const customClasses = extractClassesFromMeta(
+            String(child.meta || "")
+          );
+          const allClasses = ["tex-compiled", ...customClasses];
+          children[i] = {
+            type: "paragraph",
+            children: [
+              {
+                type: "image",
+                url: `/static/tex-svgs/${result.hash}.svg`,
+                alt: "LaTeX diagram",
+                data: {
+                  hProperties: {
+                    className: allClasses
+                  }
+                }
+              }
+            ]
+          };
+        } catch (err) {
+          if (process.env.NODE_ENV !== "production") {
+            const position = child.position;
+            const lineNumber = position?.start?.line || "?";
+            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(`${filePath}:${lineNumber}
+${details}`);
+          }
+        }
+      } else {
+        traverseTree(child, svgOutputDir, filePath, depth + 1);
+      }
+    }
+  }
+}
+function remarkLatexCompile(options) {
+  const svgOutputDir = resolve(options.svgOutputDir);
+  return (tree, file) => {
+    const fileObj = file;
+    const filePath = String(fileObj?.path || fileObj?.filename || "unknown");
+    traverseTree(tree, svgOutputDir, filePath, 0);
+  };
+}
+
+// src/plugins/remark-latex-compile/astro-integration.ts
+import { readdir, readFile, writeFile } from "fs/promises";
+import { resolve as resolve2, join, extname } from "path";
+import { createHash } from "crypto";
+function hashLatexCode(code) {
+  const normalized = code.split("\n").map((line) => line.trim()).join("\n").trim();
+  return createHash("md5").update(normalized).digest("hex").slice(0, 16);
+}
+function createAstroLatexIntegration(options) {
+  const svgOutputDir = resolve2(options.svgOutputDir);
+  const contentDir = options?.contentDir ? resolve2(options.contentDir) : resolve2("src/content/docs");
+  return {
+    name: "astro-latex-compile",
+    hooks: {
+      "astro:build:start": async () => {
+        console.log(
+          "[astro-latex-compile] Build start, scanning for tex/latex compile blocks"
+        );
+        await scanAndCompileLatex(contentDir, svgOutputDir);
+      },
+      "astro:build:done": async ({ dir }) => {
+        console.log(
+          "[astro-latex-compile] Build done, updating HTML references"
+        );
+        try {
+          await updateHtmlReferences(dir.pathname, contentDir, svgOutputDir);
+        } catch (err) {
+          console.error(
+            "[astro-latex-compile] Error updating HTML references:",
+            err
+          );
+        }
+      }
+    }
+  };
+}
+async function scanAndCompileLatex(dir, svgOutputDir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await scanAndCompileLatex(fullPath, svgOutputDir);
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name);
+      if (ext === ".md" || ext === ".mdx") {
+        await processMarkdownFile(fullPath, svgOutputDir);
+      }
+    }
+  }
+}
+function getLineNumber(content, position) {
+  return content.substring(0, position).split("\n").length;
+}
+async function processMarkdownFile(filePath, svgOutputDir) {
+  const content = await readFile(filePath, "utf-8");
+  const latexBlockRegex = /```(?:tex|latex)\s+compile\n([\s\S]*?)\n```/g;
+  const matches = content.matchAll(latexBlockRegex);
+  for (const match of matches) {
+    const latexCode = match[1];
+    const lineNumber = getLineNumber(content, match.index || 0);
+    try {
+      const result = compileLatexToSvg(latexCode, svgOutputDir);
+      const status = result.wasCompiled ? "compiled" : "used cached";
+      console.log(
+        `[astro-latex-compile] ${filePath}:${lineNumber}: ${status} ${result.hash}.svg`
+      );
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      error.message = `${filePath}:${lineNumber}
+${error.message}`;
+      throw error;
+    }
+  }
+}
+async function updateHtmlReferences(buildDir, contentDir, svgOutputDir) {
+  const latexHashes = [];
+  const entries = await readdir(contentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(contentDir, entry.name);
+    if (entry.isDirectory()) {
+      await scanMarkdownForHashes(fullPath, latexHashes);
+    }
+  }
+  await updateHtmlDirWithHashes(buildDir, latexHashes, svgOutputDir);
+}
+async function scanMarkdownForHashes(dir, hashes) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await scanMarkdownForHashes(fullPath, hashes);
+    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+      const content = await readFile(fullPath, "utf-8");
+      const latexBlockRegex = /```(?:tex|latex)\s+compile\n([\s\S]*?)\n```/g;
+      const matches = content.matchAll(latexBlockRegex);
+      for (const match of matches) {
+        const latexCode = match[1];
+        const hash = hashLatexCode(latexCode);
+        hashes.push(hash);
+      }
+    }
+  }
+}
+async function updateHtmlDirWithHashes(dir, hashes, svgOutputDir) {
+  let hashIndex = 0;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await updateHtmlDirWithHashes(fullPath, hashes, svgOutputDir);
+    } else if (entry.isFile() && entry.name.endsWith(".html")) {
+      let content = await readFile(fullPath, "utf-8");
+      let modified = false;
+      const pathSegments = svgOutputDir.split("/").slice(-2).join("/");
+      const htmlPath = `/${pathSegments}`;
+      const svgRegex = new RegExp(`src="${htmlPath}/[a-f0-9]+\\.svg"`, "g");
+      content = content.replace(svgRegex, (match) => {
+        if (hashIndex < hashes.length) {
+          modified = true;
+          return `src="${htmlPath}/${hashes[hashIndex++]}.svg"`;
+        }
+        return match;
+      });
+      if (modified) {
+        await writeFile(fullPath, content, "utf-8");
+        console.log(`[astro-latex-compile] Updated ${fullPath}`);
+      }
+    }
+  }
+}
+
+// src/plugins/remark-latex-compile/starlight-plugin.ts
+function starlightLatexCompile(options) {
+  return {
+    name: "starlight-latex-compile",
+    hooks: {
+      "config:setup": (hook) => {
+        hook.addIntegration({
+          name: "latex-compile-remark-integration",
+          hooks: {
+            "astro:config:setup": ({ updateConfig, config }) => {
+              const existingPlugins = (Array.isArray(config.markdown?.remarkPlugins) ? config.markdown.remarkPlugins : []).filter((p) => p !== void 0 && p !== null);
+              updateConfig({
+                markdown: {
+                  remarkPlugins: [...existingPlugins, [remarkLatexCompile, options]]
+                }
+              });
+            }
+          }
+        });
+        hook.addIntegration(
+          createAstroLatexIntegration({
+            svgOutputDir: options.svgOutputDir
+          })
+        );
+      }
+    }
+  };
+}
+var starlight_plugin_default = starlightLatexCompile;
+
+export {
+  starlightLatexCompile,
+  starlight_plugin_default,
+  remarkLatexCompile
+};

package/dist/cli/cannoli-latex-cleanup.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
+import {
+  hashLatexCode
+} from "../chunk-QZUB4DOG.js";
+import "../chunk-QGM4M3NI.js";
 
 // scripts/cli/cannoli-latex-cleanup.ts
 import { readdir, readFile, unlink } from "fs/promises";
 import { resolve, join } from "path";
-import { createHash } from "crypto";
 var args = process.argv.slice(2);
 var svgDir = null;
 var docsDir = "src/content/docs";
@@ -30,10 +33,6 @@ if (!checkMode && !deleteMode) {
 }
 var svgDirPath = resolve(svgDir);
 var docsDirPath = resolve(docsDir);
-function hashLatexCode(code) {
-  const normalized = code.split("\n").map((line) => line.trim()).join("\n").trim();
-  return createHash("md5").update(normalized).digest("hex").slice(0, 16);
-}
 async function scanMarkdownForHashes(dir, hashes) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });

package/dist/index.js

@@ -7,11 +7,12 @@ import {
 import {
   remarkLatexCompile,
   starlightLatexCompile
-} from "./chunk-7NVLVO6Z.js";
+} from "./chunk-UMYD2SJL.js";
 import {
   starlightSyncDocsToPublic
 } from "./chunk-GE24XGG7.js";
 import "./chunk-3ATSZG6H.js";
+import "./chunk-QZUB4DOG.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/plugins/astro-normalize-paths.ts

package/dist/plugins/remark-latex-compile.js

@@ -1,8 +1,10 @@
 import {
-  compileLatexToSvg,
   remarkLatexCompile,
   starlightLatexCompile
-} from "../chunk-7NVLVO6Z.js";
+} from "../chunk-UMYD2SJL.js";
+import {
+  compileLatexToSvg
+} from "../chunk-QZUB4DOG.js";
 import "../chunk-QGM4M3NI.js";
 export {
   compileLatexToSvg,

package/dist/plugins/starlight-latex-compile.js

@@ -1,7 +1,8 @@
 import {
   starlightLatexCompile,
   starlight_plugin_default
-} from "../chunk-7NVLVO6Z.js";
+} from "../chunk-UMYD2SJL.js";
+import "../chunk-QZUB4DOG.js";
 import "../chunk-QGM4M3NI.js";
 export {
   starlight_plugin_default as default,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "starlight-cannoli-plugins",
   "type": "module",
-  "version": "1.2.8",
+  "version": "1.2.9",
   "description": "Starlight plugins for automatic sidebar generation and link validation",
   "license": "ISC",
   "main": "./dist/index.js",

package/dist/chunk-7NVLVO6Z.js

@@ -1,483 +0,0 @@
-// src/plugins/remark-latex-compile/index.ts
-import { resolve } from "path";
-
-// src/plugins/remark-latex-compile/compile.ts
-import { createHash } from "crypto";
-import { spawnSync } from "child_process";
-import {
-  existsSync,
-  mkdirSync,
-  writeFileSync,
-  rmSync,
-  mkdtempSync
-} from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-
-// src/plugins/remark-latex-compile/error-parser.ts
-function parseLatexError(latexOutput) {
-  const lines = latexOutput.split("\n");
-  const errors = [];
-  const seenMessages = /* @__PURE__ */ new Set();
-  let hasFatal = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("!")) {
-      const message = line.substring(1).trim();
-      if (seenMessages.has(message)) continue;
-      seenMessages.add(message);
-      const context = [];
-      let lineNum;
-      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
-        const contextLine = lines[j];
-        if (contextLine.trim()) {
-          context.push(contextLine);
-        }
-        if (contextLine.startsWith("l.")) {
-          const lineMatch = contextLine.match(/^l\.(\d+)/);
-          if (lineMatch) {
-            lineNum = parseInt(lineMatch[1], 10);
-          }
-          break;
-        }
-      }
-      errors.push({
-        message,
-        line: lineNum,
-        context: context.slice(0, 3),
-        severity: "error"
-      });
-    }
-  }
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.includes("Overfull") || line.includes("Underfull")) {
-      const msg = line.trim();
-      if (!seenMessages.has(msg)) {
-        seenMessages.add(msg);
-        errors.push({
-          message: msg,
-          context: [],
-          severity: "warning"
-        });
-      }
-    }
-  }
-  for (const line of lines) {
-    if (line.toLowerCase().includes("emergency stop") || line.toLowerCase().includes("fatal error") || line.toLowerCase().includes("not found")) {
-      hasFatal = true;
-      break;
-    }
-  }
-  if (errors.length === 0 && latexOutput.length > 0) {
-    for (const line of lines) {
-      if (line.includes("error") || line.includes("Error") || line.includes("Misplaced") || line.includes("Missing")) {
-        const msg = line.trim();
-        if (!seenMessages.has(msg)) {
-          seenMessages.add(msg);
-          errors.push({
-            message: msg,
-            context: [],
-            severity: "error"
-          });
-        }
-        break;
-      }
-    }
-  }
-  if (errors.length === 0) {
-    errors.push({
-      message: "Unknown LaTeX compilation error",
-      context: [],
-      severity: "error"
-    });
-  }
-  return { errors, hasFatal };
-}
-function formatLatexError(parsed) {
-  const RED = "\x1B[31m";
-  const YELLOW = "\x1B[33m";
-  const RESET = "\x1B[0m";
-  const errorCount = parsed.errors.filter((e) => e.severity === "error").length;
-  const warningCount = parsed.errors.filter(
-    (e) => e.severity === "warning"
-  ).length;
-  let output = `${RED}[remark-latex-compile] LaTeX compilation failed${RESET}
-`;
-  output += `${RED}${errorCount} error${errorCount !== 1 ? "s" : ""}${RESET}`;
-  if (warningCount > 0) {
-    output += `, ${YELLOW}${warningCount} warning${warningCount !== 1 ? "s" : ""}${RESET}`;
-  }
-  output += "\n\n";
-  const errorsByType = parsed.errors.reduce(
-    (acc, e) => {
-      if (!acc[e.severity]) acc[e.severity] = [];
-      acc[e.severity].push(e);
-      return acc;
-    },
-    {}
-  );
-  for (const err of errorsByType["error"] || []) {
-    output += `${RED}Error${RESET}`;
-    if (err.line) output += ` (line ${err.line})`;
-    output += `: ${err.message}
-`;
-    if (err.context.length > 0) {
-      output += `  Context: ${err.context[0]}
-`;
-    }
-  }
-  for (const warn of errorsByType["warning"] || []) {
-    output += `${YELLOW}Warning${RESET}: ${warn.message}
-`;
-  }
-  return output;
-}
-function formatLatexSourceWithLineNumbers(latexSource, errors) {
-  const RED = "\x1B[31m";
-  const RESET = "\x1B[0m";
-  const lines = latexSource.split("\n");
-  const maxLineNum = lines.length;
-  const lineNumWidth = String(maxLineNum).length;
-  const errorLineNumbers = new Set(errors.map((e) => e.line).filter(Boolean));
-  const formattedLines = lines.map((line, index) => {
-    const lineNum = index + 1;
-    const lineNumStr = String(lineNum);
-    const padding = lineNumStr.length < lineNumWidth ? " " : "";
-    if (errorLineNumbers.has(lineNum)) {
-      return `${padding}${RED}[${lineNumStr}]:${RESET} ${line}`;
-    }
-    return `${padding}[${lineNumStr}]: ${line}`;
-  }).join("\n");
-  return formattedLines;
-}
-function createCompilationErrorMessage(latexSource, rawError) {
-  const parsed = parseLatexError(rawError);
-  const formatted = formatLatexError(parsed);
-  const formattedSource = formatLatexSourceWithLineNumbers(
-    latexSource,
-    parsed.errors
-  );
-  return `${formatted}
-LaTeX source:
-${formattedSource}
-`;
-}
-
-// src/plugins/remark-latex-compile/compile.ts
-function hashLatexCode(code) {
-  const normalized = code.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("%")).filter(Boolean).join("\n").trim();
-  return createHash("md5").update(normalized).digest("hex").slice(0, 16);
-}
-function buildLatexSource(latexCode) {
-  if (latexCode.includes("\\documentclass") && latexCode.includes("\\begin{document}")) {
-    return latexCode.trim();
-  }
-  const separatorRegex = /%[ \t]*===/;
-  const parts = latexCode.split(separatorRegex);
-  let preamble = "";
-  let content = latexCode.trim();
-  if (parts.length === 2) {
-    preamble = parts[0].trim();
-    content = parts[1].trim();
-  }
-  return [
-    "\\documentclass[border=5pt]{standalone}",
-    preamble,
-    "\\begin{document}",
-    "\\Large",
-    content,
-    "\\end{document}"
-  ].join("\n");
-}
-function compileLatexToSvg(latexCode, svgOutputDir) {
-  const hash = hashLatexCode(latexCode);
-  const svgPath = join(svgOutputDir, `${hash}.svg`);
-  if (existsSync(svgPath)) {
-    return { hash, svgPath, wasCompiled: false };
-  }
-  mkdirSync(svgOutputDir, { recursive: true });
-  const workDir = mkdtempSync(join(tmpdir(), "latex-compile-"));
-  const texFile = join(workDir, "diagram.tex");
-  const pdfFile = join(workDir, "diagram.pdf");
-  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;
-      throw new Error(
-        `[remark-latex-compile] pdflatex not found on PATH (${code}).`
-      );
-    }
-    if (latexResult.status !== 0) {
-      const errorOutput = latexResult.stderr?.toString() || latexResult.stdout?.toString() || "";
-      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;
-      throw new Error(
-        `[remark-latex-compile] dvisvgm not found on PATH (${code}).`
-      );
-    }
-    if (dvisvgmResult.status !== 0) {
-      const errorOutput = dvisvgmResult.stderr?.toString() || dvisvgmResult.stdout?.toString() || "";
-      throw new Error(
-        `[remark-latex-compile] PDF to SVG conversion failed (hash: ${hash}).
-Error: ${errorOutput}`
-      );
-    }
-  } finally {
-    try {
-      rmSync(workDir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  return { hash, svgPath, wasCompiled: true };
-}
-
-// src/plugins/remark-latex-compile/index.ts
-function extractClassesFromMeta(meta) {
-  const classMatch = meta.match(/class="([^"]+)"/);
-  if (classMatch && classMatch[1]) {
-    return classMatch[1].split(/\s+/).filter(Boolean);
-  }
-  return [];
-}
-function traverseTree(node, svgOutputDir, filePath, depth = 0) {
-  if (!node) return;
-  const children = node.children;
-  if (Array.isArray(children)) {
-    for (let i = 0; i < children.length; i++) {
-      const child = children[i];
-      if (child.type === "code" && (child.lang === "tex" || child.lang === "latex") && String(child.meta || "").includes("compile")) {
-        try {
-          const result = compileLatexToSvg(String(child.value), svgOutputDir);
-          const customClasses = extractClassesFromMeta(
-            String(child.meta || "")
-          );
-          const allClasses = ["tex-compiled", ...customClasses];
-          children[i] = {
-            type: "paragraph",
-            children: [
-              {
-                type: "image",
-                url: `/static/tex-svgs/${result.hash}.svg`,
-                alt: "LaTeX diagram",
-                data: {
-                  hProperties: {
-                    className: allClasses
-                  }
-                }
-              }
-            ]
-          };
-        } catch (err) {
-          if (process.env.NODE_ENV !== "production") {
-            const position = child.position;
-            const lineNumber = position?.start?.line || "?";
-            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(`${filePath}:${lineNumber}
-${details}`);
-          }
-        }
-      } else {
-        traverseTree(child, svgOutputDir, filePath, depth + 1);
-      }
-    }
-  }
-}
-function remarkLatexCompile(options) {
-  const svgOutputDir = resolve(options.svgOutputDir);
-  return (tree, file) => {
-    const fileObj = file;
-    const filePath = String(fileObj?.path || fileObj?.filename || "unknown");
-    traverseTree(tree, svgOutputDir, filePath, 0);
-  };
-}
-
-// src/plugins/remark-latex-compile/astro-integration.ts
-import { readdir, readFile, writeFile } from "fs/promises";
-import { resolve as resolve2, join as join2, extname } from "path";
-import { createHash as createHash2 } from "crypto";
-function hashLatexCode2(code) {
-  const normalized = code.split("\n").map((line) => line.trim()).join("\n").trim();
-  return createHash2("md5").update(normalized).digest("hex").slice(0, 16);
-}
-function createAstroLatexIntegration(options) {
-  const svgOutputDir = resolve2(options.svgOutputDir);
-  const contentDir = options?.contentDir ? resolve2(options.contentDir) : resolve2("src/content/docs");
-  return {
-    name: "astro-latex-compile",
-    hooks: {
-      "astro:build:start": async () => {
-        console.log(
-          "[astro-latex-compile] Build start, scanning for tex/latex compile blocks"
-        );
-        await scanAndCompileLatex(contentDir, svgOutputDir);
-      },
-      "astro:build:done": async ({ dir }) => {
-        console.log(
-          "[astro-latex-compile] Build done, updating HTML references"
-        );
-        try {
-          await updateHtmlReferences(dir.pathname, contentDir, svgOutputDir);
-        } catch (err) {
-          console.error(
-            "[astro-latex-compile] Error updating HTML references:",
-            err
-          );
-        }
-      }
-    }
-  };
-}
-async function scanAndCompileLatex(dir, svgOutputDir) {
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      await scanAndCompileLatex(fullPath, svgOutputDir);
-    } else if (entry.isFile()) {
-      const ext = extname(entry.name);
-      if (ext === ".md" || ext === ".mdx") {
-        await processMarkdownFile(fullPath, svgOutputDir);
-      }
-    }
-  }
-}
-function getLineNumber(content, position) {
-  return content.substring(0, position).split("\n").length;
-}
-async function processMarkdownFile(filePath, svgOutputDir) {
-  const content = await readFile(filePath, "utf-8");
-  const latexBlockRegex = /```(?:tex|latex)\s+compile\n([\s\S]*?)\n```/g;
-  const matches = content.matchAll(latexBlockRegex);
-  for (const match of matches) {
-    const latexCode = match[1];
-    const lineNumber = getLineNumber(content, match.index || 0);
-    try {
-      const result = compileLatexToSvg(latexCode, svgOutputDir);
-      const status = result.wasCompiled ? "compiled" : "used cached";
-      console.log(
-        `[astro-latex-compile] ${filePath}:${lineNumber}: ${status} ${result.hash}.svg`
-      );
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      error.message = `${filePath}:${lineNumber}
-${error.message}`;
-      throw error;
-    }
-  }
-}
-async function updateHtmlReferences(buildDir, contentDir, svgOutputDir) {
-  const latexHashes = [];
-  const entries = await readdir(contentDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join2(contentDir, entry.name);
-    if (entry.isDirectory()) {
-      await scanMarkdownForHashes(fullPath, latexHashes);
-    }
-  }
-  await updateHtmlDirWithHashes(buildDir, latexHashes, svgOutputDir);
-}
-async function scanMarkdownForHashes(dir, hashes) {
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      await scanMarkdownForHashes(fullPath, hashes);
-    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
-      const content = await readFile(fullPath, "utf-8");
-      const latexBlockRegex = /```(?:tex|latex)\s+compile\n([\s\S]*?)\n```/g;
-      const matches = content.matchAll(latexBlockRegex);
-      for (const match of matches) {
-        const latexCode = match[1];
-        const hash = hashLatexCode2(latexCode);
-        hashes.push(hash);
-      }
-    }
-  }
-}
-async function updateHtmlDirWithHashes(dir, hashes, svgOutputDir) {
-  let hashIndex = 0;
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      await updateHtmlDirWithHashes(fullPath, hashes, svgOutputDir);
-    } else if (entry.isFile() && entry.name.endsWith(".html")) {
-      let content = await readFile(fullPath, "utf-8");
-      let modified = false;
-      const pathSegments = svgOutputDir.split("/").slice(-2).join("/");
-      const htmlPath = `/${pathSegments}`;
-      const svgRegex = new RegExp(`src="${htmlPath}/[a-f0-9]+\\.svg"`, "g");
-      content = content.replace(svgRegex, (match) => {
-        if (hashIndex < hashes.length) {
-          modified = true;
-          return `src="${htmlPath}/${hashes[hashIndex++]}.svg"`;
-        }
-        return match;
-      });
-      if (modified) {
-        await writeFile(fullPath, content, "utf-8");
-        console.log(`[astro-latex-compile] Updated ${fullPath}`);
-      }
-    }
-  }
-}
-
-// src/plugins/remark-latex-compile/starlight-plugin.ts
-function starlightLatexCompile(options) {
-  return {
-    name: "starlight-latex-compile",
-    hooks: {
-      "config:setup": (hook) => {
-        hook.addIntegration({
-          name: "latex-compile-remark-integration",
-          hooks: {
-            "astro:config:setup": ({ updateConfig, config }) => {
-              const existingPlugins = (Array.isArray(config.markdown?.remarkPlugins) ? config.markdown.remarkPlugins : []).filter((p) => p !== void 0 && p !== null);
-              updateConfig({
-                markdown: {
-                  remarkPlugins: [...existingPlugins, [remarkLatexCompile, options]]
-                }
-              });
-            }
-          }
-        });
-        hook.addIntegration(
-          createAstroLatexIntegration({
-            svgOutputDir: options.svgOutputDir
-          })
-        );
-      }
-    }
-  };
-}
-var starlight_plugin_default = starlightLatexCompile;
-
-export {
-  compileLatexToSvg,
-  starlightLatexCompile,
-  starlight_plugin_default,
-  remarkLatexCompile
-};