feat(parser): v0.1.15 — parser short+medium term improvements

Short-term fixes:
- Fix ***bold italic*** / ___bold italic___ triple emphasis
- Fix link text inline formatting (recursive renderInline on [**bold**](url))
- Fix backtick inline code nesting (CommonMark-compliant extractInlineCodes)
- Fix tab indentation stripping in indented code blocks

Medium-term improvements:
- parseTokens() / renderTokens() separation API for token-level transform
- registerBlockHandler() table-driven block handler registry
- Backslash escape support (\* \_ \)

Also:
- Add 48 new test cases (583 total, 7 suites, all passing)
- Parser coverage: 95.43% stmts / 91.38% branches / 100% funcs / 98.25% lines
- Update README.md, site/, package.json to v0.1.15
This commit is contained in:
2026-07-24 21:39:11 +08:00
parent c6db68af59
commit d7cae48073
8 changed files with 968 additions and 253 deletions
+422 -1
View File
@@ -3,7 +3,7 @@
* 覆盖 Markdown 解析器的所有语法分支与安全特性
*/
import { parseMarkdown, safeUrl, slugify } from '../src/parser.js';
import { parseMarkdown, parseTokens, renderTokens, safeUrl, slugify, clearRenderCache, registerBlockHandler } from '../src/parser.js';
describe('parseMarkdown - 基础', () => {
test('空输入返回空字符串', () => {
@@ -697,3 +697,424 @@ describe('parseMarkdown - v0.1.4 代码块语言扩展', () => {
expect(html).toContain('language-file.txt');
});
});
// ============ v0.1.15 新增测试 ============
describe('parseMarkdown - v0.1.15 三重强调', () => {
test('***bold italic*** 渲染为 <em><strong>', () => {
const html = parseMarkdown('***bold italic***');
expect(html).toContain('<em><strong>bold italic</strong></em>');
});
test('___bold italic___ 渲染为 <em><strong>', () => {
const html = parseMarkdown('___bold italic___');
expect(html).toContain('<em><strong>bold italic</strong></em>');
});
test('段落中混用 *** 和普通格式', () => {
const html = parseMarkdown('a ***nested*** b');
expect(html).toContain('<em><strong>nested</strong></em>');
});
});
describe('parseMarkdown - v0.1.15 链接文本内格式', () => {
test('链接文本支持粗体', () => {
const html = parseMarkdown('[**bold link**](https://example.com)');
expect(html).toContain('<a href="https://example.com"');
expect(html).toContain('<strong>bold link</strong>');
});
test('链接文本支持斜体', () => {
const html = parseMarkdown('[*italic*](https://example.com)');
expect(html).toContain('<em>italic</em>');
});
test('链接文本支持行内代码', () => {
const html = parseMarkdown('[`code` link](https://example.com)');
expect(html).toContain('<code>code</code>');
});
test('链接文本支持混合格式', () => {
const html = parseMarkdown('[**bold** and *italic*](https://example.com)');
expect(html).toContain('<strong>bold</strong>');
expect(html).toContain('<em>italic</em>');
});
});
describe('parseMarkdown - v0.1.15 反引号精确嵌套', () => {
test('双反引号包裹单反引号', () => {
const html = parseMarkdown('`` ` ``');
expect(html).toContain('<code>');
// 内容应为单个反引号
expect(html).not.toContain('``');
});
test('三反引号包裹反引号代码', () => {
const html = parseMarkdown('``` `code` ```');
expect(html).toContain('<code>');
expect(html).toContain('`code`');
});
test('普通反引号代码正常', () => {
const html = parseMarkdown('`normal code`');
expect(html).toContain('<code>normal code</code>');
});
});
describe('parseMarkdown - v0.1.15 缩进代码块 Tab', () => {
test('Tab 缩进代码块剥离 Tab', () => {
const html = parseMarkdown('\tcode line');
expect(html).toContain('<pre><code>');
expect(html).toContain('code line');
// Tab 应被剥离
expect(html).not.toContain('\t');
});
test('4 空格缩进代码块正常', () => {
const html = parseMarkdown(' code line');
expect(html).toContain('<pre><code>');
expect(html).toContain('code line');
});
});
describe('parseMarkdown - v0.1.15 反斜杠转义', () => {
test('\\* 转义星号', () => {
const html = parseMarkdown('a \\* b');
expect(html).toContain('a * b');
expect(html).not.toContain('<em>');
});
test('\\_ 转义下划线', () => {
const html = parseMarkdown('a \\_ b');
expect(html).toContain('a _ b');
expect(html).not.toContain('<em>');
});
test('\\\\ 转义反斜杠本身', () => {
const html = parseMarkdown('a \\\\ b');
expect(html).toContain('a \\ b');
});
test('非标点字符不转义', () => {
const html = parseMarkdown('\\a');
expect(html).toContain('\\a');
});
});
describe('parseMarkdown - v0.1.15 parseTokens / renderTokens', () => {
test('parseTokens 返回 token 数组和 footnotes', () => {
const { tokens, footnotes } = parseTokens('# Hello\n\nworld');
expect(Array.isArray(tokens)).toBe(true);
expect(tokens.length).toBe(2);
expect(tokens[0].type).toBe('heading');
expect(tokens[0].level).toBe(1);
expect(tokens[0].text).toBe('Hello');
expect(tokens[1].type).toBe('paragraph');
expect(tokens[1].text).toBe('world');
expect(typeof footnotes).toBe('object');
});
test('parseTokens 提取脚注', () => {
const { tokens, footnotes } = parseTokens('text[^1]\n\n[^1]: note');
expect(footnotes['1']).toBe('note');
});
test('renderTokens 从 token 渲染 HTML', () => {
const { tokens, footnotes } = parseTokens('# Title\n\n**bold**');
const html = renderTokens(tokens, {}, footnotes);
expect(html).toContain('<h1');
expect(html).toContain('Title');
expect(html).toContain('<strong>bold</strong>');
});
test('renderTokens 渲染脚注区', () => {
const { tokens, footnotes } = parseTokens('text[^fn]\n\n[^fn]: footnote content');
const html = renderTokens(tokens, {}, footnotes);
expect(html).toContain('me-footnotes');
expect(html).toContain('footnote content');
});
test('parseTokens 空输入返回空', () => {
const { tokens } = parseTokens('');
expect(tokens.length).toBe(0);
const { tokens: t2 } = parseTokens(null);
expect(t2.length).toBe(0);
});
test('parseTokens 处理所有块级类型', () => {
const md = [
'# Heading',
'',
'paragraph text',
'',
'> quote',
'',
'- list item',
'',
'```',
'code',
'```',
'',
'---',
'',
'| a | b |',
'| --- | --- |',
'| 1 | 2 |',
].join('\n');
const { tokens } = parseTokens(md);
const types = tokens.map((t) => t.type);
expect(types).toContain('heading');
expect(types).toContain('paragraph');
expect(types).toContain('quote');
expect(types).toContain('ul');
expect(types).toContain('code');
expect(types).toContain('hr');
expect(types).toContain('table');
});
});
describe('parseMarkdown - v0.1.15 registerBlockHandler', () => {
test('注册自定义块级处理器', () => {
registerBlockHandler({
name: 'customAlert',
priority: 8.5,
test: (line) => {
const m = line.match(/^:::(\w+)/);
return m ? m : null;
},
parse: (lines, i, match) => {
const type = match[1];
const content = [];
let j = i + 1;
while (j < lines.length && !lines[j].startsWith(':::')) {
content.push(lines[j]);
j++;
}
if (j < lines.length) j++; // skip closing :::
return { token: { type: 'alert', alertType: type, content: content.join('\n') }, newIndex: j };
},
});
// 需要在 renderToken 中处理 alert 类型,这里只验证 token 生成
const { tokens } = parseTokens(':::info\nThis is a note\n:::');
const alertToken = tokens.find((t) => t.type === 'alert');
expect(alertToken).toBeDefined();
expect(alertToken.alertType).toBe('info');
expect(alertToken.content).toBe('This is a note');
});
});
// ============ v0.1.15 覆盖率补齐测试 ============
describe('parseMarkdown - 覆盖率:渲染缓存淘汰', () => {
test('缓存超过上限触发 FIFO 淘汰', () => {
// MAX_CACHE_SIZE = 300,填充 301 个不同文本触发淘汰
for (let i = 0; i < 301; i++) {
const text = `text ${i} **bold**`;
parseMarkdown(text);
}
// 不应抛错,且至少有一次淘汰发生
expect(true).toBe(true);
});
});
describe('parseMarkdown - 覆盖率:缩进代码块空行回退', () => {
test('缩进检测匹配但无有效代码行时返回 null token', () => {
// 4空格后无内容的行不属于代码块
const { tokens } = parseTokens(' ');
// 空行可能被空白处理器跳过,验证不生成 code token
const codeTokens = tokens.filter((t) => t.type === 'code');
expect(codeTokens.length).toBe(0);
});
});
describe('parseMarkdown - 覆盖率:Setext 标题拒绝非段落', () => {
test('列表项不被识别为 Setext 标题', () => {
const html = parseMarkdown('- item\n===');
expect(html).toContain('<ul>');
expect(html).not.toContain('<h1');
});
test('引用行不被识别为 Setext 标题', () => {
const html = parseMarkdown('> quote\n===');
expect(html).toContain('<blockquote>');
expect(html).not.toContain('<h1');
});
test('代码围栏不被识别为 Setext h2', () => {
const html = parseMarkdown('```\n---');
expect(html).toContain('<pre><code>');
expect(html).not.toContain('<h2');
});
});
describe('parseMarkdown - 覆盖率:段落收集边界', () => {
test('段落遇到 Setext 分隔行终止', () => {
const { tokens } = parseTokens('text\n===');
expect(tokens.length).toBe(1);
expect(tokens[0].type).toBe('heading');
expect(tokens[0].level).toBe(1);
});
test('段落遇到表格分隔行终止', () => {
const { tokens } = parseTokens('| a | b |\n| --- | --- |');
// 表格处理器先于段落,生成 table token
expect(tokens.length).toBe(1);
expect(tokens[0].type).toBe('table');
});
});
describe('parseMarkdown - 覆盖率:列表项空行续行', () => {
test('列表项后跟空行再跟缩进续行', () => {
const html = parseMarkdown('- item start\n\n continued');
expect(html).toContain('<ul>');
expect(html).toContain('item start');
expect(html).toContain('continued');
});
test('列表项续行缩进与非缩进', () => {
const html = parseMarkdown('- item line\n indent continuation\nno-indent');
// no-indent 行在 item line 中一起显示(非独立项)
expect(html).toContain('<ul>');
expect(html).toContain('item line');
});
});
describe('parseMarkdown - 覆盖率:任务列表子项', () => {
test('任务列表嵌套子列表', () => {
const html = parseMarkdown('- [x] done\n - sub item');
expect(html).toContain('me-task-item');
expect(html).toContain('checked');
expect(html).toContain('sub item');
});
});
describe('parseMarkdown - 覆盖率:脚注多行续行', () => {
test('脚注定义跨多行', () => {
const html = parseMarkdown('text[^multi]\n\n[^multi]: line one\n line two\nmore text');
expect(html).toContain('me-footnotes');
expect(html).toContain('line one');
});
});
describe('parseMarkdown - 覆盖率:未闭合反引号', () => {
test('未闭合的反引号原样保留', () => {
const html = parseMarkdown('text `code');
expect(html).toContain('`');
});
});
describe('parseMarkdown - 覆盖率:图片引用链接', () => {
test('图片引用 ![alt][ref]', () => {
const html = parseMarkdown('![logo][img-ref]');
expect(html).toContain('<img');
expect(html).toContain('alt="logo"');
expect(html).toContain('me-img-ref');
});
});
describe('parseMarkdown - 覆盖率:链接引用回退', () => {
test('链接引用 [text][ref] 保留原文', () => {
const html = parseMarkdown('[click][myref]');
expect(html).toContain('[click][myref]');
expect(html).not.toContain('<a');
});
});
describe('parseMarkdown - 覆盖率:自定义 token default 渲染', () => {
test('未识别 token type 返回空字符串', () => {
const tokens = [{ type: 'unknownType', text: 'whatever' }];
const html = renderTokens(tokens);
expect(html).toBe('');
});
});
describe('parseMarkdown - 覆盖率:clearRenderCache', () => {
test('clearRenderCache 清除缓存', () => {
// 先使用缓存
parseMarkdown('cached text');
// 清除后不抛错
expect(() => clearRenderCache()).not.toThrow();
});
});
describe('parseMarkdown - 覆盖率:有 title 的链接', () => {
test('链接带 title 属性', () => {
const html = parseMarkdown('[text](https://example.com "my title")');
expect(html).toContain('title="my title"');
});
});
describe('parseMarkdown - 覆盖率:图片带 title', () => {
test('图片带 title 属性', () => {
const html = parseMarkdown('![alt](https://example.com/img.png "photo title")');
expect(html).toContain('title="photo title"');
});
});
describe('parseMarkdown - 覆盖率:无 match 的图片链接回退', () => {
test('不完整的图片语法被保留', () => {
const html = parseMarkdown('![broken');
// 不完整的 ![... 不作为图片
expect(html).toContain('![broken');
});
});
// ============ 额外分支补齐(目标 95%+ Stmts ============
describe('parseMarkdown - 分支:缩进代码块空行', () => {
test('仅有缩进空格无内容的行不产生代码块', () => {
// 通过 parseTokens 检查,空白处理器先捕获空行
const { tokens } = parseTokens(' \nparagraph');
const codeTokens = tokens.filter((t) => t.type === 'code' && t.indent);
expect(codeTokens.length).toBe(0);
});
});
describe('parseMarkdown - 分支:Setext H2 拒绝列表行', () => {
test('有序列表行后跟 --- 不形成 Setext h2', () => {
const html = parseMarkdown('1. item\n---');
expect(html).toContain('<ol');
// --- 应被解析为水平线,而非 Setext 标题
expect(html).toContain('<hr');
});
});
describe('parseMarkdown - 分支:段落遇到 Setext 标题终止', () => {
test('段落收集在 Setext 分隔行前停止', () => {
const html = parseMarkdown('Some text\n=======');
expect(html).toContain('<h1');
expect(html).toContain('Some text');
});
});
describe('parseMarkdown - 分支:段落遇到表格终止', () => {
test('段落遇到表格行终止并生成表格', () => {
const html = parseMarkdown('| Name | Age |\n| --- | --- |\n| Tom | 25 |');
expect(html).toContain('<table>');
expect(html).toContain('Name');
});
});
describe('parseMarkdown - 分支:列表空行续行', () => {
test('列表项内部空行后继续', () => {
const html = parseMarkdown('- item start\n\n still item\n- next item');
expect(html).toContain('<ul>');
expect(html).toContain('item start');
expect(html).toContain('still item');
expect(html).toContain('next item');
});
});
describe('parseMarkdown - 分支:嵌套列表子项渲染', () => {
test('嵌套列表通过 subTokens 正确渲染', () => {
const html = parseMarkdown('- parent\n - child\n - child2');
expect(html).toContain('<ul>');
expect(html).toContain('parent');
expect(html).toContain('child');
expect(html).toContain('child2');
// 验证内层 ul 存在
const innerUlCount = (html.match(/<ul>/g) || []).length;
expect(innerUlCount).toBeGreaterThanOrEqual(2);
});
});