@tkeron/html-parser 1.1.2 → 1.4.0

package/src/index.ts

@@ -1,9 +1,9 @@
-import { tokenize } from './tokenizer.js';
-import { parse } from './parser.js';
+import { tokenize } from "./tokenizer/index.js";
+import { parse } from "./parser/index.js";
 
-export function parseHTML(html: string): any {
+export const parseHTML = (html: string): any => {
   const tokens = tokenize(html);
   return parse(tokens);
-}
+};
 
-export { parse } from './parser';
+export { parse } from "./parser/index.js";

package/src/parser/adoption-agency-helpers.ts

@@ -0,0 +1,145 @@
+import { createElement } from "../dom-simulator/index.js";
+
+const SPECIAL_ELEMENTS = new Set([
+  "address",
+  "applet",
+  "area",
+  "article",
+  "aside",
+  "base",
+  "basefont",
+  "bgsound",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "caption",
+  "center",
+  "col",
+  "colgroup",
+  "dd",
+  "details",
+  "dir",
+  "div",
+  "dl",
+  "dt",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "frame",
+  "frameset",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "iframe",
+  "img",
+  "input",
+  "li",
+  "link",
+  "listing",
+  "main",
+  "marquee",
+  "menu",
+  "meta",
+  "nav",
+  "noembed",
+  "noframes",
+  "noscript",
+  "object",
+  "ol",
+  "p",
+  "param",
+  "plaintext",
+  "pre",
+  "script",
+  "section",
+  "select",
+  "source",
+  "style",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "track",
+  "ul",
+  "wbr",
+  "xmp",
+]);
+
+type StackSearchResult = {
+  element: any;
+  index: number;
+};
+
+export const findFormattingElementInStack = (
+  stack: any[],
+  tagName: string,
+): StackSearchResult | null => {
+  const lowerTagName = tagName.toLowerCase();
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const element = stack[i];
+    if (element.tagName && element.tagName.toLowerCase() === lowerTagName) {
+      return { element, index: i };
+    }
+  }
+  return null;
+};
+
+export const findFurthestBlock = (
+  stack: any[],
+  formattingElementIndex: number,
+): StackSearchResult | null => {
+  for (let i = formattingElementIndex + 1; i < stack.length; i++) {
+    const element = stack[i];
+    if (isSpecialElement(element.tagName)) {
+      return { element, index: i };
+    }
+  }
+  return null;
+};
+
+export const getCommonAncestor = (
+  stack: any[],
+  formattingElementIndex: number,
+): any | null => {
+  if (formattingElementIndex <= 0) {
+    return null;
+  }
+  return stack[formattingElementIndex - 1];
+};
+
+export const isSpecialElement = (tagName: string): boolean => {
+  if (!tagName) return false;
+  return SPECIAL_ELEMENTS.has(tagName.toLowerCase());
+};
+
+export const cloneFormattingElement = (element: any): any => {
+  const attributes = element.attributes ? { ...element.attributes } : {};
+  return createElement(element.tagName.toLowerCase(), attributes);
+};
+
+export const reparentChildren = (source: any, target: any): void => {
+  while (source.childNodes.length > 0) {
+    const child = source.childNodes.shift();
+    child.parentNode = target;
+    target.childNodes.push(child);
+  }
+};

package/src/parser/constants.ts

