import { ElementType, isTag as isTagRaw } from "domelementtype"; /** * This object will be used as the prototype for Nodes when creating a * DOM-Level-1-compliant structure. */ export class Node { constructor() { /** Parent of the node */ this.parent = null; /** Previous sibling */ this.prev = null; /** Next sibling */ this.next = null; /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */ this.startIndex = null; /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */ this.endIndex = null; } // Read-write aliases for properties /** * Same as {@link parent}. * [DOM spec](https://dom.spec.whatwg.org)-compatible alias. */ get parentNode() { return this.parent; } set parentNode(parent) { this.parent = parent; } /** * Same as {@link prev}. * [DOM spec](https://dom.spec.whatwg.org)-compatible alias. */ get previousSibling() { return this.prev; } set previousSibling(prev) { this.prev = prev; } /** * Same as {@link next}. * [DOM spec](https://dom.spec.whatwg.org)-compatible alias. */ get nextSibling() { return this.next; } set nextSibling(next) { this.next = next; } /** * Clone this node, and optionally its children. * * @param recursive Clone child nodes as well. * @returns A clone of the node. */ cloneNode(recursive = false) { return cloneNode(this, recursive); } } /** * A node that contains some data. */ export class DataNode extends Node { /** * @param data The content of the data node */ constructor(data) { super(); this.data = data; } /** * Same as {@link data}. * [DOM spec](https://dom.spec.whatwg.org)-compatible alias. */ get nodeValue() { return this.data; } set nodeValue(data) { this.data = data; } } /** * Text within the document. */ export class Text extends DataNode { constructor() { super(...arguments); this.type = ElementType.Text; } get nodeType() { return 3; } } /** * Comments within the document. */ export class Comment extends DataNode { constructor() { super(...arguments); this.type = ElementType.Comment; } get nodeType() { return 8; } } /** * Processing instructions, including doc types. */ export class ProcessingInstruction extends DataNode { constructor(name, data) { super(data); this.name = name; this.type = ElementType.Directive; } get nodeType() { return 1; } } /** * A `Node` that can have children. */ export class NodeWithChildren extends Node { /** * @param children Children of the node. Only certain node types can have children. */ constructor(children) { super(); this.children = children; } // Aliases /** First child of the node. */ get firstChild() { var _a; return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null; } /** Last child of the node. */ get lastChild() { return this.children.length > 0 ? this.children[this.children.length - 1] : null; } /** * Same as {@link children}. * [DOM spec](https://dom.spec.whatwg.org)-compatible alias. */ get childNodes() { return this.children; } set childNodes(children) { this.children = children; } } export class CDATA extends NodeWithChildren { constructor() { super(...arguments); this.type = ElementType.CDATA; } get nodeType() { return 4; } } /** * The root node of the document. */ export class Document extends NodeWithChildren { constructor() { super(...arguments); this.type = ElementType.Root; } get nodeType() { return 9; } } /** * An element within the DOM. */ export class Element extends NodeWithChildren { /** * @param name Name of the tag, eg. `div`, `span`. * @param attribs Object mapping attribute names to attribute values. * @param children Children of the node. */ constructor(name, attribs, children = [], type = name === "script" ? ElementType.Script : name === "style" ? ElementType.Style : ElementType.Tag) { super(children); this.name = name; this.attribs = attribs; this.type = type; } get nodeType() { return 1; } // DOM Level 1 aliases /** * Same as {@link name}. * [DOM spec](https://dom.spec.whatwg.org)-compatible alias. */ get tagName() { return this.name; } set tagName(name) { this.name = name; } get attributes() { return Object.keys(this.attribs).map((name) => { var _a, _b; return ({ name, value: this.attribs[name], namespace: (_a = this["x-attribsNamespace"]) === null || _a === void 0 ? void 0 : _a[name], prefix: (_b = this["x-attribsPrefix"]) === null || _b === void 0 ? void 0 : _b[name], }); }); } } /** * @param node Node to check. * @returns `true` if the node is a `Element`, `false` otherwise. */ export function isTag(node) { return isTagRaw(node); } /** * @param node Node to check. * @returns `true` if the node has the type `CDATA`, `false` otherwise. */ export function isCDATA(node) { return node.type === ElementType.CDATA; } /** * @param node Node to check. * @returns `true` if the node has the type `Text`, `false` otherwise. */ export function isText(node) { return node.type === ElementType.Text; } /** * @param node Node to check. * @returns `true` if the node has the type `Comment`, `false` otherwise. */ export function isComment(node) { return node.type === ElementType.Comment; } /** * @param node Node to check. * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise. */ export function isDirective(node) { return node.type === ElementType.Directive; } /** * @param node Node to check. * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise. */ export function isDocument(node) { return node.type === ElementType.Root; } /** * @param node Node to check. * @returns `true` if the node has children, `false` otherwise. */ export function hasChildren(node) { return Object.prototype.hasOwnProperty.call(node, "children"); } /** * Clone a node, and optionally its children. * * @param recursive Clone child nodes as well. * @returns A clone of the node. */ export function cloneNode(node, recursive = false) { let result; if (isText(node)) { result = new Text(node.data); } else if (isComment(node)) { result = new Comment(node.data); } else if (isTag(node)) { const children = recursive ? cloneChildren(node.children) : []; const clone = new Element(node.name, { ...node.attribs }, children); children.forEach((child) => (child.parent = clone)); if (node.namespace != null) { clone.namespace = node.namespace; } if (node["x-attribsNamespace"]) { clone["x-attribsNamespace"] = { ...node["x-attribsNamespace"] }; } if (node["x-attribsPrefix"]) { clone["x-attribsPrefix"] = { ...node["x-attribsPrefix"] }; } result = clone; } else if (isCDATA(node)) { const children = recursive ? cloneChildren(node.children) : []; const clone = new CDATA(children); children.forEach((child) => (child.parent = clone)); result = clone; } else if (isDocument(node)) { const children = recursive ? cloneChildren(node.children) : []; const clone = new Document(children); children.forEach((child) => (child.parent = clone)); if (node["x-mode"]) { clone["x-mode"] = node["x-mode"]; } result = clone; } else if (isDirective(node)) { const instruction = new ProcessingInstruction(node.name, node.data); if (node["x-name"] != null) { instruction["x-name"] = node["x-name"]; instruction["x-publicId"] = node["x-publicId"]; instruction["x-systemId"] = node["x-systemId"]; } result = instruction; } else { throw new Error(`Not implemented yet: ${node.type}`); } result.startIndex = node.startIndex; result.endIndex = node.endIndex; if (node.sourceCodeLocation != null) { result.sourceCodeLocation = node.sourceCodeLocation; } return result; } function cloneChildren(childs) { const children = childs.map((child) => cloneNode(child, true)); for (let i = 1; i < children.length; i++) { children[i].prev = children[i - 1]; children[i - 1].next = children[i]; } return children; }