stream-markdown-parser 0.0.34 → 0.0.35

package/README.md

@@ -21,6 +21,15 @@ This package contains the core markdown parsing logic extracted from `stream-mar
 
 > ℹ️ We now build on top of [`markdown-it-ts`](https://www.npmjs.com/package/markdown-it-ts), a TypeScript-first distribution of markdown-it. The API stays the same, but we only rely on its parsing pipeline and ship richer typings for tokens and hooks.
 
+## Documentation
+
+The full usage guide lives alongside the markstream-vue docs:
+
+- English: https://markstream-vue-docs.simonhe.me/guide/api
+- 中文: https://markstream-vue-docs.simonhe.me/zh/guide/api
+
+This README highlights the parser-specific APIs; visit the docs for end-to-end integration tutorials (VitePress, workers, Tailwind, troubleshooting, etc.).
+
 ## Installation
 
 ```bash
@@ -31,9 +40,47 @@ npm install stream-markdown-parser
 yarn add stream-markdown-parser
 ```
 
+## Quick API (TL;DR)
+
+- `getMarkdown(options)` — create a `markdown-it-ts` instance with built-in plugins (task lists, sub/sup, math helpers, etc.). Also accepts `plugin`, `apply`, and `i18n` options.
+- `registerMarkdownPlugin(plugin)` / `clearRegisteredMarkdownPlugins()` — add or remove global plugins that run for every `getMarkdown()` call (useful for feature flags or tests).
+- `parseMarkdownToStructure(markdown, md, parseOptions)` — convert Markdown into the streaming-friendly AST consumed by `markstream-vue` and other renderers.
+- `processTokens(tokens)` / `parseInlineTokens(children, content)` — low-level helpers if you want to bypass the built-in AST pipeline.
+- `applyMath`, `applyContainers`, `normalizeStandaloneBackslashT`, `findMatchingClose`, etc. — utilities for custom parsing or linting workflows.
+
 ## Usage
 
-### Basic Example
+### Streaming-friendly pipeline
+
+```
+Markdown string
+   ↓ getMarkdown() → markdown-it-ts instance with plugins
+parseMarkdownToStructure() → AST (ParsedNode[])
+   ↓ feed into your renderer (markstream-vue, custom UI, workers)
+```
+
+Reuse the same `md` instance when parsing multiple documents—plugin setup is the heaviest step. When integrating with [`markstream-vue`](../../README.md), pass the AST to `<MarkdownRender :nodes="nodes" />` or supply raw `content` and hand it the same parser options.
+
+### Incremental / streaming example
+
+When consuming an AI or SSE stream you can keep appending to a buffer, parse with the same `md` instance, and send the AST to the UI (e.g., `markstream-vue`) on every chunk:
+
+```ts
+import { getMarkdown, parseMarkdownToStructure } from 'stream-markdown-parser'
+
+const md = getMarkdown()
+let buffer = ''
+
+async function handleChunk(chunk: string) {
+  buffer += chunk
+  const nodes = parseMarkdownToStructure(buffer, md)
+  postMessage({ type: 'markdown:update', nodes })
+}
+```
+
+In the UI layer, render `nodes` with `<MarkdownRender :nodes="nodes" />` to avoid re-parsing. See the [docs usage guide](../../docs/guide/usage.md) for end-to-end wiring.
+
+### Basic example
 
 ```typescript
 import { getMarkdown, parseMarkdownToStructure } from 'stream-markdown-parser'
@@ -114,6 +161,29 @@ const md = getMarkdown('editor-1', {
 })
 ```
 
+### Extending globally
+
+Need to add a plugin everywhere without touching each call site? Use the helper exports:
+
+```ts
+import {
+  clearRegisteredMarkdownPlugins,
+  registerMarkdownPlugin,
+} from 'stream-markdown-parser'
+
+registerMarkdownPlugin(myPlugin)
+
+const md = getMarkdown()
+// md now has `myPlugin` enabled in addition to anything passed via options
+
+// For tests or teardown flows:
+clearRegisteredMarkdownPlugins()
+```
+
+- `plugin` option → array of `md.use` invocations scoped to a single `getMarkdown` call.
+- `apply` option → imperatively mutate the instance (`md.inline.ruler.before(...)`). Wrap in try/catch if you need to surface errors differently; the helper logs to console to preserve legacy behaviour.
+- `registerMarkdownPlugin` → global singleton registry (handy in SSR or worker contexts where you want feature flags to apply everywhere).
+
 ## API
 
 ### Main Functions
@@ -175,6 +245,34 @@ interface MathOptions {
 }
 ```
 
