@tkeron/html-parser 1.1.2 → 1.3.0

package/src/dom-simulator/insert-before.ts

@@ -0,0 +1,108 @@
+import { NodeType } from "./node-types.js";
+import { appendChild } from "./append-child.js";
+import { removeChild } from "./remove-child.js";
+import { updateElementContent } from "./update-element-content.js";
+
+export const insertBefore = (
+  parent: any,
+  newNode: any,
+  referenceNode: any,
+): any => {
+  if (referenceNode === null) {
+    appendChild(parent, newNode);
+    return newNode;
+  }
+
+  const refIndex = parent.childNodes.indexOf(referenceNode);
+  if (refIndex === -1) {
+    throw new Error("Reference node is not a child of this node");
+  }
+
+  if (
+    newNode.nodeType === NodeType.ELEMENT_NODE ||
+    newNode.nodeType === NodeType.DOCUMENT_NODE
+  ) {
+    let ancestor = parent;
+    while (ancestor) {
+      if (ancestor === newNode) {
+        throw new Error(
+          "HierarchyRequestError: Cannot insert a node as a descendant of itself",
+        );
+      }
+      ancestor = ancestor.parentNode;
+    }
+  }
+
+  if (newNode.parentNode) {
+    removeChild(newNode.parentNode, newNode);
+  }
+
+  parent.childNodes.splice(refIndex, 0, newNode);
+  newNode.parentNode = parent;
+
+  newNode.previousSibling = referenceNode.previousSibling;
+  newNode.nextSibling = referenceNode;
+
+  if (referenceNode.previousSibling) {
+    referenceNode.previousSibling.nextSibling = newNode;
+  }
+  referenceNode.previousSibling = newNode;
+
+  if (parent.firstChild === referenceNode) {
+    parent.firstChild = newNode;
+  }
+
+  if (
+    parent.nodeType === NodeType.ELEMENT_NODE &&
+    newNode.nodeType === NodeType.ELEMENT_NODE
+  ) {
+    const parentElement = parent;
+    const newElement = newNode;
+
+    newElement.parentElement = parentElement;
+
+    let refElementIndex = -1;
+    if (referenceNode.nodeType === NodeType.ELEMENT_NODE) {
+      refElementIndex = parentElement.children.indexOf(referenceNode);
+    } else {
+      let nextElement = referenceNode.nextSibling;
+      while (nextElement && nextElement.nodeType !== NodeType.ELEMENT_NODE) {
+        nextElement = nextElement.nextSibling;
+      }
+      if (nextElement) {
+        refElementIndex = parentElement.children.indexOf(nextElement);
+      }
+    }
+
+    if (refElementIndex === -1) {
+      parentElement.children.push(newElement);
+    } else {
+      parentElement.children.splice(refElementIndex, 0, newElement);
+    }
+
+    const newElemIndex = parentElement.children.indexOf(newElement);
+    newElement.previousElementSibling =
+      newElemIndex > 0 ? parentElement.children[newElemIndex - 1] : null;
+    newElement.nextElementSibling =
+      newElemIndex < parentElement.children.length - 1
+        ? parentElement.children[newElemIndex + 1]
+        : null;
+
+    if (newElement.previousElementSibling) {
+      newElement.previousElementSibling.nextElementSibling = newElement;
+    }
+    if (newElement.nextElementSibling) {
+      newElement.nextElementSibling.previousElementSibling = newElement;
+    }
+
+    if (newElemIndex === 0) {
+      parentElement.firstElementChild = newElement;
+    }
+  }
+
+  if (parent.nodeType === NodeType.ELEMENT_NODE) {
+    updateElementContent(parent);
+  }
+
+  return newNode;
+};

package/src/dom-simulator/matches.ts

@@ -0,0 +1,26 @@
+import { NodeType } from "./node-types.js";
+import { querySelectorAll as querySelectorAllFunction } from "../selectors";
+import { createTempParent } from "./create-temp-parent.js";
+
+export const matches = (element: any, selector: string): boolean => {
+  if (!selector || element.nodeType !== NodeType.ELEMENT_NODE) {
+    return false;
+  }
+
+  try {
+    if (selector.includes(" ") || selector.includes(">")) {
+      let root = element;
+      while (root.parentNode) {
+        root = root.parentNode;
+      }
+      const results = querySelectorAllFunction(root, selector);
+      return results.includes(element);
+    }
+
+    const parent = element.parentNode || createTempParent(element);
+    const results = querySelectorAllFunction(parent, selector);
+    return results.includes(element);
+  } catch (error) {
+    return false;
+  }
+};

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

@@ -0,0 +1,26 @@
+export const enum NodeType {
+  ELEMENT_NODE = 1,
+  TEXT_NODE = 3,
+  COMMENT_NODE = 8,
+  DOCUMENT_NODE = 9,
+  DOCUMENT_TYPE_NODE = 10,
+  PROCESSING_INSTRUCTION_NODE = 7,
+  CDATA_SECTION_NODE = 4,
+}
+
+export const VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr",
+]);

package/src/dom-simulator/prepend.ts

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

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