@@ -0,0 +1,137 @@
+export const VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr",
+]);
+
+export const RAW_TEXT_ELEMENTS = new Set([
+  "script",
+  "style",
+  "textarea",
+  "title",
+]);
+
+export const AUTO_CLOSE_RULES: Record<string, string[]> = {
+  li: ["li"],
+  dt: ["dt", "dd"],
+  dd: ["dt", "dd"],
+  address: ["p"],
+  article: ["p"],
+  aside: ["p"],
+  blockquote: ["p"],
+  center: ["p"],
+  details: ["p"],
+  dialog: ["p"],
+  dir: ["p"],
+  div: ["p"],
+  dl: ["p"],
+  fieldset: ["p"],
+  figcaption: ["p"],
+  figure: ["p"],
+  footer: ["p"],
+  form: ["p"],
+  h1: ["p"],
+  h2: ["p"],
+  h3: ["p"],
+  h4: ["p"],
+  h5: ["p"],
+  h6: ["p"],
+  header: ["p"],
+  hgroup: ["p"],
+  hr: ["p"],
+  listing: ["p"],
+  main: ["p"],
+  menu: ["p"],
+  nav: ["p"],
+  ol: ["p"],
+  p: ["p"],
+  pre: ["p"],
+  section: ["p"],
+  summary: ["p"],
+  table: ["p"],
+  ul: ["p"],
+  rt: ["rt", "rp"],
+  rp: ["rt", "rp"],
+  optgroup: ["optgroup"],
+  option: ["option"],
+  thead: ["tbody", "tfoot"],
+  tbody: ["thead", "tbody", "tfoot"],
+  tfoot: ["thead", "tbody"],
+  tr: ["tr"],
+  td: ["td", "th"],
+  th: ["td", "th"],
+};
+
+export const FORMATTING_ELEMENTS = new Set([
+  "a",
+  "b",
+  "big",
+  "code",
+  "em",
+  "font",
+  "i",
+  "nobr",
+  "s",
+  "small",
+  "strike",
+  "strong",
+  "tt",
+  "u",
+]);
+
+export const TABLE_SCOPE_ELEMENTS = new Set([
+  "table",
+  "tbody",
+  "thead",
+  "tfoot",
+  "tr",
+  "template",
+  "html",
+]);
+
+export const TABLE_CONTEXT_ELEMENTS = new Set([
+  "table",
+  "tbody",
+  "thead",
+  "tfoot",
+  "tr",
+]);
+
+export const VALID_TABLE_CHILDREN = new Set([
+  "caption",
+  "colgroup",
+  "col",
+  "tbody",
+  "thead",
+  "tfoot",
+  "tr",
+  "script",
+  "template",
+  "style",
+]);
+
+export const VALID_TABLE_SECTION_CHILDREN = new Set([
+  "tr",
+  "script",
+  "template",
+  "style",
+]);
+
+export const VALID_TR_CHILDREN = new Set([
+  "td",
+  "th",
+  "script",
+  "template",
+  "style",
+]);

package/src/parser/dom-to-ast.ts

@@ -0,0 +1,79 @@
+import type { ASTNode } from "./types.js";
+import { ASTNodeType } from "./types.js";
+
+export const domToAST = (dom: any): ASTNode => {
+  if (!dom) {
+    return {
+      type: ASTNodeType.Document,
+      children: [],
+    };
+  }
+
+  if (dom.nodeType === 9) {
+    return {
+      type: ASTNodeType.Document,
+      children: dom.childNodes ? dom.childNodes.map(domToAST) : [],
+    };
+  }
+
+  if (dom.nodeType === 1) {
+    const attributes: Record<string, string> = {};
+    if (dom.attributes) {
+      for (const [name, value] of Object.entries(dom.attributes)) {
+        attributes[name] = value;
+      }
+    }
+
+    return {
+      type: ASTNodeType.Element,
+      tagName: dom.tagName.toLowerCase(),
+      attributes,
+      children: dom.childNodes ? dom.childNodes.map(domToAST) : [],
+      namespaceURI: dom.namespaceURI,
+      isSelfClosing: dom.isSelfClosing || false,
+    };
+  }
+
+  if (dom.nodeType === 3) {
+    return {
+      type: ASTNodeType.Text,
+      content: dom.textContent || "",
+    };
+  }
+
+  if (dom.nodeType === 8) {
+    return {
+      type: ASTNodeType.Comment,
+      content: (dom.data as string) || "",
+    };
+  }
+
+  if (dom.nodeType === 10) {
+    return {
+      type: ASTNodeType.Doctype,
+      name: dom.name || "html",
+      publicId: dom.publicId || "",
+      systemId: dom.systemId || "",
+      content: dom.name || "html",
+    };
+  }
+
+  if (dom.nodeType === 4) {
+    return {
+      type: ASTNodeType.CDATA,
+      content: dom.textContent || "",
+    };
+  }
+
+  if (dom.nodeType === 7) {
+    return {
+      type: "processing-instruction" as any,
+      content: dom.data || dom.textContent || "",
+    };
+  }
+
+  return {
+    type: ASTNodeType.Text,
+    content: "",
+  };
+};

