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/tree-construction-tests6.test.ts CHANGED Viewed

@@ -2,15 +2,16 @@ import { readFileSync } from "fs";
 import { parse } from "../src/index.ts";
 describe("Tree Construction Tests6 Tests", () => {
-  const content = readFileSync("tests/html5lib-data/tree-construction/tests6.dat", "utf8");
+  const content = readFileSync(
+    "tests/html5lib-data/tree-construction/tests6.dat",
+    "utf8",
+  );
   const sections = content.split("#data\n");
   for (let i = 1; i < sections.length; i++) {
     const section = sections[i];
-    const [dataPart, documentPart] = section.split("#document\n");
+    const [dataPart] = section.split("#document\n");
     const data = dataPart.trim();
-    const expectedDocument = documentPart ? documentPart.split("#errors\n")[0].trim() : "";
-    const errors = documentPart && documentPart.includes("#errors\n") ? documentPart.split("#errors\n")[1].trim() : "";
     it(`Tests6 test ${i}`, () => {
       const doc = parse(data);
@@ -18,4 +19,4 @@ describe("Tree Construction Tests6 Tests", () => {
       // TODO: Implement DOM serialization and comparison
     });
   }
-});
+});

package/tests/tree-construction-tests_innerHTML_1.test.ts CHANGED Viewed

@@ -2,15 +2,16 @@ import { readFileSync } from "fs";
 import { parse } from "../src/index.ts";
 describe("Tree Construction Tests_innerHTML_1 Tests", () => {
-  const content = readFileSync("tests/html5lib-data/tree-construction/tests_innerHTML_1.dat", "utf8");
+  const content = readFileSync(
+    "tests/html5lib-data/tree-construction/tests_innerHTML_1.dat",
+    "utf8",
+  );
   const sections = content.split("#data\n");
   for (let i = 1; i < sections.length; i++) {
     const section = sections[i];
-    const [dataPart, documentPart] = section.split("#document\n");
+    const [dataPart] = section.split("#document\n");
     const data = dataPart.trim();
-    const expectedDocument = documentPart ? documentPart.split("#errors\n")[0].trim() : "";
-    const errors = documentPart && documentPart.includes("#errors\n") ? documentPart.split("#errors\n")[1].trim() : "";
     it(`Tests_innerHTML_1 test ${i}`, () => {
       const doc = parse(data);
@@ -18,4 +19,4 @@ describe("Tree Construction Tests_innerHTML_1 Tests", () => {
       // TODO: Implement DOM serialization and comparison
     });
   }
-});
+});

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

@@ -3,10 +3,10 @@ import { parseHTML } from "../index";
 /**
  * Test suite for HTML void elements serialization
- *
+ *
  * Void elements should NOT have closing tags according to HTML spec:
  * https://html.spec.whatwg.org/multipage/syntax.html#void-elements
- *
+ *
  * List: area, base, br, col, embed, hr, img, input, link, meta, source, track, wbr
  */