@@ -0,0 +1,68 @@
+import { NodeType } from "./node-types.js";
+import { updateElementContent } from "./update-element-content.js";
+
+export const removeChild = (parent: any, child: any): any => {
+  const index = parent.childNodes.indexOf(child);
+  if (index === -1) {
+    throw new Error("Child not found");
+  }
+
+  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;
+  }
+
+  if (
+    parent.nodeType === NodeType.ELEMENT_NODE &&
+    child.nodeType === NodeType.ELEMENT_NODE
+  ) {
+    const childElement = child;
+    const elemIndex = parent.children.indexOf(childElement);
+    if (elemIndex !== -1) {
+      parent.children.splice(elemIndex, 1);
+
+      if (childElement.previousElementSibling) {
+        childElement.previousElementSibling.nextElementSibling =
+          childElement.nextElementSibling;
+      }
+      if (childElement.nextElementSibling) {
+        childElement.nextElementSibling.previousElementSibling =
+          childElement.previousElementSibling;
+      }
+
+      if (parent.firstElementChild === childElement) {
+        parent.firstElementChild = childElement.nextElementSibling;
+      }
+      if (parent.lastElementChild === childElement) {
+        parent.lastElementChild = childElement.previousElementSibling;
+      }
+    }
+  }
+
+  child.parentNode = null;
+  if (child.nodeType === NodeType.ELEMENT_NODE) {
+    child.parentElement = null;
+  }
+  child.previousSibling = null;
+  child.nextSibling = null;
+  if (child.nodeType === NodeType.ELEMENT_NODE) {
+    child.previousElementSibling = null;
+    child.nextElementSibling = null;
+  }
+
+  if (parent.nodeType === NodeType.ELEMENT_NODE) {
+    updateElementContent(parent);
+  }
+  return child;
+};

package/src/dom-simulator/remove.ts

@@ -0,0 +1,7 @@
+import { removeChild } from "./remove-child.js";
+
+export const remove = (node: any): void => {
+  if (node.parentNode) {
+    removeChild(node.parentNode, node);
+  }
+};

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

@@ -0,0 +1,152 @@
+import { NodeType } from "./node-types.js";
+import { removeChild } from "./remove-child.js";
+import { updateElementContent } from "./update-element-content.js";
+
+export const replaceChild = (
+  parent: any,
+  newChild: any,
+  oldChild: any,
+): any => {
+  const oldIndex = parent.childNodes.indexOf(oldChild);
+  if (oldIndex === -1) {
+    throw new Error("Old child is not a child of this node");
+  }
+
+  if (
+    newChild.nodeType === NodeType.ELEMENT_NODE ||
+    newChild.nodeType === NodeType.DOCUMENT_NODE
+  ) {
+    let ancestor = parent;
+    while (ancestor) {
+      if (ancestor === newChild) {
+        throw new Error(
+          "HierarchyRequestError: Cannot insert a node as a descendant of itself",
+        );
+      }
+      ancestor = ancestor.parentNode;
+    }
+  }
+
+  if (newChild.parentNode) {
+    removeChild(newChild.parentNode, newChild);
+  }
+
+  parent.childNodes[oldIndex] = newChild;
+  newChild.parentNode = parent;
+
+  newChild.previousSibling = oldChild.previousSibling;
+  newChild.nextSibling = oldChild.nextSibling;
+
+  if (oldChild.previousSibling) {
+    oldChild.previousSibling.nextSibling = newChild;
+  }
+  if (oldChild.nextSibling) {
+    oldChild.nextSibling.previousSibling = newChild;
+  }
+
+  if (parent.firstChild === oldChild) {
+    parent.firstChild = newChild;
+  }
+  if (parent.lastChild === oldChild) {
+    parent.lastChild = newChild;
+  }
+
+  if (parent.nodeType === NodeType.ELEMENT_NODE) {
+    const parentElement = parent;
+
+    if (oldChild.nodeType === NodeType.ELEMENT_NODE) {
+      const oldElemIndex = parentElement.children.indexOf(oldChild);
+      if (oldElemIndex !== -1) {
+        if (newChild.nodeType === NodeType.ELEMENT_NODE) {
+          parentElement.children[oldElemIndex] = newChild;
+          newChild.parentElement = parentElement;
+
+          newChild.previousElementSibling = oldChild.previousElementSibling;
+          newChild.nextElementSibling = oldChild.nextElementSibling;
+
+          if (oldChild.previousElementSibling) {
+            oldChild.previousElementSibling.nextElementSibling = newChild;
+          }
+          if (oldChild.nextElementSibling) {
+            oldChild.nextElementSibling.previousElementSibling = newChild;
+          }
+
+          if (parentElement.firstElementChild === oldChild) {
+            parentElement.firstElementChild = newChild;
+          }
+          if (parentElement.lastElementChild === oldChild) {
+            parentElement.lastElementChild = newChild;
+          }
+        } else {
+          parentElement.children.splice(oldElemIndex, 1);
+
+          if (oldChild.previousElementSibling) {
+            oldChild.previousElementSibling.nextElementSibling =
+              oldChild.nextElementSibling;
+          }
+          if (oldChild.nextElementSibling) {
+            oldChild.nextElementSibling.previousElementSibling =
+              oldChild.previousElementSibling;
+          }
+
+          if (parentElement.firstElementChild === oldChild) {
+            parentElement.firstElementChild = oldChild.nextElementSibling;
+          }
+          if (parentElement.lastElementChild === oldChild) {
+            parentElement.lastElementChild = oldChild.previousElementSibling;
+          }
+        }
+      }
+    } else if (newChild.nodeType === NodeType.ELEMENT_NODE) {
+      const newElement = newChild;
+      newElement.parentElement = parentElement;
+
+      let insertIndex = 0;
+      for (let i = 0; i < oldIndex; i++) {
+        if (parent.childNodes[i].nodeType === NodeType.ELEMENT_NODE) {
+          insertIndex++;
+        }
+      }
+
+      parentElement.children.splice(insertIndex, 0, newElement);
+
+      newElement.previousElementSibling =
+        insertIndex > 0 ? parentElement.children[insertIndex - 1] : null;
+      newElement.nextElementSibling =
+        insertIndex < parentElement.children.length - 1
+          ? parentElement.children[insertIndex + 1]
+          : null;
+
+      if (newElement.previousElementSibling) {
+        newElement.previousElementSibling.nextElementSibling = newElement;
+      }
+      if (newElement.nextElementSibling) {
+        newElement.nextElementSibling.previousElementSibling = newElement;
+      }
+
+      if (insertIndex === 0) {
+        parentElement.firstElementChild = newElement;
+      }
+      if (insertIndex === parentElement.children.length - 1) {
+        parentElement.lastElementChild = newElement;
+      }
+    }
+  }
+
+  oldChild.parentNode = null;
+  if (oldChild.nodeType === NodeType.ELEMENT_NODE) {
+    oldChild.parentElement = null;
+  }
+  oldChild.previousSibling = null;
+  oldChild.nextSibling = null;
+  if (oldChild.nodeType === NodeType.ELEMENT_NODE) {
+    oldChild.previousElementSibling = null;
+    oldChild.nextElementSibling = null;
+  }
+
+  if (parent.nodeType === NodeType.ELEMENT_NODE) {
+    updateElementContent(parent);
+  }
+
+  return oldChild;
+};

