@tkeron/html-parser 1.1.2 → 1.4.0

package/.github/workflows/npm_deploy.yml

@@ -16,9 +16,19 @@ jobs:
 
       - uses: oven-sh/setup-bun@v2
 
-      - run: |
-          bun i
-          bun test
-          npm publish --access public
+      - name: Install dependencies
+        run: bun i
+
+      - name: Run tests
+        run: bun test --concurrent
+
+      - name: Check version
+        id: check
+        run: bun check-versions.ts
+        continue-on-error: true
+
+      - name: Publish to npm
+        if: steps.check.outcome == 'success'
+        run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -1,16 +1,16 @@
-# HTML Parser - Powered by Bun Native Tokenizer
+# HTML Parser
 
-A fast and lightweight HTML parser for Bun that converts HTML strings into DOM Document objects. **Now powered by a native Bun tokenizer** for optimal performance.
+A fast and lightweight HTML parser for Bun that converts HTML strings into DOM Document objects. Built with a custom tokenizer optimized for Bun runtime.
 
 ## Features
 
-- ⚡ **Bun Native Tokenizer**: Optimized specifically for Bun runtime
+- ⚡ **Custom Tokenizer**: Tokenizer specifically optimized for Bun runtime
 - 🚀 **Ultra Fast**: Leverages Bun's native optimizations
-- 🪶 **Lightweight**: Minimal dependencies, native implementation
+- 🪶 **Lightweight**: Zero external dependencies
 - 🌐 **Standards Compliant**: Returns standard DOM Document objects
 - 🔧 **TypeScript Support**: Full TypeScript definitions included
-- ✅ **Well Tested**: Comprehensive test suite (5200+ tests passing)
-- 🔄 **100% Compatible**: Drop-in replacement, same API
+- ✅ **Well Tested**: Comprehensive test suite (5600+ tests passing)
+- 🎯 **HTML5 Spec**: Implements Adoption Agency Algorithm for proper formatting element handling
 
 ## Installation
 

package/bun.lock

