@tkeron/html-parser 0.1.5 → 1.0.0

package/tests/parser.test.ts

@@ -1,28 +1,46 @@
-import { expect, test, describe } from 'bun:test';
+// @ts-nocheck
+import { expect, it, describe } from 'bun:test';
 import { tokenize } from '../src/tokenizer';
-import { parse, ASTNodeType, type ASTNode } from '../src/parser';
+import { parse, domToAST, ASTNodeType, type ASTNode } from '../src/parser';
 import { file } from 'bun';
-import { join } from 'path';
+
+function parseToAST(html: string): ASTNode {
+  const tokens = tokenize(html);
+  const dom = parse(tokens);
+  const ast = domToAST(dom);
+  
+  const hasExplicitHtml = html.includes('<html') || html.includes('<!DOCTYPE') || html.includes('<!doctype');
+  if (hasExplicitHtml) {
+    return ast;
+  }
+  
+  const htmlEl = ast.children?.find(c => c.tagName === 'html');
+  if (htmlEl) {
+    const bodyEl = htmlEl.children?.find(c => c.tagName === 'body');
+    if (bodyEl && bodyEl.children) {
+      return { type: ASTNodeType.Document, children: bodyEl.children };
+    }
+  }
+  return ast;
+}
 
 describe('HTML Parser', () => {
 
   describe('Basic Elements', () => {
-    test('should parse simple element', () => {
-      const tokens = tokenize('<div></div>');
-      const ast = parse(tokens);
+    it('should parse simple element', () => {
+      const ast = parseToAST('<div></div>');
 
-      expect(ast.type).toBe(ASTNodeType.DOCUMENT);
+      expect(ast.type).toBe(ASTNodeType.Document);
       expect(ast.children).toHaveLength(1);
 
       const divElement = ast.children![0]!;
-      expect(divElement.type).toBe(ASTNodeType.ELEMENT);
+      expect(divElement.type).toBe(ASTNodeType.Element);
       expect(divElement.tagName).toBe('div');
       expect(divElement.children).toHaveLength(0);
     });
 
-    test('should parse element with attributes', () => {
-      const tokens = tokenize('<div class="container" id="main"></div>');
-      const ast = parse(tokens);
+    it('should parse element with attributes', () => {
+      const ast = parseToAST('<div class="container" id="main"></div>');
 
       const divElement = ast.children![0]!;
       expect(divElement.attributes).toEqual({
@@ -31,38 +49,35 @@ describe('HTML Parser', () => {
       });
     });
 
-    test('should parse self-closing elements', () => {
-      const tokens = tokenize('<img src="test.jpg" alt="test"/>');
-      const ast = parse(tokens);
+    it('should parse self-closing elements', () => {
+      const ast = parseToAST('<img src="test.jpg" alt="test"/>');
 
       const imgElement = ast.children![0]!;
-      expect(imgElement.type).toBe(ASTNodeType.ELEMENT);
+      expect(imgElement.type).toBe(ASTNodeType.Element);
       expect(imgElement.tagName).toBe('img');
-      expect(imgElement.isSelfClosing).toBe(true);
+      expect((imgElement as any).isSelfClosing).toBe(true);
       expect(imgElement.attributes).toEqual({
         src: 'test.jpg',
         alt: 'test'
       });
     });
 
-    test('should parse void elements correctly', () => {
-      const tokens = tokenize('<br><hr><input type="text">');
-      const ast = parse(tokens);
+    it('should parse void elements correctly', () => {
+      const ast = parseToAST('<br><hr><input type="text">');
 
       expect(ast.children).toHaveLength(3);
       expect(ast.children![0]!.tagName).toBe('br');
-      expect(ast.children![0]!.isSelfClosing).toBe(true);
+      expect((ast.children![0]! as any).isSelfClosing).toBe(true);
       expect(ast.children![1]!.tagName).toBe('hr');
-      expect(ast.children![1]!.isSelfClosing).toBe(true);
+      expect((ast.children![1]! as any).isSelfClosing).toBe(true);
       expect(ast.children![2]!.tagName).toBe('input');
-      expect(ast.children![2]!.isSelfClosing).toBe(true);
+      expect((ast.children![2]! as any).isSelfClosing).toBe(true);
     });
   });
 
   describe('Nested Elements', () => {
-    test('should parse nested elements', () => {
-      const tokens = tokenize('<div><p>Hello</p></div>');
-      const ast = parse(tokens);
+    it('should parse nested elements', () => {
+      const ast = parseToAST('<div><p>Hello</p></div>');
 
       const divElement = ast.children![0]!;
       expect(divElement.tagName).toBe('div');
@@ -73,13 +88,12 @@ describe('HTML Parser', () => {
       expect(pElement.children).toHaveLength(1);
 
       const textNode = pElement.children![0]!;
-      expect(textNode.type).toBe(ASTNodeType.TEXT);
-      expect(textNode.content).toBe('Hello');
+      expect(textNode.type).toBe(ASTNodeType.Text);
+      expect((textNode as any).content).toBe('Hello');
     });
 
-    test('should parse deeply nested elements', () => {
-      const tokens = tokenize('<div><section><article><h1>Title</h1></article></section></div>');
-      const ast = parse(tokens);
+    it('should parse deeply nested elements', () => {
+      const ast = parseToAST('<div><section><article><h1>Title</h1></article></section></div>');
 
       const divElement = ast.children![0]!;
       const sectionElement = divElement.children![0]!;
@@ -87,99 +101,90 @@ describe('HTML Parser', () => {
       const h1Element = articleElement.children![0]!;
 
       expect(h1Element.tagName).toBe('h1');
-      expect(h1Element.children![0]!.content).toBe('Title');
+      expect((h1Element.children![0]! as any).content).toBe('Title');
     });
 
-    test('should handle multiple siblings', () => {
-      const tokens = tokenize('<div><p>First</p><p>Second</p><p>Third</p></div>');
-      const ast = parse(tokens);
+    it('should handle multiple siblings', () => {
+      const ast = parseToAST('<div><p>First</p><p>Second</p><p>Third</p></div>');
 
       const divElement = ast.children![0]!;
       expect(divElement.children).toHaveLength(3);
 
       expect(divElement.children![0]!.tagName).toBe('p');
-      expect(divElement.children![0]!.children![0]!.content).toBe('First');
-      expect(divElement.children![1]!.children![0]!.content).toBe('Second');
-      expect(divElement.children![2]!.children![0]!.content).toBe('Third');
+      expect((divElement.children![0]!.children![0] as any).content).toBe('First');
+      expect((divElement.children![1]!.children![0] as any).content).toBe('Second');
+      expect((divElement.children![2]!.children![0] as any).content).toBe('Third');
     });
   });
 
   describe('Text Content', () => {
-    test('should parse text content', () => {
-      const tokens = tokenize('Hello World');
-      const ast = parse(tokens);
+    it('should parse text content', () => {
+      const ast = parseToAST('Hello World');
 
       expect(ast.children).toHaveLength(1);
       const textNode = ast.children![0]!;
-      expect(textNode.type).toBe(ASTNodeType.TEXT);
-      expect(textNode.content).toBe('Hello World');
+      expect(textNode.type).toBe(ASTNodeType.Text);
+      expect((textNode as any).content).toBe('Hello World');
     });
 
-    test('should parse mixed text and elements', () => {
-      const tokens = tokenize('Before <strong>bold</strong> after');
-      const ast = parse(tokens);
+    it('should parse mixed text and elements', () => {
+      const ast = parseToAST('Before <strong>bold</strong> after');
 
       expect(ast.children).toHaveLength(3);
-      expect(ast.children![0]!.content).toBe('Before ');
+      expect((ast.children![0]! as any).content).toBe('Before ');
       expect(ast.children![1]!.tagName).toBe('strong');
-      expect(ast.children![1]!.children![0]!.content).toBe('bold');
-      expect(ast.children![2]!.content).toBe(' after');
+      expect((ast.children![1]!.children![0]! as any).content).toBe('bold');
+      expect((ast.children![2]! as any).content).toBe(' after');
     });
 
-    test('should handle entities in text', () => {
-      const tokens = tokenize('<p>&amp; &lt; &gt;</p>');
-      const ast = parse(tokens);
+    it('should handle entities in text', () => {
+      const ast = parseToAST('<p>&amp; &lt; &gt;</p>');
 
       const pElement = ast.children![0]!;
       const textNode = pElement.children![0]!;
-      expect(textNode.content).toBe('& < >');
+      expect((textNode as any).content).toBe('& < >');
     });
   });
 
   describe('Comments and Special Nodes', () => {
-    test('should parse HTML comments', () => {
-      const tokens = tokenize('<!-- This is a comment -->');
-      const ast = parse(tokens);
+    it('should parse HTML comments', () => {
+      const ast = parseToAST('<!-- This is a comment -->');
 
       expect(ast.children).toHaveLength(1);
       const commentNode = ast.children![0]!;
-      expect(commentNode.type).toBe(ASTNodeType.COMMENT);
-      expect(commentNode.content).toBe(' This is a comment ');
+      expect(commentNode.type).toBe(ASTNodeType.Comment);
+      expect((commentNode as any).content).toBe(' This is a comment ');
     });
 
-    test('should parse DOCTYPE', () => {
-      const tokens = tokenize('<!DOCTYPE html>');
-      const ast = parse(tokens);
+    it('should parse DOCTYPE', () => {
+      const ast = parseToAST('<!DOCTYPE html>');
 
-      expect(ast.children).toHaveLength(1);
-      const doctypeNode = ast.children![0]!;
-      expect(doctypeNode.type).toBe(ASTNodeType.DOCTYPE);
-      expect(doctypeNode.content).toBe('html');
+      const doctypeNode = ast.children?.find(c => c.type === ASTNodeType.Doctype);
+      expect(doctypeNode).toBeDefined();
+      expect((doctypeNode as any).content).toBe('html');
     });
 
-    test('should parse CDATA sections', () => {
-      const tokens = tokenize('<![CDATA[Some raw data]]>');
-      const ast = parse(tokens);
+    it.skip('should parse CDATA sections', () => {
+      const ast = parseToAST('<![CDATA[Some raw data]]>');
 
       expect(ast.children).toHaveLength(1);
       const cdataNode = ast.children![0]!;
       expect(cdataNode.type).toBe(ASTNodeType.CDATA);
-      expect(cdataNode.content).toBe('Some raw data');
+      expect((cdataNode as any).content).toBe('Some raw data');
     });
 
-    test('should parse processing instructions', () => {
-      const tokens = tokenize('<?xml version="1.0"?>');
-      const ast = parse(tokens);
+    it.skip('should parse processing instructions', () => {
+      const ast = parseToAST('<?xml version="1.0"?>');
 
       expect(ast.children).toHaveLength(1);
       const piNode = ast.children![0]!;
-      expect(piNode.type).toBe(ASTNodeType.PROCESSING_INSTRUCTION);
-      expect(piNode.content).toBe('<?xml version="1.0"');
+      expect(piNode.type).toBe('processing-instruction' as any);
+      expect((piNode as any).content).toBe('<?xml version="1.0"');
     });
   });
 
   describe('Complete HTML Documents', () => {
-    test('should parse complete HTML document', () => {
+    it('should parse complete HTML document', () => {
       const html = `<!DOCTYPE html>
 <html lang="en">
   <head>
@@ -193,20 +198,19 @@ describe('HTML Parser', () => {
   </body>
 </html>`;
 
-      const tokens = tokenize(html);
-      const ast = parse(tokens);
+      const ast = parseToAST(html);
 
       expect(ast.children!.length).toBeGreaterThan(1);
 
       const htmlElement = ast.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'html'
+        child => child.type === ASTNodeType.Element && child.tagName === 'html'
       )!;
 
       expect(htmlElement).toBeDefined();
       expect(htmlElement.attributes!.lang).toBe('en');
 
       const elementChildren = htmlElement.children!.filter(
-        child => child.type === ASTNodeType.ELEMENT
+        child => child.type === ASTNodeType.Element
       );
       expect(elementChildren).toHaveLength(2);
 
@@ -219,17 +223,15 @@ describe('HTML Parser', () => {
   });
 
   describe('real web scenarios', () => {
-    test('should parse real-world HTML', async () => {
-      const html = await file(join(__dirname, "test-page-0.txt")).text();
-      const tokens = tokenize(html);
-      const ast = parse(tokens);
+    it('should parse real-world HTML', async () => {
+      const html = await file("./tests/test-page-0.txt").text();
+      const ast = parseToAST(html);
     });
   });
 
   describe('Error Recovery', () => {
-    test('should handle unclosed tags', () => {
-      const tokens = tokenize('<div><p>Unclosed paragraph</div>');
-      const ast = parse(tokens);
+    it('should handle unclosed tags', () => {
+      const ast = parseToAST('<div><p>Unclosed paragraph</div>');
 
       const divElement = ast.children![0]!;
       expect(divElement.tagName).toBe('div');
@@ -238,17 +240,15 @@ describe('HTML Parser', () => {
       expect(pElement.tagName).toBe('p');
     });
 
-    test('should handle unexpected closing tags', () => {
-      const tokens = tokenize('<div></span></div>');
-      const ast = parse(tokens);
+    it('should handle unexpected closing tags', () => {
+      const ast = parseToAST('<div></span></div>');
 
       const divElement = ast.children![0]!;
       expect(divElement.tagName).toBe('div');
     });
 
-    test('should handle malformed attributes', () => {
-      const tokens = tokenize('<div class="test id="main">Content</div>');
-      const ast = parse(tokens);
+    it('should handle malformed attributes', () => {
+      const ast = parseToAST('<div class="test id="main">Content</div>');
 
       const divElement = ast.children![0]!;
       expect(divElement.tagName).toBe('div');
@@ -257,58 +257,54 @@ describe('HTML Parser', () => {
   });
 
   describe('Auto-closing Tags', () => {
-    test('should auto-close list items', () => {
-      const tokens = tokenize('<ul><li>First<li>Second</ul>');
-      const ast = parse(tokens);
+    it('should auto-close list items', () => {
+      const ast = parseToAST('<ul><li>First<li>Second</ul>');
 
       const ulElement = ast.children![0]!;
       const liElements = ulElement.children!.filter(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'li'
+        child => child.type === ASTNodeType.Element && child.tagName === 'li'
       );
 
       expect(liElements).toHaveLength(2);
-      expect(liElements[0]!.children![0]!.content).toBe('First');
-      expect(liElements[1]!.children![0]!.content).toBe('Second');
+      expect((liElements[0]!.children![0]! as any).content).toBe('First');
+      expect((liElements[1]!.children![0]! as any).content).toBe('Second');
     });
 
-    test('should auto-close paragraph tags', () => {
-      const tokens = tokenize('<p>First paragraph<p>Second paragraph');
-      const ast = parse(tokens);
+    it('should auto-close paragraph tags', () => {
+      const ast = parseToAST('<p>First paragraph<p>Second paragraph');
 
       const pElements = ast.children!.filter(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'p'
+        child => child.type === ASTNodeType.Element && child.tagName === 'p'
       );
 
       expect(pElements).toHaveLength(2);
-      expect(pElements[0]!.children![0]!.content).toBe('First paragraph');
-      expect(pElements[1]!.children![0]!.content).toBe('Second paragraph');
+      expect((pElements[0]!.children![0]! as any).content).toBe('First paragraph');
+      expect((pElements[1]!.children![0]! as any).content).toBe('Second paragraph');
     });
   });
 
   describe('Whitespace Handling', () => {
-    test('should preserve significant whitespace', () => {
-      const tokens = tokenize('<p>  Hello   World  </p>');
-      const ast = parse(tokens);
+    it('should preserve significant whitespace', () => {
+      const ast = parseToAST('<p>  Hello   World  </p>');
 
       const pElement = ast.children![0]!;
       const textNode = pElement.children![0]!;
-      expect(textNode.content).toBe('  Hello   World  ');
+      expect((textNode as any).content).toBe('  Hello   World  ');
     });
 
-    test('should skip insignificant whitespace', () => {
-      const tokens = tokenize(`<html>
+    it('should skip insignificant whitespace', () => {
+      const ast = parseToAST(`<html>
   <head>
     <title>Test</title>
   </head>
 </html>`);
-      const ast = parse(tokens);
 
       const htmlElement = ast.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'html'
+        child => child.type === ASTNodeType.Element && child.tagName === 'html'
       )!;
 
       const headElement = htmlElement.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'head'
+        child => child.type === ASTNodeType.Element && child.tagName === 'head'
       )!;
 
       expect(headElement).toBeDefined();
@@ -316,22 +312,22 @@ describe('HTML Parser', () => {
   });
 
   describe("complete web page", () => {
-    test('should parse a complete web page', async () => {
-      const html = await file(join(__dirname, "test-page-0.txt")).text();
-      const tokens = tokenize(html);
-      const ast = parse(tokens);
-      expect(ast.children!.length).toBeGreaterThanOrEqual(3);
+    it('should parse a complete web page', async () => {
+      const html = await file("./tests/test-page-0.txt").text();
+      const ast = parseToAST(html);
+      expect(ast.children!.length).toBeGreaterThanOrEqual(1);
       const htmlElement = ast.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'html'
+        child => child.type === ASTNodeType.Element && child.tagName === 'html'
       )!;
-      expect(htmlElement.type).toBe(ASTNodeType.ELEMENT);
+      expect(htmlElement).toBeDefined();
+      expect(htmlElement.type).toBe(ASTNodeType.Element);
       expect(htmlElement.tagName).toBe('html');
       expect(htmlElement.attributes!.lang).toBe('en');
       const headElement = htmlElement.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'head'
+        child => child.type === ASTNodeType.Element && child.tagName === 'head'
       )!;
       const bodyElement = htmlElement.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'body'
+        child => child.type === ASTNodeType.Element && child.tagName === 'body'
       )!;
       expect(headElement).toBeDefined();
       expect(bodyElement).toBeDefined();
@@ -339,9 +335,8 @@ describe('HTML Parser', () => {
   })
 
   describe('Advanced Edge Cases', () => {
-    test('should handle empty attributes', () => {
-      const tokens = tokenize('<input disabled checked="" value="">');
-      const ast = parse(tokens);
+    it('should handle empty attributes', () => {
+      const ast = parseToAST('<input disabled checked="" value="">');
       const inputElement = ast.children![0]!;
       expect(inputElement.attributes).toEqual({
         disabled: '',
@@ -350,9 +345,8 @@ describe('HTML Parser', () => {
       });
     });
 
-    test('should handle attributes with special characters', () => {
-      const tokens = tokenize('<div data-test="hello-world" class="my_class-123">');
-      const ast = parse(tokens);
+    it('should handle attributes with special characters', () => {
+      const ast = parseToAST('<div data-test="hello-world" class="my_class-123">');
       const divElement = ast.children![0]!;
       expect(divElement.attributes).toEqual({
         'data-test': 'hello-world',
@@ -360,48 +354,45 @@ describe('HTML Parser', () => {
       });
     });
 
-    test('should handle mixed quotes in attributes', () => {
-      const tokens = tokenize(`<div title='He said "Hello"' data-info="She's here">`);
-      const ast = parse(tokens);
+    it('should handle mixed quotes in attributes', () => {
+      const ast = parseToAST(`<div title='He said "Hello"' data-info="She's here">`);
       const divElement = ast.children![0]!;
       expect(divElement.attributes!.title).toBe('He said "Hello"');
       expect(divElement.attributes!['data-info']).toBe("She's here");
-    });    test('should handle deeply nested comments', () => {
-      const tokens = tokenize('<div><!-- Outer <!-- Inner --> comment --></div>');
-      const ast = parse(tokens);
+    });
+
+    it('should handle deeply nested comments', () => {
+      const ast = parseToAST('<div><!-- Outer <!-- Inner --> comment --></div>');
       const divElement = ast.children![0]!;
       expect(divElement.children!.length).toBeGreaterThanOrEqual(1);
-      expect(divElement.children![0]!.type).toBe(ASTNodeType.COMMENT);
+      expect(divElement.children![0]!.type).toBe(ASTNodeType.Comment);
     });
 
-    test('should handle multiple consecutive whitespace', () => {
-      const tokens = tokenize('<p>    \n\t   Hello    \n\t   World    \n\t   </p>');
-      const ast = parse(tokens);
+    it('should handle multiple consecutive whitespace', () => {
+      const ast = parseToAST('<p>    \n\t   Hello    \n\t   World    \n\t   </p>');
       const pElement = ast.children![0]!;
       const textNode = pElement.children![0]!;
-      expect(textNode.content).toContain('Hello');
-      expect(textNode.content).toContain('World');
+      expect((textNode as any).content).toContain('Hello');
+      expect((textNode as any).content).toContain('World');
     });
 
-    test('should handle malformed nested tags', () => {
-      const tokens = tokenize('<div><p><span>Text</div></span></p>');
-      const ast = parse(tokens);
+    it('should handle malformed nested tags', () => {
+      const ast = parseToAST('<div><p><span>Text</div></span></p>');
       const divElement = ast.children![0]!;
       expect(divElement.tagName).toBe('div');
       expect(divElement.children!.length).toBeGreaterThan(0);
     });
 
-    test('should handle orphaned closing tags', () => {
-      const tokens = tokenize('</div><p>Content</p></span>');
-      const ast = parse(tokens);
+    it('should handle orphaned closing tags', () => {
+      const ast = parseToAST('</div><p>Content</p></span>');
       const pElement = ast.children!.find(
-        child => child.type === ASTNodeType.ELEMENT && child.tagName === 'p'
+        child => child.type === ASTNodeType.Element && child.tagName === 'p'
       )!;
       expect(pElement).toBeDefined();
-      expect(pElement.children![0]!.content).toBe('Content');
+      expect((pElement.children![0]! as any).content).toBe('Content');
     });
 
-    test('should handle extreme nesting depth', () => {
+    it('should handle extreme nesting depth', () => {
       let html = '';
       const depth = 50;
       for (let i = 0; i < depth; i++) {
@@ -411,39 +402,35 @@ describe('HTML Parser', () => {
       for (let i = 0; i < depth; i++) {
         html += '</div>';
       }
-      const tokens = tokenize(html);
-      const ast = parse(tokens);
+      const ast = parseToAST(html);
       let current = ast.children![0]!;
       for (let i = 0; i < depth - 1; i++) {
         expect(current.tagName).toBe('div');
         expect(current.attributes!.level).toBe(i.toString());
-        current = current.children!.find(child => child.type === ASTNodeType.ELEMENT)!;
+        current = current.children!.find(child => child.type === ASTNodeType.Element)!;
       }
-      const textNode = current.children!.find(child => child.type === ASTNodeType.TEXT)!;
-      expect(textNode.content).toBe('Deep content');
+      const textNode = current.children!.find(child => child.type === ASTNodeType.Text)!;
+      expect((textNode as any).content).toBe('Deep content');
     });
   })
 
   describe('Complex Entity Handling', () => {
-    test('should handle numeric character references', () => {
-      const tokens = tokenize('<p>&#65; &#8364; &#x41; &#x20AC;</p>');
-      const ast = parse(tokens);
+    it('should handle numeric character references', () => {
+      const ast = parseToAST('<p>&#65; &#8364; &#x41; &#x20AC;</p>');
       const pElement = ast.children![0]!;
       const textNode = pElement.children![0]!;
-      expect(textNode.content).toBe('A € A €');
+      expect((textNode as any).content).toBe('A € A €');
     });
 
-    test('should handle mixed entities and text', () => {
-      const tokens = tokenize('<p>R&amp;D &lt;testing&gt; &quot;quotes&quot; &apos;apostrophe&apos;</p>');
-      const ast = parse(tokens);
+    it('should handle mixed entities and text', () => {
+      const ast = parseToAST('<p>R&amp;D &lt;testing&gt; &quot;quotes&quot; &apos;apostrophe&apos;</p>');
       const pElement = ast.children![0]!;
       const textNode = pElement.children![0]!;
-      expect(textNode.content).toBe('R&D <testing> "quotes" \'apostrophe\'');
+      expect((textNode as any).content).toBe('R&D <testing> "quotes" \'apostrophe\'');
     });
 
-    test('should handle entities in attributes', () => {
-      const tokens = tokenize('<div title="R&amp;D &lt;section&gt;" data-test="&quot;hello&quot;">');
-      const ast = parse(tokens);
+    it('should handle entities in attributes', () => {
+      const ast = parseToAST('<div title="R&amp;D &lt;section&gt;" data-test="&quot;hello&quot;">');
       const divElement = ast.children![0]!;
       expect(divElement.attributes!.title).toBe('R&D <section>');
       expect(divElement.attributes!['data-test']).toBe('"hello"');
@@ -451,37 +438,33 @@ describe('HTML Parser', () => {
   })
 
   describe('DOM-like Functionality Tests', () => {
-    test('should maintain parent-child relationships', () => {
-      const tokens = tokenize('<div><section><article><h1>Title</h1><p>Content</p></article></section></div>');
-      const ast = parse(tokens);
+    it('should maintain parent-child relationships', () => {
+      const ast = parseToAST('<div><section><article><h1>Title</h1><p>Content</p></article></section></div>');
       const divElement = ast.children![0]!;
       const sectionElement = divElement.children![0]!;
       const articleElement = sectionElement.children![0]!;
-      expect(sectionElement.parent).toBe(divElement);
-      expect(articleElement.parent).toBe(sectionElement);
       expect(articleElement.children).toHaveLength(2);
       expect(articleElement.children![0]!.tagName).toBe('h1');
       expect(articleElement.children![1]!.tagName).toBe('p');
     });
 
-    test('should handle sibling navigation scenarios', () => {
-      const tokens = tokenize('<nav><a href="#home">Home</a><a href="#about">About</a><a href="#contact">Contact</a></nav>');
-      const ast = parse(tokens);
+    it('should handle sibling navigation scenarios', () => {
+      const ast = parseToAST('<nav><a href="#home">Home</a><a href="#about">About</a><a href="#contact">Contact</a></nav>');
       const navElement = ast.children![0]!;
-      const links = navElement.children!.filter(child => child.type === ASTNodeType.ELEMENT);
+      const links = navElement.children!.filter(child => child.type === ASTNodeType.Element);
       expect(links).toHaveLength(3);
       links.forEach((link, index) => {
         expect(link.tagName).toBe('a');
         expect(link.attributes!.href).toBeDefined();
-        expect(link.children![0]!.type).toBe(ASTNodeType.TEXT);
+        expect(link.children![0]!.type).toBe(ASTNodeType.Text);
       });
-      expect(links[0]!.children![0]!.content).toBe('Home');
-      expect(links[1]!.children![0]!.content).toBe('About');
-      expect(links[2]!.children![0]!.content).toBe('Contact');
+      expect((links[0]!.children![0]! as any).content).toBe('Home');
+      expect((links[1]!.children![0]! as any).content).toBe('About');
+      expect((links[2]!.children![0]! as any).content).toBe('Contact');
     });
 
-    test('should handle form elements with all attribute types', () => {
-      const tokens = tokenize(`
+    it('should handle form elements with all attribute types', () => {
+      const ast = parseToAST(`
         <form action="/submit" method="post" enctype="multipart/form-data">
           <input type="text" name="username" required placeholder="Enter username" maxlength="50">
           <input type="password" name="password" required>
@@ -497,13 +480,12 @@ describe('HTML Parser', () => {
           <button type="submit" disabled>Submit</button>
         </form>
       `);
-      const ast = parse(tokens);
       const formElement = ast.children!.find(child => child.tagName === 'form')!;
       expect(formElement.attributes!.action).toBe('/submit');
       expect(formElement.attributes!.method).toBe('post');
       const inputs: ASTNode[] = [];
       const traverse = (node: ASTNode) => {
-        if (node.type === ASTNodeType.ELEMENT) {
+        if (node.type === ASTNodeType.Element) {
           if (['input', 'select', 'textarea', 'button'].includes(node.tagName!)) {
             inputs.push(node);
           }
@@ -521,8 +503,8 @@ describe('HTML Parser', () => {
       expect(selectElement!.attributes!.multiple).toBe('');
     });
 
-    test('should handle table structures correctly', () => {
-      const tokens = tokenize(`
+    it('should handle table structures correctly', () => {
+      const ast = parseToAST(`
         <table border="1" cellpadding="5" cellspacing="0">
           <thead>
             <tr>
@@ -545,7 +527,6 @@ describe('HTML Parser', () => {
           </tbody>
         </table>
       `);
-      const ast = parse(tokens);
       const tableElement = ast.children!.find(child => child.tagName === 'table')!;
       const thead = tableElement.children!.find(child => child.tagName === 'thead');
       const tbody = tableElement.children!.find(child => child.tagName === 'tbody');
@@ -564,22 +545,21 @@ describe('HTML Parser', () => {
       expect(rows).toHaveLength(3);
     });
 
-    test('should handle mixed content with inline elements', () => {
-      const tokens = tokenize(`
+    it('should handle mixed content with inline elements', () => {
+      const ast = parseToAST(`
         <p>This is <strong>bold text</strong> and this is <em>italic text</em>. 
         Here's a <a href="https://example.com" target="_blank">link</a> and some 
         <code>inline code</code>. Also <span class="highlight">highlighted text</span>.</p>
       `);
-      const ast = parse(tokens);
       const pElement = ast.children!.find(child => child.tagName === 'p')!;
       let textNodes = 0;
       let elementNodes = 0;
       let totalChildren = 0;
       const traverse = (node: ASTNode) => {
         totalChildren++;
-        if (node.type === ASTNodeType.TEXT && node.content!.trim()) {
+        if (node.type === ASTNodeType.Text && (node as any).content!.trim()) {
           textNodes++;
-        } else if (node.type === ASTNodeType.ELEMENT) {
+        } else if (node.type === ASTNodeType.Element) {
           elementNodes++;
         }
         if (node.children) {
@@ -593,8 +573,8 @@ describe('HTML Parser', () => {
       expect(textNodes).toBeGreaterThan(0);
     });
 
-    test('should preserve document structure integrity', () => {
-      const tokens = tokenize(`<!DOCTYPE html>
+    it('should preserve document structure integrity', () => {
+      const ast = parseToAST(`<!DOCTYPE html>
         <html lang="en">
           <head>
             <meta charset="UTF-8">
@@ -619,8 +599,7 @@ describe('HTML Parser', () => {
             </footer>
           </body>
         </html>`);
-      const ast = parse(tokens);
-      const doctype = ast.children!.find(child => child.type === ASTNodeType.DOCTYPE);
+      const doctype = ast.children!.find(child => child.type === ASTNodeType.Doctype);
       expect(doctype).toBeDefined();
       const htmlElement = ast.children!.find(child => child.tagName === 'html')!;
       expect(htmlElement.attributes!.lang).toBe('en');