mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-20 15:02:02 +00:00
* 🔢 fix: Prevent "approximately" tildes from rendering as markdown subscript `remark-supersub` splits text nodes on every `~`; an even number of tildes wraps the in-between text in `<sub>`. "Approximately" usage like `~50% ... ~10%` pairs up and subscripts everything between the two tildes. A backslash escape cannot fix this: micromark resolves `\~` back to a bare `~` before supersub runs. Instead, `preprocessTilde` swaps approximation tildes (a `~` prefixing a number, not attached to a word) for the Unicode tilde operator `∼` (U+223C), which renders as a tilde but is not split by supersub. Mirrors `preprocessLaTeX`: early return, single regex pass, code-region skipping. Genuine subscripts (`H~2~O`, `a ~2~ b`), strikethrough, escaped tildes, and home paths are preserved. * 🔢 fix: Harden tilde preprocessing — escaped tildes, URLs, math, MarkdownLite Addresses Codex review findings: - Convert escaped approximation tildes too (`\~50%`): markdown decodes `\~` to `~` before supersub, so the escape still pairs into a subscript. - Anchor matches to a prose boundary (start / whitespace / open bracket) and exclude `\(`/`\[`/`\{`, so URL path tildes (`/~50`) and math delimiters (`$~10$`, `$$~10$$`, `\(~10\)`) are left untouched. - Apply preprocessTilde in MarkdownLite (user messages + search/subagent/ code-analysis displays), which also enables remark-supersub. * 🔧 refactor: Neutralize approximation tildes via remark plugin, not raw-text Replaces the string-level preprocessTilde with `remarkApproxTilde`, a remark plugin that rewrites "approximately" tildes (`~50%` → `∼`) on parsed text nodes before remark-supersub runs. Because it operates on the AST, code spans, fenced code blocks (backtick *and* ~~~), inline code with any backtick count, link destinations, and math spans are structurally excluded — none are `text` nodes — resolving every raw-text edge case Codex flagged without region-scanning heuristics. Escaped `\~` is covered for free (markdown decodes it before the plugin runs). - New client/src/utils/tilde.ts: `normalizeApproxTildes` (pure, per-text-node) + `remarkApproxTilde` plugin. - Wired into both renderers (markdownConfig + MarkdownLite), before supersub. - latex.ts / Markdown.tsx reverted to original; preprocessTilde removed. - tilde.spec.ts: pure-function cases + a hand-built-tree test proving code, math, and link URLs are untouched while text (incl. link text) is converted. * 🔧 fix: Cover quoted approximations and the markdown error-boundary fallback - Broaden the boundary to any non-word, non-tilde char (`(?<![\w~])`), which now includes quotes — `"~50%" ... "~10%"` was still subscripting because `"` was not a recognized prose boundary. Safe to widen because the plugin runs on text nodes, so code / links / math / URLs are already excluded structurally (the earlier allowlist only existed to dodge URL paths in raw text). - Add remarkApproxTilde to MarkdownErrorBoundary's fallback remark pipeline so the fix holds when a render error falls back to the minimal renderer. * 🔧 fix: Preserve autolink URL labels when normalizing tildes A GFM autolink renders the URL as its own label (a text node equal to the href), so the broadened boundary was rewriting `~50` inside a displayed URL to `∼50` even though the href stayed correct. Skip text nodes that are an autolink's label (value matches the destination, allowing for the implied scheme on www/email links), so the visible URL is preserved verbatim. Regular link labels (prose) are still normalized. Note: a single URL containing two `~<digit>` segments is still subscripted by remark-supersub itself — that's pre-existing behavior (reproduces with no plugin) and out of scope here. * 🔧 refactor: Drop unist-util-visit runtime dep from tilde plugin Replace the `unist-util-visit` import with a small self-contained recursive walk over text nodes (tracking the parent for the autolink-label check). This removes reliance on a transitively-hoisted runtime package — addressing the dependency- hygiene concern without adding a dependency or churning the lockfile. The type-only `unist` import remains (erased at build, no runtime resolution). Behavior is unchanged; verified against nested emphasis and list/paragraph trees.
77 lines
2.9 KiB
TypeScript
77 lines
2.9 KiB
TypeScript
import type { Node } from 'unist';
|
||
|
||
interface TextNode extends Node {
|
||
type: 'text';
|
||
value: string;
|
||
}
|
||
interface LinkNode extends Node {
|
||
type: 'link';
|
||
url: string;
|
||
}
|
||
interface ParentNode extends Node {
|
||
children?: Node[];
|
||
}
|
||
|
||
/**
|
||
* A GFM autolink renders the URL itself as its label, so the label text node equals the
|
||
* destination (with an implied scheme for `www.`/email links). Rewriting it would change the
|
||
* URL the user sees while leaving the href intact, so these are left untouched.
|
||
*/
|
||
function isAutolinkLabel(value: string, parent?: Node): boolean {
|
||
if (!parent || parent.type !== 'link') {
|
||
return false;
|
||
}
|
||
const url = (parent as LinkNode).url;
|
||
return (
|
||
url === value ||
|
||
url === `http://${value}` ||
|
||
url === `https://${value}` ||
|
||
url === `mailto:${value}`
|
||
);
|
||
}
|
||
|
||
// "Approximately" tilde: a `~` prefixing a number that is not attached to a preceding word —
|
||
// e.g. `~50%`, `~ -3%`, `~$5`, `"~50%"`, `(~10%)`. Running on parsed text nodes (never code,
|
||
// links, math, or URL destinations) means only real prose is touched, so the boundary can be
|
||
// permissive: anything except a word character or another tilde. Word-attached and
|
||
// closed-number subscripts (`H~2~O`, `a ~2~ b`) are excluded so genuine subscripts survive.
|
||
// Markdown decodes `\~` to `~` before this runs, so escaped tildes are covered too.
|
||
const APPROX_TILDE_REGEX = /(?<![\w~])~(?=[ \t]?[-−+]?\$?\d)(?![ \t]?[-−+]?\$?[\d.,]*~)/g;
|
||
// U+223C TILDE OPERATOR — renders as a tilde but is not split by remark-supersub.
|
||
const TILDE_OPERATOR = '∼';
|
||
|
||
/**
|
||
* Replaces "approximately" tildes (e.g. `~50%`) in a single text value with the Unicode
|
||
* tilde operator so `remark-supersub` does not pair them into spurious `<sub>` ranges.
|
||
* A backslash escape cannot help — markdown decodes `\~` back to `~` before supersub runs —
|
||
* so the glyph itself must change.
|
||
*/
|
||
export function normalizeApproxTildes(value: string): string {
|
||
if (value.indexOf('~') === -1) return value;
|
||
return value.replace(APPROX_TILDE_REGEX, TILDE_OPERATOR);
|
||
}
|
||
|
||
function normalizeTextNodes(node: Node, parent?: Node): void {
|
||
if (node.type === 'text') {
|
||
const textNode = node as TextNode;
|
||
if (typeof textNode.value === 'string' && !isAutolinkLabel(textNode.value, parent)) {
|
||
textNode.value = normalizeApproxTildes(textNode.value);
|
||
}
|
||
return;
|
||
}
|
||
const children = (node as ParentNode).children;
|
||
if (!children) return;
|
||
for (const child of children) {
|
||
normalizeTextNodes(child, node);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* remark plugin that neutralizes "approximately" tildes in text nodes before
|
||
* `remark-supersub` runs. Walking the parsed tree means code, links, math, and URL
|
||
* destinations are structurally excluded — none of them are `text` nodes. Autolink labels
|
||
* (which display the URL itself) are skipped so the visible URL is preserved verbatim.
|
||
*/
|
||
export function remarkApproxTilde() {
|
||
return (tree: Node) => normalizeTextNodes(tree);
|
||
}
|