@@ -52,73 +52,101 @@ describe("Void Elements - outerHTML serialization", () => {
   describe("Individual void elements with attributes", () => {
     it("should serialize <img> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><body><img src="test.jpg" alt="test image"></body></html>');
+      const doc = parseHTML(
+        '<html><body><img src="test.jpg" alt="test image"></body></html>',
+      );
       const img = doc.querySelector("img");
       expect(img).not.toBeNull();
       expect(img!.outerHTML).toBe('<img src="test.jpg" alt="test image">');
     });
     it("should serialize <input> with type attribute without closing tag", () => {
-      const doc = parseHTML('<html><body><input type="text" name="username"></body></html>');
+      const doc = parseHTML(
+        '<html><body><input type="text" name="username"></body></html>',
+      );
       const input = doc.querySelector("input");
       expect(input).not.toBeNull();
       expect(input!.outerHTML).toBe('<input type="text" name="username">');
     });
     it("should serialize <meta> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><head><meta charset="utf-8"></head><body></body></html>');
+      const doc = parseHTML(
+        '<html><head><meta charset="utf-8"></head><body></body></html>',
+      );
       const meta = doc.querySelector("meta");
       expect(meta).not.toBeNull();
       expect(meta!.outerHTML).toBe('<meta charset="utf-8">');
     });
     it("should serialize <link> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><head><link rel="stylesheet" href="style.css"></head><body></body></html>');
+      const doc = parseHTML(
+        '<html><head><link rel="stylesheet" href="style.css"></head><body></body></html>',
+      );
       const link = doc.querySelector("link");
       expect(link).not.toBeNull();
       expect(link!.outerHTML).toBe('<link rel="stylesheet" href="style.css">');
     });
     it("should serialize <base> with href without closing tag", () => {
-      const doc = parseHTML('<html><head><base href="https://example.com/"></head><body></body></html>');
+      const doc = parseHTML(
+        '<html><head><base href="https://example.com/"></head><body></body></html>',
+      );
       const base = doc.querySelector("base");
       expect(base).not.toBeNull();
       expect(base!.outerHTML).toBe('<base href="https://example.com/">');
     });
     it("should serialize <col> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><body><table><colgroup><col span="2" style="background:red"></colgroup></table></body></html>');
+      const doc = parseHTML(
+        '<html><body><table><colgroup><col span="2" style="background:red"></colgroup></table></body></html>',
+      );
       const col = doc.querySelector("col");
       expect(col).not.toBeNull();
       expect(col!.outerHTML).toBe('<col span="2" style="background:red">');
     });
     it("should serialize <embed> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><body><embed src="video.swf" type="application/x-shockwave-flash"></body></html>');
+      const doc = parseHTML(
+        '<html><body><embed src="video.swf" type="application/x-shockwave-flash"></body></html>',
+      );
       const embed = doc.querySelector("embed");
       expect(embed).not.toBeNull();
-      expect(embed!.outerHTML).toBe('<embed src="video.swf" type="application/x-shockwave-flash">');
+      expect(embed!.outerHTML).toBe(
+        '<embed src="video.swf" type="application/x-shockwave-flash">',
+      );
     });
     it("should serialize <source> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><body><video><source src="video.mp4" type="video/mp4"></video></body></html>');
+      const doc = parseHTML(
+        '<html><body><video><source src="video.mp4" type="video/mp4"></video></body></html>',
+      );
       const source = doc.querySelector("source");
       expect(source).not.toBeNull();
-      expect(source!.outerHTML).toBe('<source src="video.mp4" type="video/mp4">');
+      expect(source!.outerHTML).toBe(
+        '<source src="video.mp4" type="video/mp4">',
+      );
     });
     it("should serialize <track> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><body><video><track kind="subtitles" src="subs.vtt" srclang="en"></video></body></html>');
+      const doc = parseHTML(
+        '<html><body><video><track kind="subtitles" src="subs.vtt" srclang="en"></video></body></html>',
+      );
       const track = doc.querySelector("track");
       expect(track).not.toBeNull();
-      expect(track!.outerHTML).toBe('<track kind="subtitles" src="subs.vtt" srclang="en">');
+      expect(track!.outerHTML).toBe(
+        '<track kind="subtitles" src="subs.vtt" srclang="en">',
+      );
     });
     it("should serialize <area> with attributes without closing tag", () => {
-      const doc = parseHTML('<html><body><map name="test"><area shape="rect" coords="0,0,100,100" href="link.html"></map></body></html>');
+      const doc = parseHTML(
+        '<html><body><map name="test"><area shape="rect" coords="0,0,100,100" href="link.html"></map></body></html>',
+      );
       const area = doc.querySelector("area");
       expect(area).not.toBeNull();
-      expect(area!.outerHTML).toBe('<area shape="rect" coords="0,0,100,100" href="link.html">');
+      expect(area!.outerHTML).toBe(
+        '<area shape="rect" coords="0,0,100,100" href="link.html">',
+      );
     });
   });
