@pi-archimedes/core 2.7.3 → 2.9.0

package/src/thinking/theme.test.ts

@@ -1,216 +0,0 @@
-import { describe, it, expect } from "vitest";
-import * as fc from "fast-check";
-import { dimAnsiLine, buildMutedMarkdownTheme } from "./theme.js";
-import { stripAnsi } from "../text.js";
-
-// ── dimAnsiLine ──────────────────────────────────────────────────────────────
-
-describe("dimAnsiLine", () => {
-	const makeCache = () => new Map<string, string>();
-
-	it("dims a single truecolor fg escape", () => {
-		const cache = makeCache();
-		const input = "\x1b[38;2;255;128;64mhello";
-		const result = dimAnsiLine(input, 0.4, 0.5, cache);
-		// Output should still be a truecolor fg escape (38;2;...)
-		expect(result).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello/);
-		// But the color should be different (dimmed)
-		expect(result).not.toBe(input);
-	});
-
-	it("dims multiple fg escapes in one line", () => {
-		const cache = makeCache();
-		const input = "\x1b[38;2;255;0;0mred\x1b[38;2;0;0;255mblue";
-		const result = dimAnsiLine(input, 0.4, 0.5, cache);
-		// Both escapes should be rewritten to dimmed versions
-		expect(result).not.toContain("\x1b[38;2;255;0;0m");
-		expect(result).not.toContain("\x1b[38;2;0;0;255m");
-		// Text content preserved
-		expect(stripAnsi(result)).toBe("redblue");
-	});
-
-	it("leaves lines with no fg escapes unchanged", () => {
-		const cache = makeCache();
-		const input = "plain text without escapes";
-		const result = dimAnsiLine(input, 0.4, 0.5, cache);
-		expect(result).toBe(input);
-	});
-
-	it("preserves non-fg escapes (bold, italic, reset)", () => {
-		const cache = makeCache();
-		const input = "\x1b[1mbold\x1b[0m \x1b[3mitalic\x1b[23m";
-		const result = dimAnsiLine(input, 0.4, 0.5, cache);
-		expect(result).toContain("\x1b[1m");
-		expect(result).toContain("\x1b[0m");
-		expect(result).toContain("\x1b[3m");
-		expect(result).toContain("\x1b[23m");
-	});
-
-	it("cache hit returns same result", () => {
-		const cache = makeCache();
-		const escape = "\x1b[38;2;200;100;50m";
-		const input = `${escape}text`;
-		const first = dimAnsiLine(input, 0.4, 0.5, cache);
-		const second = dimAnsiLine(input, 0.4, 0.5, cache);
-		expect(first).toBe(second);
-		// Cache should have the entry
-		expect(cache.has(escape)).toBe(true);
-	});
-
-	it("passes through unrecognized escapes unchanged", () => {
-		const cache = makeCache();
-		// A bg escape (48;2;...) should not be matched by FG_COLOR_ESCAPE_RE
-		const input = "\x1b[48;2;10;10;10mbg text";
-		const result = dimAnsiLine(input, 0.4, 0.5, cache);
-		expect(result).toBe(input);
-	});
-
-	it("dims 256-palette fg escapes to truecolor", () => {
-		const cache = makeCache();
-		const input = "\x1b[38;5;196mred"; // 256-palette red
-		const result = dimAnsiLine(input, 0.4, 0.5, cache);
-		// Output should be truecolor (38;2;...), not 256-palette
-		expect(result).toMatch(/\x1b\[38;2;\d+;\d+;\d+mred/);
-		expect(result).not.toContain("\x1b[38;5;");
-	});
-
-	it("handles empty string", () => {
-		const cache = makeCache();
-		expect(dimAnsiLine("", 0.4, 0.5, cache)).toBe("");
-	});
-
-	it("property: preserves non-ANSI text content", () => {
-		fc.assert(
-			fc.property(
-				fc.string({ maxLength: 200 }),
-				(s) => {
-					const cache = makeCache();
-					const result = dimAnsiLine(s, 0.4, 0.5, cache);
-					return stripAnsi(s) === stripAnsi(result);
-				},
-			),
-		);
-	});
-
-	it("property: never introduces 38;5; escapes (only produces truecolor 38;2;)", () => {
-		fc.assert(
-			fc.property(
-				fc.string({ maxLength: 200 }),
-				(s) => {
-					const cache = makeCache();
-					const result = dimAnsiLine(s, 0.4, 0.5, cache);
-					// Any 38;5; in output must have been in the input
-					// (dimAnsiLine only produces 38;2; output)
-					const inputHas256 = s.includes("38;5;");
-					const outputHas256 = result.includes("38;5;");
-					// If input didn't have 38;5;, output shouldn't either
-					// (because we only dim via truecolor)
-					if (!inputHas256) {
-						return !outputHas256;
-					}
-					// If input had 38;5;, they get replaced with 38;2;
-					// So output should NOT have 38;5; either
-					return !outputHas256;
-				},
-			),
-		);
-	});
-});
-
-// ── buildMutedMarkdownTheme ──────────────────────────────────────────────────
-
-describe("buildMutedMarkdownTheme", () => {
-	const mockTheme = {
-		fg: (token: string, text: string) => `\x1b[38;2;180;180;180m${text}\x1b[0m`,
-		getFgAnsi: (token: string) => "\x1b[38;2;180;180;180m",
-		italic: (text: string) => `\x1b[3m${text}\x1b[23m`,
-	};
-
-	it("returns MarkdownTheme with all required fields", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		expect(typeof theme.codeBlockIndent).toBe("string");
-		expect(typeof theme.heading).toBe("function");
-		expect(typeof theme.link).toBe("function");
-		expect(typeof theme.linkUrl).toBe("function");
-		expect(typeof theme.code).toBe("function");
-		expect(typeof theme.codeBlock).toBe("function");
-		expect(typeof theme.codeBlockBorder).toBe("function");
-		expect(typeof theme.quote).toBe("function");
-		expect(typeof theme.quoteBorder).toBe("function");
-		expect(typeof theme.hr).toBe("function");
-		expect(typeof theme.listBullet).toBe("function");
-		expect(typeof theme.bold).toBe("function");
-		expect(typeof theme.italic).toBe("function");
-		expect(typeof theme.strikethrough).toBe("function");
-		expect(typeof theme.underline).toBe("function");
-		expect(typeof theme.highlightCode).toBe("function");
-	});
-
-	it("heading uses gold color (#FFD700)", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		const result = theme.heading("Title");
-		// Gold is #FFD700 = rgb(255, 215, 0)
-		expect(result).toContain("\x1b[38;2;255;215;0m");
-		expect(result).toContain("Title");
-	});
-
-	it("bold uses gold color (#FFD700)", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		const result = theme.bold("Strong");
-		expect(result).toContain("\x1b[38;2;255;215;0m");
-		expect(result).toContain("Strong");
-	});
-
-	it("codeBlock uses thinkingText", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		const result = theme.codeBlock("code here");
-		expect(result).toContain("code here");
-	});
-
-	it("italic wraps with ANSI italic codes", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		const result = theme.italic("slanted");
-		expect(result).toContain("\x1b[3m");
-		expect(result).toContain("\x1b[23m");
-		expect(result).toContain("slanted");
-	});
-
-	it("codeBlockIndent is empty string", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		expect(theme.codeBlockIndent).toBe("");
-	});
-
-	it("highlightCode returns array of strings", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		const result = theme.highlightCode!("const x = 1;", "javascript");
-		expect(Array.isArray(result)).toBe(true);
-		expect(result.length).toBeGreaterThan(0);
-	});
-
-	it("highlightCode dims ANSI escapes in output", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any);
-		const result = theme.highlightCode!("const x = 1;", "javascript");
-		// Output should contain dimmed truecolor escapes
-		const joined = result.join("\n");
-		expect(joined).toMatch(/\x1b\[38;2;\d+;\d+;\d+m/);
-	});
-
-	it("different saturationFactor produces different dimmed output", () => {
-		const cache = new Map<string, string>();
-		const input = "\x1b[38;2;255;128;64mhello";
-		const resultLow = dimAnsiLine(input, 0.4, 0.3, cache);
-		const cache2 = new Map<string, string>();
-		const resultHigh = dimAnsiLine(input, 0.4, 0.7, cache2);
-		// Same input with different saturation factors must produce different escapes
-		expect(resultLow).not.toBe(resultHigh);
-		// Both must still be valid truecolor fg escapes
-		expect(resultLow).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello/);
-		expect(resultHigh).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello/);
-	});
-
-	it("accepts custom codeDefaultLightness", () => {
-		const theme = buildMutedMarkdownTheme(mockTheme as any, { codeDefaultLightness: 0.9 });
-		const result = theme.highlightCode!("test", "plaintext");
-		expect(Array.isArray(result)).toBe(true);
-	});
-});

