@tkeron/html-parser 0.1.5 → 0.1.7

package/README.md

@@ -11,7 +11,7 @@ A fast and lightweight HTML parser for Bun that converts HTML strings into DOM D
 - 🪶 **Lightweight**: Minimal dependencies, native implementation
 - 🌐 **Standards Compliant**: Returns standard DOM Document objects
 - 🔧 **TypeScript Support**: Full TypeScript definitions included
-- ✅ **Well Tested**: Comprehensive unit test suite (181/181 passing)
+- ✅ **Well Tested**: Comprehensive unit test suite (569 tests passing)
 - 🔄 **100% Compatible**: Drop-in replacement, same API
 
 ## Installation

package/bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "@tkeron/html-parser",
       "devDependencies": {
-        "@types/bun": "^1.3.4",
+        "@types/bun": "^1.3.6",
       },
       "peerDependencies": {
         "typescript": "^5.9.3",
@@ -13,11 +13,11 @@
     },
   },
   "packages": {
-    "@types/bun": ["@types/bun@1.3.4", "", { "dependencies": { "bun-types": "1.3.4" } }, "sha512-EEPTKXHP+zKGPkhRLv+HI0UEX8/o+65hqARxLy8Ov5rIxMBPNTjeZww00CIihrIQGEQBYg+0roO5qOnS/7boGA=="],
+    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
 
     "@types/node": ["@types/node@25.0.3", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA=="],
 
-    "bun-types": ["bun-types@1.3.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-5ua817+BZPZOlNaRgGBpZJOSAQ9RQ17pkwPD0yR7CfJg+r8DgIILByFifDTa+IPDDxzf5VNhtNlcKqFzDgJvlQ=="],
+    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
 
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tkeron/html-parser",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A fast and lightweight HTML parser for Bun",
   "main": "index.js",
   "module": "index.ts",
@@ -8,16 +8,17 @@
   "author": "tkeron",
   "license": "MIT",
   "devDependencies": {
-    "@types/bun": "^1.3.4"
+    "@types/bun": "^1.3.6"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"
   },
   "keywords": [
-    "cli",
-    "commands",
-    "command-line",
-    "arguments"
+    "html",
+    "parser",
+    "dom",
+    "bun",
+    "tokenizer"
   ],
   "repository": {
     "url": "git@github.com:tkeron/html-parser.git"

package/src/css-selector.ts

@@ -14,33 +14,47 @@ function parseSelector(selector: string): SelectorGroup[] {
 
   return parts.map((part) => {
     const trimmed = part.trim();
-    let tokens: SelectorToken[];
-
-    if (trimmed.startsWith("#")) {
-      tokens = [{ type: "id", value: trimmed.slice(1) }];
-    } else if (trimmed.startsWith(".")) {
-      tokens = [{ type: "class", value: trimmed.slice(1) }];
-    } else if (trimmed.includes("[") && trimmed.includes("]")) {
-      const attributeMatch = trimmed.match(/^([^[\]]*)\[([^=\]]+)(?:=["']?([^"'\]]*?)["']?)?\]$/);
-      if (attributeMatch) {
-        const [, tagName, attrName, attrValue] = attributeMatch;
-        tokens = [];
-        
-        if (tagName && tagName.trim()) {
-          tokens.push({ type: "tag", value: tagName.trim().toLowerCase() });
-        }
-        
-        tokens.push({ 
-          type: "attribute", 
-          value: (attrName || "").trim(),
-          attributeName: (attrName || "").trim(),
-          attributeValue: attrValue ? attrValue.trim() : undefined
-        });
-      } else {
-        tokens = [{ type: "tag", value: trimmed.toLowerCase() }];
-      }
-    } else {
-      tokens = [{ type: "tag", value: trimmed.toLowerCase() }];
+    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 };
@@ -74,6 +88,10 @@ function matchesToken(element: any, token: SelectorToken): boolean {
 }
 
 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));
 }
 

package/src/dom-simulator.ts

@@ -6,6 +6,11 @@ import {
   querySelectorAll as querySelectorAllFunction,
 } from "./css-selector.js";
 
+const VOID_ELEMENTS = new Set([
+  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+  'link', 'meta', 'param', 'source', 'track', 'wbr'
+]);
+
 export const enum NodeType {
   ELEMENT_NODE = 1,
   TEXT_NODE = 3,
@@ -22,9 +27,13 @@ export function createElement(
 ): any {
   const innerHTML = "";
   const tagNameLower = tagName.toLowerCase();
-  const initialOuterHTML = `<${tagNameLower}${Object.entries(attributes)
+  const isVoid = VOID_ELEMENTS.has(tagNameLower);
+  const attrsStr = Object.entries(attributes)
     .map(([k, v]) => ` ${k}="${v}"`)
-    .join("")}></${tagNameLower}>`;
+    .join("");
+  const initialOuterHTML = isVoid
+    ? `<${tagNameLower}${attrsStr}>`
+    : `<${tagNameLower}${attrsStr}></${tagNameLower}>`;
   const textContent = "";
 
   const element: any = {
@@ -54,6 +63,18 @@ export function createElement(
       return child;
     },
 
+    prepend(...nodes: any[]): void {
+      prepend(element, ...nodes);
+    },
+
+    append(...nodes: any[]): void {
+      append(element, ...nodes);
+    },
+
+    remove(): void {
+      remove(element);
+    },
+
     removeChild(child: any): any {
       return removeChild(element, child);
     },
@@ -96,6 +117,10 @@ export function createElement(
       return querySelectorAllFunction(element, selector);
     },
 
+    matches(selector: string): boolean {
+      return matches(element, selector);
+    },
+
     cloneNode(deep: boolean = false): any {
       return cloneNode(element, deep);
     },
@@ -172,6 +197,10 @@ export function createTextNode(content: string): any {
     lastChild: null,
     nextSibling: null,
     previousSibling: null,
+
+    remove(): void {
+      remove(textNode);
+    },
   };
   return textNode;
 }
@@ -189,6 +218,10 @@ export function createComment(content: string): any {
     lastChild: null,
     nextSibling: null,
     previousSibling: null,
+
+    remove(): void {
+      remove(commentNode);
+    },
   };
   return commentNode;
 }
@@ -222,6 +255,14 @@ export function createDocument(): any {
       return child;
     },
 
+    prepend(...nodes: any[]): void {
+      prepend(document, ...nodes);
+    },
+
+    append(...nodes: any[]): void {
+      append(document, ...nodes);
+    },
+
     removeChild(child: any): any {
       return removeChild(document, child);
     },
@@ -395,6 +436,83 @@ function appendChild(parent: any, child: any): void {
   }
 }
 
+function prepend(parent: any, ...nodes: any[]): void {
+  if (nodes.length === 0) return;
+
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const node = nodes[i];
+    let childNode: any;
+
+    if (typeof node === 'string') {
+      childNode = createTextNode(node);
+    } else {
+      childNode = node;
+    }
+
+    if (parent.firstChild) {
+      insertBefore(parent, childNode, parent.firstChild);
+    } else {
+      appendChild(parent, childNode);
+    }
+  }
+}
+
+function append(parent: any, ...nodes: any[]): void {
+  if (nodes.length === 0) return;
+
+  for (const node of nodes) {
+    let childNode: any;
+
+    if (typeof node === 'string') {
+      childNode = createTextNode(node);
+    } else {
+      childNode = node;
+    }
+
+    appendChild(parent, childNode);
+  }
+}
+
+function remove(node: any): void {
+  if (node.parentNode) {
+    removeChild(node.parentNode, node);
+  }
+}
+
+function matches(element: any, selector: string): boolean {
+  if (!selector || element.nodeType !== NodeType.ELEMENT_NODE) {
+    return false;
+  }
+
+  try {
+    // Para selectores complejos con descendientes, necesitamos buscar desde un ancestro
+    if (selector.includes(' ') || selector.includes('>')) {
+      // Buscar desde la raíz del documento
+      let root = element;
+      while (root.parentNode) {
+        root = root.parentNode;
+      }
+      const results = querySelectorAllFunction(root, selector);
+      return results.includes(element);
+    }
+    
+    // Para selectores simples, usar el padre o crear uno temporal
+    const parent = element.parentNode || createTempParent(element);
+    const results = querySelectorAllFunction(parent, selector);
+    return results.includes(element);
+  } catch (error) {
+    return false;
+  }
+}
+
+function createTempParent(element: any): any {
+  const temp = createElement('div');
+  temp.childNodes.push(element);
+  temp.children.push(element);
+  element._tempParent = temp;
+  return temp;
+}
+
 function removeChild(parent: any, child: any): any {
   const index = parent.childNodes.indexOf(child);
   if (index === -1) {
@@ -733,9 +851,10 @@ function updateElementContent(element: any): void {
     .map(([k, v]) => ` ${k}="${v}"`)
     .join("");
   const tagNameLower = element.tagName.toLowerCase();
+  const isVoid = VOID_ELEMENTS.has(tagNameLower);
   
   Object.defineProperty(element, "_internalOuterHTML", {
-    value: `<${tagNameLower}${attrs}>${innerHTML}</${tagNameLower}>`,
+    value: isVoid ? `<${tagNameLower}${attrs}>` : `<${tagNameLower}${attrs}>${innerHTML}</${tagNameLower}>`,
     writable: true,
     enumerable: false,
     configurable: true,
@@ -830,9 +949,10 @@ export function setInnerHTML(element: any, html: string): void {
     .map(([k, v]) => ` ${k}="${v}"`)
     .join("");
   const tagNameLower = element.tagName.toLowerCase();
+  const isVoid = VOID_ELEMENTS.has(tagNameLower);
   
   Object.defineProperty(element, "_internalOuterHTML", {
-    value: `<${tagNameLower}${attrs}>${actualInnerHTML}</${tagNameLower}>`,
+    value: isVoid ? `<${tagNameLower}${attrs}>` : `<${tagNameLower}${attrs}>${actualInnerHTML}</${tagNameLower}>`,
     writable: true,
     enumerable: false,
     configurable: true,

package/src/parser.ts

@@ -314,42 +314,3 @@ function shouldSkipWhitespace(parent: ASTNode): boolean {
 
   return parent.tagName ? skipWhitespaceIn.has(parent.tagName) : false;
 }
-
-export function traverseAST(node: ASTNode, callback: (node: ASTNode) => void): void {
-  callback(node);
-  
-  if (node.children) {
-    for (const child of node.children) {
-      traverseAST(child, callback);
-    }
-  }
-}
-
-export function findNodesByTagName(root: ASTNode, tagName: string): ASTNode[] {
-  const results: ASTNode[] = [];
-  
-  traverseAST(root, (node) => {
-    if (node.type === ASTNodeType.ELEMENT && node.tagName === tagName.toLowerCase()) {
-      results.push(node);
-    }
-  });
-
-  return results;
-}
-
-export function findNodesByAttribute(root: ASTNode, attrName: string, attrValue?: string): ASTNode[] {
-  const results: ASTNode[] = [];
-  
-  traverseAST(root, (node) => {
-    if (node.type === ASTNodeType.ELEMENT && node.attributes) {
-      const hasAttr = attrName in node.attributes;
-      const valueMatches = attrValue === undefined || node.attributes[attrName] === attrValue;
-      
-      if (hasAttr && valueMatches) {
-        results.push(node);
-      }
-    }
-  });
-
-  return results;
-}

package/src/tokenizer.ts

@@ -251,99 +251,3 @@ export function tokenize(html: string): Token[] {
   
   return tokens;
 }
-
-export function tokenizeWithRewriter(html: string): Token[] {
-  const tokens: Token[] = [];
-  let textBuffer = '';
-  let position = 0;
-  
-  const rewriter = new HTMLRewriter();
-  
-  rewriter.on('*', {
-    element(element) {
-      if (textBuffer.trim()) {
-        tokens.push({
-          type: TokenType.TEXT,
-          value: decodeEntities(textBuffer),
-          position: calculatePosition(html, position - textBuffer.length)
-        });
-        textBuffer = '';
-      }
-      
-      const attributes: Record<string, string> = {};
-      for (const [name, value] of element.attributes) {
-        attributes[name] = value;
-      }
-      
-      tokens.push({
-        type: TokenType.TAG_OPEN,
-        value: element.tagName.toLowerCase(),
-        position: calculatePosition(html, position),
-        attributes,
-        isSelfClosing: element.selfClosing
-      });
-      
-      if (!element.selfClosing) {
-        element.onEndTag((endTag) => {
-          tokens.push({
-            type: TokenType.TAG_CLOSE,
-            value: endTag.name.toLowerCase(),
-            position: calculatePosition(html, position),
-            isClosing: true
-          });
-        });
-      }
-    },
-    
-    text(text) {
-      textBuffer += text.text;
-    },
-    
-    comments(comment) {
-      tokens.push({
-        type: TokenType.COMMENT,
-        value: comment.text,
-        position: calculatePosition(html, position)
-      });
-    }
-  });
-  
-  try {
-    const response = new Response(html, {
-      headers: { 'Content-Type': 'text/html' }
-    });
-    
-    rewriter.transform(response);
-    
-    if (textBuffer.trim()) {
-      tokens.push({
-        type: TokenType.TEXT,
-        value: decodeEntities(textBuffer),
-        position: calculatePosition(html, position - textBuffer.length)
-      });
-    }
-    
-  } catch (error) {
-    console.warn('HTMLRewriter failed, falling back to manual parsing:', error);
-    return tokenize(html);
-  }
-  
-  tokens.sort((a, b) => a.position.offset - b.position.offset);
-  tokens.push({
-    type: TokenType.EOF,
-    value: '',
-    position: calculatePosition(html, html.length)
-  });
-  
-  return tokens;
-}
-
-export function smartTokenize(html: string): Token[] {
-  const hasSpecialContent = /<!DOCTYPE|<!--|\[CDATA\[|<\?/.test(html);
-  
-  if (hasSpecialContent || html.length < 1000) {
-    return tokenize(html);
-  } else {
-    return tokenizeWithRewriter(html);
-  }
-}