Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🔢 fix: Prevent "approximately" tildes from rendering as markdown subscript (#13743)

Danny Avila7c071e244b0e
diff --git a/client/src/components/Chat/Messages/Content/MarkdownErrorBoundary.tsx b/client/src/components/Chat/Messages/Content/MarkdownErrorBoundary.tsx
index 9862da2102..08d91a43b5 100644
--- a/client/src/components/Chat/Messages/Content/MarkdownErrorBoundary.tsx
+++ b/client/src/components/Chat/Messages/Content/MarkdownErrorBoundary.tsx
@@ -5,8 +5,8 @@ import ReactMarkdown from 'react-markdown';
import rehypeHighlight from 'rehype-highlight';
import type { PluggableList } from 'unified';
import { code, codeNoExecution, a, p, table } from './MarkdownComponents';
+import { langSubset, remarkApproxTilde } from '~/utils';
import { CodeBlockProvider } from '~/Providers';
-import { langSubset } from '~/utils';
interface ErrorBoundaryState {
hasError: boolean;
@@ -61,6 +61,7 @@ class MarkdownErrorBoundary extends React.Component<
<CodeBlockProvider>
<ReactMarkdown
remarkPlugins={[
+ remarkApproxTilde,
/** @ts-ignore */
supersub,
remarkGfm,
diff --git a/client/src/components/Chat/Messages/Content/MarkdownLite.tsx b/client/src/components/Chat/Messages/Content/MarkdownLite.tsx
index 44656ae77f..b9d70480d8 100644
--- a/client/src/components/Chat/Messages/Content/MarkdownLite.tsx
+++ b/client/src/components/Chat/Messages/Content/MarkdownLite.tsx
@@ -9,7 +9,7 @@ import type { PluggableList } from 'unified';
import { code, codeNoExecution, a, p, img, table } from './MarkdownComponents';
import { CodeBlockProvider, ArtifactProvider } from '~/Providers';
import MarkdownErrorBoundary from './MarkdownErrorBoundary';
-import { langSubset } from '~/utils';
+import { langSubset, remarkApproxTilde } from '~/utils';
const MarkdownLite = memo(
({ content = '', codeExecution = true }: { content?: string; codeExecution?: boolean }) => {
@@ -31,6 +31,7 @@ const MarkdownLite = memo(
<CodeBlockProvider>
<ReactMarkdown
remarkPlugins={[
+ remarkApproxTilde,
/** @ts-ignore */
supersub,
remarkGfm,
diff --git a/client/src/components/Chat/Messages/Content/markdownConfig.ts b/client/src/components/Chat/Messages/Content/markdownConfig.ts
index e33d5aa568..90ac6a7044 100644
--- a/client/src/components/Chat/Messages/Content/markdownConfig.ts
+++ b/client/src/components/Chat/Messages/Content/markdownConfig.ts
@@ -14,8 +14,8 @@ import {
import { Citation, CompositeCitation, HighlightedText } from '~/components/Web/Citation';
import { Artifact, artifactPlugin } from '~/components/Artifacts/Artifact';
import { code, a, p, img, table } from './MarkdownComponents';
+import { langSubset, remarkApproxTilde } from '~/utils';
import { unicodeCitation } from '~/components/Web';
-import { langSubset } from '~/utils';
/**
* Single source of truth for the markdown rendering pipeline, shared by the
@@ -37,6 +37,7 @@ let markdownComponentsCache: { [nodeType: string]: ElementType } | null = null;
export const getRemarkPlugins = (): PluggableList => {
if (remarkPluginsCache === null) {
remarkPluginsCache = [
+ remarkApproxTilde,
supersub,
remarkGfm,
remarkDirective,
diff --git a/client/src/utils/index.ts b/client/src/utils/index.ts
index 0beb890c0b..ea322b047f 100644
--- a/client/src/utils/index.ts
+++ b/client/src/utils/index.ts
@@ -10,6 +10,7 @@ export * from './email';
export * from './share';
export * from './files';
export * from './latex';
+export * from './tilde';
export * from './forms';
export * from './roles';
export * from './errors';
diff --git a/client/src/utils/tilde.spec.ts b/client/src/utils/tilde.spec.ts
new file mode 100644
index 0000000000..fbda8d8258
--- /dev/null
+++ b/client/src/utils/tilde.spec.ts
@@ -0,0 +1,143 @@
+import type { Node } from 'unist';
+import { normalizeApproxTildes, remarkApproxTilde } from './tilde';
+
+const T = '∼'; // U+223C TILDE OPERATOR
+
+describe('normalizeApproxTildes', () => {
+ test('returns the same string when no tilde is present', () => {
+ const content = 'a plain string without any tilde';
+ expect(normalizeApproxTildes(content)).toBe(content);
+ });
+
+ test('neutralizes a paired approximation that would become subscript', () => {
+ expect(normalizeApproxTildes('down. ~50% of IPOs ... to ~10%).')).toBe(
+ `down. ${T}50% of IPOs ... to ${T}10%).`,
+ );
+ });
+
+ test('neutralizes a single approximation tilde', () => {
+ expect(normalizeApproxTildes('about ~50 people')).toBe(`about ${T}50 people`);
+ });
+
+ test('neutralizes approximation before currency and after an open bracket', () => {
+ expect(normalizeApproxTildes('range (~$5 to ~10%)')).toBe(`range (${T}$5 to ${T}10%)`);
+ });
+
+ test('neutralizes a spaced negative approximation', () => {
+ expect(normalizeApproxTildes('is ~ -3% from')).toBe(`is ${T} -3% from`);
+ });
+
+ test('neutralizes quoted approximations', () => {
+ expect(normalizeApproxTildes('about "~50%" and "~10%"')).toBe(`about "${T}50%" and "${T}10%"`);
+ });
+
+ test('preserves word-attached subscripts', () => {
+ expect(normalizeApproxTildes('H~2~O and x~1~')).toBe('H~2~O and x~1~');
+ });
+
+ test('preserves a space-delimited closed-number subscript', () => {
+ expect(normalizeApproxTildes('the term a ~2~ here')).toBe('the term a ~2~ here');
+ });
+
+ test('does not match a tilde attached to a preceding number', () => {
+ expect(normalizeApproxTildes('range 5~10 items')).toBe('range 5~10 items');
+ });
+});
+
+interface TextNode extends Node {
+ type: 'text';
+ value: string;
+}
+interface CodeNode extends Node {
+ type: 'inlineCode' | 'code';
+ value: string;
+}
+interface MathNode extends Node {
+ type: 'inlineMath' | 'math';
+ value: string;
+}
+interface LinkNode extends Node {
+ type: 'link';
+ url: string;
+ children: Node[];
+}
+
+describe('remarkApproxTilde', () => {
+ /**
+ * supersub only splits `text` nodes, so the plugin's contract is to rewrite
+ * approximation tildes in text nodes while leaving every other node type — code,
+ * math, and link destinations — byte-for-byte untouched. A hand-built tree proves
+ * that contract without depending on the parser.
+ */
+ test('rewrites text nodes but leaves code, math, and link URLs untouched', () => {
+ const text: TextNode = { type: 'text', value: 'about ~50% and ~10% here' };
+ const inlineCode: CodeNode = { type: 'inlineCode', value: '~50%' };
+ const fenced: CodeNode = { type: 'code', value: '~50% in code\n~/path' };
+ const inlineMath: MathNode = { type: 'inlineMath', value: 'x ~ 10' };
+ const displayMath: MathNode = { type: 'math', value: '~10' };
+ const linkText: TextNode = { type: 'text', value: '~50% off' };
+ const link: LinkNode = {
+ type: 'link',
+ url: 'https://example.com/~50/file',
+ children: [linkText],
+ };
+ const tree: Node = {
+ type: 'root',
+ children: [text, inlineCode, fenced, inlineMath, displayMath, link],
+ } as Node;
+
+ remarkApproxTilde()(tree);
+
+ expect(text.value).toBe(`about ${T}50% and ${T}10% here`);
+ expect(inlineCode.value).toBe('~50%');
+ expect(fenced.value).toBe('~50% in code\n~/path');
+ expect(inlineMath.value).toBe('x ~ 10');
+ expect(displayMath.value).toBe('~10');
+ expect(link.url).toBe('https://example.com/~50/file');
+ expect(linkText.value).toBe(`${T}50% off`);
+ });
+
+ test('preserves an autolink label that displays the URL', () => {
+ const label: TextNode = { type: 'text', value: 'https://example.com/~50/file' };
+ const link: LinkNode = {
+ type: 'link',
+ url: 'https://example.com/~50/file',
+ children: [label],
+ };
+ remarkApproxTilde()({ type: 'root', children: [link] } as Node);
+ expect(label.value).toBe('https://example.com/~50/file');
+ });
+
+ test('preserves a www autolink label whose href has an implied scheme', () => {
+ const label: TextNode = { type: 'text', value: 'www.example.com/~50/x' };
+ const link: LinkNode = {
+ type: 'link',
+ url: 'http://www.example.com/~50/x',
+ children: [label],
+ };
+ remarkApproxTilde()({ type: 'root', children: [link] } as Node);
+ expect(label.value).toBe('www.example.com/~50/x');
+ });
+
+ test('still converts a regular link label that is prose', () => {
+ const label: TextNode = { type: 'text', value: '~50% to ~10% off' };
+ const link: LinkNode = { type: 'link', url: 'https://example.com', children: [label] };
+ remarkApproxTilde()({ type: 'root', children: [link] } as Node);
+ expect(label.value).toBe(`${T}50% to ${T}10% off`);
+ });
+
+ test('removes both tildes of an approximation pair so no `~` remains to subscript', () => {
+ const node: TextNode = { type: 'text', value: 'first ~50% then ~10% drop' };
+ const tree: Node = { type: 'root', children: [node] } as Node;
+ remarkApproxTilde()(tree);
+ expect(node.value).not.toContain('~');
+ expect(node.value).toBe(`first ${T}50% then ${T}10% drop`);
+ });
+
+ test('leaves a genuine subscript text node intact for supersub to handle', () => {
+ const node: TextNode = { type: 'text', value: 'water H~2~O molecule' };
+ const tree: Node = { type: 'root', children: [node] } as Node;
+ remarkApproxTilde()(tree);
+ expect(node.value).toBe('water H~2~O molecule');
+ });
+});
diff --git a/client/src/utils/tilde.ts b/client/src/utils/tilde.ts
new file mode 100644
index 0000000000..e2b4384ae5
--- /dev/null
+++ b/client/src/utils/tilde.ts
@@ -0,0 +1,77 @@
+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);
+}