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

@tkeron/html-parser 1.1.2 → 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 (131) 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/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 +6 -2
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 +6 -4
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/selectors/query-selector-all.test.ts ADDED Viewed

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "bun:test";
+import { querySelectorAll } from "../../src/selectors";
+import { parseHTML } from "../../index";
+describe("querySelectorAll", () => {
+  const htmlContent = `
+        <html>
+            <body>
+                <p id="intro" class="first">
+                    <span class="highlight">Hello</span>
+                </p>
+                <p class="second">World</p>
+                <div>
+                    <p class="note">Note</p>
+                </div>
+            </body>
+        </html>
+    `;
+  const doc = parseHTML(htmlContent);
+  it("should be a function", () => {
+    expect(typeof querySelectorAll).toBe("function");
+  });
+  it("should find all elements by tag name", () => {
+    const paragraphs = querySelectorAll(doc, "p");
+    expect(paragraphs.length).toBe(3);
+    expect(paragraphs[0]!.attributes.class).toBe("first");
+    expect(paragraphs[1]!.attributes.class).toBe("second");
+    expect(paragraphs[2]!.attributes.class).toBe("note");
+  });
+  it("should find all elements by class name", () => {
+    const second = querySelectorAll(doc, ".second");
+    expect(second.length).toBe(1);
+    expect(second[0]!.tagName).toBe("P");
+  });
+});

package/tests/selectors/query-selector.test.ts ADDED Viewed

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "bun:test";
+import { querySelector } from "../../src/selectors";
+import { parseHTML } from "../../index";
+describe("querySelector", () => {
+  const htmlContent = `
+        <html>
+            <body>
+                <p id="intro" class="first">
+                    <span class="highlight">Hello</span>
+                </p>
+                <p class="second">World</p>
+                <div>
+                    <p class="note">Note</p>
+                </div>
+            </body>
+        </html>
+    `;
+  const doc = parseHTML(htmlContent);
+  it("should be a function", () => {
+    expect(typeof querySelector).toBe("function");
+  });
+  it("should find the first element by tag name", () => {
+    const firstParagraph = querySelector(doc, "p");
+    expect(firstParagraph).not.toBeNull();
+    expect(firstParagraph?.attributes.id).toBe("intro");
+  });
+  it("should find an element by ID", () => {
+    const intro = querySelector(doc, "#intro");
+    expect(intro).not.toBeNull();
+    expect(intro?.tagName).toBe("P");
+  });
+  it("should return null if no element is found", () => {
+    const nonExistent = querySelector(doc, "#nonexistent");
+    expect(nonExistent).toBeNull();
+  });
+});

package/tests/serializer/attributes.test.ts ADDED Viewed

