@tkeron/html-parser 1.1.2 → 1.3.0

package/tests/dom-extended.test.ts

@@ -1,34 +1,36 @@
-import { describe, it, expect } from 'bun:test';
-import { parseHTML } from '../index';
-import {
-  setInnerHTML
-} from '../src/dom-simulator';
-
-describe('DOM Extended Functionality', () => {
-  describe('innerHTML and outerHTML', () => {
-    it('should generate correct innerHTML for simple elements', () => {
-      const doc = parseHTML('<div>Hello World</div>') as Document;
+import { describe, it, expect } from "bun:test";
+import { parseHTML } from "../index";
+import { setInnerHTML } from "../src/dom-simulator/index.js";
+
+describe("DOM Extended Functionality", () => {
+  describe("innerHTML and outerHTML", () => {
+    it("should generate correct innerHTML for simple elements", () => {
+      const doc = parseHTML("<div>Hello World</div>") as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.innerHTML).toBe('Hello World');
+      expect(div.innerHTML).toBe("Hello World");
     });
 
-    it('should generate correct innerHTML for nested elements', () => {
-      const doc = parseHTML('<div><p>Hello</p><span>World</span></div>') as Document;
+    it("should generate correct innerHTML for nested elements", () => {
+      const doc = parseHTML(
+        "<div><p>Hello</p><span>World</span></div>",
+      ) as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.innerHTML).toBe('<p>Hello</p><span>World</span>');
+      expect(div.innerHTML).toBe("<p>Hello</p><span>World</span>");
     });
 
-    it('should generate correct outerHTML for elements', () => {
+    it("should generate correct outerHTML for elements", () => {
       const doc = parseHTML('<div class="test">Hello</div>') as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
       expect(div.outerHTML).toBe('<div class="test">Hello</div>');
     });
 
-    it('should generate correct outerHTML for elements with multiple attributes', () => {
-      const doc = parseHTML('<input type="text" name="username" value="test">') as Document;
+    it("should generate correct outerHTML for elements with multiple attributes", () => {
+      const doc = parseHTML(
+        '<input type="text" name="username" value="test">',
+      ) as Document;
       const input = doc.body?.firstChild as HTMLElement;
 
       expect(input.outerHTML).toContain('type="text"');
@@ -36,40 +38,44 @@ describe('DOM Extended Functionality', () => {
       expect(input.outerHTML).toContain('value="test"');
     });
 
-    it('should handle comments in innerHTML', () => {
-      const doc = parseHTML('<div><!-- comment -->text</div>') as Document;
+    it("should handle comments in innerHTML", () => {
+      const doc = parseHTML("<div><!-- comment -->text</div>") as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.innerHTML).toBe('<!-- comment -->text');
+      expect(div.innerHTML).toBe("<!-- comment -->text");
     });
   });
 
-  describe('textContent property', () => {
-    it('should provide textContent on elements', () => {
-      const doc = parseHTML('<div>Hello <span>World</span></div>') as Document;
+  describe("textContent property", () => {
+    it("should provide textContent on elements", () => {
+      const doc = parseHTML("<div>Hello <span>World</span></div>") as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.textContent).toBe('Hello World');
+      expect(div.textContent).toBe("Hello World");
     });
 
-    it('should provide textContent for deeply nested elements', () => {
-      const doc = parseHTML('<div><p><em>Hello</em> <strong>Beautiful</strong></p> <span>World</span></div>') as Document;
+    it("should provide textContent for deeply nested elements", () => {
+      const doc = parseHTML(
+        "<div><p><em>Hello</em> <strong>Beautiful</strong></p> <span>World</span></div>",
+      ) as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.textContent).toBe('Hello Beautiful World');
+      expect(div.textContent).toBe("Hello Beautiful World");
     });
 
-    it('should ignore comments in textContent', () => {
-      const doc = parseHTML('<div>Hello <!-- comment --> World</div>') as Document;
+    it("should ignore comments in textContent", () => {
+      const doc = parseHTML(
+        "<div>Hello <!-- comment --> World</div>",
+      ) as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.textContent).toBe('Hello  World');
+      expect(div.textContent).toBe("Hello  World");
     });
   });
 
-  describe('element navigation properties', () => {
-    it('should provide parentElement property', () => {
-      const doc = parseHTML('<div><p>Hello</p></div>') as Document;
+  describe("element navigation properties", () => {
+    it("should provide parentElement property", () => {
+      const doc = parseHTML("<div><p>Hello</p></div>") as Document;
       const div = doc.body?.firstChild as HTMLElement;
       const p = div.children[0];
 
@@ -77,16 +83,20 @@ describe('DOM Extended Functionality', () => {
       expect(p?.parentElement).toBe(div);
     });
 
-    it('should provide firstElementChild and lastElementChild', () => {
-      const doc = parseHTML('<div><span>First</span><p>Second</p><em>Last</em></div>') as Document;
+    it("should provide firstElementChild and lastElementChild", () => {
+      const doc = parseHTML(
+        "<div><span>First</span><p>Second</p><em>Last</em></div>",
+      ) as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      expect(div.firstElementChild?.tagName).toBe('SPAN');
-      expect(div.lastElementChild?.tagName).toBe('EM');
+      expect(div.firstElementChild?.tagName).toBe("SPAN");
+      expect(div.lastElementChild?.tagName).toBe("EM");
     });
 
-    it('should provide nextElementSibling and previousElementSibling', () => {
-      const doc = parseHTML('<div><span>First</span><p>Second</p><em>Last</em></div>') as Document;
+    it("should provide nextElementSibling and previousElementSibling", () => {
+      const doc = parseHTML(
+        "<div><span>First</span><p>Second</p><em>Last</em></div>",
+      ) as Document;
       const div = doc.body?.firstChild as HTMLElement;
       const span = div.children[0];
       const p = div.children[1];
@@ -108,51 +118,57 @@ describe('DOM Extended Functionality', () => {
     });
   });
 
-  describe('setInnerHTML functionality', () => {
-    it('should clear existing content when setting innerHTML', () => {
-      const doc = parseHTML('<div><p>Old content</p></div>') as Document;
+  describe("setInnerHTML functionality", () => {
+    it("should clear existing content when setting innerHTML", () => {
+      const doc = parseHTML("<div><p>Old content</p></div>") as Document;
       const div = doc.body?.firstChild as HTMLElement;
 
-      setInnerHTML(div, 'New content');
+      setInnerHTML(div, "New content");
 
-      expect(div.innerHTML).toBe('New content');
+      expect(div.innerHTML).toBe("New content");
       expect(div.children.length).toBe(0);
       expect(div.childNodes.length).toBe(1);
       expect(div.childNodes[0]?.nodeType).toBe(3);
-      expect(div.childNodes[0]?.textContent).toBe('New content');
+      expect(div.childNodes[0]?.textContent).toBe("New content");
     });
   });
 
-  describe('Document body property type validation', () => {
-    it('should have body property with HTMLElement type', () => {
-      const doc = parseHTML('<html><body><p>Content</p></body></html>') as Document;
+  describe("Document body property type validation", () => {
+    it("should have body property with HTMLElement type", () => {
+      const doc = parseHTML(
+        "<html><body><p>Content</p></body></html>",
+      ) as Document;
 
       expect(doc.body).toBeTruthy();
-      expect(doc.body?.tagName).toBe('BODY');
-      expect(doc.body?.innerHTML).toBe('<p>Content</p>');
-      expect(doc.body?.textContent).toBe('Content');
+      expect(doc.body?.tagName).toBe("BODY");
+      expect(doc.body?.innerHTML).toBe("<p>Content</p>");
+      expect(doc.body?.textContent).toBe("Content");
     });
 
-    it('should have head property with HTMLElement type', () => {
-      const doc = parseHTML('<html><head><title>Test</title></head><body></body></html>') as Document;
+    it("should have head property with HTMLElement type", () => {
+      const doc = parseHTML(
+        "<html><head><title>Test</title></head><body></body></html>",
+      ) as Document;
 
       expect(doc.head).toBeTruthy();
-      expect(doc.head?.tagName).toBe('HEAD');
-      expect(doc.head?.innerHTML).toBe('<title>Test</title>');
+      expect(doc.head?.tagName).toBe("HEAD");
+      expect(doc.head?.innerHTML).toBe("<title>Test</title>");
     });
 
-    it('should have documentElement property with HTMLElement type', () => {
-      const doc = parseHTML('<html><head></head><body></body></html>') as Document;
+    it("should have documentElement property with HTMLElement type", () => {
+      const doc = parseHTML(
+        "<html><head></head><body></body></html>",
+      ) as Document;
 
       expect(doc.documentElement).toBeTruthy();
-      expect(doc.documentElement?.tagName).toBe('HTML');
+      expect(doc.documentElement?.tagName).toBe("HTML");
       expect(doc.documentElement?.children.length).toBe(2);
     });
   });
 
-  describe('DOM mutation and manipulation', () => {
+  describe("DOM mutation and manipulation", () => {
     it("should append an element and update innerHTML accordingly", () => {
-      const doc = parseHTML('<html><head></head><body></body></html>');
+      const doc = parseHTML("<html><head></head><body></body></html>");
 
       const body = doc.querySelector("body");
 
@@ -164,10 +180,7 @@ describe('DOM Extended Functionality', () => {
 
       const innerHTML = body?.innerHTML;
 
-      expect(innerHTML).toBe('<h1>Hello World</h1>');
-
+      expect(innerHTML).toBe("<h1>Hello World</h1>");
     });
   });
-
-
 });

package/tests/dom-manipulation.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "bun:test";
 import { parseHTML } from "../index";
-import { NodeType } from "../src/dom-simulator";
+import { NodeType } from "../src/dom-simulator/index.js";
 
 describe("DOM Manipulation - insertBefore", () => {
   describe("Basic insertBefore functionality", () => {
@@ -255,7 +255,7 @@ describe("DOM Manipulation - insertBefore", () => {
   describe("insertBefore with node relocation", () => {
     it("should remove node from previous parent when inserting", () => {
       const doc = parseHTML(
-        "<div id='parent1'><span>Child</span></div><div id='parent2'></div>"
+        "<div id='parent1'><span>Child</span></div><div id='parent2'></div>",
       );
       const parent1 = doc.querySelector("#parent1");
       const parent2 = doc.querySelector("#parent2");
@@ -270,7 +270,7 @@ describe("DOM Manipulation - insertBefore", () => {
 
     it("should update all relationships when moving node between parents", () => {
       const doc = parseHTML(
-        "<div id='p1'><span>A</span><span>B</span></div><div id='p2'><span>C</span></div>"
+        "<div id='p1'><span>A</span><span>B</span></div><div id='p2'><span>C</span></div>",
       );
       const parent1 = doc.querySelector("#p1");
       const parent2 = doc.querySelector("#p2");
@@ -319,7 +319,7 @@ describe("DOM Manipulation - replaceChild", () => {
 
     it("should replace middle child in multiple children", () => {
       const doc = parseHTML(
-        "<div><span>First</span><span>Old</span><span>Third</span></div>"
+        "<div><span>First</span><span>Old</span><span>Third</span></div>",
       );
       const div = doc.querySelector("div");
       const oldSpan = div.childNodes[1];
@@ -383,7 +383,7 @@ describe("DOM Manipulation - replaceChild", () => {
   describe("replaceChild sibling relationships", () => {
     it("should transfer sibling relationships to new node", () => {
       const doc = parseHTML(
-        "<div><span>A</span><span>Old</span><span>C</span></div>"
+        "<div><span>A</span><span>Old</span><span>C</span></div>",
       );
       const div = doc.querySelector("div");
       const spanA = div.childNodes[0];
@@ -430,7 +430,9 @@ describe("DOM Manipulation - replaceChild", () => {
     });
 
     it("should clear old child's relationships", () => {
-      const doc = parseHTML("<div><span>A</span><span>Old</span><span>C</span></div>");
+      const doc = parseHTML(
+        "<div><span>A</span><span>Old</span><span>C</span></div>",
+      );
       const div = doc.querySelector("div");
       const oldSpan = div.childNodes[1];
 
@@ -447,7 +449,7 @@ describe("DOM Manipulation - replaceChild", () => {
   describe("replaceChild element-specific relationships", () => {
     it("should update children array when replacing element with element", () => {
       const doc = parseHTML(
-        "<div><span>A</span><span>Old</span><span>C</span></div>"
+        "<div><span>A</span><span>Old</span><span>C</span></div>",
       );
       const div = doc.querySelector("div");
       const oldSpan = div.children[1];
@@ -464,7 +466,7 @@ describe("DOM Manipulation - replaceChild", () => {
 
     it("should update element sibling relationships", () => {
       const doc = parseHTML(
-        "<div><span>A</span><span>Old</span><span>C</span></div>"
+        "<div><span>A</span><span>Old</span><span>C</span></div>",
       );
       const div = doc.querySelector("div");
       const spanA = div.children[0];
@@ -504,7 +506,7 @@ describe("DOM Manipulation - replaceChild", () => {
 
     it("should remove from children array when replacing element with text", () => {
       const doc = parseHTML(
-        "<div><span>A</span><span>Old</span><span>C</span></div>"
+        "<div><span>A</span><span>Old</span><span>C</span></div>",
       );
       const div = doc.querySelector("div");
       const spanA = div.children[0];
@@ -582,7 +584,7 @@ describe("DOM Manipulation - replaceChild", () => {
   describe("replaceChild with node relocation", () => {
     it("should remove node from previous parent before replacing", () => {
       const doc = parseHTML(
-        "<div id='p1'><span>Moving</span></div><div id='p2'><span>Old</span></div>"
+        "<div id='p1'><span>Moving</span></div><div id='p2'><span>Old</span></div>",
       );
       const parent1 = doc.querySelector("#p1");
       const parent2 = doc.querySelector("#p2");
@@ -830,7 +832,9 @@ describe("DOM Manipulation - prepend", () => {
 
   describe("prepend with parent relocation", () => {
     it("should move node from another parent when prepending", () => {
-      const doc = parseHTML("<div id='a'><span>Child</span></div><div id='b'><span>Other</span></div>");
+      const doc = parseHTML(
+        "<div id='a'><span>Child</span></div><div id='b'><span>Other</span></div>",
+      );
       const divA = doc.querySelector("#a");
       const divB = doc.querySelector("#b");
       const child = divA.querySelector("span");
@@ -844,7 +848,9 @@ describe("DOM Manipulation - prepend", () => {
     });
 
     it("should remove from old parent before prepending", () => {
-      const doc = parseHTML("<div id='a'><span id='1'>1</span><span id='2'>2</span></div><div id='b'></div>");
+      const doc = parseHTML(
+        "<div id='a'><span id='1'>1</span><span id='2'>2</span></div><div id='b'></div>",
+      );
       const divA = doc.querySelector("#a");
       const divB = doc.querySelector("#b");
       const span1 = doc.querySelector("#1");
@@ -1005,7 +1011,6 @@ describe("DOM Manipulation - append", () => {
     it("should append text node after elements", () => {
       const doc = parseHTML("<div><span>Element</span></div>");
       const div = doc.querySelector("div");
-      const span = div.childNodes[0];
 
       const textNode = doc.createTextNode(" Text");
 
@@ -1053,7 +1058,9 @@ describe("DOM Manipulation - append", () => {
 
   describe("append with parent relocation", () => {
     it("should move node from another parent when appending", () => {
-      const doc = parseHTML("<div id='a'><span>Child</span></div><div id='b'><span>Other</span></div>");
+      const doc = parseHTML(
+        "<div id='a'><span>Child</span></div><div id='b'><span>Other</span></div>",
+      );
       const divA = doc.querySelector("#a");
       const divB = doc.querySelector("#b");
       const child = divA.querySelector("span");
@@ -1067,7 +1074,9 @@ describe("DOM Manipulation - append", () => {
     });
 
     it("should remove from old parent before appending", () => {
-      const doc = parseHTML("<div id='a'><span id='1'>1</span><span id='2'>2</span></div><div id='b'></div>");
+      const doc = parseHTML(
+        "<div id='a'><span id='1'>1</span><span id='2'>2</span></div><div id='b'></div>",
+      );
       const divA = doc.querySelector("#a");
       const divB = doc.querySelector("#b");
       const span2 = doc.querySelector("#2");
@@ -1137,7 +1146,9 @@ describe("DOM Manipulation - append", () => {
 describe("DOM Manipulation - remove", () => {
   describe("Basic remove functionality", () => {
     it("should remove an element from its parent", () => {
-      const doc = parseHTML("<div><span id='1'>First</span><span id='2'>Second</span></div>");
+      const doc = parseHTML(
+        "<div><span id='1'>First</span><span id='2'>Second</span></div>",
+      );
       const div = doc.querySelector("div");
       const span1 = doc.querySelector("#1");
 
@@ -1170,7 +1181,9 @@ describe("DOM Manipulation - remove", () => {
     });
 
     it("should remove first child", () => {
-      const doc = parseHTML("<div><span>First</span><span>Second</span><span>Third</span></div>");
+      const doc = parseHTML(
+        "<div><span>First</span><span>Second</span><span>Third</span></div>",
+      );
       const div = doc.querySelector("div");
       const first = div.childNodes[0];
 
@@ -1182,7 +1195,9 @@ describe("DOM Manipulation - remove", () => {
     });
 
     it("should remove last child", () => {
-      const doc = parseHTML("<div><span>First</span><span>Second</span><span>Third</span></div>");
+      const doc = parseHTML(
+        "<div><span>First</span><span>Second</span><span>Third</span></div>",
+      );
       const div = doc.querySelector("div");
       const last = div.childNodes[2];
 
@@ -1194,7 +1209,9 @@ describe("DOM Manipulation - remove", () => {
     });
 
     it("should remove middle child", () => {
-      const doc = parseHTML("<div><span>First</span><span>Second</span><span>Third</span></div>");
+      const doc = parseHTML(
+        "<div><span>First</span><span>Second</span><span>Third</span></div>",
+      );
       const div = doc.querySelector("div");
       const middle = div.childNodes[1];
 
@@ -1208,7 +1225,9 @@ describe("DOM Manipulation - remove", () => {
 
   describe("remove sibling relationships", () => {
     it("should update nextSibling and previousSibling correctly", () => {
-      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const doc = parseHTML(
+        "<div><span>A</span><span>B</span><span>C</span></div>",
+      );
       const div = doc.querySelector("div");
       const spanA = div.childNodes[0];
       const spanB = div.childNodes[1];
@@ -1223,7 +1242,9 @@ describe("DOM Manipulation - remove", () => {
     });
 
     it("should update element sibling relationships", () => {
-      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const doc = parseHTML(
+        "<div><span>A</span><span>B</span><span>C</span></div>",
+      );
       const div = doc.querySelector("div");
       const spanA = div.childNodes[0];
       const spanB = div.childNodes[1];
@@ -1276,7 +1297,9 @@ describe("DOM Manipulation - remove", () => {
 
   describe("remove synchronization", () => {
     it("should update innerHTML correctly", () => {
-      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const doc = parseHTML(
+        "<div><span>A</span><span>B</span><span>C</span></div>",
+      );
       const div = doc.querySelector("div");
       const spanB = div.childNodes[1];
 
@@ -1296,7 +1319,9 @@ describe("DOM Manipulation - remove", () => {
     });
 
     it("should update children array correctly", () => {
-      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const doc = parseHTML(
+        "<div><span>A</span><span>B</span><span>C</span></div>",
+      );
       const div = doc.querySelector("div");
       const spanB = div.children[1];
 
@@ -1310,7 +1335,9 @@ describe("DOM Manipulation - remove", () => {
 
   describe("remove multiple elements", () => {
     it("should remove multiple elements sequentially", () => {
-      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const doc = parseHTML(
+        "<div><span>A</span><span>B</span><span>C</span></div>",
+      );
       const div = doc.querySelector("div");
       const spanA = div.childNodes[0];
       const spanB = div.childNodes[1];

package/tests/dom.test.ts

@@ -7,8 +7,8 @@ import {
   hasAttribute,
   setAttribute,
   removeAttribute,
-} from "../src/dom-simulator";
-import { parse } from "../src/parser";
+  createDocument,
+} from "../src/dom-simulator/index.js";
 
 function getBodyContent(doc: any): any {
   return doc.body?.firstChild;
@@ -67,7 +67,9 @@ describe("DOM Simulator - Phase 1: Structure and Conversion", () => {
     });
 
     it("should parse comments", () => {
-      const doc = parseHTML("<div><!-- This is a comment --></div><p>Hello</p>");
+      const doc = parseHTML(
+        "<div><!-- This is a comment --></div><p>Hello</p>",
+      );
 
       const body = doc.body;
       expect(body.childNodes.length).toBe(2);
@@ -93,7 +95,7 @@ describe("DOM Simulator - Phase 1: Structure and Conversion", () => {
 
     it("should set sibling relationships correctly", () => {
       const doc = parseHTML(
-        "<div><p>First</p><span>Second</span><em>Third</em></div>"
+        "<div><p>First</p><span>Second</span><em>Third</em></div>",
       );
 
       const div = getBodyContent(doc);
@@ -181,7 +183,7 @@ describe("DOM Simulator - Phase 2: Navigation and Attributes", () => {
 
     it("should get text from deeply nested elements", () => {
       const doc = parseHTML(
-        "<div>Start <p>Middle <em>Deep <strong>Deeper</strong></em></p> End</div>"
+        "<div>Start <p>Middle <em>Deep <strong>Deeper</strong></em></p> End</div>",
       );
       const div = getBodyContent(doc);
 
@@ -213,7 +215,7 @@ describe("DOM Simulator - Phase 2: Navigation and Attributes", () => {
   describe("Attribute functions", () => {
     it("should get existing attributes", () => {
       const doc = parseHTML(
-        '<div id="test" class="highlight" data-value="123">Content</div>'
+        '<div id="test" class="highlight" data-value="123">Content</div>',
       );
       const div = getBodyContent(doc) as any;
 
@@ -265,7 +267,7 @@ describe("DOM Simulator - Phase 2: Navigation and Attributes", () => {
 
     it("should remove attributes", () => {
       const doc = parseHTML(
-        '<div id="test" class="highlight" data-value="123">Content</div>'
+        '<div id="test" class="highlight" data-value="123">Content</div>',
       );
       const div = getBodyContent(doc) as any;
 
@@ -353,7 +355,7 @@ describe("DOM extra tests", () => {
   });
 
   it("should create a new Document", () => {
-    const doc = parseHTML();
+    const doc = createDocument();
     expect(doc).toBeTruthy();
     expect(doc.nodeType).toBe(NodeType.DOCUMENT_NODE);
     expect(doc.nodeName).toBe("#document");
@@ -370,7 +372,7 @@ describe("DOM extra tests", () => {
 
     expect(doc.head?.querySelector("title")?.textContent).toBe("Sample Page");
     expect(doc.head?.querySelector("meta")?.getAttribute("charset")).toBe(
-      "UTF-8"
+      "UTF-8",
     );
   });
 
@@ -387,7 +389,7 @@ describe("DOM extra tests", () => {
     expect(paragraphs.length).toBe(2);
     expect(paragraphs[0]?.textContent).toBe("First paragraph.");
     expect(paragraphs[1]?.textContent).toBe(
-      "Second paragraph with formatting."
+      "Second paragraph with formatting.",
     );
 
     const strong = section.querySelector("strong")!;
@@ -408,7 +410,7 @@ describe("DOM extra tests", () => {
 
     const main = doc.body?.querySelector("main")!;
     const commentNode = (main.childNodes as any).find(
-      (n: any) => n.nodeType === NodeType.COMMENT_NODE
+      (n: any) => n.nodeType === NodeType.COMMENT_NODE,
     );
     expect(commentNode).toBeTruthy();
     expect(commentNode?.nodeValue?.trim()).toBe("Footer note");
@@ -425,7 +427,7 @@ describe("DOM extra tests", () => {
     const header = doc.body?.querySelector("#main-header")!;
 
     const clonedFooter = (doc.body?.querySelector("footer") as any).cloneNode(
-      true
+      true,
     );
     expect(clonedFooter.nodeName).toBe("FOOTER");
     expect(clonedFooter.querySelector("a")?.textContent).toBe("Email us");
@@ -480,7 +482,7 @@ describe("DOM extra tests", () => {
 
     expect(container.querySelector("h2")?.textContent).toBe("Dynamic Content");
     expect(container.querySelector("p")?.textContent).toBe(
-      "This is a dynamically added paragraph."
+      "This is a dynamically added paragraph.",
     );
     expect(container.querySelectorAll("li").length).toBe(2);
   });

package/tests/encoding/detect-encoding.test.ts

@@ -0,0 +1,33 @@
+import { expect, it } from "bun:test";
+import { detectEncoding } from "../../src/encoding/index.ts";
+
+it("should detect charset from meta tag", () => {
+  const html = '<html><head><meta charset="utf-8"></head></html>';
+  expect(detectEncoding(html)).toBe("utf-8");
+});
+
+it("should detect charset from meta tag with single quotes", () => {
+  const html = "<html><head><meta charset='iso-8859-1'></head></html>";
+  expect(detectEncoding(html)).toBe("windows-1252");
+});
+
+it("should detect charset from content-type meta", () => {
+  const html =
+    '<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"></head></html>';
+  expect(detectEncoding(html)).toBe("utf-8");
+});
+
+it("should return windows-1252 as default", () => {
+  const html = "<html><head></head></html>";
+  expect(detectEncoding(html)).toBe("windows-1252");
+});
+
+it("should normalize encoding aliases", () => {
+  const html = '<html><head><meta charset="UTF-8"></head></html>';
+  expect(detectEncoding(html)).toBe("utf-8");
+});
+
+it("should handle case insensitive charset", () => {
+  const html = '<html><head><meta CHARSET="utf-8"></head></html>';
+  expect(detectEncoding(html)).toBe("utf-8");
+});

package/tests/google-dom.test.ts

@@ -100,8 +100,8 @@ describe("Google DOM Parsing Test", () => {
       for (let i = 0; i < Math.min(navLinks.length, 5); i++) {
         const link = navLinks[i];
         if (link) {
-          const href = link.getAttribute("href");
-          const text = link.textContent?.trim();
+          link.getAttribute("href");
+          link.textContent?.trim();
         }
       }
     }