[Bug] preprocessLaTeX mutates fenced code block content in Default render mode

[rickintoplace]

Describe the bug

In Default render mode, fenced code blocks containing regex character classes are rendered incorrectly.

Reproduction

Input:

|[\]\\]/g

const re = /[.*+?^${}()|[\]\\]/g;

Actual result in Default mode

|[$\$/g

const re = /[.*+?^${}()|[$\$/g;

Expected behavior

Expected result

|[\]\\]/g

const re = /[.*+?^${}()|[\]\\]/g;

Screenshots or logs

The same content renders correctly in Markdown and Plaintext mode.
The issue only occurs in Default, which calls:

preprocessLaTeX(contentToRender)

The problem appears to be in MarkdownRenderer.jsx, inside preprocessLaTeX.

Code blocks are temporarily replaced with placeholders, but then restored before these global replacements are executed:

processedContent = processedContent
  .replace(/\\\[/g, "$$")
  .replace(/\\\]/g, "$$")
  .replace(/\\\(/g, "$")
  .replace(/\\\)/g, "$");

As a result, code block content is modified. For example, the \] sequence inside a regex is interpreted as a LaTeX delimiter and replaced.

There is also a second issue: in JavaScript replacement strings, "$$" means a single literal $, not two dollar signs. So this replacement:

.replace(/\\\]/g, "$$")

inserts $, not $$.

Suggested fix

Restore code blocks only after the LaTeX delimiter replacements, and use replacement callbacks for literal dollar signs:

  processedContent = processedContent.replace(/<<LATEX_(\d+)>>/g, (_, i) => {
    return latexExpressions[parseInt(i)];
  });

- processedContent = processedContent.replace(
-   /<<CODE_BLOCK_(\d+)>>/g,
-   (_, i) => {
-     return codeBlocks[parseInt(i)];
-   }
- );

  processedContent = processedContent
-   .replace(/\\\[/g, "$$")
-   .replace(/\\\]/g, "$$")
-   .replace(/\\\(/g, "$")
-   .replace(/\\\)/g, "$");
+   .replace(/\\\[/g, () => "$$")
+   .replace(/\\\]/g, () => "$$")
+   .replace(/\\\(/g, () => "$")
+   .replace(/\\\)/g, () => "$");

+ processedContent = processedContent.replace(
+   /<<CODE_BLOCK_(\d+)>>/g,
+   (_, i) => {
+     return codeBlocks[parseInt(i)];
+   }
+ );

Environment

No response

Confirmation

• I have confirmed this bug exists on the latest version
• I have searched through existing issues
• I have checked the Network connection
• I reproduced the bug couple of times to ensure the source of that

[rickintoplace]

Default is broken	Markdown works	Fixed default

Below is a Tampermonkey-Hotfix that works for me

Tampermonkey-JS

// ==UserScript==
// @name         chat-ai MarkdownRenderer LaTeX/codeblock hotfix
// @namespace    local-hotfix
// @version      2026-05-17
// @description  Prevent preprocessLaTeX-style replacements from mutating fenced/inline code!
// @author       Rick
// @match        https://chat-ai.academiccloud.de/chat/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=academiccloud.de
// @grant        none
// ==/UserScript==

(function () {
  "use strict";

  if (window.__MarkdownRendererLatexCodeblockHotfixInstalled) {
    return;
  }

  window.__MarkdownRendererLatexCodeblockHotfixInstalled = true;

  const nativeReplace = String.prototype.replace;

  const latexDelimiterReplacements = new Map([
    [String.raw`\\\[`, "$$"],
    [String.raw`\\\]`, "$$"],
    [String.raw`\\\(`, "$"],
    [String.raw`\\\)`, "$"],
  ]);

  const codeBlockOrInlineCodeRegex = /(```[\s\S]*?```|`[^`\n]+`)/g;

  function replaceOutsideMarkdownCode(input, searchRegex, literalReplacement) {
    const text = String(input);

    let output = "";
    let lastIndex = 0;
    let match;

    codeBlockOrInlineCodeRegex.lastIndex = 0;

    while ((match = codeBlockOrInlineCodeRegex.exec(text)) !== null) {
      const beforeCode = text.slice(lastIndex, match.index);
      const code = match[0];

      const freshRegex = new RegExp(searchRegex.source, searchRegex.flags);

      output += nativeReplace.call(
        beforeCode,
        freshRegex,
        () => literalReplacement
      );

      output += code;

      lastIndex = match.index + code.length;
    }

    const afterLastCode = text.slice(lastIndex);
    const freshRegex = new RegExp(searchRegex.source, searchRegex.flags);

    output += nativeReplace.call(
      afterLastCode,
      freshRegex,
      () => literalReplacement
    );

    return output;
  }

  String.prototype.replace = function patchedReplace(searchValue, replaceValue) {
    try {
      if (
        searchValue instanceof RegExp &&
        searchValue.global &&
        latexDelimiterReplacements.has(searchValue.source)
      ) {
        const intendedLiteral = latexDelimiterReplacements.get(
          searchValue.source
        );

        // Only do this:
        //   .replace(/\\\[/g, "$$")
        //   .replace(/\\\]/g, "$$")
        //   .replace(/\\\(/g, "$")
        //   .replace(/\\\)/g, "$")

        if (replaceValue === intendedLiteral) {
          return replaceOutsideMarkdownCode(
            String(this),
            searchValue,
            intendedLiteral
          );
        }
      }
    } catch (err) {
      // Fallback to as it was
    }

    return nativeReplace.apply(this, arguments);
  };

  console.info(
    "[MarkdownRenderer hotfix] Installed LaTeX/codeblock replacement patch"
  );
})();