@@ -136,22 +164,25 @@ describe("Void Elements - outerHTML serialization", () => {
   describe("Multiple void elements in same document", () => {
     it("should serialize multiple void elements correctly", () => {
-      const doc = parseHTML('<html><body><img src="test.jpg"><br><input type="text"></body></html>');
+      const doc = parseHTML(
+        '<html><body><img src="test.jpg"><br><input type="text"></body></html>',
+      );
       const img = doc.querySelector("img");
       const br = doc.querySelector("br");
       const input = doc.querySelector("input");
       expect(img!.outerHTML).toBe('<img src="test.jpg">');
       expect(br!.outerHTML).toBe("<br>");
       expect(input!.outerHTML).toBe('<input type="text">');
     });
     it("should serialize document with multiple void elements without closing tags", () => {
-      const html = '<html><body><img src="test.jpg"><br><input type="text"></body></html>';
+      const html =
+        '<html><body><img src="test.jpg"><br><input type="text"></body></html>';
       const doc = parseHTML(html);
       const outerHTML = doc.documentElement.outerHTML;
       expect(outerHTML).not.toContain("</img>");
       expect(outerHTML).not.toContain("</br>");
       expect(outerHTML).not.toContain("</input>");
@@ -170,11 +201,11 @@ describe("Void Elements - outerHTML serialization", () => {
         <body></body>
       </html>`;
       const doc = parseHTML(html);
       const metas = doc.querySelectorAll("meta");
       const link = doc.querySelector("link");
       const base = doc.querySelector("base");
       metas.forEach((meta: any) => {
         expect(meta.outerHTML).not.toContain("</meta>");
       });
@@ -210,7 +241,9 @@ describe("Void Elements - outerHTML serialization", () => {
       const meta = doc.createElement("meta");
       meta.setAttribute("name", "description");
       meta.setAttribute("content", "Test page");
-      expect(meta.outerHTML).toBe('<meta name="description" content="Test page">');
+      expect(meta.outerHTML).toBe(
+        '<meta name="description" content="Test page">',
+      );
     });
     it("should serialize dynamically created <hr> without closing tag", () => {
@@ -285,14 +318,18 @@ describe("Void Elements - outerHTML serialization", () => {
     });
     it("should serialize <style> with closing tag", () => {
-      const doc = parseHTML("<html><head><style></style></head><body></body></html>");
+      const doc = parseHTML(
+        "<html><head><style></style></head><body></body></html>",
+      );
       const style = doc.querySelector("style");
       expect(style).not.toBeNull();
       expect(style!.outerHTML).toBe("<style></style>");
     });
     it("should serialize <iframe> with closing tag", () => {
-      const doc = parseHTML('<html><body><iframe src="page.html"></iframe></body></html>');
+      const doc = parseHTML(
+        '<html><body><iframe src="page.html"></iframe></body></html>',
+      );
       const iframe = doc.querySelector("iframe");
       expect(iframe).not.toBeNull();
       expect(iframe!.outerHTML).toBe('<iframe src="page.html"></iframe>');
@@ -336,7 +373,7 @@ describe("Void Elements - outerHTML serialization", () => {
     });
     it("should not include innerHTML content in void element", () => {
-      const doc = parseHTML("<html><body><img src=\"test.jpg\"></body></html>");
+      const doc = parseHTML('<html><body><img src="test.jpg"></body></html>');
       const img = doc.querySelector("img");
       expect(img).not.toBeNull();
       expect(img!.innerHTML).toBe("");
@@ -357,11 +394,11 @@ describe("Void Elements - outerHTML serialization", () => {
           </form>
         </div>
       </body></html>`;
       const doc = parseHTML(html);
       const inputs = doc.querySelectorAll("input");
       const br = doc.querySelector("br");
       expect(inputs.length).toBe(2);
       inputs.forEach((input: any) => {
         expect(input.outerHTML).not.toContain("</input>");
@@ -379,11 +416,11 @@ describe("Void Elements - outerHTML serialization", () => {
           <tr><td><img src="icon.png"></td></tr>
         </table>
       </body></html>`;
       const doc = parseHTML(html);
       const cols = doc.querySelectorAll("col");
       const img = doc.querySelector("img");
       expect(cols.length).toBe(2);
       cols.forEach((col: any) => {
         expect(col.outerHTML).not.toContain("</col>");
@@ -394,24 +431,30 @@ describe("Void Elements - outerHTML serialization", () => {
   describe("Edge cases", () => {
     it("should handle void element with boolean attributes", () => {
-      const doc = parseHTML('<html><body><input type="checkbox" checked disabled></body></html>');
+      const doc = parseHTML(
+        '<html><body><input type="checkbox" checked disabled></body></html>',
+      );
       const input = doc.querySelector("input");
       expect(input).not.toBeNull();
       expect(input!.outerHTML).not.toContain("</input>");
     });
     it("should handle void element with empty attribute value", () => {
-      const doc = parseHTML('<html><body><input type="text" value=""></body></html>');
+      const doc = parseHTML(
+        '<html><body><input type="text" value=""></body></html>',
+      );
       const input = doc.querySelector("input");
       expect(input).not.toBeNull();
       expect(input!.outerHTML).not.toContain("</input>");
     });
     it("should handle uppercase void element tag names", () => {
-      const doc = parseHTML("<html><body><BR><IMG SRC=\"test.jpg\"></body></html>");
+      const doc = parseHTML(
+        '<html><body><BR><IMG SRC="test.jpg"></body></html>',
+      );
       const br = doc.querySelector("br");
       const img = doc.querySelector("img");
       expect(br).not.toBeNull();
       expect(img).not.toBeNull();
       expect(br!.outerHTML).not.toContain("</br>");
@@ -421,10 +464,12 @@ describe("Void Elements - outerHTML serialization", () => {
     });
     it("should handle mixed case void element tag names", () => {
-      const doc = parseHTML("<html><body><Br><ImG src=\"test.jpg\"></body></html>");
+      const doc = parseHTML(
+        '<html><body><Br><ImG src="test.jpg"></body></html>',
+      );
       const br = doc.querySelector("br");
       const img = doc.querySelector("img");
       expect(br).not.toBeNull();
       expect(img).not.toBeNull();
       expect(br!.outerHTML.toLowerCase()).not.toContain("</br>");
@@ -449,10 +494,10 @@ describe("Void Elements - outerHTML serialization", () => {
           </form>
         </body>
       </html>`;
       const doc = parseHTML(html);
       const fullHTML = doc.documentElement.outerHTML;
       // Check no void elements have closing tags
       expect(fullHTML).not.toContain("</meta>");
       expect(fullHTML).not.toContain("</link>");
@@ -460,7 +505,7 @@ describe("Void Elements - outerHTML serialization", () => {
       expect(fullHTML).not.toContain("</hr>");
       expect(fullHTML).not.toContain("</input>");
       expect(fullHTML).not.toContain("</br>");
       // Check non-void elements still have closing tags
       expect(fullHTML).toContain("</head>");
       expect(fullHTML).toContain("</body>");

package/tsconfig.json CHANGED Viewed

@@ -18,7 +18,7 @@
     "noUncheckedIndexedAccess": true,
     "noImplicitOverride": true,
-    "noUnusedLocals": false,
+    "noUnusedLocals": true,
     "noUnusedParameters": false,
     "noPropertyAccessFromIndexSignature": false
   }

package/src/css-selector.ts DELETED Viewed

@@ -1,185 +0,0 @@
-interface SelectorToken {
-  type: "tag" | "class" | "id" | "attribute";
-  value: string;
-  attributeName?: string;
-  attributeValue?: string;
-}
-interface SelectorGroup {
-  tokens: SelectorToken[];
-}
-function parseSelector(selector: string): SelectorGroup[] {
-  const parts = selector.trim().split(/\s+/);
-  return parts.map((part) => {
-    const trimmed = part.trim();
-    let tokens: SelectorToken[] = [];
-    // Handle universal selector
-    if (trimmed === '*') {
-      // Match any element - we'll handle this specially
-      return { tokens: [] };
-    }
-    // Parse complex selectors like p#intro.first or .foo.bar.baz
-    let remaining = trimmed;
-    // Extract tag name first if present
-    const tagMatch = remaining.match(/^([a-zA-Z][a-zA-Z0-9-]*)/);
-    if (tagMatch) {
-      tokens.push({ type: "tag", value: tagMatch[1].toLowerCase() });
-      remaining = remaining.slice(tagMatch[1].length);
-    }
-    // Extract all IDs (HTML5 allows IDs starting with digits)
-    const idMatches = remaining.matchAll(/#([a-zA-Z0-9][a-zA-Z0-9_-]*)/g);
-    for (const match of idMatches) {
-      tokens.push({ type: "id", value: match[1] });
-    }
-    remaining = remaining.replace(/#[a-zA-Z0-9][a-zA-Z0-9_-]*/g, '');
-    // Extract all classes
-    const classMatches = remaining.matchAll(/\.([a-zA-Z][a-zA-Z0-9_-]*)/g);
-    for (const match of classMatches) {
-      tokens.push({ type: "class", value: match[1] });
-    }
-    remaining = remaining.replace(/\.[a-zA-Z][a-zA-Z0-9_-]*/g, '');
-    // Extract attributes
-    const attrMatches = remaining.matchAll(/\[([^=\]]+)(?:=["']?([^"'\]]*?)["']?)?\]/g);
-    for (const match of attrMatches) {
-      tokens.push({
-        type: "attribute",
-        value: match[1].trim(),
-        attributeName: match[1].trim(),
-        attributeValue: match[2] ? match[2].trim() : undefined
-      });
-    }
-    return { tokens };
-  });
-}
-function matchesToken(element: any, token: SelectorToken): boolean {
-  if (!element || !element.tagName) {
-    return false;
-  }
-  switch (token.type) {
-    case "tag":
-      return element.tagName.toLowerCase() === token.value;
-    case "class":
-      const classAttr =
-        element.attributes?.class || element.attributes?.className || "";
-      const classes = classAttr.split(/\s+/).filter(Boolean);
-      return classes.includes(token.value);
-    case "id":
-      return element.attributes?.id === token.value;
-    case "attribute":
-      const attrValue = element.attributes?.[token.attributeName || ""];
-      if (token.attributeValue === undefined) {
-        return attrValue !== undefined;
-      }
-      return attrValue === token.attributeValue;
-    default:
-      return false;
-  }
-}
-function matchesSelector(element: any, tokens: SelectorToken[]): boolean {
-  // Universal selector - matches any element
-  if (tokens.length === 0) {
-    return true;
-  }
-  return tokens.every((token) => matchesToken(element, token));
-}
-function findElementsDescendant(
-  node: any,
-  selectorGroups: SelectorGroup[],
-  groupIndex: number,
-  results: any[]
-): void {
-  if (groupIndex >= selectorGroups.length) {
-    return;
-  }
-  const currentGroup = selectorGroups[groupIndex];
-  if (!currentGroup) {
-    return;
-  }
-  const isLastGroup = groupIndex === selectorGroups.length - 1;
-  for (const child of node.childNodes || []) {
-    if (child.nodeType === 1) {
-      const element = child;
-      if (matchesSelector(element, currentGroup.tokens)) {
-        if (isLastGroup) {
-          results.push(element);
-        } else {
-          findElementsDescendant(
-            element,
-            selectorGroups,
-            groupIndex + 1,
-            results
-          );
-        }
-      }
-    }
-    const shouldContinueSearching =
-      !isLastGroup ||
-      child.nodeType !== 1 ||
-      !matchesSelector(child, currentGroup.tokens);
-    if (shouldContinueSearching) {
-      findElementsDescendant(child, selectorGroups, groupIndex, results);
-    }
-  }
-}
-function findElements(
-  node: any,
-  selectorGroups: SelectorGroup[],
-  results: any[]
-): void {
-  if (selectorGroups.length === 1) {
-    const firstGroup = selectorGroups[0];
-    if (firstGroup) {
-      const tokens = firstGroup.tokens;
-      findElementsSimple(node, tokens, results);
-    }
-  } else {
-    findElementsDescendant(node, selectorGroups, 0, results);
-  }
-}
-function findElementsSimple(
-  node: any,
-  tokens: SelectorToken[],
-  results: any[]
-): void {
-  if (node.nodeType === 1) {
-    const element = node;
-    if (matchesSelector(element, tokens)) {
-      results.push(element);
-    }
-  }
-  for (const child of node.childNodes || []) {
-    findElementsSimple(child, tokens, results);
-  }
-}
-export function querySelectorAll(root: any, selector: string): any[] {
-  const selectorGroups = parseSelector(selector);
-  const results: any[] = [];
-  findElements(root, selectorGroups, results);
-  return results;
-}
-export function querySelector(root: any, selector: string): any | null {
-  const results = querySelectorAll(root, selector);
-  return results[0] || null;
-}

package/src/encoding.ts DELETED Viewed

@@ -1,39 +0,0 @@
-/**
- * Detects the character encoding of an HTML document.
- * Based on HTML5 specification for encoding detection.
- */
-const encodingAliases: Record<string, string> = {
-  'iso-8859-1': 'windows-1252',
-  'iso8859-1': 'windows-1252',
-  'iso-8859-2': 'iso-8859-2',
-  'iso8859-2': 'iso-8859-2',
-  'utf-8': 'utf-8',
-  'utf8': 'utf-8',
-  // Add more as needed
-};
-function normalizeEncoding(name: string): string | null {
-  const lower = name.toLowerCase().replace(/[^a-z0-9-]/g, '');
-  return encodingAliases[lower] || lower;
-}
-export function detectEncoding(html: string): string | null {
-  // Limit to first 1024 characters for performance
-  const prefix = html.substring(0, 1024);
-  // Look for <meta charset="...">
-  const charsetMatch = prefix.match(/<meta[^>]*charset\s*=\s*["']?([^"'\s>]+)["']?/i);
-  if (charsetMatch) {
-    return normalizeEncoding(charsetMatch[1]);
-  }
-  // Look for <meta http-equiv="Content-Type" content="text/html; charset=...">
-  const contentTypeMatch = prefix.match(/<meta[^>]*http-equiv\s*=\s*["']?\s*content-type\s*["']?[^>]*content\s*=\s*["']?\s*text\/html;\s*charset\s*=\s*([^"'\s>]+)["']?/i);
-  if (contentTypeMatch) {
-    return normalizeEncoding(contentTypeMatch[1]);
-  }
-  // Default to Windows-1252 if no encoding found (as per HTML5 spec)
-  return 'windows-1252';
-}