@@ -0,0 +1,132 @@
+import {
+  needsQuotes,
+  serializeAttribute,
+  serializeAttributes,
+} from "../../src/serializer/attributes.js";
+describe("needsQuotes", () => {
+  it("should return true for empty string", () => {
+    expect(needsQuotes("")).toBe(true);
+  });
+  it("should return true for strings with spaces", () => {
+    expect(needsQuotes("a b")).toBe(true);
+  });
+  it("should return true for strings with tabs", () => {
+    expect(needsQuotes("a\tb")).toBe(true);
+  });
+  it("should return true for strings with newlines", () => {
+    expect(needsQuotes("a\nb")).toBe(true);
+  });
+  it("should return true for strings with carriage returns", () => {
+    expect(needsQuotes("a\rb")).toBe(true);
+  });
+  it("should return true for strings with form feeds", () => {
+    expect(needsQuotes("a\fb")).toBe(true);
+  });
+  it("should return true for strings with single quotes", () => {
+    expect(needsQuotes("a'b")).toBe(true);
+  });
+  it("should return true for strings with double quotes", () => {
+    expect(needsQuotes('a"b')).toBe(true);
+  });
+  it("should return true for strings with equals", () => {
+    expect(needsQuotes("a=b")).toBe(true);
+  });
+  it("should return true for strings with greater than", () => {
+    expect(needsQuotes("a>b")).toBe(true);
+  });
+  it("should return true for strings with backticks", () => {
+    expect(needsQuotes("a`b")).toBe(true);
+  });
+  it("should return false for simple strings", () => {
+    expect(needsQuotes("abc")).toBe(false);
+  });
+});
+describe("serializeAttribute", () => {
+  it("should minimize boolean attributes", () => {
+    expect(serializeAttribute("disabled", "disabled")).toBe("disabled");
+  });
+  it("should not minimize when option is false", () => {
+    expect(
+      serializeAttribute("disabled", "disabled", {
+        minimize_boolean_attributes: false,
+      }),
+    ).toBe("disabled=disabled");
+  });
+  it("should serialize without quotes when not needed", () => {
+    expect(serializeAttribute("id", "test")).toBe("id=test");
+  });
+  it("should serialize with double quotes when needed", () => {
+    expect(serializeAttribute("class", "a b")).toBe('class="a b"');
+  });
+  it("should serialize with single quotes when value contains double quotes", () => {
+    expect(serializeAttribute("data", 'a"b')).toBe("data='a\"b'");
+  });
+  it("should serialize with double quotes when value contains single quotes", () => {
+    expect(serializeAttribute("data", "a'b")).toBe('data="a\'b"');
+  });
+  it("should serialize with double quotes when value contains both quotes", () => {
+    expect(serializeAttribute("data", "a\"b'c")).toBe('data="a&quot;b\'c"');
+  });
+  it("should force quote character when specified", () => {
+    expect(serializeAttribute("data", "test", { quote_char: "'" })).toBe(
+      "data='test'",
+    );
+  });
+  it("should escape less-than in attributes when option is set", () => {
+    expect(
+      serializeAttribute("data", "a<b", { escape_lt_in_attrs: true }),
+    ).toBe("data=a&lt;b");
+  });
+  it("should always quote when quote_attr_values is true", () => {
+    expect(serializeAttribute("id", "test", { quote_attr_values: true })).toBe(
+      'id="test"',
+    );
+  });
+});
+describe("serializeAttributes", () => {
+  it("should serialize array of attributes", () => {
+    const attrs = [
+      { name: "id", value: "test" },
+      { name: "class", value: "a b" },
+    ];
+    expect(serializeAttributes(attrs)).toBe(' class="a b" id=test');
+  });
+  it("should serialize object attributes", () => {
+    const attrs = { id: "test", class: "a b" };
+    expect(serializeAttributes(attrs)).toBe(' class="a b" id=test');
+  });
+  it("should sort attributes alphabetically", () => {
+    const attrs = { z: "1", a: "2" };
+    expect(serializeAttributes(attrs)).toBe(" a=2 z=1");
+  });
+  it("should handle empty attributes", () => {
+    expect(serializeAttributes([])).toBe("");
+    expect(serializeAttributes({})).toBe("");
+  });
+});

package/tests/serializer/escape.test.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "bun:test";
+import {
+  escapeText,
+  escapeAttributeValue,
+} from "../../src/serializer/escape.js";
+describe("escapeText", () => {
+  it("should escape ampersands", () => {
+    expect(escapeText("a & b")).toBe("a &amp; b");
+  });
+  it("should escape less-than signs", () => {
+    expect(escapeText("a < b")).toBe("a &lt; b");
+  });
+  it("should escape greater-than signs", () => {
+    expect(escapeText("a > b")).toBe("a &gt; b");
+  });
+  it("should escape multiple characters", () => {
+    expect(escapeText("a & b < c > d")).toBe("a &amp; b &lt; c &gt; d");
+  });
+  it("should handle empty string", () => {
+    expect(escapeText("")).toBe("");
+  });
+});
+describe("escapeAttributeValue", () => {
+  it("should escape ampersands", () => {
+    expect(escapeAttributeValue("a & b")).toBe("a &amp; b");
+  });
+  it("should escape double quotes", () => {
+    expect(escapeAttributeValue('a " b')).toBe("a &quot; b");
+  });
+  it("should escape single quotes", () => {
+    expect(escapeAttributeValue("a ' b")).toBe("a &#39; b");
+  });
+  it("should escape multiple characters", () => {
+    expect(escapeAttributeValue("a & b \" c ' d")).toBe(
+      "a &amp; b &quot; c &#39; d",
+    );
+  });
+  it("should handle empty string", () => {
+    expect(escapeAttributeValue("")).toBe("");
+  });
+});

