npm - @tkeron/html-parser - Versions diffs - 1.1.1 → 1.3.0 - Mend

@tkeron/html-parser 1.1.1 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (132) hide show

package/.github/workflows/npm_deploy.yml +14 -4
package/README.md +6 -6
package/bun.lock +6 -8
package/check-versions.ts +147 -0
package/index.ts +4 -8
package/package.json +5 -6
package/src/dom-simulator/append-child.ts +130 -0
package/src/dom-simulator/append.ts +18 -0
package/src/dom-simulator/attributes.ts +23 -0
package/src/dom-simulator/clone-node.ts +51 -0
package/src/dom-simulator/convert-ast-node-to-dom.ts +37 -0
package/src/dom-simulator/create-cdata.ts +18 -0
package/src/dom-simulator/create-comment.ts +23 -0
package/src/dom-simulator/create-doctype.ts +24 -0
package/src/dom-simulator/create-document.ts +81 -0
package/src/dom-simulator/create-element.ts +195 -0
package/src/dom-simulator/create-processing-instruction.ts +19 -0
package/src/dom-simulator/create-temp-parent.ts +9 -0
package/src/dom-simulator/create-text-node.ts +23 -0
package/src/dom-simulator/escape-text-content.ts +6 -0
package/src/dom-simulator/find-special-elements.ts +14 -0
package/src/dom-simulator/get-text-content.ts +18 -0
package/src/dom-simulator/index.ts +36 -0
package/src/dom-simulator/inner-outer-html.ts +182 -0
package/src/dom-simulator/insert-after.ts +20 -0
package/src/dom-simulator/insert-before.ts +108 -0
package/src/dom-simulator/matches.ts +26 -0
package/src/dom-simulator/node-types.ts +26 -0
package/src/dom-simulator/prepend.ts +24 -0
package/src/dom-simulator/remove-child.ts +68 -0
package/src/dom-simulator/remove.ts +7 -0
package/src/dom-simulator/replace-child.ts +152 -0
package/src/dom-simulator/set-text-content.ts +33 -0
package/src/dom-simulator/update-element-content.ts +56 -0
package/src/dom-simulator.ts +12 -1126
package/src/encoding/constants.ts +8 -0
package/src/encoding/detect-encoding.ts +21 -0
package/src/encoding/index.ts +1 -0
package/src/encoding/normalize-encoding.ts +6 -0
package/src/html-entities.ts +2127 -0
package/src/index.ts +5 -5
package/src/parser/adoption-agency-helpers.ts +145 -0
package/src/parser/constants.ts +137 -0
package/src/parser/dom-to-ast.ts +79 -0
package/src/parser/index.ts +9 -0
package/src/parser/parse.ts +772 -0
package/src/parser/types.ts +56 -0
package/src/selectors/find-elements-descendant.ts +47 -0
package/src/selectors/index.ts +2 -0
package/src/selectors/matches-selector.ts +12 -0
package/src/selectors/matches-token.ts +27 -0
package/src/selectors/parse-selector.ts +48 -0
package/src/selectors/query-selector-all.ts +43 -0
package/src/selectors/query-selector.ts +6 -0
package/src/selectors/types.ts +10 -0
package/src/serializer/attributes.ts +74 -0
package/src/serializer/escape.ts +13 -0
package/src/serializer/index.ts +1 -0
package/src/serializer/serialize-tokens.ts +511 -0
package/src/tokenizer/calculate-position.ts +10 -0
package/src/tokenizer/constants.ts +11 -0
package/src/tokenizer/decode-entities.ts +64 -0
package/src/tokenizer/index.ts +2 -0
package/src/tokenizer/parse-attributes.ts +74 -0
package/src/tokenizer/tokenize.ts +165 -0
package/src/tokenizer/types.ts +25 -0
package/tests/adoption-agency-helpers.test.ts +304 -0
package/tests/advanced.test.ts +242 -221
package/tests/cloneNode.test.ts +19 -66
package/tests/custom-elements-head.test.ts +54 -55
package/tests/dom-extended.test.ts +77 -64
package/tests/dom-manipulation.test.ts +51 -24
package/tests/dom.test.ts +15 -13
package/tests/edge-cases.test.ts +300 -174
package/tests/encoding/detect-encoding.test.ts +33 -0
package/tests/google-dom.test.ts +2 -2
package/tests/helpers/tokenizer-adapter.test.ts +29 -43
package/tests/helpers/tokenizer-adapter.ts +36 -33
package/tests/helpers/tree-adapter.test.ts +20 -20
package/tests/helpers/tree-adapter.ts +34 -24
package/tests/html-entities-text.test.ts +71 -0
package/tests/innerhtml-void-elements.test.ts +52 -36
package/tests/outerHTML-replacement.test.ts +37 -65
package/tests/parser/dom-to-ast.test.ts +109 -0
package/tests/parser/parse.test.ts +139 -0
package/tests/parser.test.ts +281 -217
package/tests/selectors/query-selector-all.test.ts +39 -0
package/tests/selectors/query-selector.test.ts +42 -0
package/tests/serializer/attributes.test.ts +132 -0
package/tests/serializer/escape.test.ts +51 -0
package/tests/serializer/serialize-tokens.test.ts +80 -0
package/tests/serializer-core.test.ts +6 -6
package/tests/serializer-injectmeta.test.ts +6 -6
package/tests/serializer-optionaltags.test.ts +9 -6
package/tests/serializer-options.test.ts +6 -6
package/tests/serializer-whitespace.test.ts +6 -6
package/tests/tokenizer/calculate-position.test.ts +34 -0
package/tests/tokenizer/decode-entities.test.ts +31 -0
package/tests/tokenizer/parse-attributes.test.ts +44 -0
package/tests/tokenizer/tokenize.test.ts +757 -0
package/tests/tokenizer-namedEntities.test.ts +10 -7
package/tests/tokenizer-pendingSpecChanges.test.ts +10 -7
package/tests/tokenizer.test.ts +268 -256
package/tests/tree-construction-adoption01.test.ts +25 -16
package/tests/tree-construction-adoption02.test.ts +30 -19
package/tests/tree-construction-domjs-unsafe.test.ts +7 -5
package/tests/tree-construction-entities02.test.ts +18 -16
package/tests/tree-construction-html5test-com.test.ts +16 -10
package/tests/tree-construction-math.test.ts +11 -9
package/tests/tree-construction-namespace-sensitivity.test.ts +11 -9
package/tests/tree-construction-noscript01.test.ts +11 -9
package/tests/tree-construction-ruby.test.ts +6 -4
package/tests/tree-construction-scriptdata01.test.ts +6 -4
package/tests/tree-construction-svg.test.ts +6 -4
package/tests/tree-construction-template.test.ts +6 -4
package/tests/tree-construction-tests10.test.ts +6 -4
package/tests/tree-construction-tests11.test.ts +6 -4
package/tests/tree-construction-tests20.test.ts +7 -4
package/tests/tree-construction-tests21.test.ts +7 -4
package/tests/tree-construction-tests23.test.ts +7 -4
package/tests/tree-construction-tests24.test.ts +7 -4
package/tests/tree-construction-tests5.test.ts +6 -5
package/tests/tree-construction-tests6.test.ts +6 -5
package/tests/tree-construction-tests_innerHTML_1.test.ts +6 -5
package/tests/void-elements.test.ts +85 -40
package/tsconfig.json +1 -1
package/src/css-selector.ts +0 -185
package/src/encoding.ts +0 -39
package/src/parser.ts +0 -682
package/src/serializer.ts +0 -450
package/src/tokenizer.ts +0 -325
package/tests/selectors.test.ts +0 -128

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