+### Parse hooks (fine-grained transforms)
+
+Both `parseMarkdownToStructure()` and `<MarkdownRender :parse-options>` accept the same hook signature:
+
+```ts
+interface ParseOptions {
+  preTransformTokens?: (tokens: Token[]) => Token[]
+  postTransformTokens?: (tokens: Token[]) => Token[]
+  postTransformNodes?: (nodes: ParsedNode[]) => ParsedNode[]
+}
+```
+
+Example — flag AI “thinking” blocks:
+
+```ts
+const parseOptions = {
+  postTransformNodes(nodes) {
+    return nodes.map(node =>
+      node.type === 'html_block' && /<thinking>/.test(node.value)
+        ? { ...node, meta: { type: 'thinking' } }
+        : node,
+    )
+  },
+}
+```
+
+Use the metadata in your renderer to show custom UI without mangling the original Markdown.
+
 ### Utility Functions
 
 #### `isMathLike(content)`
@@ -198,6 +296,14 @@ Find the matching closing delimiter in a string, handling nested pairs.
 
 **Returns:** `number` - Index of matching close, or -1 if not found
 
+## Tips & troubleshooting
+
+- **Reuse parser instances**: cache `getMarkdown()` results per worker/request to avoid re-registering plugins.
+- **Server-side parsing**: run `parseMarkdownToStructure` on the server, ship the AST to the client, and hydrate with `markstream-vue` for deterministic output.
+- **Custom HTML widgets**: pre-extract `<MyWidget>` blocks before parsing (replace with placeholders) and reinject them during rendering instead of mutating `html_block` nodes post-parse.
+- **Styling**: when piping nodes into `markstream-vue`, follow the docs [CSS checklist](../../docs/guide/troubleshooting.md#css-looks-wrong-start-here) so Tailwind/UnoCSS don’t override library styles.
+- **Error handling**: the `apply` hook swallows exceptions to maintain backwards compatibility. If you want strict mode, wrap your mutators before passing them in and rethrow/log as needed.
+
 #### `parseFenceToken(token)`
 
 Parse a code fence token into a CodeBlockNode.
@@ -217,6 +323,26 @@ Normalize backslash-t sequences in math content.
 
 **Returns:** `string`
 
+### Lower-level helpers
+
+If you need full control over how tokens are transformed, you can import the primitive builders directly:
+
+```ts
+import type { MarkdownToken } from 'stream-markdown-parser'
+import {
+
+  parseInlineTokens,
+  processTokens
+} from 'stream-markdown-parser'
+
+const tokens: MarkdownToken[] = md.parse(markdown, {})
+const nodes = processTokens(tokens)
+// or operate at inline granularity:
+const inlineNodes = parseInlineTokens(tokens[0].children ?? [], tokens[0].content ?? '')
+```
+
+`processTokens` is what `parseMarkdownToStructure` uses internally, so you can remix the AST pipeline without reimplementing the Markdown-it loop.
+
 ### Plugin Functions
 
 #### `applyMath(md, options?)`
@@ -303,6 +429,41 @@ While this package is framework-agnostic, it's designed to work seamlessly with:
 - ✅ **Vanilla JS** - Direct HTML rendering
 - ✅ **Any framework** - Parse to AST and render as needed
 
+### Example — dedicated worker feeding markstream-vue
+
+Offload parsing to a Web Worker while the UI renders via `markstream-vue`:
+
+```ts
+// worker.ts
+import { getMarkdown, parseMarkdownToStructure } from 'stream-markdown-parser'
+
+const md = getMarkdown()
+let buffer = ''
+
+globalThis.addEventListener('message', (event) => {
+  if (event.data.type === 'chunk') {
+    buffer += event.data.value
+    const nodes = parseMarkdownToStructure(buffer, md)
+    globalThis.postMessage({ type: 'update', nodes })
+  }
+})
+```
+
+```ts
+// ui.ts
+const worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' })
+worker.addEventListener('message', (event) => {
+  if (event.data.type === 'update')
+    nodes.value = event.data.nodes
+})
+```
+
+```vue
+<MarkdownRender :nodes="nodes" />
+```
+
+This pattern keeps Markdown-it work off the main thread and lets you reuse the same AST in any framework.
+
 ## Migration from `stream-markdown-parser`
 
 If you're migrating from using the markdown utils in `stream-markdown-parser`:

package/README.zh-CN.md

@@ -21,6 +21,15 @@
 
 > ℹ️ 自当前版本起我们基于 [`markdown-it-ts`](https://www.npmjs.com/package/markdown-it-ts)（一个 TypeScript 优先的 markdown-it 发行版）进行构建。API 与 markdown-it 保持一致，但内部仅依赖其解析流程，并提供更丰富的 token 类型定义。
 
+## 文档
+
+完整的使用说明与集成教程见 markstream-vue 文档站：
+
+- English: https://markstream-vue-docs.simonhe.me/guide/api
+- 中文: https://markstream-vue-docs.simonhe.me/zh/guide/api
+
+本 README 聚焦解析器 API；如需 VitePress/Vite/Nuxt 集成、Worker 流式解析、Tailwind/UnoCSS 配置等指南，请查阅上述文档。
+
 ## 安装
 
 ```bash
@@ -31,8 +40,46 @@ npm install stream-markdown-parser
 yarn add stream-markdown-parser
 ```
 
+## 快速 API 速览
+
+- `getMarkdown(options)` — 返回一个预配置的 `markdown-it-ts` 实例；支持 `plugin`、`apply`、`i18n` 等选项（内置任务列表、上下标、数学等插件）。
+- `registerMarkdownPlugin(plugin)` / `clearRegisteredMarkdownPlugins()` — 全局注册/清除插件，在所有 `getMarkdown()` 调用中生效（适合特性开关或测试环境）。
+- `parseMarkdownToStructure(markdown, md, parseOptions)` — 将 Markdown 转换为可供 `markstream-vue` 等渲染器使用的 AST。
+- `processTokens(tokens)` / `parseInlineTokens(children, content)` — 更底层的 token → 节点工具，方便自定义管线。
+- `applyMath`、`applyContainers`、`normalizeStandaloneBackslashT`、`findMatchingClose` 等 — 用于构建自定义解析、lint 或内容清洗流程。
+
 ## 使用
 
+### 流式解析流程
+
+```
+Markdown 字符串
+   ↓ getMarkdown() → 带插件的 markdown-it-ts 实例
+parseMarkdownToStructure() → AST (ParsedNode[])
+   ↓ 交给你的渲染器（markstream-vue、自定义 UI、Worker 等）
+```
+
+多次解析时复用同一个 `md` 实例可以避免重复注册插件。与 [`markstream-vue`](../../README.zh-CN.md) 一起使用时，你可以把 AST 传给 `<MarkdownRender :nodes="nodes" />`，或仅传入原始 `content` 并共享同一套解析配置。
+
+### 增量 / 流式示例
+
+处理 AI/SSE 流时，可以复用同一个 `md` 实例不停地对累积缓冲区解析，并把 AST 推送给 UI（例如 `markstream-vue`）：
+
+```ts
+import { getMarkdown, parseMarkdownToStructure } from 'stream-markdown-parser'
+
+const md = getMarkdown()
+let buffer = ''
+
+async function handleChunk(chunk: string) {
+  buffer += chunk
+  const nodes = parseMarkdownToStructure(buffer, md)
+  postMessage({ type: 'markdown:update', nodes })
+}
+```
+
+在前端通过 `<MarkdownRender :nodes="nodes" />` 渲染即可避免重复解析。具体串联示例见[文档用法指南](../../docs/zh/guide/usage.md)。
+
 ### 基础示例
 
 ```typescript
@@ -113,6 +160,29 @@ const md = getMarkdown('editor-1', {
 })
 ```
 
+### 全局扩展
+
+想在所有 `getMarkdown()` 实例上启用同一个插件，而无需修改调用点？可使用内置 helper：
+
+```ts
+import {
+  clearRegisteredMarkdownPlugins,
+  registerMarkdownPlugin,
+} from 'stream-markdown-parser'
+
+registerMarkdownPlugin(myPlugin)
+
+const md = getMarkdown()
+// 现在 md 会自动包含 myPlugin
+
+// 测试或清理阶段：
+clearRegisteredMarkdownPlugins()
+```
+
+- `plugin` 选项 → 针对单次 `getMarkdown` 调用传入 `md.use(...)`。
+- `apply` 选项 → 直接操作实例（如 `md.inline.ruler.before(...)`）。如果需要严格模式，可自行包裹 try/catch；默认会打印错误保持兼容。
+- `registerMarkdownPlugin` → 全局注册表，适用于 SSR / Worker 等场景统一开启功能。
+
 ## API
 
 ### 主要函数
@@ -174,6 +244,34 @@ interface MathOptions {
 }
 ```
 
+### 解析钩子（精细化变换）
+
+`parseMarkdownToStructure()` 与 `<MarkdownRender :parse-options>` 可使用相同的钩子：
+
+```ts
+interface ParseOptions {
+  preTransformTokens?: (tokens: Token[]) => Token[]
+  postTransformTokens?: (tokens: Token[]) => Token[]
+  postTransformNodes?: (nodes: ParsedNode[]) => ParsedNode[]
+}
+```
+
+示例 —— 标记 AI “思考” 块：
+
+```ts
+const parseOptions = {
+  postTransformNodes(nodes) {
+    return nodes.map(node =>
+      node.type === 'html_block' && /<thinking>/.test(node.value)
+        ? { ...node, meta: { type: 'thinking' } }
+        : node,
+    )
+  },
+}
+```
+
+在渲染器中读取 `node.meta` 即可渲染自定义 UI，而无需直接修改 Markdown 文本。
+
 ### 工具函数
 
 #### `isMathLike(content)`
@@ -197,6 +295,14 @@ interface MathOptions {
 
 **返回值：** `number` - 匹配闭合的索引，如果未找到则返回 -1
 
+## 使用建议与排障
+
+- **复用解析实例**：缓存 `getMarkdown()` 的结果，避免重复注册插件。
+- **服务端解析**：在服务端运行 `parseMarkdownToStructure` 后把 AST 下发给客户端，配合 `markstream-vue` 实现确定性输出。
+- **自定义 HTML 组件**：在解析前先把 `<MyWidget>` 这类片段替换为占位符，渲染时再注入，避免在 `html_block` 上进行脆弱的字符串操作。
+- **样式提示**：如果将节点交给 `markstream-vue`，务必按照文档的 [CSS 排查清单](../../docs/zh/guide/troubleshooting.md#css-looks-wrong-start-here) 调整 reset / layer，防止 Tailwind/UnoCSS 覆盖样式。
+- **错误处理**：`apply` 钩子内部默认捕获异常后打印日志，如需在 CI/生产中抛出错误，可在传入前自行封装并 rethrow。
+
 #### `parseFenceToken(token)`
 
 将代码围栏 token 解析为 CodeBlockNode。
@@ -216,6 +322,26 @@ interface MathOptions {
 
 **返回值：** `string`
 
+### 低阶辅助函数
+
+需要更细粒度地控制 token → AST 流程时，可直接使用以下导出：
+
+```ts
+import type { MarkdownToken } from 'stream-markdown-parser'
+import {
+
+  parseInlineTokens,
+  processTokens
+} from 'stream-markdown-parser'
+
+const tokens: MarkdownToken[] = md.parse(markdown, {})
+const nodes = processTokens(tokens)
+// 或仅解析内联内容：
+const inlineNodes = parseInlineTokens(tokens[0].children ?? [], tokens[0].content ?? '')
+```
+
+`processTokens` 即 `parseMarkdownToStructure` 内部使用的同一个转换器，可在自定义管线中复用，避免重复实现 Markdown-it 遍历。
+
 ### 插件函数
 
 #### `applyMath(md, options?)`

package/dist/index.js

@@ -601,7 +601,7 @@ var require_markdown_it_task_checkbox = /* @__PURE__ */ __commonJS({ "../../node
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.8/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.9/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
 var import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM(require_markdown_it_task_checkbox(), 1);
 var __defProp = Object.defineProperty;
 var __export = (all) => {
@@ -2187,7 +2187,7 @@ var require_punycode = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/pu
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.8/node_modules/markdown-it-ts/dist/index.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.9/node_modules/markdown-it-ts/dist/index.js
 var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
 var utils_exports = /* @__PURE__ */ __export({
 	arrayReplaceAt: () => arrayReplaceAt,
@@ -5708,12 +5708,10 @@ var Renderer = class {
 	rules;
 	baseOptions;
 	normalizedBase;
-	bufferPool;
 	constructor(options = {}) {
 		this.baseOptions = { ...options };
 		this.normalizedBase = this.buildNormalizedBase();
 		this.rules = { ...defaultRules };
-		this.bufferPool = [];
 	}
 	set(options) {
 		this.baseOptions = {
@@ -5723,65 +5721,54 @@ var Renderer = class {
 		this.normalizedBase = this.buildNormalizedBase();
 		return this;
 	}
-	render(tokens, options = {}, env = {}) {
+	render(tokens, options, env) {
 		if (!Array.isArray(tokens)) throw new TypeError("render expects token array as first argument");
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
+		const envRef = env ?? {};
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				this.pushInlineTokens(token.children || [], merged, env, chunks);
+				output += this.renderInlineTokens(token.children || [], merged, envRef);
 				continue;
 			}
 			const rule = this.rules[token.type];
-			if (rule) chunks.push(ensureSyncResult(rule(tokens, i, merged, env, this), token.type));
-			else chunks.push(this.renderToken(tokens, i, merged));
+			if (rule) output += ensureSyncResult(rule(tokens, i, merged, envRef, this), token.type);
+			else output += this.renderToken(tokens, i, merged);
 		}
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
 		return output;
 	}
-	async renderAsync(tokens, options = {}, env = {}) {
+	async renderAsync(tokens, options, env) {
 		if (!Array.isArray(tokens)) throw new TypeError("render expects token array as first argument");
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
+		const envRef = env ?? {};
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				await this.pushInlineTokensAsync(token.children || [], merged, env, chunks);
+				output += await this.renderInlineTokensAsync(token.children || [], merged, envRef);
 				continue;
 			}
 			const rule = this.rules[token.type];
-			if (rule) chunks.push(await resolveResult(rule(tokens, i, merged, env, this)));
-			else chunks.push(this.renderToken(tokens, i, merged));
+			if (rule) output += await resolveResult(rule(tokens, i, merged, envRef, this));
+			else output += this.renderToken(tokens, i, merged);
 		}
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
 		return output;
 	}
-	renderInline(tokens, options = {}, env = {}) {
+	renderInline(tokens, options, env) {
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
-		this.pushInlineTokens(tokens, merged, env, chunks);
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
-		return output;
+		const envRef = env ?? {};
+		return this.renderInlineTokens(tokens, merged, envRef);
 	}
-	async renderInlineAsync(tokens, options = {}, env = {}) {
+	async renderInlineAsync(tokens, options, env) {
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
-		await this.pushInlineTokensAsync(tokens, merged, env, chunks);
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
-		return output;
+		const envRef = env ?? {};
+		return this.renderInlineTokensAsync(tokens, merged, envRef);
 	}
-	renderInlineAsText(tokens, options = {}, env = {}) {
+	renderInlineAsText(tokens, options, env) {
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
-		this.renderInlineAsTextInternal(tokens, merged, env, chunks);
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
-		return output;
+		const envRef = env ?? {};
+		return this.renderInlineAsTextInternal(tokens, merged, envRef);
 	}
 	renderAttrs(token) {
 		if (!token.attrs || token.attrs.length === 0) return "";
@@ -5841,56 +5828,53 @@ var Renderer = class {
 			...this.baseOptions
 		});
 	}
-	pushInlineTokens(tokens, options, env, buffer) {
+	renderInlineTokens(tokens, options, env) {
+		if (!tokens || tokens.length === 0) return "";
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			const rule = this.rules[token.type];
-			if (rule) buffer.push(ensureSyncResult(rule(tokens, i, options, env, this), token.type));
-			else buffer.push(this.renderToken(tokens, i, options));
+			if (rule) output += ensureSyncResult(rule(tokens, i, options, env, this), token.type);
+			else output += this.renderToken(tokens, i, options);
 		}
+		return output;
 	}
-	async pushInlineTokensAsync(tokens, options, env, buffer) {
+	async renderInlineTokensAsync(tokens, options, env) {
+		if (!tokens || tokens.length === 0) return "";
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			const rule = this.rules[token.type];
-			if (rule) buffer.push(await resolveResult(rule(tokens, i, options, env, this)));
-			else buffer.push(this.renderToken(tokens, i, options));
+			if (rule) output += await resolveResult(rule(tokens, i, options, env, this));
+			else output += this.renderToken(tokens, i, options);
 		}
+		return output;
 	}
-	renderInlineAsTextInternal(tokens, options, env, buffer) {
+	renderInlineAsTextInternal(tokens, options, env) {
+		if (!tokens || tokens.length === 0) return "";
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			switch (token.type) {
 				case "text":
 				case "text_special":
-					buffer.push(token.content);
+					output += token.content;
 					break;
 				case "image":
-					this.renderInlineAsTextInternal(token.children || [], options, env, buffer);
+					output += this.renderInlineAsTextInternal(token.children || [], options, env);
 					break;
 				case "html_inline":
 				case "html_block":
-					buffer.push(token.content);
+					output += token.content;
 					break;
 				case "softbreak":
 				case "hardbreak":
-					buffer.push("\n");
+					output += "\n";
 					break;
 				default: break;
 			}
 		}
-	}
-	acquireBuffer() {
-		const buf = this.bufferPool.pop();
-		if (buf) {
-			buf.length = 0;
-			return buf;
-		}
-		return [];
-	}
-	releaseBuffer(buffer) {
-		buffer.length = 0;
-		this.bufferPool.push(buffer);
+		return output;
 	}
 };
 var renderer_default = Renderer;
@@ -7273,7 +7257,6 @@ function fixLinkToken(tokens) {
 			i -= replacerTokens.length - 1;
 			continue;
 		} else if (curToken.content?.startsWith("](") && tokens[i - 1].type === "strong_close" && tokens[i - 4]?.type === "text" && tokens[i - 4]?.content?.includes("**[")) {
-			i++;
 			const replacerTokens = [];
 			const beforeText = tokens[i - 4].content.split("**[")[0];
 			if (beforeText) replacerTokens.push(textToken(beforeText));
@@ -8047,7 +8030,7 @@ function applyMath(md, mathOpts) {
 				}
 				foundAny = true;
 				if (!silent) {
-					const before = src.slice(0, index);
+					const before = src.slice(s.pos - s.pending.length, index);
 					let toPushBefore = src.slice(0, searchPos) ? src.slice(preMathPos, index) : before;
 					const isStrongPrefix = countUnescapedStrong(toPushBefore) % 2 === 1;
 					if (index !== s.pos && isStrongPrefix) toPushBefore = s.pending + src.slice(s.pos, index);
@@ -8453,6 +8436,10 @@ function parseHtmlInlineCodeToken(token, tokens, i) {
 		const m = html.match(/>([\s\S]*?)<\s*\/\s*[\w-]+>/);
 		return m ? m[1] : "";
 	}
+	if (tag === "br") return [{
+		type: "hardbreak",
+		raw: code$1
+	}, i + 1];
 	if (tag === "a") {
 		let loading = false;
 		if (!nextToken || nextToken?.type === "text" && (!nnextToken || nnextToken.type !== "html_inline") || !nextToken) loading = true;
@@ -8606,11 +8593,13 @@ function parseLinkToken(tokens, startIndex, options) {
 //#endregion
 //#region src/parser/inline-parsers/math-inline-parser.ts
 function parseMathInlineToken(token) {
+	const content = token.content ?? "";
+	const raw = token.raw === "$$" ? `$${content}$` : token.raw || "";
 	return {
 		type: "math_inline",
-		content: String(token.content ?? ""),
+		content,
 		loading: !!token.loading,
-		raw: token.raw
+		raw
 	};
 }
 
@@ -9726,11 +9715,13 @@ function parseHtmlBlock(token) {
 //#endregion
 //#region src/parser/node-parsers/math-block-parser.ts
 function parseMathBlock(token) {
+	const content = String(token.content ?? "");
+	const raw = token.raw === "$$" ? `$$${content}$$` : String(token.raw ?? "");
 	return {
 		type: "math_block",
-		content: String(token.content ?? ""),
+		content,
 		loading: !!token.loading,
-		raw: String(token.raw ?? "")
+		raw
 	};
 }