package/src/dom-simulator/set-text-content.ts

@@ -0,0 +1,33 @@
+import { NodeType } from "./node-types.js";
+import { updateElementContent } from "./update-element-content.js";
+
+export const setTextContent = (element: any, text: string): void => {
+  element.childNodes = [];
+  element.children = [];
+  element.firstChild = null;
+  element.lastChild = null;
+  element.firstElementChild = null;
+  element.lastElementChild = null;
+
+  if (text) {
+    const textNode: any = {
+      nodeType: NodeType.TEXT_NODE,
+      nodeName: "#text",
+      nodeValue: text,
+      textContent: text,
+      data: text,
+      childNodes: [],
+      parentNode: element,
+      firstChild: null,
+      lastChild: null,
+      nextSibling: null,
+      previousSibling: null,
+    };
+
+    element.childNodes.push(textNode);
+    element.firstChild = textNode;
+    element.lastChild = textNode;
+  }
+
+  updateElementContent(element);
+};

package/src/dom-simulator/update-element-content.ts

@@ -0,0 +1,56 @@
+import { NodeType, VOID_ELEMENTS } from "./node-types.js";
+import { getTextContent } from "./get-text-content.js";
+import { escapeTextContent } from "./escape-text-content.js";
+
+export const updateElementContent = (element: any): void => {
+  const innerHTML = element.childNodes
+    .map((child: any) => {
+      if (child.nodeType === NodeType.TEXT_NODE) {
+        return escapeTextContent(child.textContent || "");
+      } else if (child.nodeType === NodeType.ELEMENT_NODE) {
+        return child.outerHTML;
+      } else if (child.nodeType === NodeType.COMMENT_NODE) {
+        return `<!--${child.data}-->`;
+      }
+      return "";
+    })
+    .join("");
+
+  Object.defineProperty(element, "_internalInnerHTML", {
+    value: innerHTML,
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+
+  const attrs = Object.entries(element.attributes)
+    .map(([k, v]) => ` ${k}="${v}"`)
+    .join("");
+  const tagNameLower = element.tagName.toLowerCase();
+  const isVoid = VOID_ELEMENTS.has(tagNameLower);
+
+  const outerHTML = isVoid
+    ? `<${tagNameLower}${attrs}>`
+    : `<${tagNameLower}${attrs}>${innerHTML}</${tagNameLower}>`;
+
+  Object.defineProperty(element, "_internalOuterHTML", {
+    value: outerHTML,
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+
+  const computedTextContent = getTextContent(element);
+  Object.defineProperty(element, "_internalTextContent", {
+    value: computedTextContent,
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+
+  if (element.parentElement) {
+    element.parentElement._internalOuterHTML = undefined;
+    element.parentElement._internalInnerHTML = undefined;
+    element.parentElement._internalTextContent = undefined;
+  }
+};