@@ -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 CHANGED Viewed

@@ -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();
         }
       }
     }

package/tests/helpers/tokenizer-adapter.test.ts CHANGED Viewed

@@ -1,70 +1,56 @@
-import { tokenize } from '../../src/tokenizer';
-import { adaptTokens, type Html5libToken } from './tokenizer-adapter.ts';
+import { tokenize } from "../../src/tokenizer/index.js";
+import { adaptTokens } from "./tokenizer-adapter.ts";
-describe('Tokenizer Adapter Tests', () => {
-  it('should adapt simple start tag', () => {
-    const tokens = tokenize('<div>');
+describe("Tokenizer Adapter Tests", () => {
+  it("should adapt simple start tag", () => {
+    const tokens = tokenize("<div>");
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['StartTag', 'div', {}]
-    ]);
+    expect(adapted).toEqual([["StartTag", "div", {}]]);
   });
-  it('should adapt start tag with attributes', () => {
+  it("should adapt start tag with attributes", () => {
     const tokens = tokenize('<div class="foo" id="bar">');
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['StartTag', 'div', { class: 'foo', id: 'bar' }]
-    ]);
+    expect(adapted).toEqual([["StartTag", "div", { class: "foo", id: "bar" }]]);
   });
-  it('should adapt self-closing tag', () => {
-    const tokens = tokenize('<br/>');
+  it("should adapt self-closing tag", () => {
+    const tokens = tokenize("<br/>");
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['StartTag', 'br', {}, true]
-    ]);
+    expect(adapted).toEqual([["StartTag", "br", {}, true]]);
   });
-  it('should adapt end tag', () => {
-    const tokens = tokenize('</div>');
+  it("should adapt end tag", () => {
+    const tokens = tokenize("</div>");
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['EndTag', 'div']
-    ]);
+    expect(adapted).toEqual([["EndTag", "div"]]);
   });
-  it('should adapt text', () => {
-    const tokens = tokenize('hello world');
+  it("should adapt text", () => {
+    const tokens = tokenize("hello world");
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['Character', 'hello world']
-    ]);
+    expect(adapted).toEqual([["Character", "hello world"]]);
   });
-  it('should adapt comment', () => {
-    const tokens = tokenize('<!-- comment -->');
+  it("should adapt comment", () => {
+    const tokens = tokenize("<!-- comment -->");
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['Comment', ' comment ']
-    ]);
+    expect(adapted).toEqual([["Comment", " comment "]]);
   });
-  it('should adapt DOCTYPE', () => {
-    const tokens = tokenize('<!DOCTYPE html>');
+  it("should adapt DOCTYPE", () => {
+    const tokens = tokenize("<!DOCTYPE html>");
     const adapted = adaptTokens(tokens);
-    expect(adapted).toEqual([
-      ['DOCTYPE', 'html', null, null, true]
-    ]);
+    expect(adapted).toEqual([["DOCTYPE", "html", null, null, true]]);
   });
-  it('should adapt mixed content', () => {
-    const tokens = tokenize('<div>hello</div>');
+  it("should adapt mixed content", () => {
+    const tokens = tokenize("<div>hello</div>");
     const adapted = adaptTokens(tokens);
     expect(adapted).toEqual([
-      ['StartTag', 'div', {}],
-      ['Character', 'hello'],
-      ['EndTag', 'div']
+      ["StartTag", "div", {}],
+      ["Character", "hello"],
+      ["EndTag", "div"],
     ]);
   });
-});
+});

package/tests/helpers/tokenizer-adapter.ts CHANGED Viewed

@@ -1,65 +1,68 @@
 // tests/helpers/tokenizer-adapter.ts
-import type { Token } from '../../src/tokenizer';
+import type { Token } from "../../src/tokenizer/index.js";
-export type Html5libToken =
-  | ['StartTag', string, Record<string, string>]
-  | ['StartTag', string, Record<string, string>, boolean] // con self-closing flag
-  | ['EndTag', string]
-  | ['Character', string]
-  | ['Comment', string]
-  | ['DOCTYPE', string, string | null, string | null, boolean];
+export type Html5libToken =
+  | ["StartTag", string, Record<string, string>]
+  | ["StartTag", string, Record<string, string>, boolean] // con self-closing flag
+  | ["EndTag", string]
+  | ["Character", string]
+  | ["Comment", string]
+  | ["DOCTYPE", string, string | null, string | null, boolean];
 export function adaptTokens(tokens: Token[]): Html5libToken[] {
   const result: Html5libToken[] = [];
   for (const token of tokens) {
-    if (token.type === 'EOF') continue;
+    if (token.type === "EOF") continue;
     switch (token.type) {
-      case 'TAG_OPEN':
+      case "TAG_OPEN":
         if (token.isClosing) {
-          result.push(['EndTag', token.value]);
+          result.push(["EndTag", token.value]);
         } else {
           const attrs = token.attributes || {};
           if (token.isSelfClosing) {
-            result.push(['StartTag', token.value, attrs, true]);
+            result.push(["StartTag", token.value, attrs, true]);
           } else {
-            result.push(['StartTag', token.value, attrs]);
+            result.push(["StartTag", token.value, attrs]);
           }
         }
         break;
-      case 'TAG_CLOSE':
-        result.push(['EndTag', token.value]);
+      case "TAG_CLOSE":
+        result.push(["EndTag", token.value]);
         break;
-      case 'TEXT':
-        result.push(['Character', token.value]);
+      case "TEXT":
+        result.push(["Character", token.value]);
         break;
-      case 'COMMENT':
-        result.push(['Comment', token.value]);
+      case "COMMENT":
+        result.push(["Comment", token.value]);
         break;
-      case 'DOCTYPE':
+      case "DOCTYPE":
         // Parsear DOCTYPE para extraer name, publicId, systemId
-        result.push(['DOCTYPE', token.value, null, null, true]);
+        result.push(["DOCTYPE", token.value, null, null, true]);
         break;
-      case 'CDATA':
-        result.push(['Character', token.value]);
+      case "CDATA":
+        result.push(["Character", token.value]);
         break;
     }
   }
   return result;
 }
 // Función para comparar tokens, manejando casos especiales
-export function compareTokens(actual: Html5libToken[], expected: any[]): boolean {
+export function compareTokens(
+  actual: Html5libToken[],
+  expected: any[],
+): boolean {
   // Implementar comparación flexible
   // - Coalescer Characters consecutivos
   // - Ignorar diferencias de whitespace en algunos casos
   return JSON.stringify(actual) === JSON.stringify(expected);
-}
+}

package/tests/helpers/tree-adapter.test.ts CHANGED Viewed

@@ -1,39 +1,39 @@
-import { parseHTML } from '../../index.ts';
-import { serializeToHtml5lib } from './tree-adapter.ts';
+import { parseHTML } from "../../index.ts";
+import { serializeToHtml5lib } from "./tree-adapter.ts";
-describe('Tree Adapter Tests', () => {
-  it('should serialize simple element', () => {
-    const doc = parseHTML('<div></div>');
+describe("Tree Adapter Tests", () => {
+  it("should serialize simple element", () => {
+    const doc = parseHTML("<div></div>");
     const serialized = serializeToHtml5lib(doc);
-    expect(serialized).toContain('| <html>');
-    expect(serialized).toContain('|   <body>');
-    expect(serialized).toContain('|     <div>');
+    expect(serialized).toContain("| <html>");
+    expect(serialized).toContain("|   <body>");
+    expect(serialized).toContain("|     <div>");
   });
-  it('should serialize element with attributes', () => {
+  it("should serialize element with attributes", () => {
     const doc = parseHTML('<div class="foo" id="bar"></div>');
     const serialized = serializeToHtml5lib(doc);
-    expect(serialized).toContain('<div>');
+    expect(serialized).toContain("<div>");
     expect(serialized).toContain('class="foo"');
     expect(serialized).toContain('id="bar"');
   });
-  it('should serialize text content', () => {
-    const doc = parseHTML('<div>hello</div>');
+  it("should serialize text content", () => {
+    const doc = parseHTML("<div>hello</div>");
     const serialized = serializeToHtml5lib(doc);
     expect(serialized).toContain('"hello"');
   });
-  it('should serialize comment', () => {
-    const doc = parseHTML('<div><!-- comment --></div>');
+  it("should serialize comment", () => {
+    const doc = parseHTML("<div><!-- comment --></div>");
     const serialized = serializeToHtml5lib(doc);
-    expect(serialized).toContain('<!--  comment  -->');
+    expect(serialized).toContain("<!--  comment  -->");
   });
-  it('should serialize DOCTYPE', () => {
-    const doc = parseHTML('<!DOCTYPE html><div></div>');
+  it("should serialize DOCTYPE", () => {
+    const doc = parseHTML("<!DOCTYPE html><div></div>");
     const serialized = serializeToHtml5lib(doc);
-    expect(serialized).toContain('<!DOCTYPE html>');
-    expect(serialized).toContain('<div>');
+    expect(serialized).toContain("<!DOCTYPE html>");
+    expect(serialized).toContain("<div>");
   });
-});
+});

package/tests/helpers/tree-adapter.ts CHANGED Viewed

@@ -4,57 +4,67 @@ export interface SerializeOptions {
   skipImplicitDoctype?: boolean;
 }
-export function serializeToHtml5lib(doc: any, options: SerializeOptions = {}): string {
+export function serializeToHtml5lib(
+  doc: any,
+  options: SerializeOptions = {},
+): string {
   const lines: string[] = [];
   function serialize(node: any, depth: number): void {
-    const indent = '| ' + '  '.repeat(depth);
+    const indent = "| " + "  ".repeat(depth);
-    if (node.nodeType === 9) { // DOCUMENT
+    if (node.nodeType === 9) {
+      // DOCUMENT
       for (const child of node.childNodes || []) {
         serialize(child, depth);
       }
-    } else if (node.nodeType === 1) { // ELEMENT
+    } else if (node.nodeType === 1) {
+      // ELEMENT
       const tagName = node.tagName.toLowerCase();
       const ns = node.namespaceURI;
-      let nsPrefix = '';
-      if (ns === 'http://www.w3.org/2000/svg') {
-        nsPrefix = ' svg';
-      } else if (ns === 'http://www.w3.org/1998/Math/MathML') {
-        nsPrefix = ' math';
+      let nsPrefix = "";
+      if (ns === "http://www.w3.org/2000/svg") {
+        nsPrefix = " svg";
+      } else if (ns === "http://www.w3.org/1998/Math/MathML") {
+        nsPrefix = " math";
       }
       lines.push(`${indent}<${tagName}${nsPrefix}>`);
       // Atributos en orden alfabético
-      const attrs = Object.entries(node.attributes || {}).sort(([a], [b]) => a.localeCompare(b));
+      const attrs = Object.entries(node.attributes || {}).sort(([a], [b]) =>
+        a.localeCompare(b),
+      );
       for (const [name, value] of attrs) {
         lines.push(`${indent}  ${name}="${value}"`);
       }
       // Template special case
-      if (node.tagName.toLowerCase() === 'template' && node.content) {
+      if (node.tagName.toLowerCase() === "template" && node.content) {
         lines.push(`${indent}  content`);
         serialize(node.content, depth + 2);
       }
       // Children
       for (const child of node.childNodes || []) {
         serialize(child, depth + 1);
       }
-    } else if (node.nodeType === 3) { // TEXT
+    } else if (node.nodeType === 3) {
+      // TEXT
       lines.push(`${indent}"${node.textContent}"`);
-    } else if (node.nodeType === 8) { // COMMENT
-      const commentData = node.data || node.nodeValue || node.textContent || '';
+    } else if (node.nodeType === 8) {
+      // COMMENT
+      const commentData = node.data || node.nodeValue || node.textContent || "";
       lines.push(`${indent}<!-- ${commentData} -->`);
-    } else if (node.nodeType === 10) { // DOCTYPE
+    } else if (node.nodeType === 10) {
+      // DOCTYPE
       if (!options.skipImplicitDoctype) {
-        lines.push(`${indent}<!DOCTYPE ${node.name || 'html'}>`);
+        lines.push(`${indent}<!DOCTYPE ${node.name || "html"}>`);
       }
     }
   }
   serialize(doc, 0);
-  return lines.join('\n') + '\n';
-}
+  return lines.join("\n") + "\n";
+}

package/tests/html-entities-text.test.ts ADDED Viewed

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "bun:test";
+import { parseHTML } from "../src/index";
+describe("HTML entities in text content", () => {
+  it("should preserve &lt; and &gt; entities when serializing innerHTML", () => {
+    const doc = parseHTML("<p>&lt;div&gt;</p>");
+    const p = doc.querySelector("p");
+    expect(p.innerHTML).toBe("&lt;div&gt;");
+  });
+  it("should preserve &lt; and &gt; in code elements", () => {
+    const doc = parseHTML(
+      "<code>&lt;script&gt;alert('xss')&lt;/script&gt;</code>",
+    );
+    const code = doc.querySelector("code");
+    expect(code.innerHTML).toBe("&lt;script&gt;alert('xss')&lt;/script&gt;");
+  });
+  it("should preserve &amp; entity when serializing innerHTML", () => {
+    const doc = parseHTML("<span>foo &amp; bar</span>");
+    const span = doc.querySelector("span");
+    expect(span.innerHTML).toBe("foo &amp; bar");
+  });
+  it("should preserve mixed entities in text", () => {
+    const doc = parseHTML(
+      "<div>&lt;a href=&quot;test&quot;&gt;link&lt;/a&gt;</div>",
+    );
+    const div = doc.querySelector("div");
+    expect(div.innerHTML).toBe('&lt;a href="test"&gt;link&lt;/a&gt;');
+  });
+  it("should handle textContent correctly (decoded)", () => {
+    const doc = parseHTML("<p>&lt;div&gt;</p>");
+    const p = doc.querySelector("p");
+    expect(p.textContent).toBe("<div>");
+  });
+  it("should preserve entities in outerHTML", () => {
+    const doc = parseHTML("<p>&lt;test&gt;</p>");
+    const p = doc.querySelector("p");
+    expect(p.outerHTML).toBe("<p>&lt;test&gt;</p>");
+  });
+  it("should preserve entities in nested elements", () => {
+    const doc = parseHTML("<div><span>&lt;nested&gt;</span></div>");
+    const div = doc.querySelector("div");
+    expect(div.innerHTML).toBe("<span>&lt;nested&gt;</span>");
+  });
+  it("should handle multiple text nodes with entities", () => {
+    const doc = parseHTML("<p>&lt;first&gt; and &lt;second&gt;</p>");
+    const p = doc.querySelector("p");
+    expect(p.innerHTML).toBe("&lt;first&gt; and &lt;second&gt;");
+  });
+  it("should not double-escape already escaped content", () => {
+    const doc = parseHTML("<p>&amp;lt;</p>");
+    const p = doc.querySelector("p");
+    expect(p.textContent).toBe("&lt;");
+    expect(p.innerHTML).toBe("&amp;lt;");
+  });
+  it("should preserve entities after DOM manipulation", () => {
+    const doc = parseHTML("<div></div>");
+    const div = doc.querySelector("div");
+    const text = doc.createTextNode("<script>alert('xss')</script>");
+    div.appendChild(text);
+    expect(div.innerHTML).toBe("&lt;script&gt;alert('xss')&lt;/script&gt;");
+  });
+});

package/tests/innerhtml-void-elements.test.ts CHANGED Viewed

@@ -2,50 +2,51 @@ import { describe, it, expect } from "bun:test";
 import { parseHTML } from "../src/index";
 describe("innerHTML with void elements", () => {
-  it('innerHTML should work with void elements', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML should work with void elements", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
     element!.innerHTML = '<meta name="test">';
     expect(element!.innerHTML).toBe('<meta name="test">');
     expect(element!.childNodes.length).toBe(1);
   });
-  it('innerHTML should work with multiple void elements', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML should work with multiple void elements", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
     element!.innerHTML = '<meta name="a"><link rel="b"><input type="c">';
     expect(element!.childNodes.length).toBe(3);
   });
-  it('innerHTML should work with mixed void and non-void elements', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML should work with mixed void and non-void elements", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
-    element!.innerHTML = '<meta name="test"><div>Hello</div><br><span>World</span>';
+    element!.innerHTML =
+      '<meta name="test"><div>Hello</div><br><span>World</span>';
     expect(element!.childNodes.length).toBe(4);
-    expect(element!.children[0].tagName).toBe('META');
-    expect(element!.children[1].tagName).toBe('DIV');
-    expect(element!.children[2].tagName).toBe('BR');
-    expect(element!.children[3].tagName).toBe('SPAN');
+    expect(element!.children[0].tagName).toBe("META");
+    expect(element!.children[1].tagName).toBe("DIV");
+    expect(element!.children[2].tagName).toBe("BR");
+    expect(element!.children[3].tagName).toBe("SPAN");
   });
-  it('innerHTML should work with void elements nested inside containers', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML should work with void elements nested inside containers", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
     element!.innerHTML = '<div><img src="test.jpg"><input type="text"></div>';
     expect(element!.childNodes.length).toBe(1);
     const div = element!.children[0];
     expect(div.childNodes.length).toBe(2);
-    expect(div.children[0].tagName).toBe('IMG');
-    expect(div.children[1].tagName).toBe('INPUT');
+    expect(div.children[0].tagName).toBe("IMG");
+    expect(div.children[1].tagName).toBe("INPUT");
   });
-  it('innerHTML can be replaced multiple times with void elements', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML can be replaced multiple times with void elements", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
     element!.innerHTML = '<meta name="first">';
     expect(element!.childNodes.length).toBe(1);
@@ -53,17 +54,31 @@ describe("innerHTML with void elements", () => {
     element!.innerHTML = '<link rel="second"><hr>';
     expect(element!.childNodes.length).toBe(2);
-    element!.innerHTML = '';
+    element!.innerHTML = "";
     expect(element!.childNodes.length).toBe(0);
   });
-  it('innerHTML should work with all void element types', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML should work with all void element types", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
     // Test all void elements
-    const voidElements = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr'];
+    const voidElements = [
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "source",
+      "track",
+      "wbr",
+    ];
     for (const tag of voidElements) {
       element!.innerHTML = `<${tag}>`;
       expect(element!.childNodes.length).toBe(1);
@@ -71,14 +86,15 @@ describe("innerHTML with void elements", () => {
     }
   });
-  it('innerHTML with void elements preserves attributes', () => {
-    const doc = parseHTML('<custom></custom>');
-    const element = doc.querySelector('custom');
+  it("innerHTML with void elements preserves attributes", () => {
+    const doc = parseHTML("<custom></custom>");
+    const element = doc.querySelector("custom");
-    element!.innerHTML = '<meta charset="utf-8" name="viewport" content="width=device-width">';
+    element!.innerHTML =
+      '<meta charset="utf-8" name="viewport" content="width=device-width">';
     const meta = element!.children[0];
-    expect(meta.getAttribute('charset')).toBe('utf-8');
-    expect(meta.getAttribute('name')).toBe('viewport');
-    expect(meta.getAttribute('content')).toBe('width=device-width');
+    expect(meta.getAttribute("charset")).toBe("utf-8");
+    expect(meta.getAttribute("name")).toBe("viewport");
+    expect(meta.getAttribute("content")).toBe("width=device-width");
   });
-});
+});