package/tests/serializer/serialize-tokens.test.ts ADDED Viewed

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "bun:test";
+import { serializeTokens } from "../../src/serializer/serialize-tokens.js";
+describe("serializeTokens", () => {
+  it("should serialize empty tokens", () => {
+    expect(serializeTokens([])).toBe("");
+  });
+  it("should serialize text tokens", () => {
+    const tokens = [["Characters", "Hello world"]];
+    expect(serializeTokens(tokens)).toBe("Hello world");
+  });
+  it("should serialize start and end tags", () => {
+    const tokens = [
+      ["StartTag", null, "div", []],
+      ["Characters", "content"],
+      ["EndTag", null, "div"],
+    ];
+    expect(serializeTokens(tokens)).toBe("<div>content</div>");
+  });
+  it("should serialize self-closing tags", () => {
+    const tokens = [["EmptyTag", "br", []]];
+    expect(serializeTokens(tokens)).toBe("<br>");
+  });
+  it("should serialize attributes", () => {
+    const tokens = [
+      [
+        "StartTag",
+        null,
+        "div",
+        [
+          { name: "id", value: "test" },
+          { name: "class", value: "a b" },
+        ],
+      ],
+    ];
+    expect(serializeTokens(tokens)).toBe('<div class="a b" id=test>');
+  });
+  it("should serialize comments", () => {
+    const tokens = [["Comment", " comment "]];
+    expect(serializeTokens(tokens)).toBe("<!-- comment -->");
+  });
+  it("should serialize doctype", () => {
+    const tokens = [["Doctype", "html", "", ""]];
+    expect(serializeTokens(tokens)).toBe("<!DOCTYPE html>");
+  });
+  it("should escape text content", () => {
+    const tokens = [["Characters", "a & b < c > d"]];
+    expect(serializeTokens(tokens)).toBe("a &amp; b &lt; c &gt; d");
+  });
+  it("should handle script content", () => {
+    const tokens = [
+      ["StartTag", null, "script", []],
+      ["Characters", "<script>alert('test')</script>"],
+      ["EndTag", null, "script"],
+    ];
+    expect(serializeTokens(tokens)).toBe(
+      "<script><script>alert('test')</script></script>",
+    );
+  });
+  it("should inject meta charset when option is set", () => {
+    const tokens = [
+      ["StartTag", null, "html", []],
+      ["StartTag", null, "head", []],
+      ["EndTag", null, "head"],
+      ["StartTag", null, "body", []],
+      ["EndTag", null, "body"],
+      ["EndTag", null, "html"],
+    ];
+    expect(serializeTokens(tokens, { inject_meta_charset: true })).toBe("");
+  });
+});

package/tests/serializer-core.test.ts CHANGED Viewed

@@ -1,9 +1,9 @@
-import { expect, it, describe } from 'bun:test';
-import { serializeTokens } from '../src/serializer';
-import { readFileSync } from 'fs';
+import { expect, it, describe } from "bun:test";
+import { serializeTokens } from "../src/serializer";
+import { readFileSync } from "fs";
-describe('Serializer Core Tests', () => {
-  const content = readFileSync('tests/serializer-data/core.test', 'utf8');
+describe("Serializer Core Tests", () => {
+  const content = readFileSync("tests/serializer-data/core.test", "utf8");
   const data = JSON.parse(content);
   const tests = data.tests;
@@ -13,4 +13,4 @@ describe('Serializer Core Tests', () => {
       expect(result).toBe(test.expected[0]);
     });
   });
-});
+});