package/src/parser/foster-parenting-helpers.ts

@@ -0,0 +1,48 @@
+export const mergeAdjacentTextNodes = (
+  parent: any,
+  insertIndex: number,
+): void => {
+  if (!parent.childNodes || parent.childNodes.length < 2) {
+    return;
+  }
+
+  const node = parent.childNodes[insertIndex];
+  if (!node || node.nodeType !== 3) {
+    return;
+  }
+
+  if (insertIndex > 0) {
+    const prevNode = parent.childNodes[insertIndex - 1];
+    if (prevNode && prevNode.nodeType === 3) {
+      prevNode.textContent =
+        (prevNode.textContent || "") + (node.textContent || "");
+      prevNode.nodeValue = prevNode.textContent;
+      parent.childNodes.splice(insertIndex, 1);
+      return;
+    }
+  }
+
+  if (insertIndex < parent.childNodes.length - 1) {
+    const nextNode = parent.childNodes[insertIndex + 1];
+    if (nextNode && nextNode.nodeType === 3) {
+      node.textContent =
+        (node.textContent || "") + (nextNode.textContent || "");
+      node.nodeValue = node.textContent;
+      parent.childNodes.splice(insertIndex + 1, 1);
+    }
+  }
+};
+
+export const insertNodeBeforeTable = (
+  parent: any,
+  tableElement: any,
+  node: any,
+): number => {
+  const idx = parent.childNodes.indexOf(tableElement);
+  if (idx !== -1) {
+    node.parentNode = parent;
+    parent.childNodes.splice(idx, 0, node);
+    return idx;
+  }
+  return -1;
+};

package/src/parser/implicit-table-structure.ts

@@ -0,0 +1,65 @@
+import { createElement, appendChild } from "../dom-simulator/index.js";
+
+export const CELL_ELEMENTS = new Set(["td", "th"]);
+
+export const TABLE_SECTION_ELEMENTS = new Set(["tbody", "thead", "tfoot"]);
+
+export const shouldCreateImplicitTableStructure = (
+  parentTagName: string,
+  childTagName: string,
+): boolean => {
+  const parent = parentTagName.toLowerCase();
+  const child = childTagName.toLowerCase();
+
+  if (CELL_ELEMENTS.has(child)) {
+    return parent === "table" || TABLE_SECTION_ELEMENTS.has(parent);
+  }
+
+  if (child === "tr") {
+    return parent === "table";
+  }
+
+  return false;
+};
+
+export const createImplicitTableStructure = (
+  stack: any[],
+  parentTagName: string,
+  childTagName: string,
+): any => {
+  const parent = parentTagName.toLowerCase();
+  const child = childTagName.toLowerCase();
+  const currentParent = stack[stack.length - 1];
+
+  if (CELL_ELEMENTS.has(child)) {
+    if (parent === "table") {
+      const tbody = createElement("tbody", {});
+      appendChild(currentParent, tbody);
+      stack.push(tbody);
+
+      const tr = createElement("tr", {});
+      appendChild(tbody, tr);
+      stack.push(tr);
+
+      return tr;
+    }
+
+    if (TABLE_SECTION_ELEMENTS.has(parent)) {
+      const tr = createElement("tr", {});
+      appendChild(currentParent, tr);
+      stack.push(tr);
+
+      return tr;
+    }
+  }
+
+  if (child === "tr" && parent === "table") {
+    const tbody = createElement("tbody", {});
+    appendChild(currentParent, tbody);
+    stack.push(tbody);
+
+    return tbody;
+  }
+
+  return currentParent;
+};

package/src/parser/index.ts

@@ -0,0 +1,9 @@
+export { parse } from "./parse";
+export { domToAST } from "./dom-to-ast";
+export type { ParserState, ParseError, InsertionMode, ASTNode } from "./types";
+export { ASTNodeType } from "./types";
+export {
+  VOID_ELEMENTS,
+  RAW_TEXT_ELEMENTS,
+  AUTO_CLOSE_RULES,
+} from "./constants";