meno-core 1.0.21 → 1.0.23

package/lib/shared/richtext/htmlToTiptap.test.ts

@@ -0,0 +1,948 @@
+/**
+ * HTML to Tiptap JSON Converter Tests
+ *
+ * Tests the conversion of HTML strings into Tiptap document format.
+ * Uses happy-dom DOMParser for browser-like HTML parsing.
+ */
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { Window } from 'happy-dom';
+import { htmlToTiptap } from './htmlToTiptap';
+import type { TiptapDocument, TiptapNode } from './types';
+
+// Register DOMParser globally so htmlToTiptap uses the DOM-based path
+beforeAll(() => {
+  const win = new Window({ url: 'http://localhost:3000' });
+  (globalThis as any).DOMParser = win.DOMParser;
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Shorthand to find a node by type within arbitrary depth */
+function findNode(doc: TiptapDocument, type: string): TiptapNode | undefined {
+  function search(nodes: TiptapNode[]): TiptapNode | undefined {
+    for (const n of nodes) {
+      if (n.type === type) return n;
+      if (n.content) {
+        const found = search(n.content);
+        if (found) return found;
+      }
+    }
+    return undefined;
+  }
+  return search(doc.content);
+}
+
+/** Collect all nodes of a given type */
+function findAllNodes(doc: TiptapDocument, type: string): TiptapNode[] {
+  const result: TiptapNode[] = [];
+  function search(nodes: TiptapNode[]) {
+    for (const n of nodes) {
+      if (n.type === type) result.push(n);
+      if (n.content) search(n.content);
+    }
+  }
+  search(doc.content);
+  return result;
+}
+
+// ===========================================================================
+// Tests
+// ===========================================================================
+
+describe('htmlToTiptap', () => {
+  // -------------------------------------------------------------------------
+  // Basic / empty input
+  // -------------------------------------------------------------------------
+  describe('basic input handling', () => {
+    test('should return empty doc for empty string', () => {
+      const result = htmlToTiptap('');
+      expect(result).toEqual({ type: 'doc', content: [] });
+    });
+
+    test('should return empty doc for null input', () => {
+      const result = htmlToTiptap(null as any);
+      expect(result).toEqual({ type: 'doc', content: [] });
+    });
+
+    test('should return empty doc for undefined input', () => {
+      const result = htmlToTiptap(undefined as any);
+      expect(result).toEqual({ type: 'doc', content: [] });
+    });
+
+    test('should wrap plain text in a paragraph', () => {
+      const result = htmlToTiptap('Hello world');
+      expect(result.type).toBe('doc');
+      expect(result.content.length).toBe(1);
+      expect(result.content[0].type).toBe('paragraph');
+      expect(result.content[0].content).toBeDefined();
+      expect(result.content[0].content![0].type).toBe('text');
+      expect(result.content[0].content![0].text).toBe('Hello world');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Block elements
+  // -------------------------------------------------------------------------
+  describe('block elements', () => {
+    test('should convert <p> to paragraph node', () => {
+      const result = htmlToTiptap('<p>Hello</p>');
+      expect(result.content.length).toBe(1);
+      expect(result.content[0].type).toBe('paragraph');
+      expect(result.content[0].content![0].text).toBe('Hello');
+    });
+
+    test('should convert <p> with text-align style to paragraph with textAlign attr', () => {
+      const result = htmlToTiptap('<p style="text-align: center">Centered</p>');
+      const p = result.content[0];
+      expect(p.type).toBe('paragraph');
+      expect(p.attrs).toBeDefined();
+      expect(p.attrs!.textAlign).toBe('center');
+    });
+
+    test('should convert <p> with text-align justify', () => {
+      const result = htmlToTiptap('<p style="text-align: justify">Justified</p>');
+      expect(result.content[0].attrs!.textAlign).toBe('justify');
+    });
+
+    test('should not set textAlign for unsupported alignment value', () => {
+      const result = htmlToTiptap('<p style="text-align: start">Text</p>');
+      const p = result.content[0];
+      // 'start' is not in the allowed list
+      expect(p.attrs?.textAlign).toBeUndefined();
+    });
+
+    describe('headings', () => {
+      for (let level = 1; level <= 6; level++) {
+        test(`should convert <h${level}> to heading with level ${level}`, () => {
+          const result = htmlToTiptap(`<h${level}>Heading ${level}</h${level}>`);
+          const heading = result.content[0];
+          expect(heading.type).toBe('heading');
+          expect(heading.attrs!.level).toBe(level);
+          expect(heading.content![0].text).toBe(`Heading ${level}`);
+        });
+      }
+
+      test('should convert <h2> with text-align to heading with textAlign', () => {
+        const result = htmlToTiptap('<h2 style="text-align: right">Right Heading</h2>');
+        const heading = result.content[0];
+        expect(heading.type).toBe('heading');
+        expect(heading.attrs!.level).toBe(2);
+        expect(heading.attrs!.textAlign).toBe('right');
+      });
+    });
+
+    describe('lists', () => {
+      test('should convert <ul><li> to bulletList with listItem children', () => {
+        const result = htmlToTiptap('<ul><li>Item 1</li><li>Item 2</li></ul>');
+        expect(result.content.length).toBe(1);
+        const list = result.content[0];
+        expect(list.type).toBe('bulletList');
+        expect(list.content!.length).toBe(2);
+        expect(list.content![0].type).toBe('listItem');
+        expect(list.content![1].type).toBe('listItem');
+      });
+
+      test('should convert <ol><li> to orderedList', () => {
+        const result = htmlToTiptap('<ol><li>First</li><li>Second</li></ol>');
+        const list = result.content[0];
+        expect(list.type).toBe('orderedList');
+        expect(list.content!.length).toBe(2);
+      });
+
+      test('should convert <ol start="3"> to orderedList with start attr', () => {
+        const result = htmlToTiptap('<ol start="3"><li>Third</li></ol>');
+        const list = result.content[0];
+        expect(list.type).toBe('orderedList');
+        expect(list.attrs!.start).toBe(3);
+      });
+
+      test('should wrap list item inline content in paragraph', () => {
+        const result = htmlToTiptap('<ul><li>Simple text</li></ul>');
+        const listItem = result.content[0].content![0];
+        expect(listItem.type).toBe('listItem');
+        expect(listItem.content![0].type).toBe('paragraph');
+        expect(listItem.content![0].content![0].text).toBe('Simple text');
+      });
+
+      test('should preserve block content inside list items', () => {
+        const result = htmlToTiptap('<ul><li><p>Block content</p></li></ul>');
+        const listItem = result.content[0].content![0];
+        expect(listItem.type).toBe('listItem');
+        expect(listItem.content![0].type).toBe('paragraph');
+      });
+
+      test('should give empty list item an empty paragraph', () => {
+        const result = htmlToTiptap('<ul><li></li></ul>');
+        const listItem = result.content[0].content![0];
+        expect(listItem.type).toBe('listItem');
+        expect(listItem.content!.length).toBe(1);
+        expect(listItem.content![0].type).toBe('paragraph');
+      });
+    });
+
+    test('should convert <blockquote> to blockquote node', () => {
+      const result = htmlToTiptap('<blockquote>Quoted text</blockquote>');
+      const bq = result.content[0];
+      expect(bq.type).toBe('blockquote');
+      // Content should be wrapped in paragraph
+      expect(bq.content![0].type).toBe('paragraph');
+    });
+
+    test('should convert empty <blockquote> to blockquote with empty paragraph', () => {
+      const result = htmlToTiptap('<blockquote></blockquote>');
+      const bq = result.content[0];
+      expect(bq.type).toBe('blockquote');
+      expect(bq.content!.length).toBe(1);
+      expect(bq.content![0].type).toBe('paragraph');
+    });
+
+    test('should convert <pre><code> to codeBlock', () => {
+      const result = htmlToTiptap('<pre><code>const x = 1;</code></pre>');
+      const codeBlock = result.content[0];
+      expect(codeBlock.type).toBe('codeBlock');
+      expect(codeBlock.content![0].text).toBe('const x = 1;');
+    });
+
+    test('should parse language from <code class="language-javascript">', () => {
+      const result = htmlToTiptap('<pre><code class="language-javascript">let y = 2;</code></pre>');
+      const codeBlock = result.content[0];
+      expect(codeBlock.type).toBe('codeBlock');
+      expect(codeBlock.attrs!.language).toBe('javascript');
+    });
+
+    test('should handle <pre> without <code> child', () => {
+      const result = htmlToTiptap('<pre>Plain preformatted</pre>');
+      const codeBlock = result.content[0];
+      expect(codeBlock.type).toBe('codeBlock');
+      expect(codeBlock.content![0].text).toBe('Plain preformatted');
+    });
+
+    test('should convert <hr> to horizontalRule', () => {
+      const result = htmlToTiptap('<p>Above</p><hr><p>Below</p>');
+      const hr = result.content[1];
+      expect(hr.type).toBe('horizontalRule');
+    });
+
+    test('should convert <br> to hardBreak', () => {
+      const result = htmlToTiptap('<p>Line 1<br>Line 2</p>');
+      const p = result.content[0];
+      expect(p.type).toBe('paragraph');
+      // Should contain text, hardBreak, text
+      const types = p.content!.map((n) => n.type);
+      expect(types).toContain('hardBreak');
+    });
+
+    test('should convert <img> to image node with attrs', () => {
+      const result = htmlToTiptap('<img src="/photo.jpg" alt="A photo" width="100" height="200">');
+      const img = findNode(result, 'image');
+      expect(img).toBeDefined();
+      expect(img!.attrs!.src).toBe('/photo.jpg');
+      expect(img!.attrs!.alt).toBe('A photo');
+      expect(img!.attrs!.width).toBe(100);
+      expect(img!.attrs!.height).toBe(200);
+    });
+
+    test('should convert <img> with title attribute', () => {
+      const result = htmlToTiptap('<img src="/pic.png" title="My pic">');
+      const img = findNode(result, 'image');
+      expect(img!.attrs!.title).toBe('My pic');
+    });
+
+    test('should convert <img> with only src', () => {
+      const result = htmlToTiptap('<img src="/minimal.png">');
+      const img = findNode(result, 'image');
+      expect(img!.attrs!.src).toBe('/minimal.png');
+      expect(img!.attrs!.alt).toBeUndefined();
+      expect(img!.attrs!.width).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Inline elements (marks)
+  // -------------------------------------------------------------------------
+  describe('inline marks', () => {
+    test('should convert <strong> to bold mark', () => {
+      const result = htmlToTiptap('<p><strong>Bold text</strong></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Bold text');
+      expect(textNode.marks).toBeDefined();
+      expect(textNode.marks!.some((m) => m.type === 'bold')).toBe(true);
+    });
+
+    test('should convert <b> to bold mark', () => {
+      const result = htmlToTiptap('<p><b>Bold text</b></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.marks!.some((m) => m.type === 'bold')).toBe(true);
+    });
+
+    test('should convert <em> to italic mark', () => {
+      const result = htmlToTiptap('<p><em>Italic text</em></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Italic text');
+      expect(textNode.marks!.some((m) => m.type === 'italic')).toBe(true);
+    });
+
+    test('should convert <i> to italic mark', () => {
+      const result = htmlToTiptap('<p><i>Italic text</i></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.marks!.some((m) => m.type === 'italic')).toBe(true);
+    });
+
+    test('should convert <u> to underline mark', () => {
+      const result = htmlToTiptap('<p><u>Underlined</u></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.marks!.some((m) => m.type === 'underline')).toBe(true);
+    });
+
+    test('should convert <s> to strike mark', () => {
+      const result = htmlToTiptap('<p><s>Struck</s></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.marks!.some((m) => m.type === 'strike')).toBe(true);
+    });
+
+    test('should convert <del> to strike mark', () => {
+      const result = htmlToTiptap('<p><del>Deleted</del></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.marks!.some((m) => m.type === 'strike')).toBe(true);
+    });
+
+    test('should convert <code> to code mark', () => {
+      const result = htmlToTiptap('<p><code>inline code</code></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('inline code');
+      expect(textNode.marks!.some((m) => m.type === 'code')).toBe(true);
+    });
+
+    test('should convert <a> to text with link mark', () => {
+      const result = htmlToTiptap('<p><a href="https://example.com">Click here</a></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Click here');
+      const linkMark = textNode.marks!.find((m) => m.type === 'link');
+      expect(linkMark).toBeDefined();
+      expect(linkMark!.attrs!.href).toBe('https://example.com');
+    });
+
+    test('should convert <a> with target and rel attributes', () => {
+      const result = htmlToTiptap(
+        '<p><a href="/page" target="_blank" rel="noopener">Link</a></p>'
+      );
+      const textNode = result.content[0].content![0];
+      const linkMark = textNode.marks!.find((m) => m.type === 'link');
+      expect(linkMark!.attrs!.href).toBe('/page');
+      expect(linkMark!.attrs!.target).toBe('_blank');
+      expect(linkMark!.attrs!.rel).toBe('noopener');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Nested marks
+  // -------------------------------------------------------------------------
+  describe('nested marks', () => {
+    test('should apply both bold and italic marks for <strong><em>', () => {
+      const result = htmlToTiptap('<p><strong><em>Bold and italic</em></strong></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Bold and italic');
+      expect(textNode.marks!.length).toBeGreaterThanOrEqual(2);
+      const markTypes = textNode.marks!.map((m) => m.type);
+      expect(markTypes).toContain('bold');
+      expect(markTypes).toContain('italic');
+    });
+
+    test('should apply bold and italic for <em><strong> (reverse nesting)', () => {
+      const result = htmlToTiptap('<p><em><strong>Italic and bold</strong></em></p>');
+      const textNode = result.content[0].content![0];
+      const markTypes = textNode.marks!.map((m) => m.type);
+      expect(markTypes).toContain('bold');
+      expect(markTypes).toContain('italic');
+    });
+
+    test('should handle bold inside link', () => {
+      const result = htmlToTiptap(
+        '<p><a href="/url"><strong>Bold link</strong></a></p>'
+      );
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Bold link');
+      const markTypes = textNode.marks!.map((m) => m.type);
+      expect(markTypes).toContain('bold');
+      expect(markTypes).toContain('link');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Span handling
+  // -------------------------------------------------------------------------
+  describe('span handling', () => {
+    test('should convert <span data-meno-span="custom"> to textStyle mark', () => {
+      const result = htmlToTiptap('<p><span data-meno-span="custom">Styled</span></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Styled');
+      const styleMark = textNode.marks!.find((m) => m.type === 'textStyle');
+      expect(styleMark).toBeDefined();
+      expect(styleMark!.attrs!.class).toBe('custom');
+    });
+
+    test('should pass through <span> without special attrs as just children', () => {
+      const result = htmlToTiptap('<p><span>Plain span</span></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.type).toBe('text');
+      expect(textNode.text).toBe('Plain span');
+      // Should not have any marks (or at least no textStyle mark)
+      const hasTextStyle = textNode.marks?.some((m) => m.type === 'textStyle');
+      expect(hasTextStyle).toBeFalsy();
+    });
+
+    test('should handle <span> with style but no data-meno-span (returns children)', () => {
+      const result = htmlToTiptap('<p><span style="color: red">Red</span></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.text).toBe('Red');
+      // Currently the implementation returns children without marks for styled spans
+      const hasTextStyle = textNode.marks?.some((m) => m.type === 'textStyle');
+      expect(hasTextStyle).toBeFalsy();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Tables
+  // -------------------------------------------------------------------------
+  describe('tables', () => {
+    test('should convert a basic table with thead and tbody', () => {
+      const html = `
+        <table>
+          <thead>
+            <tr><th>Header 1</th><th>Header 2</th></tr>
+          </thead>
+          <tbody>
+            <tr><td>Cell 1</td><td>Cell 2</td></tr>
+          </tbody>
+        </table>
+      `;
+      const result = htmlToTiptap(html);
+      const table = findNode(result, 'table');
+      expect(table).toBeDefined();
+      expect(table!.content!.length).toBe(2); // 2 rows
+
+      // First row should have tableHeader cells
+      const headerRow = table!.content![0];
+      expect(headerRow.type).toBe('tableRow');
+      expect(headerRow.content![0].type).toBe('tableHeader');
+      expect(headerRow.content![1].type).toBe('tableHeader');
+
+      // Second row should have tableCell cells
+      const bodyRow = table!.content![1];
+      expect(bodyRow.type).toBe('tableRow');
+      expect(bodyRow.content![0].type).toBe('tableCell');
+    });
+
+    test('should handle table cells with colspan and rowspan', () => {
+      const html = '<table><tbody><tr><td colspan="2" rowspan="3">Wide cell</td></tr></tbody></table>';
+      const result = htmlToTiptap(html);
+      const cell = findNode(result, 'tableCell');
+      expect(cell).toBeDefined();
+      expect(cell!.attrs!.colspan).toBe(2);
+      expect(cell!.attrs!.rowspan).toBe(3);
+    });
+
+    test('should handle direct <tr> children without thead/tbody', () => {
+      const html = '<table><tr><td>Direct</td></tr></table>';
+      const result = htmlToTiptap(html);
+      const table = findNode(result, 'table');
+      expect(table).toBeDefined();
+      expect(table!.content!.length).toBe(1);
+      const row = table!.content![0];
+      expect(row.type).toBe('tableRow');
+      expect(row.content![0].type).toBe('tableCell');
+    });
+
+    test('should give empty table cells an empty paragraph', () => {
+      const html = '<table><tbody><tr><td></td></tr></tbody></table>';
+      const result = htmlToTiptap(html);
+      const cell = findNode(result, 'tableCell');
+      expect(cell).toBeDefined();
+      expect(cell!.content!.length).toBe(1);
+      expect(cell!.content![0].type).toBe('paragraph');
+    });
+
+    test('should handle <th> cells in thead as tableHeader', () => {
+      const html = '<table><thead><tr><th>H1</th></tr></thead></table>';
+      const result = htmlToTiptap(html);
+      const header = findNode(result, 'tableHeader');
+      expect(header).toBeDefined();
+    });
+
+    test('should treat <td> in thead as tableHeader (isHeader flag)', () => {
+      const html = '<table><thead><tr><td>Header-like</td></tr></thead></table>';
+      const result = htmlToTiptap(html);
+      // parseTableRow is called with isHeader=true for thead, so td becomes tableHeader
+      const header = findNode(result, 'tableHeader');
+      expect(header).toBeDefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Container elements
+  // -------------------------------------------------------------------------
+  describe('container elements', () => {
+    test('should parse <div> children without wrapping node', () => {
+      const result = htmlToTiptap('<div><p>Inside div</p></div>');
+      // The div should not produce a wrapping node; its children (the <p>) should be at top level
+      expect(result.content[0].type).toBe('paragraph');
+      expect(result.content[0].content![0].text).toBe('Inside div');
+    });
+
+    test('should parse <article> children without wrapping node', () => {
+      const result = htmlToTiptap('<article><p>Article content</p></article>');
+      expect(result.content[0].type).toBe('paragraph');
+    });
+
+    test('should parse <section> children without wrapping node', () => {
+      const result = htmlToTiptap('<section><p>Section content</p></section>');
+      expect(result.content[0].type).toBe('paragraph');
+    });
+
+    test('should parse <main> children without wrapping node', () => {
+      const result = htmlToTiptap('<main><p>Main content</p></main>');
+      expect(result.content[0].type).toBe('paragraph');
+    });
+
+    test('should parse <header> children without wrapping node', () => {
+      const result = htmlToTiptap('<header><h1>Title</h1></header>');
+      expect(result.content[0].type).toBe('heading');
+    });
+
+    test('should parse <footer> children without wrapping node', () => {
+      const result = htmlToTiptap('<footer><p>Footer</p></footer>');
+      expect(result.content[0].type).toBe('paragraph');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Inline content wrapping
+  // -------------------------------------------------------------------------
+  describe('inline content wrapping', () => {
+    test('should wrap top-level text in a paragraph', () => {
+      const result = htmlToTiptap('Just text');
+      expect(result.content.length).toBe(1);
+      expect(result.content[0].type).toBe('paragraph');
+    });
+
+    test('should wrap mixed inline and block siblings correctly', () => {
+      // Inline text followed by a block element and more inline text
+      const result = htmlToTiptap('Before<p>Block</p>After');
+      // 'Before' should be wrapped in a paragraph, then the <p>, then 'After' in a paragraph
+      expect(result.content.length).toBe(3);
+      expect(result.content[0].type).toBe('paragraph');
+      expect(result.content[0].content![0].text).toBe('Before');
+      expect(result.content[1].type).toBe('paragraph');
+      expect(result.content[1].content![0].text).toBe('Block');
+      expect(result.content[2].type).toBe('paragraph');
+      expect(result.content[2].content![0].text).toBe('After');
+    });
+
+    test('should group consecutive inline elements into one paragraph', () => {
+      const result = htmlToTiptap('<strong>Bold</strong> and <em>italic</em>');
+      // All inline content should end up in a single paragraph
+      expect(result.content.length).toBe(1);
+      expect(result.content[0].type).toBe('paragraph');
+      // Should have multiple text nodes inside
+      expect(result.content[0].content!.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Multiple paragraphs and mixed content
+  // -------------------------------------------------------------------------
+  describe('complex content', () => {
+    test('should convert multiple paragraphs', () => {
+      const result = htmlToTiptap('<p>First</p><p>Second</p><p>Third</p>');
+      expect(result.content.length).toBe(3);
+      expect(result.content[0].content![0].text).toBe('First');
+      expect(result.content[1].content![0].text).toBe('Second');
+      expect(result.content[2].content![0].text).toBe('Third');
+    });
+
+    test('should convert paragraph with mixed text and marks', () => {
+      const result = htmlToTiptap('<p>Normal <strong>bold</strong> normal</p>');
+      const p = result.content[0];
+      expect(p.type).toBe('paragraph');
+      expect(p.content!.length).toBe(3);
+      expect(p.content![0].text).toBe('Normal ');
+      expect(p.content![0].marks).toBeUndefined();
+      expect(p.content![1].text).toBe('bold');
+      expect(p.content![1].marks![0].type).toBe('bold');
+      expect(p.content![2].text).toBe(' normal');
+    });
+
+    test('should handle empty paragraph', () => {
+      const result = htmlToTiptap('<p></p>');
+      expect(result.content.length).toBe(1);
+      const p = result.content[0];
+      expect(p.type).toBe('paragraph');
+      // Empty paragraph should not have content property (or have undefined content)
+      expect(p.content).toBeUndefined();
+    });
+
+    test('should handle heading followed by paragraph', () => {
+      const result = htmlToTiptap('<h1>Title</h1><p>Body text</p>');
+      expect(result.content.length).toBe(2);
+      expect(result.content[0].type).toBe('heading');
+      expect(result.content[1].type).toBe('paragraph');
+    });
+
+    test('should handle blockquote containing paragraph', () => {
+      const result = htmlToTiptap('<blockquote><p>Quoted paragraph</p></blockquote>');
+      const bq = result.content[0];
+      expect(bq.type).toBe('blockquote');
+      expect(bq.content![0].type).toBe('paragraph');
+      expect(bq.content![0].content![0].text).toBe('Quoted paragraph');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Unknown elements
+  // -------------------------------------------------------------------------
+  describe('unknown elements', () => {
+    test('should parse children of unknown elements', () => {
+      const result = htmlToTiptap('<custom-element><p>Content</p></custom-element>');
+      // Unknown element should have its children parsed
+      expect(result.content[0].type).toBe('paragraph');
+      expect(result.content[0].content![0].text).toBe('Content');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Document structure validation
+  // -------------------------------------------------------------------------
+  describe('document structure', () => {
+    test('should always return type "doc"', () => {
+      expect(htmlToTiptap('').type).toBe('doc');
+      expect(htmlToTiptap('<p>test</p>').type).toBe('doc');
+      expect(htmlToTiptap(null as any).type).toBe('doc');
+    });
+
+    test('should always return content as an array', () => {
+      expect(Array.isArray(htmlToTiptap('').content)).toBe(true);
+      expect(Array.isArray(htmlToTiptap('<p>test</p>').content)).toBe(true);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Code block edge cases
+  // -------------------------------------------------------------------------
+  describe('code block edge cases', () => {
+    test('should handle <pre><code> with no language class', () => {
+      const result = htmlToTiptap('<pre><code>plain code</code></pre>');
+      const codeBlock = result.content[0];
+      expect(codeBlock.type).toBe('codeBlock');
+      expect(codeBlock.attrs?.language).toBeUndefined();
+    });
+
+    test('should handle <pre><code class="language-python">', () => {
+      const result = htmlToTiptap('<pre><code class="language-python">print("hi")</code></pre>');
+      const codeBlock = result.content[0];
+      expect(codeBlock.attrs!.language).toBe('python');
+    });
+
+    test('should handle empty code block', () => {
+      const result = htmlToTiptap('<pre><code></code></pre>');
+      const codeBlock = result.content[0];
+      expect(codeBlock.type).toBe('codeBlock');
+      expect(codeBlock.content).toEqual([]);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Image edge cases
+  // -------------------------------------------------------------------------
+  describe('image edge cases', () => {
+    test('should handle <img> with empty src', () => {
+      const result = htmlToTiptap('<img src="">');
+      const img = findNode(result, 'image');
+      expect(img).toBeDefined();
+      expect(img!.attrs!.src).toBe('');
+    });
+
+    test('should handle <img> without src attribute', () => {
+      const result = htmlToTiptap('<img alt="no source">');
+      const img = findNode(result, 'image');
+      expect(img).toBeDefined();
+      // getAttribute('src') returns null, fallback is ''
+      expect(img!.attrs!.src).toBe('');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Link edge cases
+  // -------------------------------------------------------------------------
+  describe('link edge cases', () => {
+    test('should handle <a> without href', () => {
+      const result = htmlToTiptap('<p><a>No href</a></p>');
+      const textNode = result.content[0].content![0];
+      const linkMark = textNode.marks!.find((m) => m.type === 'link');
+      expect(linkMark).toBeDefined();
+      expect(linkMark!.attrs!.href).toBe('');
+    });
+
+    test('should handle <a> with only href (no target or rel)', () => {
+      const result = htmlToTiptap('<p><a href="/page">Link</a></p>');
+      const textNode = result.content[0].content![0];
+      const linkMark = textNode.marks!.find((m) => m.type === 'link');
+      expect(linkMark!.attrs!.href).toBe('/page');
+      expect(linkMark!.attrs!.target).toBeUndefined();
+      expect(linkMark!.attrs!.rel).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Horizontal rule as standalone
+  // -------------------------------------------------------------------------
+  describe('horizontal rule', () => {
+    test('should convert standalone <hr>', () => {
+      const result = htmlToTiptap('<hr>');
+      const hr = findNode(result, 'horizontalRule');
+      expect(hr).toBeDefined();
+      expect(hr!.type).toBe('horizontalRule');
+    });
+
+    test('should handle <hr> between paragraphs', () => {
+      const result = htmlToTiptap('<p>Above</p><hr><p>Below</p>');
+      expect(result.content.length).toBe(3);
+      expect(result.content[0].type).toBe('paragraph');
+      expect(result.content[1].type).toBe('horizontalRule');
+      expect(result.content[2].type).toBe('paragraph');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Nested lists
+  // -------------------------------------------------------------------------
+  describe('nested lists', () => {
+    test('should handle nested <ul> inside <li>', () => {
+      const html = '<ul><li>Parent<ul><li>Child</li></ul></li></ul>';
+      const result = htmlToTiptap(html);
+      const outerList = result.content[0];
+      expect(outerList.type).toBe('bulletList');
+      const listItem = outerList.content![0];
+      expect(listItem.type).toBe('listItem');
+      // The list item should contain both a paragraph (for "Parent") and a nested bulletList
+      const nestedList = listItem.content!.find((n) => n.type === 'bulletList');
+      expect(nestedList).toBeDefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Whitespace handling
+  // -------------------------------------------------------------------------
+  describe('whitespace handling', () => {
+    test('should preserve meaningful whitespace in text', () => {
+      const result = htmlToTiptap('<p>Hello World</p>');
+      expect(result.content[0].content![0].text).toBe('Hello World');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Server-side fallback (no DOMParser)
+  // -------------------------------------------------------------------------
+  describe('server-side fallback (no DOMParser)', () => {
+    test('should fall back to stripping HTML when DOMParser is unavailable', () => {
+      const originalDOMParser = (globalThis as any).DOMParser;
+      delete (globalThis as any).DOMParser;
+      try {
+        const result = htmlToTiptap('<p>Hello <strong>world</strong></p>');
+        expect(result.type).toBe('doc');
+        expect(result.content.length).toBe(1);
+        expect(result.content[0].type).toBe('paragraph');
+        // Should strip HTML tags and return plain text
+        expect(result.content[0].content![0].type).toBe('text');
+        expect(result.content[0].content![0].text).toBe('Hello world');
+      } finally {
+        (globalThis as any).DOMParser = originalDOMParser;
+      }
+    });
+
+    test('should handle plain text without DOMParser', () => {
+      const originalDOMParser = (globalThis as any).DOMParser;
+      delete (globalThis as any).DOMParser;
+      try {
+        const result = htmlToTiptap('Just plain text');
+        expect(result.content[0].content![0].text).toBe('Just plain text');
+      } finally {
+        (globalThis as any).DOMParser = originalDOMParser;
+      }
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Non-element node types (comment nodes, etc.)
+  // -------------------------------------------------------------------------
+  describe('non-element node types', () => {
+    test('should ignore HTML comments', () => {
+      const result = htmlToTiptap('<p>Before<!-- comment -->After</p>');
+      const p = result.content[0];
+      expect(p.type).toBe('paragraph');
+      // Comment node should be ignored, only text nodes remain
+      const textNodes = p.content!.filter((n) => n.type === 'text');
+      expect(textNodes.length).toBeGreaterThanOrEqual(1);
+      const fullText = textNodes.map((n) => n.text).join('');
+      expect(fullText).toContain('Before');
+      expect(fullText).toContain('After');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Standalone table elements via parseNode switch
+  // -------------------------------------------------------------------------
+  describe('table elements parsed standalone via parseNode', () => {
+    test('should handle <strike> tag as strike mark', () => {
+      const result = htmlToTiptap('<p><strike>Strikethrough</strike></p>');
+      const textNode = result.content[0].content![0];
+      expect(textNode.marks!.some((m) => m.type === 'strike')).toBe(true);
+    });
+
+    test('should handle table with tfoot section', () => {
+      const html = `
+        <table>
+          <thead><tr><th>Head</th></tr></thead>
+          <tbody><tr><td>Body</td></tr></tbody>
+          <tfoot><tr><td>Foot</td></tr></tfoot>
+        </table>
+      `;
+      const result = htmlToTiptap(html);
+      const table = findNode(result, 'table');
+      expect(table).toBeDefined();
+      // Should have 3 rows: head, body, foot
+      expect(table!.content!.length).toBe(3);
+    });
+
+    test('should handle table with both section rows and direct tr children', () => {
+      // Note: happy-dom may restructure the HTML, moving direct <tr> into <tbody>.
+      // The key test is that parseTable handles both cases.
+      const html = `
+        <table>
+          <tbody><tr><td>Section row</td></tr></tbody>
+          <tr><td>Direct row</td></tr>
+        </table>
+      `;
+      const result = htmlToTiptap(html);
+      const table = findNode(result, 'table');
+      expect(table).toBeDefined();
+      // At minimum, we should get at least 1 row
+      expect(table!.content!.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // addMarkToNodes recursive path (non-text node with content inside marks)
+  // -------------------------------------------------------------------------
+  describe('marks on non-text nodes', () => {
+    test('should apply mark recursively to nested inline content', () => {
+      // <strong> wrapping a <br> and text - hardBreak is a non-text node
+      const result = htmlToTiptap('<p><strong>Before<br>After</strong></p>');
+      const p = result.content[0];
+      expect(p.type).toBe('paragraph');
+      // Should have text nodes with bold mark and a hardBreak
+      const boldTexts = p.content!.filter(
+        (n) => n.type === 'text' && n.marks?.some((m) => m.type === 'bold')
+      );
+      expect(boldTexts.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test('should handle bold link (mark applied to non-text node with content)', () => {
+      // <strong> wrapping an <a> -- parseInlineWithMark returns nodes from the <a>,
+      // and addMarkToNodes must handle the case where a node has content (the link text)
+      // but is not a text node itself. However, parseLink returns text nodes with link mark,
+      // so the bold mark is applied to text nodes that already have marks.
+      const result = htmlToTiptap('<p><strong><a href="/url">Link text</a></strong></p>');
+      const p = result.content[0];
+      const textNode = p.content![0];
+      expect(textNode.type).toBe('text');
+      expect(textNode.text).toBe('Link text');
+      const markTypes = textNode.marks!.map((m) => m.type);
+      expect(markTypes).toContain('bold');
+      expect(markTypes).toContain('link');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Standalone table elements (tr, td, th outside table)
+  // -------------------------------------------------------------------------
+  describe('standalone table elements outside table context', () => {
+    test('should handle standalone <tr> inside a div', () => {
+      // This should trigger the 'tr' case in parseNode switch (line 207-208)
+      const result = htmlToTiptap('<div><tr><td>Cell</td></tr></div>');
+      // The tr is parsed via parseTableRow -> produces tableRow
+      const tableRow = findNode(result, 'tableRow');
+      // Depending on happy-dom's handling, the <tr> may or may not survive
+      // But parseNode should handle it
+      expect(result.type).toBe('doc');
+    });
+
+    test('should handle standalone <td> inside a div', () => {
+      // This triggers the 'td' case in parseNode switch (line 209-210)
+      const result = htmlToTiptap('<div><td>Cell content</td></div>');
+      expect(result.type).toBe('doc');
+    });
+
+    test('should handle standalone <th> inside a div', () => {
+      // This triggers the 'th' case in parseNode switch (line 211-212)
+      const result = htmlToTiptap('<div><th>Header content</th></div>');
+      expect(result.type).toBe('doc');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Empty heading
+  // -------------------------------------------------------------------------
+  describe('empty heading', () => {
+    test('should handle empty heading', () => {
+      const result = htmlToTiptap('<h1></h1>');
+      const heading = result.content[0];
+      expect(heading.type).toBe('heading');
+      expect(heading.attrs!.level).toBe(1);
+      expect(heading.content).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Edge case: content that produces empty after parsing
+  // -------------------------------------------------------------------------
+  describe('edge cases for empty content paths', () => {
+    test('should handle HTML with only a comment (no real content)', () => {
+      // Comments may be stripped by happy-dom, potentially yielding empty content
+      const result = htmlToTiptap('<!-- only a comment -->');
+      expect(result.type).toBe('doc');
+      // Either empty doc or paragraph wrapping empty text -- both are valid
+      expect(Array.isArray(result.content)).toBe(true);
+    });
+
+    test('should handle numeric input coerced to string context', () => {
+      // The guard checks typeof html !== 'string'
+      const result = htmlToTiptap(42 as any);
+      expect(result).toEqual({ type: 'doc', content: [] });
+    });
+
+    test('should handle boolean input', () => {
+      const result = htmlToTiptap(true as any);
+      expect(result).toEqual({ type: 'doc', content: [] });
+    });
+
+    test('should handle object input', () => {
+      const result = htmlToTiptap({} as any);
+      expect(result).toEqual({ type: 'doc', content: [] });
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Standalone <li> outside of list (triggers parseNode li path directly)
+  // -------------------------------------------------------------------------
+  describe('standalone list item', () => {
+    test('should handle <li> wrapped in a non-list container (div)', () => {
+      // When a <li> is a child of a div, parseNode encounters it directly
+      const result = htmlToTiptap('<div><li>Item outside list</li></div>');
+      const listItem = findNode(result, 'listItem');
+      expect(listItem).toBeDefined();
+      expect(listItem!.content![0].type).toBe('paragraph');
+    });
+  });
+});