package/tests/serializer-injectmeta.test.ts CHANGED Viewed

@@ -1,9 +1,9 @@
-import { expect, it, describe } from 'bun:test';
-import { serializeTokens } from '../src/serializer';
-import { readFileSync } from 'fs';
+import { expect, it, describe } from "bun:test";
+import { serializeTokens } from "../src/serializer";
+import { readFileSync } from "fs";
-describe('Serializer Inject Meta Tests', () => {
-  const content = readFileSync('tests/serializer-data/injectmeta.test', 'utf8');
+describe("Serializer Inject Meta Tests", () => {
+  const content = readFileSync("tests/serializer-data/injectmeta.test", "utf8");
   const data = JSON.parse(content);
   const tests = data.tests;
@@ -13,4 +13,4 @@ describe('Serializer Inject Meta Tests', () => {
       expect(result).toBe(test.expected[0]);
     });
   });
-});
+});

package/tests/serializer-optionaltags.test.ts CHANGED Viewed

@@ -1,9 +1,12 @@
-import { expect, it, describe } from 'bun:test';
-import { serializeTokens } from '../src/serializer';
-import { readFileSync } from 'fs';
+import { expect, it, describe } from "bun:test";
+import { serializeTokens } from "../src/serializer";
+import { readFileSync } from "fs";
-describe('Serializer Optional Tags Tests', () => {
-  const content = readFileSync('tests/serializer-data/optionaltags.test', 'utf8');
+describe("Serializer Optional Tags Tests", () => {
+  const content = readFileSync(
+    "tests/serializer-data/optionaltags.test",
+    "utf8",
+  );
   const data = JSON.parse(content);
   const tests = data.tests;
@@ -13,4 +16,4 @@ describe('Serializer Optional Tags Tests', () => {
       expect(result).toBe(test.expected[0]);
     });
   });
-});
+});

package/tests/serializer-options.test.ts CHANGED Viewed

@@ -1,9 +1,9 @@
-import { expect, it, describe } from 'bun:test';
-import { serializeTokens } from '../src/serializer';
-import { readFileSync } from 'fs';
+import { expect, it, describe } from "bun:test";
+import { serializeTokens } from "../src/serializer";
+import { readFileSync } from "fs";
-describe('Serializer Options Tests', () => {
-  const content = readFileSync('tests/serializer-data/options.test', 'utf8');
+describe("Serializer Options Tests", () => {
+  const content = readFileSync("tests/serializer-data/options.test", "utf8");
   const data = JSON.parse(content);
   const tests = data.tests;
@@ -13,4 +13,4 @@ describe('Serializer Options Tests', () => {
       expect(result).toBe(test.expected[0]);
     });
   });
-});
+});

package/tests/serializer-whitespace.test.ts CHANGED Viewed

@@ -1,9 +1,9 @@
-import { expect, it, describe } from 'bun:test';
-import { serializeTokens } from '../src/serializer';
-import { readFileSync } from 'fs';
+import { expect, it, describe } from "bun:test";
+import { serializeTokens } from "../src/serializer";
+import { readFileSync } from "fs";
-describe('Serializer Whitespace Tests', () => {
-  const content = readFileSync('tests/serializer-data/whitespace.test', 'utf8');
+describe("Serializer Whitespace Tests", () => {
+  const content = readFileSync("tests/serializer-data/whitespace.test", "utf8");
   const data = JSON.parse(content);
   const tests = data.tests;
@@ -13,4 +13,4 @@ describe('Serializer Whitespace Tests', () => {
       expect(result).toBe(test.expected[0]);
     });
   });
-});
+});