package/src/thinking/theme.ts

@@ -1,156 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import {
-  highlightCode as piHighlightCode,
-  initTheme as piInitTheme,
-} from "@earendil-works/pi-coding-agent";
-import type { MarkdownTheme } from "@earendil-works/pi-tui";
-import {
-  deriveDimColor,
-  hslToRgb,
-  parseAnsiFgToRgb,
-  rgbToHsl,
-  rgbToTruecolorFg,
-  hexToRgb,
-} from "../color.js";
-
-export interface MutedThemeOptions {
-  saturationFactor?: number; // default 0.5
-  codeDefaultLightness?: number; // default 0.85 — lighter than the token dim floor
-}
-
-const DEFAULT_ANCHOR_L = 0.4;
-const DEFAULT_CODE_DEFAULT_L = 0.85;
-
-// Matches any foreground-color SGR escape: truecolor (38;2;r;g;b) or 256-palette (38;5;n).
-// We intentionally only target fg color escapes; bg (48;...) and style escapes
-// (bold/italic/reset/etc.) are left untouched.
-const FG_COLOR_ESCAPE_RE = /\x1b\[38;(?:2;\d{1,3};\d{1,3};\d{1,3}|5;\d{1,3})m/g;
-
-// pi 0.84.4's module-level `highlightCode` reads a *global* Theme
-// singleton that throws until `initTheme()` runs. pi's interactive
-// mode initializes it at startup, but contexts that build the muted
-// theme without going through that initialization (e.g. unit tests)
-// would otherwise get "Theme not initialized. Call initTheme() first."
-// We probe on first use and, only when the global is not set, call
-// `initTheme("dark")` — built-in theme, no file watcher attached.
-let piThemeReady = false;
-function ensurePiHighlightable(): void {
-  if (piThemeReady) return;
-  piThemeReady = true;
-  try {
-    piHighlightCode(""); // probe: throws when the global is unset
-  } catch (err) {
-    // Only fall back when the probe failed for the known reason, so an
-    // already-established pi theme is never clobbered by a surprise. 
-    if (String(err).includes("Theme not initialized")) piInitTheme("dark");
-  }
-}
-
-/**
- * Rewrite every foreground-color SGR escape in `line` to its dimmed truecolor
- * variant, preserving all other content (text, non-color escapes, resets).
- *
- * The cache memoizes raw→dim escape strings; callers should share a single
- * cache across all lines in one theme-build invocation — highlightCode runs
- * on every streaming chunk so the rewrite must be cheap.
- */
-export function dimAnsiLine(
-  line: string,
-  anchorL: number,
-  saturationFactor: number,
-  cache: Map<string, string>,
-): string {
-  return line.replace(FG_COLOR_ESCAPE_RE, (match) => {
-    const cached = cache.get(match);
-    if (cached !== undefined) return cached;
-    const rgb = parseAnsiFgToRgb(match);
-    if (!rgb) {
-      cache.set(match, match);
-      return match;
-    }
-    // deriveDimColor takes hex; we already have rgb, so build a hex string.
-    const hex =
-      "#" +
-      [rgb.r, rgb.g, rgb.b]
-        .map((v) => v.toString(16).padStart(2, "0"))
-        .join("");
-    const dimHex = deriveDimColor(hex, anchorL, saturationFactor);
-    const dimmed = rgbToTruecolorFg(hexToRgb(dimHex));
-    cache.set(match, dimmed);
-    return dimmed;
-  });
-}
-
-export function buildMutedMarkdownTheme(
-  piTheme: Theme,
-  opts: MutedThemeOptions = {},
-): MarkdownTheme {
-  const saturationFactor = opts.saturationFactor ?? 0.5;
-  const codeDefaultL = opts.codeDefaultLightness ?? DEFAULT_CODE_DEFAULT_L;
-
-  // Anchor lightness: derived from the theme's thinkingText foreground color.
-  const thinkingAnsi = piTheme.getFgAnsi("thinkingText");
-  const anchorRgb = parseAnsiFgToRgb(thinkingAnsi);
-  const anchorHsl = anchorRgb ? rgbToHsl(anchorRgb) : null;
-  const anchorL = anchorHsl ? anchorHsl.l : DEFAULT_ANCHOR_L;
-
-  // Default fg color used for UN-highlighted chars inside code blocks.
-  // cli-highlight only emits color escapes for recognized tokens — the gaps
-  // between them (operators, whitespace, unrecognized identifiers) render in
-  // the terminal's default color (often bright white on dark themes).
-  //
-  // We build a color that harmonizes with thinkingText (same hue/saturation)
-  // but sits at a BRIGHTER lightness than the token dim floor (anchorL),
-  // so white text is dimmed noticeably less than the colored tokens. Prepend
-  // this escape per line and re-emit it after every `\x1b[39m` fg reset so
-  // the gaps inherit this color instead of the terminal default.
-  const codeDefaultFg = anchorHsl
-    ? rgbToTruecolorFg(
-      hslToRgb({
-        h: anchorHsl.h,
-        s: anchorHsl.s,
-        l: codeDefaultL,
-      }),
-    )
-    : "";
-
-  // Shared memoization cache for the entire theme lifetime.
-  const dimCache = new Map<string, string>();
-
-  const fg = (token: string, text: string) =>
-    piTheme.fg(token as Parameters<Theme["fg"]>[0], text);
-
-  return {
-    codeBlockIndent: "",
-    heading: (text) => `\x1b[1m${rgbToTruecolorFg(hexToRgb("#FFD700"))}${text}\x1b[39m\x1b[22m`,
-    link: (text) => `\x1b[4m${fg("thinkingText", text)}\x1b[24m`,
-    linkUrl: (text) => fg("dim", text),
-    code: (text) => fg("dim", text),
-    codeBlock: (text) => fg("thinkingText", text),
-    codeBlockBorder: (text) => fg("dim", text),
-    quote: (text) => fg("thinkingText", text),
-    quoteBorder: (text) => fg("dim", text),
-    hr: (text) => fg("dim", text),
-    listBullet: (text) => fg("dim", text),
-    bold: (text) => `\x1b[1m${rgbToTruecolorFg(hexToRgb("#FFD700"))}${text}\x1b[39m\x1b[22m`,
-    italic: (text) => `\x1b[3m${text}\x1b[23m`,
-    strikethrough: (text) => `\x1b[9m${fg("dim", text)}\x1b[29m`,
-    underline: (text) => `\x1b[4m${fg("thinkingText", text)}\x1b[24m`,
-    highlightCode: (code, lang) => {
-      ensurePiHighlightable();
-      const lines = piHighlightCode(code, lang);
-      return lines.map((l) => {
-        const dimmed = dimAnsiLine(l, anchorL, saturationFactor, dimCache);
-        if (!codeDefaultFg) return dimmed;
-        // Blanket the line in the code-default color; after every fg reset
-        // (emitted by cli-highlight between colored tokens) re-open the
-        // default so un-tokenized chars inherit it.
-        const withDefault = dimmed.replace(
-          /\x1b\[39m/g,
-          `\x1b[39m${codeDefaultFg}`,
-        );
-        return `${codeDefaultFg}${withDefault}\x1b[39m`;
-      });
-    },
-  };
-}

package/src/thinking/transform.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { transformThinkingContent } from "./transform.js";
-
-describe("transformThinkingContent", () => {
-  it("modifies thinking content on assistant messages", () => {
-    const message = {
-      role: "assistant" as const,
-      content: [
-        { type: "thinking" as const, thinking: "  some thinking  " },
-      ],
-    };
-    transformThinkingContent(message);
-    expect(message.content[0]!.thinking).toBe("some thinking");
-  });
-
-  it("skips non-assistant messages", () => {
-    const message = {
-      role: "user" as const,
-      content: [
-        { type: "thinking" as const, thinking: "  should not change  " },
-      ],
-    };
-    transformThinkingContent(message);
-    expect(message.content[0]!.thinking).toBe("  should not change  ");
-  });
-
-  it("skips empty thinking", () => {
-    const message = {
-      role: "assistant" as const,
-      content: [
-        { type: "thinking" as const, thinking: "   " },
-      ],
-    };
-    transformThinkingContent(message);
-    expect(message.content[0]!.thinking).toBe("   ");
-  });
-
-  it("skips thinking with undefined value", () => {
-    const message = {
-      role: "assistant" as const,
-      content: [
-        { type: "thinking" as const } as { type: string; thinking?: string },
-      ],
-    };
-    transformThinkingContent(message);
-    expect(message.content[0]!.thinking).toBeUndefined();
-  });
-
-  it("calls unindentCodeBlocks on thinking content", () => {
-    const message = {
-      role: "assistant" as const,
-      content: [
-        {
-          type: "thinking" as const,
-          thinking: "```\n    indented code\n    more code\n```",
-        },
-      ],
-    };
-    transformThinkingContent(message);
-    expect(message.content[0]!.thinking).toBe("```\nindented code\nmore code\n```");
-  });
-
-  it("handles mixed content types", () => {
-    const message = {
-      role: "assistant" as const,
-      content: [
-        { type: "text" as const, text: "some text" },
-        { type: "thinking" as const, thinking: "  thinking content  " },
-        { type: "text" as const, text: "more text" },
-      ],
-    };
-    transformThinkingContent(message);
-    expect(message.content[0]).toEqual({ type: "text", text: "some text" });
-    expect(message.content[1]!.thinking).toBe("thinking content");
-    expect(message.content[2]).toEqual({ type: "text", text: "more text" });
-  });
-
-  it("after transform, thinking is trimmed", () => {
-    const message = {
-      role: "assistant" as const,
-      content: [
-        { type: "thinking" as const, thinking: "  hello world  " },
-      ],
-    };
-    transformThinkingContent(message);
-    const thinking = message.content[0]!.thinking;
-    expect(thinking).toBe(thinking?.trim());
-  });
-});

package/src/thinking/transform.ts

@@ -1,21 +0,0 @@
-import { unindentCodeBlocks } from "./unindent.js";
-
-/**
- * message_end handler: mutate thinking content before it reaches the UI.
- *
- * Only does unindent of fenced code blocks. The "Thinking..." label is
- * prepended inside updateContent (patch.ts) so it appears during streaming,
- * not just after thinking completes.
- */
-export function transformThinkingContent(
-	message: { role: string; content: Array<{ type: string; thinking?: string }> },
-): void {
-	if (message.role !== "assistant") return;
-
-	for (const content of message.content) {
-		if (content.type === "thinking" && content.thinking?.trim()) {
-			const trimmed = content.thinking.trim();
-			content.thinking = unindentCodeBlocks(trimmed);
-		}
-	}
-}

package/src/thinking/unindent.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect } from "vitest";
-import * as fc from "fast-check";
-import { unindentCodeBlocks } from "./unindent.js";
-
-describe("unindentCodeBlocks", () => {
-  it("strips common leading whitespace from fenced code blocks", () => {
-    const input = "```\n    line1\n    line2\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\nline1\nline2\n```");
-  });
-
-  it("preserves empty lines structure", () => {
-    const input = "```\n    line1\n\n    line2\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\nline1\n\nline2\n```");
-  });
-
-  it("leaves whitespace-only blocks untouched", () => {
-    const input = "```\n    \n    \n```";
-    expect(unindentCodeBlocks(input)).toBe("```\n    \n    \n```");
-  });
-
-  it("handles CRLF → LF normalization", () => {
-    const input = "```\r\n    line1\r\n    line2\r\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\nline1\nline2\n```");
-  });
-
-  it("handles blocks with 0 indent on some lines (no stripping)", () => {
-    const input = "```\n    indented\nnotindented\n    indented\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\n    indented\nnotindented\n    indented\n```");
-  });
-
-  it("strips trailing empty lines from code blocks", () => {
-    const input = "```\n    line1\n    line2\n\n\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\nline1\nline2\n```");
-  });
-
-  it("handles language tags", () => {
-    const input = "```python\n    def foo():\n        pass\n```";
-    expect(unindentCodeBlocks(input)).toBe("```python\ndef foo():\n    pass\n```");
-  });
-
-  it("leaves text outside code blocks unchanged", () => {
-    const input = "Some text\n```\n    code\n```\nMore text";
-    expect(unindentCodeBlocks(input)).toBe("Some text\n```\ncode\n```\nMore text");
-  });
-
-  it("handles multiple code blocks", () => {
-    const input = "```\n    block1\n```\n```\n    block2\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\nblock1\n```\n```\nblock2\n```");
-  });
-
-  it("handles empty code blocks with content", () => {
-    const input = "```\n```";
-    expect(unindentCodeBlocks(input)).toBe("```\n```");
-  });
-
-  it("property: idempotence — unindentCodeBlocks(unindentCodeBlocks(x)) === unindentCodeBlocks(x)", () => {
-    fc.assert(
-      fc.property(fc.string({ maxLength: 500 }), (s) => {
-        const once = unindentCodeBlocks(s);
-        const twice = unindentCodeBlocks(once);
-        return once === twice;
-      }),
-    );
-  });
-
-  it("property: output never contains CRLF (\\r\\n)", () => {
-    fc.assert(
-      fc.property(fc.string({ maxLength: 500 }), (s) => {
-        const result = unindentCodeBlocks(s);
-        return !result.includes("\r\n");
-      }),
-    );
-  });
-});

