meno-core 1.0.53 → 1.1.0

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

@@ -4,15 +4,30 @@
  * 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 { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { window as domWindow } from '../../test-utils/dom-setup';
 import { htmlToTiptap } from './htmlToTiptap';
 import type { TiptapDocument, TiptapNode } from './types';
 
-// Register DOMParser globally so htmlToTiptap uses the DOM-based path
+// Register DOMParser globally so htmlToTiptap uses the DOM-based path.
+// IMPORTANT: reuse the preloaded dom-setup window — it carries the
+// `window.SyntaxError` patch that happy-dom's selector parser needs (it does
+// `new this.window.SyntaxError(...)` on every querySelector). A fresh
+// `new Window()` lacks the patch, so every element.querySelector() in
+// parseCodeBlock/parseTable throws "undefined is not a constructor".
+const originalDOMParser = (globalThis as { DOMParser?: unknown }).DOMParser;
 beforeAll(() => {
-  const win = new Window({ url: 'http://localhost:3000' });
-  (globalThis as any).DOMParser = win.DOMParser;
+  (globalThis as { DOMParser?: unknown }).DOMParser = domWindow.DOMParser;
+});
+
+// Restore the global afterwards so it doesn't leak into later test files —
+// htmlToTiptap (and other modules) branch on `typeof DOMParser`.
+afterAll(() => {
+  if (originalDOMParser === undefined) {
+    delete (globalThis as { DOMParser?: unknown }).DOMParser;
+  } else {
+    (globalThis as { DOMParser?: unknown }).DOMParser = originalDOMParser;
+  }
 });
 
 // ---------------------------------------------------------------------------
@@ -35,7 +50,7 @@ function findNode(doc: TiptapDocument, type: string): TiptapNode | undefined {
 }
 
 /** Collect all nodes of a given type */
-function findAllNodes(doc: TiptapDocument, type: string): TiptapNode[] {
+function _findAllNodes(doc: TiptapDocument, type: string): TiptapNode[] {
   const result: TiptapNode[] = [];
   function search(nodes: TiptapNode[]) {
     for (const n of nodes) {
@@ -75,10 +90,10 @@ describe('htmlToTiptap', () => {
       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');
+      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');
     });
   });
 
@@ -89,13 +104,13 @@ describe('htmlToTiptap', () => {
     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');
+      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];
+      const p = result.content[0]!;
       expect(p.type).toBe('paragraph');
       expect(p.attrs).toBeDefined();
       expect(p.attrs!.textAlign).toBe('center');
@@ -103,12 +118,12 @@ describe('htmlToTiptap', () => {
 
     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');
+      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];
+      const p = result.content[0]!;
       // 'start' is not in the allowed list
       expect(p.attrs?.textAlign).toBeUndefined();
     });
@@ -117,16 +132,16 @@ describe('htmlToTiptap', () => {
       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];
+          const heading = result.content[0]!;
           expect(heading.type).toBe('heading');
           expect(heading.attrs!.level).toBe(level);
-          expect(heading.content![0].text).toBe(`Heading ${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];
+        const heading = result.content[0]!;
         expect(heading.type).toBe('heading');
         expect(heading.attrs!.level).toBe(2);
         expect(heading.attrs!.textAlign).toBe('right');
@@ -137,97 +152,97 @@ describe('htmlToTiptap', () => {
       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];
+        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');
+        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];
+        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];
+        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];
+        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');
+        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];
+        const listItem = result.content[0]!.content![0]!;
         expect(listItem.type).toBe('listItem');
-        expect(listItem.content![0].type).toBe('paragraph');
+        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];
+        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');
+        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];
+      const bq = result.content[0]!;
       expect(bq.type).toBe('blockquote');
       // Content should be wrapped in paragraph
-      expect(bq.content![0].type).toBe('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];
+      const bq = result.content[0]!;
       expect(bq.type).toBe('blockquote');
       expect(bq.content!.length).toBe(1);
-      expect(bq.content![0].type).toBe('paragraph');
+      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];
+      const codeBlock = result.content[0]!;
       expect(codeBlock.type).toBe('codeBlock');
-      expect(codeBlock.content![0].text).toBe('const x = 1;');
+      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];
+      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];
+      const codeBlock = result.content[0]!;
       expect(codeBlock.type).toBe('codeBlock');
-      expect(codeBlock.content![0].text).toBe('Plain preformatted');
+      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];
+      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];
+      const p = result.content[0]!;
       expect(p.type).toBe('paragraph');
       // Should contain text, hardBreak, text
       const types = p.content!.map((n) => n.type);
@@ -265,7 +280,7 @@ describe('htmlToTiptap', () => {
   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];
+      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);
@@ -273,51 +288,51 @@ describe('htmlToTiptap', () => {
 
     test('should convert <b> to bold mark', () => {
       const result = htmlToTiptap('<p><b>Bold text</b></p>');
-      const textNode = result.content[0].content![0];
+      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];
+      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];
+      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];
+      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];
+      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];
+      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];
+      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];
+      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();
@@ -325,10 +340,8 @@ describe('htmlToTiptap', () => {
     });
 
     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 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');
@@ -342,7 +355,7 @@ describe('htmlToTiptap', () => {
   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];
+      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);
@@ -352,17 +365,15 @@ describe('htmlToTiptap', () => {
 
     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 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];
+      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');
@@ -376,7 +387,7 @@ describe('htmlToTiptap', () => {
   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];
+      const textNode = result.content[0]!.content![0]!;
       expect(textNode.text).toBe('Styled');
       const styleMark = textNode.marks!.find((m) => m.type === 'textStyle');
       expect(styleMark).toBeDefined();
@@ -385,7 +396,7 @@ describe('htmlToTiptap', () => {
 
     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];
+      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)
@@ -395,7 +406,7 @@ describe('htmlToTiptap', () => {
 
     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];
+      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');
@@ -424,15 +435,15 @@ describe('htmlToTiptap', () => {
       expect(table!.content!.length).toBe(2); // 2 rows
 
       // First row should have tableHeader cells
-      const headerRow = table!.content![0];
+      const headerRow = table!.content![0]!;
       expect(headerRow.type).toBe('tableRow');
-      expect(headerRow.content![0].type).toBe('tableHeader');
-      expect(headerRow.content![1].type).toBe('tableHeader');
+      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];
+      const bodyRow = table!.content![1]!;
       expect(bodyRow.type).toBe('tableRow');
-      expect(bodyRow.content![0].type).toBe('tableCell');
+      expect(bodyRow.content![0]!.type).toBe('tableCell');
     });
 
     test('should handle table cells with colspan and rowspan', () => {
@@ -450,9 +461,9 @@ describe('htmlToTiptap', () => {
       const table = findNode(result, 'table');
       expect(table).toBeDefined();
       expect(table!.content!.length).toBe(1);
-      const row = table!.content![0];
+      const row = table!.content![0]!;
       expect(row.type).toBe('tableRow');
-      expect(row.content![0].type).toBe('tableCell');
+      expect(row.content![0]!.type).toBe('tableCell');
     });
 
     test('should give empty table cells an empty paragraph', () => {
@@ -461,7 +472,7 @@ describe('htmlToTiptap', () => {
       const cell = findNode(result, 'tableCell');
       expect(cell).toBeDefined();
       expect(cell!.content!.length).toBe(1);
-      expect(cell!.content![0].type).toBe('paragraph');
+      expect(cell!.content![0]!.type).toBe('paragraph');
     });
 
     test('should handle <th> cells in thead as tableHeader', () => {
@@ -487,33 +498,33 @@ describe('htmlToTiptap', () => {
     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');
+      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');
+      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');
+      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');
+      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');
+      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');
+      expect(result.content[0]!.type).toBe('paragraph');
     });
   });
 
@@ -524,7 +535,7 @@ describe('htmlToTiptap', () => {
     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');
+      expect(result.content[0]!.type).toBe('paragraph');
     });
 
     test('should wrap mixed inline and block siblings correctly', () => {
@@ -532,21 +543,21 @@ describe('htmlToTiptap', () => {
       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');
+      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');
+      expect(result.content[0]!.type).toBe('paragraph');
       // Should have multiple text nodes inside
-      expect(result.content[0].content!.length).toBeGreaterThanOrEqual(2);
+      expect(result.content[0]!.content!.length).toBeGreaterThanOrEqual(2);
     });
   });
 
@@ -557,27 +568,27 @@ describe('htmlToTiptap', () => {
     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');
+      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];
+      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');
+      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];
+      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();
@@ -586,16 +597,16 @@ describe('htmlToTiptap', () => {
     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');
+      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];
+      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');
+      expect(bq.content![0]!.type).toBe('paragraph');
+      expect(bq.content![0]!.content![0]!.text).toBe('Quoted paragraph');
     });
   });
 
@@ -606,8 +617,8 @@ describe('htmlToTiptap', () => {
     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');
+      expect(result.content[0]!.type).toBe('paragraph');
+      expect(result.content[0]!.content![0]!.text).toBe('Content');
     });
   });
 
@@ -633,20 +644,20 @@ describe('htmlToTiptap', () => {
   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];
+      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];
+      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];
+      const codeBlock = result.content[0]!;
       expect(codeBlock.type).toBe('codeBlock');
       expect(codeBlock.content).toEqual([]);
     });
@@ -678,7 +689,7 @@ describe('htmlToTiptap', () => {
   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 textNode = result.content[0]!.content![0]!;
       const linkMark = textNode.marks!.find((m) => m.type === 'link');
       expect(linkMark).toBeDefined();
       expect(linkMark!.attrs!.href).toBe('');
@@ -686,7 +697,7 @@ describe('htmlToTiptap', () => {
 
     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 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();
@@ -708,9 +719,9 @@ describe('htmlToTiptap', () => {
     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');
+      expect(result.content[0]!.type).toBe('paragraph');
+      expect(result.content[1]!.type).toBe('horizontalRule');
+      expect(result.content[2]!.type).toBe('paragraph');
     });
   });
 
@@ -721,9 +732,9 @@ describe('htmlToTiptap', () => {
     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];
+      const outerList = result.content[0]!;
       expect(outerList.type).toBe('bulletList');
-      const listItem = outerList.content![0];
+      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');
@@ -737,7 +748,7 @@ describe('htmlToTiptap', () => {
   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');
+      expect(result.content[0]!.content![0]!.text).toBe('Hello World');
     });
   });
 
@@ -752,10 +763,10 @@ describe('htmlToTiptap', () => {
         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');
+        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');
+        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;
       }
@@ -766,7 +777,7 @@ describe('htmlToTiptap', () => {
       delete (globalThis as any).DOMParser;
       try {
         const result = htmlToTiptap('Just plain text');
-        expect(result.content[0].content![0].text).toBe('Just plain text');
+        expect(result.content[0]!.content![0]!.text).toBe('Just plain text');
       } finally {
         (globalThis as any).DOMParser = originalDOMParser;
       }
@@ -779,7 +790,7 @@ describe('htmlToTiptap', () => {
   describe('non-element node types', () => {
     test('should ignore HTML comments', () => {
       const result = htmlToTiptap('<p>Before<!-- comment -->After</p>');
-      const p = result.content[0];
+      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');
@@ -796,7 +807,7 @@ describe('htmlToTiptap', () => {
   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];
+      const textNode = result.content[0]!.content![0]!;
       expect(textNode.marks!.some((m) => m.type === 'strike')).toBe(true);
     });
 
@@ -839,12 +850,10 @@ describe('htmlToTiptap', () => {
     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];
+      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')
-      );
+      const boldTexts = p.content!.filter((n) => n.type === 'text' && n.marks?.some((m) => m.type === 'bold'));
       expect(boldTexts.length).toBeGreaterThanOrEqual(1);
     });
 
@@ -854,8 +863,8 @@ describe('htmlToTiptap', () => {
       // 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];
+      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);
@@ -872,7 +881,7 @@ describe('htmlToTiptap', () => {
       // 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');
+      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');
@@ -897,7 +906,7 @@ describe('htmlToTiptap', () => {
   describe('empty heading', () => {
     test('should handle empty heading', () => {
       const result = htmlToTiptap('<h1></h1>');
-      const heading = result.content[0];
+      const heading = result.content[0]!;
       expect(heading.type).toBe('heading');
       expect(heading.attrs!.level).toBe(1);
       expect(heading.content).toBeUndefined();
@@ -942,7 +951,7 @@ describe('htmlToTiptap', () => {
       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');
+      expect(listItem!.content![0]!.type).toBe('paragraph');
     });
   });
 });