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/outerHTML-replacement.test.ts CHANGED Viewed

@@ -3,10 +3,6 @@ import { parseHTML } from "../index";
 describe("outerHTML replacement - Browser behavior", () => {
   it("should replace element with its innerHTML when setting outerHTML = innerHTML", () => {
     const doc = parseHTML(`
       <html>
         <body>
@@ -16,35 +12,29 @@ describe("outerHTML replacement - Browser behavior", () => {
         </body>
       </html>
     `);
     const elem = doc.querySelector("#mi-prueba");
     expect(elem).not.toBeNull();
     const innerHTML = elem!.innerHTML;
     expect(innerHTML).toContain("<strong>Lorem ipsum!</strong>");
     expect(innerHTML).toContain("Dolor sit amet consectetur.");
     const parent = elem!.parentNode;
     expect(parent).not.toBeNull();
     expect(parent!.childNodes).toContain(elem);
     elem!.outerHTML = innerHTML;
     const elemAfter = doc.querySelector("#mi-prueba");
     expect(elemAfter).toBeNull();
     const body = doc.querySelector("body");
     expect(body!.innerHTML).toContain("<strong>Lorem ipsum!</strong>");
     expect(body!.innerHTML).toContain("Dolor sit amet consectetur.");
     expect(body!.innerHTML).not.toContain('id="mi-prueba"');
-    expect(body!.innerHTML).not.toContain('style=');
+    expect(body!.innerHTML).not.toContain("style=");
   });
   it("should replace element with simple text content", () => {
@@ -53,20 +43,17 @@ describe("outerHTML replacement - Browser behavior", () => {
         <p id="paragraph" class="styled">Simple text</p>
       </div>
     `);
     const paragraph = doc.querySelector("#paragraph");
     expect(paragraph).not.toBeNull();
     const parent = paragraph!.parentNode;
     const innerHTML = paragraph!.innerHTML;
     paragraph!.outerHTML = innerHTML;
     expect(doc.querySelector("#paragraph")).toBeNull();
     expect(parent!.textContent).toContain("Simple text");
   });
@@ -79,20 +66,17 @@ describe("outerHTML replacement - Browser behavior", () => {
         </li>
       </ul>
     `);
     const container = doc.querySelector("#item-container");
     expect(container).not.toBeNull();
     const ul = doc.querySelector("ul");
     const innerHTML = container!.innerHTML;
     container!.outerHTML = innerHTML;
     expect(doc.querySelector("#item-container")).toBeNull();
     const spans = ul!.querySelectorAll("span");
     expect(spans.length).toBe(2);
     expect(spans[0]?.textContent).toBe("Item 1");
@@ -105,20 +89,17 @@ describe("outerHTML replacement - Browser behavior", () => {
         <span id="to-remove"></span>
       </div>
     `);
     const span = doc.querySelector("#to-remove");
     expect(span).not.toBeNull();
     const parent = span!.parentNode;
     const childCountBefore = parent!.childNodes.length;
     span!.outerHTML = "";
     expect(doc.querySelector("#to-remove")).toBeNull();
     expect(parent!.childNodes.length).toBe(childCountBefore - 1);
   });
@@ -128,19 +109,16 @@ describe("outerHTML replacement - Browser behavior", () => {
         <p id="old">Old content</p>
       </div>
     `);
     const oldParagraph = doc.querySelector("#old");
     expect(oldParagraph).not.toBeNull();
     const parent = oldParagraph!.parentNode;
     oldParagraph!.outerHTML = '<div id="new">New content</div>';
     expect(doc.querySelector("#old")).toBeNull();
     const newDiv = doc.querySelector("#new");
     expect(newDiv).not.toBeNull();
     expect(newDiv!.textContent).toBe("New content");
@@ -155,19 +133,16 @@ describe("outerHTML replacement - Browser behavior", () => {
         <span>Last</span>
       </div>
     `);
     const middle = doc.querySelector("#middle");
     const firstSpan = doc.querySelectorAll("span")[0];
     const lastSpan = doc.querySelectorAll("span")[1];
     middle!.outerHTML = middle!.innerHTML;
     expect(firstSpan!.nextSibling).not.toBe(middle);
     expect(lastSpan!.previousSibling).not.toBe(middle);
     const parent = firstSpan!.parentNode;
     expect(parent!.textContent).toContain("Middle");
   });
@@ -185,21 +160,18 @@ describe("outerHTML replacement - Browser behavior", () => {
         </section>
       </article>
     `);
     const wrapper = doc.querySelector("#wrapper");
     expect(wrapper).not.toBeNull();
     const article = doc.querySelector("article");
     const innerHTML = wrapper!.innerHTML;
     wrapper!.outerHTML = innerHTML;
     expect(doc.querySelector("#wrapper")).toBeNull();
     expect(doc.querySelector("section")).toBeNull();
     expect(article!.querySelector("h2")).not.toBeNull();
     expect(article!.querySelector("h2")!.textContent).toBe("Title");
     expect(article!.querySelector("strong")).not.toBeNull();

package/tests/parser/dom-to-ast.test.ts ADDED Viewed

@@ -0,0 +1,109 @@
+import { domToAST } from "../../src/parser/index";
+import {
+  createDocument,
+  createElement,
+  createTextNode,
+  createComment,
+  createDoctype,
+} from "../../src/dom-simulator/index.js";
+it("should convert document to AST", () => {
+  const doc = createDocument();
+  const ast = domToAST(doc);
+  expect(ast.type).toBe("document");
+  expect(ast.children).toEqual([]);
+});
+it("should convert element to AST", () => {
+  const element = createElement("div", { class: "test", id: "mydiv" });
+  const ast = domToAST(element);
+  expect(ast.type).toBe("element");
+  expect(ast.tagName).toBe("div");
+  expect(ast.attributes).toEqual({ class: "test", id: "mydiv" });
+  expect(ast.children).toEqual([]);
+});
+it("should convert element with children to AST", () => {
+  const element = createElement("div", {});
+  const text = createTextNode("Hello");
+  element.appendChild(text);
+  const ast = domToAST(element);
+  expect(ast.type).toBe("element");
+  expect(ast.tagName).toBe("div");
+  expect(ast.children).toHaveLength(1);
+  expect(ast.children[0].type).toBe("text");
+  expect(ast.children[0].content).toBe("Hello");
+});
+it("should convert text node to AST", () => {
+  const text = createTextNode("Hello world");
+  const ast = domToAST(text);
+  expect(ast.type).toBe("text");
+  expect(ast.content).toBe("Hello world");
+});
+it("should convert comment to AST", () => {
+  const comment = createComment("This is a comment");
+  const ast = domToAST(comment);
+  expect(ast.type).toBe("comment");
+  expect(ast.content).toBe("This is a comment");
+});
+it("should convert doctype to AST", () => {
+  const doctype = createDoctype("html");
+  const ast = domToAST(doctype);
+  expect(ast.type).toBe("doctype");
+  expect(ast.name).toBe("html");
+  expect(ast.publicId).toBe("");
+  expect(ast.systemId).toBe("");
+});
+it("should convert doctype with ids to AST", () => {
+  const doctype = createDoctype("html", "public", "system");
+  const ast = domToAST(doctype);
+  expect(ast.type).toBe("doctype");
+  expect(ast.name).toBe("html");
+  expect(ast.publicId).toBe("public");
+  expect(ast.systemId).toBe("system");
+});
+it("should handle null input", () => {
+  const ast = domToAST(null);
+  expect(ast.type).toBe("document");
+  expect(ast.children).toEqual([]);
+});
+it("should convert nested elements to AST", () => {
+  const div = createElement("div", { class: "container" });
+  const span = createElement("span", { class: "inner" });
+  const text = createTextNode("content");
+  span.appendChild(text);
+  div.appendChild(span);
+  const ast = domToAST(div);
+  expect(ast.type).toBe("element");
+  expect(ast.tagName).toBe("div");
+  expect(ast.attributes).toEqual({ class: "container" });
+  expect(ast.children).toHaveLength(1);
+  const childAst = ast.children[0];
+  expect(childAst.type).toBe("element");
+  expect(childAst.tagName).toBe("span");
+  expect(childAst.attributes).toEqual({ class: "inner" });
+  expect(childAst.children).toHaveLength(1);
+  expect(childAst.children[0].type).toBe("text");
+  expect(childAst.children[0].content).toBe("content");
+});
+it("should convert element with namespace to AST", () => {
+  const element = createElement("svg", {}, "http://www.w3.org/2000/svg");
+  const ast = domToAST(element);
+  expect(ast.type).toBe("element");
+  expect(ast.tagName).toBe("svg");
+  expect(ast.namespaceURI).toBe("http://www.w3.org/2000/svg");
+});
+it("should handle unknown node types", () => {
+  const unknownNode = { nodeType: 999 };
+  const ast = domToAST(unknownNode);
+  expect(ast.type).toBe("text");
+  expect(ast.content).toBe("");
+});

package/tests/parser/parse.test.ts ADDED Viewed

@@ -0,0 +1,139 @@
+import { parse } from "../../src/parser/index";
+import { tokenize } from "../../src/tokenizer/index";
+it("should parse empty HTML", () => {
+  const tokens = tokenize("");
+  const result = parse(tokens);
+  expect(result.nodeType).toBe(9);
+  expect(result.childNodes).toHaveLength(1);
+  expect(result.documentElement.tagName).toBe("HTML");
+});
+it("should parse simple HTML", () => {
+  const tokens = tokenize("<html><body>Hello</body></html>");
+  const result = parse(tokens);
+  expect(result.nodeType).toBe(9);
+  expect(result.documentElement.tagName).toBe("HTML");
+  expect(result.body.tagName).toBe("BODY");
+  expect(result.body.childNodes[0].textContent).toBe("Hello");
+});
+it("should parse HTML with doctype", () => {
+  const tokens = tokenize("<!DOCTYPE html><html></html>");
+  const result = parse(tokens);
+  expect(result.doctype.name).toBe("html");
+  expect(result.documentElement.tagName).toBe("HTML");
+});
+it("should parse HTML with comments", () => {
+  const tokens = tokenize("<!-- comment --><html></html>");
+  const result = parse(tokens);
+  expect(result.childNodes[0].nodeType).toBe(8);
+  expect(result.childNodes[0].textContent).toBe(" comment ");
+});
+it("should parse HTML with attributes", () => {
+  const tokens = tokenize('<div class="test" id="mydiv">content</div>');
+  const result = parse(tokens);
+  const div = result.body.childNodes[0];
+  expect(div.tagName).toBe("DIV");
+  expect(div.attributes.class).toBe("test");
+  expect(div.attributes.id).toBe("mydiv");
+  expect(div.childNodes[0].textContent).toBe("content");
+});
+it("should parse self-closing tags", () => {
+  const tokens = tokenize("<img src='test.jpg' />");
+  const result = parse(tokens);
+  const img = result.body.childNodes[0];
+  expect(img.tagName).toBe("IMG");
+  expect(img.attributes.src).toBe("test.jpg");
+  expect(img.childNodes).toHaveLength(0);
+});
+it("should parse void elements", () => {
+  const tokens = tokenize("<br><hr><input>");
+  const result = parse(tokens);
+  expect(result.body.childNodes).toHaveLength(3);
+  expect(result.body.childNodes[0].tagName).toBe("BR");
+  expect(result.body.childNodes[1].tagName).toBe("HR");
+  expect(result.body.childNodes[2].tagName).toBe("INPUT");
+});
+it("should handle unclosed tags", () => {
+  const tokens = tokenize("<div><p>Hello");
+  const result = parse(tokens);
+  expect(result.body.childNodes[0].tagName).toBe("DIV");
+  expect(result.body.childNodes[0].childNodes[0].tagName).toBe("P");
+});
+it("should parse nested elements", () => {
+  const tokens = tokenize("<div><span>inner</span></div>");
+  const result = parse(tokens);
+  const div = result.body.childNodes[0];
+  expect(div.tagName).toBe("DIV");
+  const span = div.childNodes[0];
+  expect(span.tagName).toBe("SPAN");
+  expect(span.childNodes[0].textContent).toBe("inner");
+});
+it("should parse multiple root elements", () => {
+  const tokens = tokenize("<div>first</div><div>second</div>");
+  const result = parse(tokens);
+  expect(result.body.childNodes).toHaveLength(2);
+  expect(result.body.childNodes[0].childNodes[0].textContent).toBe("first");
+  expect(result.body.childNodes[1].childNodes[0].textContent).toBe("second");
+});
+it("should handle malformed HTML", () => {
+  const tokens = tokenize("<div><p>Hello</div>");
+  const result = parse(tokens);
+  expect(result.body.childNodes[0].tagName).toBe("DIV");
+  expect(result.body.childNodes[0].childNodes[0].tagName).toBe("P");
+});
+it("should parse HTML with head and body", () => {
+  const tokens = tokenize(
+    "<html><head><title>Test</title></head><body>Content</body></html>",
+  );
+  const result = parse(tokens);
+  expect(result.head.tagName).toBe("HEAD");
+  expect(result.head.childNodes[0].tagName).toBe("TITLE");
+  expect(result.body.tagName).toBe("BODY");
+  expect(result.body.childNodes[0].textContent).toBe("Content");
+});
+it("should parse HTML without explicit html tag", () => {
+  const tokens = tokenize(
+    "<head><title>Test</title></head><body>Content</body>",
+  );
+  const result = parse(tokens);
+  expect(result.documentElement.tagName).toBe("HTML");
+  expect(result.head.tagName).toBe("HEAD");
+  expect(result.body.tagName).toBe("BODY");
+});
+it("should parse text content", () => {
+  const tokens = tokenize("Hello <b>world</b>!");
+  const result = parse(tokens);
+  expect(result.body.childNodes).toHaveLength(3);
+  expect(result.body.childNodes[0].textContent).toBe("Hello ");
+  expect(result.body.childNodes[1].tagName).toBe("B");
+  expect(result.body.childNodes[2].textContent).toBe("!");
+});
+it("should handle whitespace", () => {
+  const tokens = tokenize("  <div>  content  </div>  ");
+  const result = parse(tokens);
+  const div = result.body.childNodes[0];
+  expect(div.tagName).toBe("DIV");
+  expect(div.childNodes[0].textContent).toBe("  content  ");
+});
+it("should parse custom elements", () => {
+  const tokens = tokenize("<my-element>content</my-element>");
+  const result = parse(tokens);
+  const element = result.body?.childNodes[0] as any;
+  expect(element?.tagName).toBe("MY-ELEMENT");
+  expect(element?.childNodes[0]?.textContent).toBe("content");
+});