package/src/thinking/unindent.ts

@@ -1,74 +0,0 @@
-/**
- * Strip common leading whitespace and trailing blank lines from every fenced
- * code block in `text`.  Returns the transformed string.
- *
- * Algorithm per block:
- * 0. Normalize `\r\n` → `\n` in the full input text before processing.
- * 1. Find the minimum leading whitespace across all non-empty lines.
- * 2. Strip that many characters from the start of every line
- *    (empty lines stay empty — they contribute no content but preserve structure).
- * 3. Pop trailing empty lines.
- *
- * Trailing blank lines are ALWAYS stripped, even from 0-indent blocks.
- * Leading whitespace is only stripped when minIndent > 0.
- * Blocks containing only whitespace are left untouched.
- *
- * Known limitations:
- * - Only space-based indentation is handled (tabs are not expanded).
- * - If one line has 0 indent and others have N indent, nothing is stripped
- *   (minIndent === 0). This is standard textwrap.dedent behavior.
- * - Fenced code blocks using 4+ backticks may be misparsed. The regex uses a
- *   negative lookahead to reject 4+ backtick openings (`/^(```(?!`))/
- * - Line endings in the output are always `\n` (CRLF input is normalized).
- */
-export function unindentCodeBlocks(text: string): string {
-	// Step 0: normalize CRLF → LF
-	text = text.replace(/\r\n/g, "\n");
-
-	// Regex matches fenced code blocks with 3 backticks (not 4+).
-	// Group 1: opening fence
-	// Group 2: language tag (may be empty)
-	// Group 3: block content (everything between fences)
-	// Group 4: closing fence
-	const regex = /^(```(?!`))([^\n]*)\n([\s\S]*?)^(```(?!`))[ \t]*$/gm;
-
-	return text.replace(regex, (match, opening, lang, content, closing) => {
-		const lines = content.split("\n");
-
-		// Check if all lines are empty or whitespace-only → leave untouched
-		const allWhitespace = lines.every((line: string) => line.trim() === "");
-		if (allWhitespace) {
-			return match;
-		}
-
-		// Find minimum leading space count across non-empty lines
-		let minIndent = Infinity;
-		for (const line of lines) {
-			if (line.length === 0) continue; // skip empty lines
-			const m = line.match(/^( +)/);
-			if (m) {
-				minIndent = Math.min(minIndent, m[1].length);
-			} else {
-				// Line has no leading spaces → minIndent is 0
-				minIndent = 0;
-				break;
-			}
-		}
-
-		// Strip common leading whitespace (only if minIndent > 0)
-		if (minIndent > 0 && minIndent !== Infinity) {
-			for (let i = 0; i < lines.length; i++) {
-				if (lines[i].length >= minIndent) {
-					lines[i] = lines[i].slice(minIndent);
-				}
-			}
-		}
-
-		// Pop trailing empty lines
-		while (lines.length > 0 && lines[lines.length - 1] === "") {
-			lines.pop();
-		}
-
-		return `${opening}${lang}\n${lines.join("\n")}\n${closing}`;
-	});
-}