@tkeron/html-parser 1.1.2 → 1.3.0

package/src/parser/types.ts

@@ -0,0 +1,56 @@
+import type { Token } from "../tokenizer/index.js";
+
+export interface ParserState {
+  tokens: Token[];
+  position: number;
+  length: number;
+  stack: any[];
+  root: any;
+  insertionMode: InsertionMode;
+  errors: ParseError[];
+  explicitHead?: boolean;
+  activeFormattingElements: any[];
+  formElementPointer?: any;
+}
+
+export interface ParseError {
+  message: string;
+  position: number;
+  line: number;
+  column: number;
+  severity: "error" | "warning";
+}
+
+export enum InsertionMode {
+  Initial = "initial",
+  BeforeHtml = "beforeHtml",
+  BeforeHead = "beforeHead",
+  InHead = "inHead",
+  AfterHead = "afterHead",
+  InBody = "inBody",
+}
+
+export enum ASTNodeType {
+  Document = "document",
+  Element = "element",
+  Text = "text",
+  Comment = "comment",
+  Doctype = "doctype",
+  CDATA = "cdata",
+}
+
+export interface ASTNode {
+  type: ASTNodeType;
+  tagName?: string;
+  value?: string;
+  attributes?: Record<string, string>;
+  children?: ASTNode[];
+  isSelfClosing?: boolean;
+  content?: string;
+  name?: string;
+  publicId?: string;
+  systemId?: string;
+  namespaceURI?: string;
+  target?: string;
+  data?: string;
+}

package/src/selectors/find-elements-descendant.ts

@@ -0,0 +1,47 @@
+import type { SelectorGroup } from "./types.js";
+import { matchesSelector } from "./matches-selector.js";
+
+export const 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);
+    }
+  }
+};

package/src/selectors/index.ts

@@ -0,0 +1,2 @@
+export { querySelectorAll } from "./query-selector-all.ts";
+export { querySelector } from "./query-selector.ts";

package/src/selectors/matches-selector.ts

@@ -0,0 +1,12 @@
+import type { SelectorToken } from "./types.js";
+import { matchesToken } from "./matches-token.js";
+
+export const matchesSelector = (
+  element: any,
+  tokens: SelectorToken[],
+): boolean => {
+  if (tokens.length === 0) {
+    return true;
+  }
+  return tokens.every((token) => matchesToken(element, token));
+};

package/src/selectors/matches-token.ts

@@ -0,0 +1,27 @@
+import type { SelectorToken } from "./types.js";
+
+export const 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;
+  }
+};

package/src/selectors/parse-selector.ts

@@ -0,0 +1,48 @@
+import type { SelectorGroup, SelectorToken } from "./types.js";
+
+export const parseSelector = (selector: string): SelectorGroup[] => {
+  const parts = selector.trim().split(/\s+/);
+
+  return parts.map((part) => {
+    const trimmed = part.trim();
+    let tokens: SelectorToken[] = [];
+
+    if (trimmed === "*") {
+      return { tokens: [] };
+    }
+
+    let remaining = trimmed;
+
+    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);
+    }
+
+    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, "");
+
+    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, "");
+
+    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 };
+  });
+};

package/src/selectors/query-selector-all.ts

@@ -0,0 +1,43 @@
+import type { SelectorGroup, SelectorToken } from "./types.js";
+import { parseSelector } from "./parse-selector.js";
+import { matchesSelector } from "./matches-selector.js";
+import { findElementsDescendant } from "./find-elements-descendant.js";
+
+const 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);
+  }
+};
+
+const 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);
+  }
+};
+
+export const querySelectorAll = (root: any, selector: string): any[] => {
+  const selectorGroups = parseSelector(selector);
+  const results: any[] = [];
+  findElements(root, selectorGroups, results);
+  return results;
+};

package/src/selectors/query-selector.ts

@@ -0,0 +1,6 @@
+import { querySelectorAll } from "./query-selector-all.js";
+
+export const querySelector = (root: any, selector: string): any | null => {
+  const results = querySelectorAll(root, selector);
+  return results[0] || null;
+};

package/src/selectors/types.ts

@@ -0,0 +1,10 @@
+export interface SelectorToken {
+  type: "tag" | "class" | "id" | "attribute";
+  value: string;
+  attributeName?: string;
+  attributeValue?: string;
+}
+
+export interface SelectorGroup {
+  tokens: SelectorToken[];
+}

package/src/serializer/attributes.ts

@@ -0,0 +1,74 @@
+export const needsQuotes = (value: string): boolean => {
+  return value === "" || /[\t\n\r\f "'=`>]/.test(value);
+};
+
+export const serializeAttribute = (
+  name: string,
+  value: string,
+  options?: {
+    quote_char?: string;
+    quote_attr_values?: boolean;
+    minimize_boolean_attributes?: boolean;
+    escape_lt_in_attrs?: boolean;
+    escape_rcdata?: boolean;
+  },
+): string => {
+  if (options?.minimize_boolean_attributes !== false && value === name) {
+    return name;
+  }
+  const needsQuote =
+    needsQuotes(value) || options?.quote_attr_values || !!options?.quote_char;
+  if (!needsQuote) {
+    let escaped = value.replace(/&/g, "&");
+    if (options?.escape_lt_in_attrs) {
+      escaped = escaped.replace(/</g, "&lt;");
+    }
+    return `${name}=${escaped}`;
+  }
+  let escaped = value.replace(/&/g, "&amp;");
+  if (options?.escape_lt_in_attrs) {
+    escaped = escaped.replace(/</g, "&lt;");
+  }
+  const forcedQuote = options?.quote_char;
+  if (forcedQuote) {
+    if (forcedQuote === "'") {
+      escaped = escaped.replace(/'/g, "&#39;");
+    } else {
+      escaped = escaped.replace(/"/g, "&quot;");
+    }
+    return `${name}=${forcedQuote}${escaped}${forcedQuote}`;
+  } else {
+    if (value.includes('"') && value.includes("'")) {
+      escaped = escaped.replace(/"/g, "&quot;");
+      return `${name}="${escaped}"`;
+    } else if (value.includes('"')) {
+      return `${name}='${escaped}'`;
+    } else {
+      escaped = escaped.replace(/"/g, "&quot;");
+      return `${name}="${escaped}"`;
+    }
+  }
+};
+
+export const serializeAttributes = (
+  attrs: any,
+  options?: {
+    quote_char?: string;
+    quote_attr_values?: boolean;
+    minimize_boolean_attributes?: boolean;
+    escape_lt_in_attrs?: boolean;
+    use_trailing_solidus?: boolean;
+    escape_rcdata?: boolean;
+  },
+): string => {
+  let attrList: [string, string][];
+  if (Array.isArray(attrs)) {
+    attrList = attrs.map((attr: any) => [attr.name, attr.value]);
+  } else {
+    attrList = attrs ? Object.entries(attrs) : [];
+  }
+  attrList.sort(([a], [b]) => a.localeCompare(b));
+  return attrList
+    .map(([name, value]) => " " + serializeAttribute(name, value, options))
+    .join("");
+};

package/src/serializer/escape.ts

@@ -0,0 +1,13 @@
+export const escapeText = (text: string): string => {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+};
+
+export const escapeAttributeValue = (value: string): string => {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+};

package/src/serializer/index.ts

@@ -0,0 +1 @@
+export { serializeTokens } from "./serialize-tokens.js";