node-html-parser 4.1.5

package/dist/esm/nodes/node.js

@@ -0,0 +1,25 @@
+import { decode, encode } from 'he';
+/**
+ * Node Class as base class for TextNode and HTMLElement.
+ */
+export default class Node {
+    constructor(parentNode = null, range) {
+        this.parentNode = parentNode;
+        this.childNodes = [];
+        Object.defineProperty(this, 'range', {
+            enumerable: false,
+            writable: true,
+            configurable: true,
+            value: range !== null && range !== void 0 ? range : [-1, -1]
+        });
+    }
+    get innerText() {
+        return this.rawText;
+    }
+    get textContent() {
+        return decode(this.rawText);
+    }
+    set textContent(val) {
+        this.rawText = encode(val);
+    }
+}

package/dist/esm/nodes/text.js

@@ -0,0 +1,95 @@
+import { decode } from 'he';
+import Node from './node';
+import NodeType from './type';
+/**
+ * TextNode to contain a text element in DOM tree.
+ * @param {string} value [description]
+ */
+export default class TextNode extends Node {
+    constructor(rawText, parentNode, range) {
+        super(parentNode, range);
+        /**
+         * Node Type declaration.
+         * @type {Number}
+         */
+        this.nodeType = NodeType.TEXT_NODE;
+        this._rawText = rawText;
+    }
+    get rawText() {
+        return this._rawText;
+    }
+    /**
+     * Set rawText and invalidate trimmed caches
+     */
+    set rawText(text) {
+        this._rawText = text;
+        this._trimmedRawText = void 0;
+        this._trimmedText = void 0;
+    }
+    /**
+     * Returns raw text with all whitespace trimmed except single leading/trailing non-breaking space
+     */
+    get trimmedRawText() {
+        if (this._trimmedRawText !== undefined)
+            return this._trimmedRawText;
+        this._trimmedRawText = trimText(this.rawText);
+        return this._trimmedRawText;
+    }
+    /**
+     * Returns text with all whitespace trimmed except single leading/trailing non-breaking space
+     */
+    get trimmedText() {
+        if (this._trimmedText !== undefined)
+            return this._trimmedText;
+        this._trimmedText = trimText(this.text);
+        return this._trimmedText;
+    }
+    /**
+     * Get unescaped text value of current node and its children.
+     * @return {string} text content
+     */
+    get text() {
+        return decode(this.rawText);
+    }
+    /**
+     * Detect if the node contains only white space.
+     * @return {boolean}
+     */
+    get isWhitespace() {
+        return /^(\s| )*$/.test(this.rawText);
+    }
+    toString() {
+        return this.rawText;
+    }
+}
+/**
+ * Trim whitespace except single leading/trailing non-breaking space
+ */
+function trimText(text) {
+    let i = 0;
+    let startPos;
+    let endPos;
+    while (i >= 0 && i < text.length) {
+        if (/\S/.test(text[i])) {
+            if (startPos === undefined) {
+                startPos = i;
+                i = text.length;
+            }
+            else {
+                endPos = i;
+                i = void 0;
+            }
+        }
+        if (startPos === undefined)
+            i++;
+        else
+            i--;
+    }
+    if (startPos === undefined)
+        startPos = 0;
+    if (endPos === undefined)
+        endPos = text.length - 1;
+    const hasLeadingSpace = startPos > 0 && /[^\S\r\n]/.test(text[startPos - 1]);
+    const hasTrailingSpace = endPos < (text.length - 1) && /[^\S\r\n]/.test(text[endPos + 1]);
+    return (hasLeadingSpace ? ' ' : '') + text.slice(startPos, endPos + 1) + (hasTrailingSpace ? ' ' : '');
+}

package/dist/esm/nodes/type.js

@@ -0,0 +1,7 @@
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+    NodeType[NodeType["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+})(NodeType || (NodeType = {}));
+export default NodeType;

package/dist/esm/parse.js

@@ -0,0 +1 @@
+export { parse as default } from './nodes/html';

package/dist/esm/valid.js

@@ -0,0 +1,9 @@
+import { base_parse } from './nodes/html';
+/**
+ * Parses HTML and returns a root element
+ * Parse a chuck of HTML source.
+ */
+export default function valid(data, options = { lowerCaseTagName: false, comment: false }) {
+    const stack = base_parse(data, options);
+    return Boolean(stack.length === 1);
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as CommentNode } from './nodes/comment';
+export { default as HTMLElement, Options } from './nodes/html';
+export { default as parse, default } from './parse';
+export { default as valid } from './valid';
+export { default as Node } from './nodes/node';
+export { default as TextNode } from './nodes/text';
+export { default as NodeType } from './nodes/type';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeType = exports.TextNode = exports.Node = exports.valid = exports.default = exports.parse = exports.HTMLElement = exports.CommentNode = void 0;
+var comment_1 = require("./nodes/comment");
+Object.defineProperty(exports, "CommentNode", { enumerable: true, get: function () { return __importDefault(comment_1).default; } });
+var html_1 = require("./nodes/html");
+Object.defineProperty(exports, "HTMLElement", { enumerable: true, get: function () { return __importDefault(html_1).default; } });
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return __importDefault(parse_1).default; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(parse_1).default; } });
+var valid_1 = require("./valid");
+Object.defineProperty(exports, "valid", { enumerable: true, get: function () { return __importDefault(valid_1).default; } });
+var node_1 = require("./nodes/node");
+Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return __importDefault(node_1).default; } });
+var text_1 = require("./nodes/text");
+Object.defineProperty(exports, "TextNode", { enumerable: true, get: function () { return __importDefault(text_1).default; } });
+var type_1 = require("./nodes/type");
+Object.defineProperty(exports, "NodeType", { enumerable: true, get: function () { return __importDefault(type_1).default; } });