package/tests/tokenizer/calculate-position.test.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import { expect, it, describe } from "bun:test";
+import { calculatePosition } from "../../src/tokenizer/calculate-position.js";
+describe("calculatePosition", () => {
+  it("should calculate position at start", () => {
+    const result = calculatePosition("hello", 0);
+    expect(result).toEqual({ line: 1, column: 0, offset: 0 });
+  });
+  it("should calculate position in middle of line", () => {
+    const result = calculatePosition("hello", 2);
+    expect(result).toEqual({ line: 1, column: 2, offset: 2 });
+  });
+  it("should calculate position after newline", () => {
+    const result = calculatePosition("hello\nworld", 6);
+    expect(result).toEqual({ line: 2, column: 0, offset: 6 });
+  });
+  it("should calculate position in second line", () => {
+    const result = calculatePosition("hello\nworld", 8);
+    expect(result).toEqual({ line: 2, column: 2, offset: 8 });
+  });
+  it("should handle multiple newlines", () => {
+    const result = calculatePosition("a\nb\nc", 4);
+    expect(result).toEqual({ line: 3, column: 0, offset: 4 });
+  });
+  it("should handle empty string", () => {
+    const result = calculatePosition("", 0);
+    expect(result).toEqual({ line: 1, column: 0, offset: 0 });
+  });
+});

package/tests/tokenizer/decode-entities.test.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import { expect, it, describe } from "bun:test";
+import { decodeEntities } from "../../src/tokenizer/decode-entities.js";
+describe("decodeEntities", () => {
+  it("should decode named entities", () => {
+    expect(decodeEntities("&amp;")).toBe("&");
+    expect(decodeEntities("&lt;")).toBe("<");
+    expect(decodeEntities("&gt;")).toBe(">");
+    expect(decodeEntities("&quot;")).toBe('"');
+    expect(decodeEntities("&apos;")).toBe("'");
+  });
+  it("should decode numeric entities", () => {
+    expect(decodeEntities("&#65;")).toBe("A");
+    expect(decodeEntities("&#x41;")).toBe("A");
+    expect(decodeEntities("&#x27;")).toBe("'");
+  });
+  it("should handle invalid entities", () => {
+    expect(decodeEntities("&invalid;")).toBe("&invalid;");
+    expect(decodeEntities("&amp")).toBe("&amp");
+  });
+  it("should replace null characters", () => {
+    expect(decodeEntities("test\u0000test")).toBe("test\uFFFDtest");
+  });
+  it("should handle mixed content", () => {
+    expect(decodeEntities("a&lt;b&gt;c&amp;d")).toBe("a<b>c&d");
+  });
+});

package/tests/tokenizer/parse-attributes.test.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import { expect, it, describe } from "bun:test";
+import { parseAttributes } from "../../src/tokenizer/parse-attributes.js";
+describe("parseAttributes", () => {
+  it("should parse simple attributes", () => {
+    const result = parseAttributes('id="test" class="foo"');
+    expect(result).toEqual({ id: "test", class: "foo" });
+  });
+  it("should parse attributes with single quotes", () => {
+    const result = parseAttributes("id='test' class='foo'");
+    expect(result).toEqual({ id: "test", class: "foo" });
+  });
+  it("should parse attributes without quotes", () => {
+    const result = parseAttributes("id=test class=foo");
+    expect(result).toEqual({ id: "test", class: "foo" });
+  });
+  it("should decode entities in attribute values", () => {
+    const result = parseAttributes('content="a&lt;b"');
+    expect(result).toEqual({ content: "a<b" });
+  });
+  it("should handle boolean attributes", () => {
+    const result = parseAttributes("disabled checked");
+    expect(result).toEqual({ disabled: "", checked: "" });
+  });
+  it("should handle empty attribute string", () => {
+    const result = parseAttributes("");
+    expect(result).toEqual({});
+  });
+  it("should handle malformed attributes", () => {
+    const result = parseAttributes('id="test" = class="foo"');
+    expect(result).toEqual({ id: "test", class: "foo" });
+  });
+  it("should lowercase attribute names", () => {
+    const result = parseAttributes('ID="test" CLASS="foo"');
+    expect(result).toEqual({ id: "test", class: "foo" });
+  });
+});