@@ -4,11 +4,9 @@
   "workspaces": {
     "": {
       "name": "@tkeron/html-parser",
-      "dependencies": {
-        "all-named-html-entities": "^3.1.3",
-      },
       "devDependencies": {
-        "@types/bun": "^1.3.6",
+        "@types/bun": "^1.3.8",
+        "prettier": "^3.8.1",
       },
       "peerDependencies": {
         "typescript": "^5.9.3",
@@ -16,13 +14,13 @@
     },
   },
   "packages": {
-    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
+    "@types/bun": ["@types/bun@1.3.8", "", { "dependencies": { "bun-types": "1.3.8" } }, "sha512-3LvWJ2q5GerAXYxO2mffLTqOzEu5qnhEAlh48Vnu8WQfnmSwbgagjGZV6BoHKJztENYEDn6QmVd949W4uESRJA=="],
 
-    "@types/node": ["@types/node@25.0.3", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA=="],
+    "@types/node": ["@types/node@25.1.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-t7frlewr6+cbx+9Ohpl0NOTKXZNV9xHRmNOvql47BFJKcEG1CxtxlPEEe+gR9uhVWM4DwhnvTF110mIL4yP9RA=="],
 
-    "all-named-html-entities": ["all-named-html-entities@3.1.3", "", {}, "sha512-eG7/XkhxyIUWApWvhVPcusxZ3PTebJo1AvkFkQj7MDSkBYmzXZsNadKZWuo1UxEX6QrE7y7JQx7G3Fx0YjVtnA=="],
+    "bun-types": ["bun-types@1.3.8", "", { "dependencies": { "@types/node": "*" } }, "sha512-fL99nxdOWvV4LqjmC+8Q9kW3M4QTtTR1eePs94v5ctGqU8OeceWrSUaRw3JYb7tU3FkMIAjkueehrHPPPGKi5Q=="],
 
-    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
+    "prettier": ["prettier@3.8.1", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg=="],
 
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 

package/check-versions.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+
+import { readFileSync } from "fs";
+import { join } from "path";
+
+/**
+ * Compares two semver versions including pre-release identifiers
+ * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1: string, v2: string): number {
+  const parseVersion = (version: string) => {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+    if (!match) throw new Error(`Invalid version format: ${version}`);
+
+    const [, major, minor, patch, preRelease] = match;
+    if (!major || !minor || !patch)
+      throw new Error(`Invalid version format: ${version}`);
+    return {
+      major: parseInt(major),
+      minor: parseInt(minor),
+      patch: parseInt(patch),
+      preRelease: preRelease || null,
+    };
+  };
+
+  const v1Parts = parseVersion(v1);
+  const v2Parts = parseVersion(v2);
+
+  if (v1Parts.major !== v2Parts.major)
+    return v1Parts.major > v2Parts.major ? 1 : -1;
+  if (v1Parts.minor !== v2Parts.minor)
+    return v1Parts.minor > v2Parts.minor ? 1 : -1;
+  if (v1Parts.patch !== v2Parts.patch)
+    return v1Parts.patch > v2Parts.patch ? 1 : -1;
+
+  if (!v1Parts.preRelease && !v2Parts.preRelease) return 0;
+
+  if (!v1Parts.preRelease) return 1;
+  if (!v2Parts.preRelease) return -1;
+
+  const preReleasePriority: Record<string, number> = {
+    alpha: 1,
+    beta: 2,
+    rc: 3,
+    pre: 4,
+  };
+
+  const parsePreRelease = (pr: string) => {
+    const match = pr.match(/^([a-z]+)\.?(\d+)?$/);
+    if (!match) return { type: pr, num: 0 };
+    const type = match[1];
+    if (!type) return { type: pr, num: 0 };
+    return {
+      type,
+      num: match[2] ? parseInt(match[2]) : 0,
+    };
+  };
+
+  const pr1 = parsePreRelease(v1Parts.preRelease);
+  const pr2 = parsePreRelease(v2Parts.preRelease);
+
+  const priority1 = preReleasePriority[pr1.type] || 999;
+  const priority2 = preReleasePriority[pr2.type] || 999;
+
+  if (priority1 !== priority2) return priority1 > priority2 ? 1 : -1;
+  if (pr1.num !== pr2.num) return pr1.num > pr2.num ? 1 : -1;
+
+  return v1Parts.preRelease.localeCompare(v2Parts.preRelease);
+}
+
+async function checkVersions() {
+  try {
+    const packageJsonPath = join(process.cwd(), "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const localVersion = packageJson.version;
+
+    console.log("📦 Package: @tkeron/html-parser\n");
+    console.log("🏠 Local version:", localVersion);
+
+    const getDistTag = (version: string): string => {
+      if (!version.includes("-")) return "latest";
+
+      const preRelease = version.split("-")[1];
+      if (!preRelease) return "latest";
+      if (preRelease.startsWith("alpha")) return "alpha";
+      if (preRelease.startsWith("beta")) return "beta";
+      if (preRelease.startsWith("rc")) return "rc";
+      if (preRelease.startsWith("pre")) return "pre";
+
+      return "latest";
+    };
+
+    const distTag = getDistTag(localVersion);
+    console.log("🏷️  Comparing against tag:", distTag);
+
+    const response = await fetch(
+      "https://registry.npmjs.org/@tkeron/html-parser",
+    );
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const publishedVersion = data["dist-tags"][distTag];
+
+    if (!publishedVersion) {
+      console.log(`\n${"=".repeat(50)}`);
+      console.log(`ℹ️  No published version found for tag '${distTag}'`);
+      console.log("   → This will be the first version with this tag");
+      console.log("=".repeat(50));
+      process.exit(0);
+    }
+
+    console.log("📡 Published version:", publishedVersion);
+
+    const comparison = compareVersions(localVersion, publishedVersion);
+
+    console.log("\n" + "=".repeat(50));
+
+    if (comparison > 0) {
+      console.log("✅ NEW VERSION DETECTED");
+      console.log(`   ${localVersion} > ${publishedVersion}`);
+      console.log("   → Should publish to npm");
+      console.log("=".repeat(50));
+      process.exit(0);
+    } else if (comparison === 0) {
+      console.log("ℹ️  SAME VERSION");
+      console.log(`   ${localVersion} = ${publishedVersion}`);
+      console.log("   → No need to publish");
+      console.log("=".repeat(50));
+      process.exit(1);
+    } else {
+      console.log("⚠️  LOCAL VERSION IS OLDER");
+      console.log(`   ${localVersion} < ${publishedVersion}`);
+      console.log("   → Should not publish");
+      console.log("=".repeat(50));
+      process.exit(1);
+    }
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("❌ Error:", message);
+    process.exit(1);
+  }
+}
+
+checkVersions();

package/index.ts

@@ -1,17 +1,13 @@
-import { tokenize } from './src/tokenizer.js';
-import { parse } from './src/parser.js';
-import {
-  astToDOM,
-} from './src/dom-simulator.js';
+import { tokenize } from "./src/tokenizer/index.js";
+import { parse } from "./src/parser/index.js";
+import { astToDOM } from "./src/dom-simulator.js";
 
 export function parseHTML(html: string = ""): Document {
   const tokens = tokenize(html);
   const ast = parse(tokens);
   // If parse already returns a DOM document, return it directly
-  if (ast && typeof ast.nodeType === 'number' && ast.nodeType === 9) {
+  if (ast && typeof ast.nodeType === "number" && ast.nodeType === 9) {
     return ast;
   }
   return astToDOM(ast);
 }
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tkeron/html-parser",
-  "version": "1.1.2",
+  "version": "1.4.0",
   "description": "A fast and lightweight HTML parser for Bun",
   "main": "index.js",
   "module": "index.ts",
@@ -8,10 +8,12 @@
   "author": "tkeron",
   "license": "MIT",
   "scripts": {
-    "test": "bun test --concurrent"
+    "test": "bun test --concurrent",
+    "lint": "prettier --write ."
   },
   "devDependencies": {
-    "@types/bun": "^1.3.6"
+    "@types/bun": "^1.3.8",
+    "prettier": "^3.8.1"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"
@@ -25,8 +27,5 @@
   ],
   "repository": {
     "url": "git@github.com:tkeron/html-parser.git"
-  },
-  "dependencies": {
-    "all-named-html-entities": "^3.1.3"
   }
 }

package/src/dom-simulator/append-child.ts

@@ -0,0 +1,130 @@
+import { NodeType } from "./node-types.js";
+import { updateElementContent } from "./update-element-content.js";
+
+const removeChild = (parent: any, child: any): void => {
+  const index = parent.childNodes.indexOf(child);
+  if (index === -1) return;
+
+  parent.childNodes.splice(index, 1);
+
+  if (child.previousSibling) {
+    child.previousSibling.nextSibling = child.nextSibling;
+  }
+  if (child.nextSibling) {
+    child.nextSibling.previousSibling = child.previousSibling;
+  }
+
+  if (parent.firstChild === child) {
+    parent.firstChild = child.nextSibling;
+  }
+  if (parent.lastChild === child) {
+    parent.lastChild = child.previousSibling;
+  }
+
+  child.parentNode = null;
+  child.nextSibling = null;
+  child.previousSibling = null;
+
+  if (
+    parent.nodeType === NodeType.ELEMENT_NODE &&
+    child.nodeType === NodeType.ELEMENT_NODE
+  ) {
+    const parentElement = parent;
+    const childElement = child;
+
+    const elementIndex = parentElement.children.indexOf(childElement);
+    if (elementIndex !== -1) {
+      parentElement.children.splice(elementIndex, 1);
+
+      if (childElement.previousElementSibling) {
+        childElement.previousElementSibling.nextElementSibling =
+          childElement.nextElementSibling;
+      }
+      if (childElement.nextElementSibling) {
+        childElement.nextElementSibling.previousElementSibling =
+          childElement.previousElementSibling;
+      }
+
+      if (parentElement.firstElementChild === childElement) {
+        parentElement.firstElementChild = childElement.nextElementSibling;
+      }
+      if (parentElement.lastElementChild === childElement) {
+        parentElement.lastElementChild = childElement.previousElementSibling;
+      }
+
+      childElement.parentElement = null;
+      childElement.nextElementSibling = null;
+      childElement.previousElementSibling = null;
+    }
+  }
+
+  if (parent.nodeType === NodeType.ELEMENT_NODE) {
+    updateElementContent(parent);
+  }
+};
+
+export const appendChild = (parent: any, child: any): void => {
+  if (
+    child.nodeType === NodeType.ELEMENT_NODE ||
+    child.nodeType === NodeType.DOCUMENT_NODE
+  ) {
+    let ancestor = parent;
+    while (ancestor) {
+      if (ancestor === child) {
+        throw new Error(
+          "HierarchyRequestError: Cannot insert a node as a descendant of itself",
+        );
+      }
+      ancestor = ancestor.parentNode;
+    }
+  }
+
+  if (child.parentNode) {
+    removeChild(child.parentNode, child);
+  }
+
+  child.parentNode = parent;
+  parent.childNodes.push(child);
+
+  if (parent.childNodes.length > 1) {
+    const previousSibling = parent.childNodes[parent.childNodes.length - 2];
+    if (previousSibling) {
+      previousSibling.nextSibling = child;
+      child.previousSibling = previousSibling;
+    }
+  }
+
+  if (parent.childNodes.length === 1) {
+    parent.firstChild = child;
+  }
+  parent.lastChild = child;
+
+  if (
+    parent.nodeType === NodeType.ELEMENT_NODE &&
+    child.nodeType === NodeType.ELEMENT_NODE
+  ) {
+    const parentElement = parent;
+    const childElement = child;
+
+    childElement.parentElement = parentElement;
+    parentElement.children.push(childElement);
+
+    if (parentElement.children.length === 1) {
+      parentElement.firstElementChild = childElement;
+    }
+    parentElement.lastElementChild = childElement;
+
+    if (parentElement.children.length > 1) {
+      const previousElementSibling =
+        parentElement.children[parentElement.children.length - 2];
+      if (previousElementSibling) {
+        previousElementSibling.nextElementSibling = childElement;
+        childElement.previousElementSibling = previousElementSibling;
+      }
+    }
+  }
+
+  if (parent.nodeType === NodeType.ELEMENT_NODE) {
+    updateElementContent(parent);
+  }
+};

package/src/dom-simulator/append.ts

@@ -0,0 +1,18 @@
+import { createTextNode } from "./create-text-node.js";
+import { appendChild } from "./append-child.js";
+
+export const 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);
+  }
+};

package/src/dom-simulator/attributes.ts

@@ -0,0 +1,23 @@
+import { updateElementContent } from "./update-element-content.js";
+
+export const getAttribute = (element: any, name: string): string | null => {
+  return element.attributes[name] || null;
+};
+
+export const hasAttribute = (element: any, name: string): boolean => {
+  return name in element.attributes;
+};
+
+export const setAttribute = (
+  element: any,
+  name: string,
+  value: string,
+): void => {
+  element.attributes[name] = value;
+  updateElementContent(element);
+};
+
+export const removeAttribute = (element: any, name: string): void => {
+  delete element.attributes[name];
+  updateElementContent(element);
+};

package/src/dom-simulator/clone-node.ts

@@ -0,0 +1,51 @@
+import { NodeType } from "./node-types.js";
+import { createElement } from "./index.js";
+
+const cloneNode = (node: any, deep: boolean = false): any => {
+  if (node.nodeType === NodeType.ELEMENT_NODE) {
+    const cloned = createElement(node.tagName, node.attributes);
+
+    if (deep) {
+      for (const child of node.childNodes) {
+        const clonedChild = cloneNode(child, true);
+        cloned.appendChild(clonedChild);
+      }
+    }
+
+    return cloned;
+  } else if (node.nodeType === NodeType.TEXT_NODE) {
+    return {
+      nodeType: NodeType.TEXT_NODE,
+      textContent: node.textContent,
+      parentNode: null,
+      parentElement: null,
+      previousSibling: null,
+      nextSibling: null,
+    };
+  } else if (node.nodeType === NodeType.COMMENT_NODE) {
+    return {
+      nodeType: NodeType.COMMENT_NODE,
+      data: node.data,
+      textContent: node.textContent,
+      parentNode: null,
+      parentElement: null,
+      previousSibling: null,
+      nextSibling: null,
+    };
+  } else if (node.nodeType === NodeType.DOCUMENT_TYPE_NODE) {
+    return {
+      nodeType: NodeType.DOCUMENT_TYPE_NODE,
+      name: node.name,
+      publicId: node.publicId,
+      systemId: node.systemId,
+      parentNode: null,
+      parentElement: null,
+      previousSibling: null,
+      nextSibling: null,
+    };
+  } else {
+    throw new Error(`Unsupported node type: ${node.nodeType}`);
+  }
+};
+
+export { cloneNode };

package/src/dom-simulator/convert-ast-node-to-dom.ts

@@ -0,0 +1,37 @@
+import type { ASTNode } from "../parser/index";
+import { createElement } from "./create-element.js";
+import { createTextNode } from "./create-text-node.js";
+import { createComment } from "./create-comment.js";
+import { appendChild } from "./append-child.js";
+import { updateElementContent } from "./update-element-content.js";
+
+export const convertASTNodeToDOM = (astNode: ASTNode): any => {
+  switch (astNode.type) {
+    case "ELEMENT":
+      const tagName = astNode.tagName || "div";
+      const element = createElement(tagName, astNode.attributes || {});
+
+      if (astNode.children) {
+        for (const child of astNode.children) {
+          const domChild = convertASTNodeToDOM(child);
+          if (domChild) {
+            appendChild(element, domChild);
+          }
+        }
+      }
+
+      updateElementContent(element);
+      return element;
+    case "TEXT":
+      return createTextNode(astNode.content || "");
+    case "COMMENT":
+      return createComment(astNode.content || "");
+    case "CDATA":
+      return createTextNode(astNode.content || "");
+    case "DOCTYPE":
+    case "PROCESSING_INSTRUCTION":
+      return null;
+    default:
+      return null;
+  }
+};

package/src/dom-simulator/create-cdata.ts

@@ -0,0 +1,18 @@
+import { NodeType } from "./node-types.js";
+
+export const createCDATA = (content: string): any => {
+  const cdataNode: any = {
+    nodeType: NodeType.CDATA_SECTION_NODE,
+    nodeName: "#cdata-section",
+    nodeValue: content,
+    textContent: content,
+    data: content,
+    childNodes: [],
+    parentNode: null,
+    firstChild: null,
+    lastChild: null,
+    nextSibling: null,
+    previousSibling: null,
+  };
+  return cdataNode;
+};

package/src/dom-simulator/create-comment.ts

@@ -0,0 +1,23 @@
+import { NodeType } from "./node-types.js";
+import { remove } from "./index.js";
+
+export const createComment = (content: string): any => {
+  const commentNode: any = {
+    nodeType: NodeType.COMMENT_NODE,
+    nodeName: "#comment",
+    nodeValue: content,
+    textContent: content,
+    data: content,
+    childNodes: [],
+    parentNode: null,
+    firstChild: null,
+    lastChild: null,
+    nextSibling: null,
+    previousSibling: null,
+
+    remove(): void {
+      remove(commentNode);
+    },
+  };
+  return commentNode;
+};

package/src/dom-simulator/create-doctype.ts

@@ -0,0 +1,24 @@
+import { NodeType } from "./node-types.js";
+
+export const createDoctype = (
+  name: string = "html",
+  publicId?: string,
+  systemId?: string,
+): any => {
+  const doctypeNode: any = {
+    nodeType: NodeType.DOCUMENT_TYPE_NODE,
+    nodeName: name.toUpperCase(),
+    name: name.toLowerCase(),
+    nodeValue: null,
+    textContent: "",
+    publicId: publicId || null,
+    systemId: systemId || null,
+    childNodes: [],
+    parentNode: null,
+    firstChild: null,
+    lastChild: null,
+    nextSibling: null,
+    previousSibling: null,
+  };
+  return doctypeNode;
+};