LibreChat/client/src/utils/tilde.ts
Danny Avila 7c071e244b
🔢 fix: Prevent "approximately" tildes from rendering as markdown subscript (#13743)
* 🔢 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.
2026-06-14 16:59:12 -04:00

77 lines
2.9 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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);
}