@bernierllc/markdown-parser 1.2.5 → 1.5.0

package/__tests__/MarkdownParser.test.ts

@@ -1,791 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { MarkdownParser } from '../src/MarkdownParser';
-
-describe('MarkdownParser', () => {
-  describe('Constructor', () => {
-    it('should create parser with default config', () => {
-      const parser = new MarkdownParser();
-      expect(parser).toBeInstanceOf(MarkdownParser);
-    });
-
-    it('should create parser with custom config', () => {
-      const parser = new MarkdownParser({
-        gfm: false,
-        commonmark: false,
-        cache: { enabled: true, maxSize: 500, ttl: 1800 },
-      });
-      expect(parser).toBeInstanceOf(MarkdownParser);
-    });
-  });
-
-  describe('parse() - Headings', () => {
-    it('should parse heading levels correctly', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Heading 1\n## Heading 2\n### Heading 3');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(3);
-      expect(result.ast!.children![0].type).toBe('heading');
-      expect(result.ast!.children![0].attributes!.level).toBe(1);
-      expect(result.ast!.children![1].attributes!.level).toBe(2);
-      expect(result.ast!.children![2].attributes!.level).toBe(3);
-    });
-
-    it('should parse heading text correctly', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Test Heading');
-
-      expect(result.success).toBe(true);
-      const heading = result.ast!.children![0];
-      expect(heading.children![0].type).toBe('text');
-      expect(heading.children![0].value).toBe('Test Heading');
-    });
-
-    it('should handle headings with inline formatting', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# This is **bold** text');
-
-      expect(result.success).toBe(true);
-      const heading = result.ast!.children![0];
-      expect(heading.children).toHaveLength(3);
-      expect(heading.children![1].type).toBe('strong');
-    });
-
-    it('should handle all heading levels (1-6)', async () => {
-      const parser = new MarkdownParser();
-      const markdown = ['# H1', '## H2', '### H3', '#### H4', '##### H5', '###### H6'].join('\n');
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(6);
-      for (let i = 0; i < 6; i++) {
-        expect(result.ast!.children![i].attributes!.level).toBe(i + 1);
-      }
-    });
-  });
-
-  describe('parse() - Paragraphs', () => {
-    it('should parse simple paragraph', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('This is a paragraph.');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(1);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-    });
-
-    it('should parse multi-line paragraph', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Line 1\nLine 2\nLine 3');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(1);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-    });
-
-    it('should split paragraphs on blank lines', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph 1\n\nParagraph 2');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(2);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-      expect(result.ast!.children![1].type).toBe('paragraph');
-    });
-  });
-
-  describe('parse() - Code Blocks', () => {
-    it('should parse fenced code block', async () => {
-      const parser = new MarkdownParser();
-      const markdown = '```javascript\nconst x = 1;\n```';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('codeBlock');
-      expect(result.ast!.children![0].value).toBe('const x = 1;');
-      expect(result.ast!.children![0].attributes!.language).toBe('javascript');
-    });
-
-    it('should parse code block without language', async () => {
-      const parser = new MarkdownParser();
-      const markdown = '```\ncode here\n```';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('codeBlock');
-      expect(result.ast!.children![0].attributes!.language).toBe('plaintext');
-    });
-
-    it('should parse multi-line code block', async () => {
-      const parser = new MarkdownParser();
-      const markdown = '```python\ndef hello():\n    print("Hello")\n```';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].value).toBe('def hello():\n    print("Hello")');
-    });
-  });
-
-  describe('parse() - Lists', () => {
-    it('should parse unordered list', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('- Item 1\n- Item 2\n- Item 3');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('list');
-      expect(result.ast!.children![0].attributes!.ordered).toBe(false);
-      expect(result.ast!.children![0].children).toHaveLength(3);
-    });
-
-    it('should parse ordered list', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('1. Item 1\n2. Item 2\n3. Item 3');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('list');
-      expect(result.ast!.children![0].attributes!.ordered).toBe(true);
-      expect(result.ast!.children![0].children).toHaveLength(3);
-    });
-
-    it('should parse list with different markers', async () => {
-      const parser = new MarkdownParser();
-      const result1 = await parser.parse('* Item 1\n* Item 2');
-      const result2 = await parser.parse('+ Item 1\n+ Item 2');
-
-      expect(result1.success).toBe(true);
-      expect(result2.success).toBe(true);
-      expect(result1.ast!.children![0].type).toBe('list');
-      expect(result2.ast!.children![0].type).toBe('list');
-    });
-  });
-
-  describe('parse() - GFM Task Lists', () => {
-    it('should parse unchecked task', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('- [ ] Task 1');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('taskListItem');
-      expect(result.ast!.children![0].attributes!.checked).toBe(false);
-    });
-
-    it('should parse checked task', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('- [x] Task 1');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('taskListItem');
-      expect(result.ast!.children![0].attributes!.checked).toBe(true);
-    });
-
-    it('should parse multiple tasks', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('- [ ] Task 1\n- [x] Task 2\n- [ ] Task 3');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(3);
-      expect(result.ast!.children![0].attributes!.checked).toBe(false);
-      expect(result.ast!.children![1].attributes!.checked).toBe(true);
-      expect(result.ast!.children![2].attributes!.checked).toBe(false);
-    });
-
-    it('should not parse tasks when GFM is disabled', async () => {
-      const parser = new MarkdownParser({ gfm: false });
-      const result = await parser.parse('- [ ] Task 1');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('list');
-    });
-  });
-
-  describe('parse() - Blockquotes', () => {
-    it('should parse simple blockquote', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('> Quote text');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('blockquote');
-    });
-
-    it('should parse multi-line blockquote', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('> Line 1\n> Line 2\n> Line 3');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('blockquote');
-    });
-  });
-
-  describe('parse() - Horizontal Rules', () => {
-    it('should parse horizontal rule with asterisks', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('***');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('horizontalRule');
-    });
-
-    it('should parse horizontal rule with hyphens', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('---');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('horizontalRule');
-    });
-
-    it('should parse horizontal rule with underscores', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('___');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('horizontalRule');
-    });
-  });
-
-  describe('parse() - Inline Formatting', () => {
-    it('should parse bold text with **', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('This is **bold** text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('strong');
-      expect(paragraph.children![1].children![0].value).toBe('bold');
-    });
-
-    it('should parse bold text with __', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('This is __bold__ text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('strong');
-    });
-
-    it('should parse italic text with *', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('This is *italic* text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('emphasis');
-      expect(paragraph.children![1].children![0].value).toBe('italic');
-    });
-
-    it('should parse italic text with _', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('This is _italic_ text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('emphasis');
-    });
-
-    it('should parse inline code', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Use `console.log()` to debug');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('code');
-      expect(paragraph.children![1].value).toBe('console.log()');
-    });
-
-    it('should parse strikethrough (GFM)', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('This is ~~deleted~~ text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('strikethrough');
-      expect(paragraph.children![1].children![0].value).toBe('deleted');
-    });
-
-    it('should not parse strikethrough when GFM is disabled', async () => {
-      const parser = new MarkdownParser({ gfm: false });
-      const result = await parser.parse('This is ~~deleted~~ text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      // Should be treated as plain text
-      expect(paragraph.children![0].type).toBe('text');
-    });
-  });
-
-  describe('parse() - Links and Images', () => {
-    it('should parse link', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('[Link text](https://example.com)');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![0].type).toBe('link');
-      expect(paragraph.children![0].attributes!.href).toBe('https://example.com');
-      expect(paragraph.children![0].children![0].value).toBe('Link text');
-    });
-
-    it('should parse image', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('![Alt text](https://example.com/image.jpg)');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![0].type).toBe('image');
-      expect(paragraph.children![0].attributes!.alt).toBe('Alt text');
-      expect(paragraph.children![0].attributes!.src).toBe('https://example.com/image.jpg');
-    });
-
-    it('should parse autolink (GFM)', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('Visit https://example.com for more');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![1].type).toBe('autolink');
-      expect(paragraph.children![1].attributes!.href).toBe('https://example.com');
-    });
-  });
-
-  describe('parse() - Tables (GFM)', () => {
-    it('should parse simple table', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| Header 1 | Header 2 |\n| --- | --- |\n| Cell 1 | Cell 2 |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('table');
-      expect(result.ast!.children![0].children).toHaveLength(2); // Header + 1 body row
-    });
-
-    it('should parse table with alignment', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| Left | Center | Right |\n| :--- | :---: | ---: |\n| L | C | R |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      const table = result.ast!.children![0];
-      const bodyRow = table.children![1];
-      expect(bodyRow.children![0].attributes!.align).toBe('left');
-      expect(bodyRow.children![1].attributes!.align).toBe('center');
-      expect(bodyRow.children![2].attributes!.align).toBe('right');
-    });
-
-    it('should not parse tables when GFM is disabled', async () => {
-      const parser = new MarkdownParser({ gfm: false });
-      const markdown = '| Header 1 | Header 2 |\n| --- | --- |\n| Cell 1 | Cell 2 |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      // Should be treated as paragraphs
-      expect(result.ast!.children![0].type).toBe('paragraph');
-    });
-  });
-
-  describe('parse() - Edge Cases', () => {
-    it('should handle empty string', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(0);
-    });
-
-    it('should handle only whitespace', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('   \n   \n   ');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(0);
-    });
-
-    it('should handle malformed markdown gracefully', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Heading [broken link(');
-
-      expect(result.success).toBe(true);
-      // Should not crash
-    });
-
-    it('should handle unicode characters', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Hello 世界 🌍');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].children![0].value).toContain('世界');
-      expect(result.ast!.children![0].children![0].value).toContain('🌍');
-    });
-
-    it('should handle very long lines', async () => {
-      const parser = new MarkdownParser();
-      const longLine = 'a'.repeat(10000);
-      const result = await parser.parse(longLine);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('parse() - Metadata', () => {
-    it('should include parse time in metadata', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Test');
-
-      expect(result.metadata).toBeDefined();
-      expect(result.metadata!.parseTime).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should include node count in metadata', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Test\n\nParagraph');
-
-      expect(result.metadata!.nodeCount).toBeGreaterThan(0);
-    });
-
-    it('should indicate cache hit in metadata', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const markdown = '# Test';
-
-      await parser.parse(markdown);
-      const result = await parser.parse(markdown);
-
-      expect(result.metadata!.cached).toBe(true);
-    });
-  });
-
-  describe('clearCache()', () => {
-    it('should clear the cache', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const markdown = '# Test';
-
-      await parser.parse(markdown);
-      parser.clearCache();
-      const result = await parser.parse(markdown);
-
-      expect(result.metadata!.cached).toBe(false);
-    });
-  });
-
-  describe('getCacheStats()', () => {
-    it('should return cache statistics', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-
-      const stats1 = parser.getCacheStats();
-      expect(stats1.enabled).toBe(true);
-      expect(stats1.size).toBe(0);
-
-      await parser.parse('# Test 1');
-      await parser.parse('# Test 2');
-
-      const stats2 = parser.getCacheStats();
-      expect(stats2.size).toBe(2);
-    });
-
-    it('should return disabled cache stats', () => {
-      const parser = new MarkdownParser({ cache: { enabled: false } });
-
-      const stats = parser.getCacheStats();
-      expect(stats.enabled).toBe(false);
-      expect(stats.size).toBe(0);
-    });
-  });
-
-  describe('pruneCache()', () => {
-    it('should remove expired entries', async () => {
-      const parser = new MarkdownParser({
-        cache: { enabled: true, ttl: 1 }, // 1 second TTL
-      });
-
-      await parser.parse('# Test 1');
-      await parser.parse('# Test 2');
-
-      // Wait for expiration
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      const removed = parser.pruneCache();
-      expect(removed).toBe(2);
-    });
-
-    it('should return 0 when cache is disabled', () => {
-      const parser = new MarkdownParser({ cache: { enabled: false } });
-      const removed = parser.pruneCache();
-      expect(removed).toBe(0);
-    });
-  });
-
-  describe('parse() - Advanced Table Features (GFM)', () => {
-    it('should parse table with multiple body rows', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| H1 | H2 |\n| --- | --- |\n| R1C1 | R1C2 |\n| R2C1 | R2C2 |\n| R3C1 | R3C2 |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      const table = result.ast!.children![0];
-      expect(table.type).toBe('table');
-      expect(table.children).toHaveLength(4); // 1 header + 3 body rows
-    });
-
-    it('should parse table with left alignment', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| Left |\n| :--- |\n| L |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      const table = result.ast!.children![0];
-      const bodyRow = table.children![1];
-      expect(bodyRow.children![0].attributes!.align).toBe('left');
-    });
-
-    it('should parse table with default left alignment when no colon', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| Default |\n| --- |\n| D |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      const table = result.ast!.children![0];
-      const bodyRow = table.children![1];
-      expect(bodyRow.children![0].attributes!.align).toBe('left');
-    });
-
-    it('should parse table with inline formatting in cells', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| Header |\n| --- |\n| **bold** and *italic* |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      const table = result.ast!.children![0];
-      const bodyRow = table.children![1];
-      const cell = bodyRow.children![0];
-      expect(cell.children!.some(n => n.type === 'strong')).toBe(true);
-      expect(cell.children!.some(n => n.type === 'emphasis')).toBe(true);
-    });
-
-    it('should stop parsing table when row does not contain pipe', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const markdown = '| H1 | H2 |\n| --- | --- |\n| R1 | R2 |\nNot a table row\n| R3 | R4 |';
-      const result = await parser.parse(markdown);
-
-      expect(result.success).toBe(true);
-      // Should parse first table with 2 rows (header + R1)
-      const table = result.ast!.children![0];
-      expect(table.type).toBe('table');
-      // Should also have a paragraph for "Not a table row"
-      expect(result.ast!.children![1].type).toBe('paragraph');
-    });
-  });
-
-  describe('parse() - Inline Parsing Edge Cases', () => {
-    it('should parse image with empty alt text', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('![](https://example.com/img.jpg)');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![0].type).toBe('image');
-      expect(paragraph.children![0].attributes!.alt).toBe('');
-      expect(paragraph.children![0].attributes!.src).toBe('https://example.com/img.jpg');
-    });
-
-    it('should not parse autolink when GFM is disabled', async () => {
-      const parser = new MarkdownParser({ gfm: false });
-      const result = await parser.parse('Visit https://example.com');
-
-      expect(result.success).toBe(true);
-      // Should be plain text
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children![0].type).toBe('text');
-    });
-
-    it('should handle single character fallback in inline parsing', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Text with * single asterisk');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      // Should include the asterisk as text
-      expect(paragraph.children!.some(n => n.type === 'text' && n.value === '*')).toBe(true);
-    });
-
-    it('should handle special characters in text', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Text with ~ and [ characters');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.children!.some(n => n.type === 'text')).toBe(true);
-    });
-  });
-
-  describe('parse() - Multi-line Paragraph Edge Cases', () => {
-    it('should not continue paragraph when encountering heading', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph line 1\n# Heading');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children).toHaveLength(2);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-      expect(result.ast!.children![1].type).toBe('heading');
-    });
-
-    it('should not continue paragraph when encountering code block', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph line 1\n```\ncode\n```');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-      expect(result.ast!.children![1].type).toBe('codeBlock');
-    });
-
-    it('should not continue paragraph when encountering blockquote', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph line 1\n> Quote');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-      expect(result.ast!.children![1].type).toBe('blockquote');
-    });
-
-    it('should not continue paragraph when encountering list', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph line 1\n- List item');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-      expect(result.ast!.children![1].type).toBe('list');
-    });
-
-    it('should not continue paragraph when encountering horizontal rule', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph line 1\n***');
-
-      expect(result.success).toBe(true);
-      expect(result.ast!.children![0].type).toBe('paragraph');
-      expect(result.ast!.children![1].type).toBe('horizontalRule');
-    });
-  });
-
-  describe('parse() - Error Handling', () => {
-    it('should handle errors gracefully and return error result', async () => {
-      const parser = new MarkdownParser();
-
-      // Mock parseToAST to throw error
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const parserWithPrivate = parser as any;
-      const originalParseToAST = parserWithPrivate.parseToAST.bind(parser);
-      parserWithPrivate.parseToAST = jest.fn().mockRejectedValue(new Error('Parse failed'));
-
-      const result = await parser.parse('# Test');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Parse failed');
-      expect(result.ast).toBeUndefined();
-
-      // Restore original method
-      parserWithPrivate.parseToAST = originalParseToAST;
-    });
-
-    it('should handle unknown errors', async () => {
-      const parser = new MarkdownParser();
-
-      // Mock parseToAST to throw non-Error
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const parserWithPrivate = parser as any;
-      const originalParseToAST = parserWithPrivate.parseToAST.bind(parser);
-      parserWithPrivate.parseToAST = jest.fn().mockRejectedValue('String error');
-
-      const result = await parser.parse('# Test');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Unknown parse error');
-
-      // Restore original method
-      parserWithPrivate.parseToAST = originalParseToAST;
-    });
-  });
-
-  describe('parse() - Position Tracking', () => {
-    it('should track position for headings', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('# Heading');
-
-      expect(result.success).toBe(true);
-      const heading = result.ast!.children![0];
-      expect(heading.position).toBeDefined();
-      expect(heading.position!.start.line).toBe(1);
-    });
-
-    it('should track position for code blocks', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('```\ncode\n```');
-
-      expect(result.success).toBe(true);
-      const codeBlock = result.ast!.children![0];
-      expect(codeBlock.position).toBeDefined();
-      expect(codeBlock.position!.start.line).toBe(1);
-    });
-
-    it('should track position for blockquotes', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('> Quote');
-
-      expect(result.success).toBe(true);
-      const blockquote = result.ast!.children![0];
-      expect(blockquote.position).toBeDefined();
-      expect(blockquote.position!.start.line).toBe(1);
-    });
-
-    it('should track position for lists', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('- Item 1\n- Item 2');
-
-      expect(result.success).toBe(true);
-      const list = result.ast!.children![0];
-      expect(list.position).toBeDefined();
-      expect(list.position!.start.line).toBe(1);
-    });
-
-    it('should track position for task list items', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('- [ ] Task');
-
-      expect(result.success).toBe(true);
-      const task = result.ast!.children![0];
-      expect(task.position).toBeDefined();
-      expect(task.position!.start.line).toBe(1);
-    });
-
-    it('should track position for tables', async () => {
-      const parser = new MarkdownParser({ gfm: true });
-      const result = await parser.parse('| H |\n| --- |\n| C |');
-
-      expect(result.success).toBe(true);
-      const table = result.ast!.children![0];
-      expect(table.position).toBeDefined();
-      expect(table.position!.start.line).toBe(1);
-    });
-
-    it('should track position for paragraphs', async () => {
-      const parser = new MarkdownParser();
-      const result = await parser.parse('Paragraph text');
-
-      expect(result.success).toBe(true);
-      const paragraph = result.ast!.children![0];
-      expect(paragraph.position).toBeDefined();
-      expect(paragraph.position!.start.line).toBe(1);
-    });
-  });
-
-
-  describe('clearCache() - Cache disabled scenarios', () => {
-    it('should not throw when clearing disabled cache', () => {
-      const parser = new MarkdownParser({ cache: { enabled: false } });
-
-      expect(() => parser.clearCache()).not.toThrow();
-    });
-  });
-});