node-html-parser 4.1.5

package/dist/nodes/node.d.ts

@@ -0,0 +1,18 @@
+import NodeType from './type';
+import HTMLElement from './html';
+/**
+ * Node Class as base class for TextNode and HTMLElement.
+ */
+export default abstract class Node {
+    parentNode: HTMLElement;
+    abstract nodeType: NodeType;
+    childNodes: Node[];
+    range: readonly [number, number];
+    abstract text: string;
+    abstract rawText: string;
+    abstract toString(): string;
+    constructor(parentNode?: HTMLElement, range?: [number, number]);
+    get innerText(): string;
+    get textContent(): string;
+    set textContent(val: string);
+}

package/dist/nodes/node.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var he_1 = require("he");
+/**
+ * Node Class as base class for TextNode and HTMLElement.
+ */
+var Node = /** @class */ (function () {
+    function Node(parentNode, range) {
+        if (parentNode === void 0) { parentNode = null; }
+        this.parentNode = parentNode;
+        this.childNodes = [];
+        Object.defineProperty(this, 'range', {
+            enumerable: false,
+            writable: true,
+            configurable: true,
+            value: range !== null && range !== void 0 ? range : [-1, -1]
+        });
+    }
+    Object.defineProperty(Node.prototype, "innerText", {
+        get: function () {
+            return this.rawText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "textContent", {
+        get: function () {
+            return (0, he_1.decode)(this.rawText);
+        },
+        set: function (val) {
+            this.rawText = (0, he_1.encode)(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Node;
+}());
+exports.default = Node;

package/dist/nodes/text.d.ts

@@ -0,0 +1,42 @@
+import HTMLElement from './html';
+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: string, parentNode: HTMLElement, range?: [number, number]);
+    /**
+     * Node Type declaration.
+     * @type {Number}
+     */
+    nodeType: NodeType;
+    private _rawText;
+    private _trimmedRawText?;
+    private _trimmedText?;
+    get rawText(): string;
+    /**
+     * Set rawText and invalidate trimmed caches
+     */
+    set rawText(text: string);
+    /**
+     * Returns raw text with all whitespace trimmed except single leading/trailing non-breaking space
+     */
+    get trimmedRawText(): string;
+    /**
+     * Returns text with all whitespace trimmed except single leading/trailing non-breaking space
+     */
+    get trimmedText(): string;
+    /**
+     * Get unescaped text value of current node and its children.
+     * @return {string} text content
+     */
+    get text(): string;
+    /**
+     * Detect if the node contains only white space.
+     * @return {boolean}
+     */
+    get isWhitespace(): boolean;
+    toString(): string;
+}

package/dist/nodes/text.js

@@ -0,0 +1,139 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var he_1 = require("he");
+var node_1 = __importDefault(require("./node"));
+var type_1 = __importDefault(require("./type"));
+/**
+ * TextNode to contain a text element in DOM tree.
+ * @param {string} value [description]
+ */
+var TextNode = /** @class */ (function (_super) {
+    __extends(TextNode, _super);
+    function TextNode(rawText, parentNode, range) {
+        var _this = _super.call(this, parentNode, range) || this;
+        /**
+         * Node Type declaration.
+         * @type {Number}
+         */
+        _this.nodeType = type_1.default.TEXT_NODE;
+        _this._rawText = rawText;
+        return _this;
+    }
+    Object.defineProperty(TextNode.prototype, "rawText", {
+        get: function () {
+            return this._rawText;
+        },
+        /**
+         * Set rawText and invalidate trimmed caches
+         */
+        set: function (text) {
+            this._rawText = text;
+            this._trimmedRawText = void 0;
+            this._trimmedText = void 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "trimmedRawText", {
+        /**
+         * Returns raw text with all whitespace trimmed except single leading/trailing non-breaking space
+         */
+        get: function () {
+            if (this._trimmedRawText !== undefined)
+                return this._trimmedRawText;
+            this._trimmedRawText = trimText(this.rawText);
+            return this._trimmedRawText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "trimmedText", {
+        /**
+         * Returns text with all whitespace trimmed except single leading/trailing non-breaking space
+         */
+        get: function () {
+            if (this._trimmedText !== undefined)
+                return this._trimmedText;
+            this._trimmedText = trimText(this.text);
+            return this._trimmedText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "text", {
+        /**
+         * Get unescaped text value of current node and its children.
+         * @return {string} text content
+         */
+        get: function () {
+            return (0, he_1.decode)(this.rawText);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "isWhitespace", {
+        /**
+         * Detect if the node contains only white space.
+         * @return {boolean}
+         */
+        get: function () {
+            return /^(\s| )*$/.test(this.rawText);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextNode.prototype.toString = function () {
+        return this.rawText;
+    };
+    return TextNode;
+}(node_1.default));
+exports.default = TextNode;
+/**
+ * Trim whitespace except single leading/trailing non-breaking space
+ */
+function trimText(text) {
+    var i = 0;
+    var startPos;
+    var 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;
+    var hasLeadingSpace = startPos > 0 && /[^\S\r\n]/.test(text[startPos - 1]);
+    var hasTrailingSpace = endPos < (text.length - 1) && /[^\S\r\n]/.test(text[endPos + 1]);
+    return (hasLeadingSpace ? ' ' : '') + text.slice(startPos, endPos + 1) + (hasTrailingSpace ? ' ' : '');
+}

package/dist/nodes/type.d.ts

@@ -0,0 +1,6 @@
+declare enum NodeType {
+    ELEMENT_NODE = 1,
+    TEXT_NODE = 3,
+    COMMENT_NODE = 8
+}
+export default NodeType;

package/dist/nodes/type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = {}));
+exports.default = NodeType;

package/dist/parse.d.ts

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

package/dist/parse.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var html_1 = require("./nodes/html");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return html_1.parse; } });

package/dist/valid.d.ts

@@ -0,0 +1,6 @@
+import { Options } from './nodes/html';
+/**
+ * Parses HTML and returns a root element
+ * Parse a chuck of HTML source.
+ */
+export default function valid(data: string, options?: Partial<Options>): boolean;

package/dist/valid.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var html_1 = require("./nodes/html");
+/**
+ * Parses HTML and returns a root element
+ * Parse a chuck of HTML source.
+ */
+function valid(data, options) {
+    if (options === void 0) { options = { lowerCaseTagName: false, comment: false }; }
+    var stack = (0, html_1.base_parse)(data, options);
+    return Boolean(stack.length === 1);
+}
+exports.default = valid;

package/package.json

@@ -0,0 +1,88 @@
+{
+	"name": "node-html-parser",
+	"version": "4.1.5",
+	"description": "A very fast HTML parser, generating a simplified DOM, with basic element query support.",
+	"main": "dist/index.js",
+	"module": "dist/esm/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"test": "mocha",
+		"lint": "eslint ./src/*.ts ./src/**/*.ts",
+		"clean": "del-cli ./dist/",
+		"ts:cjs": "tsc -m commonjs",
+		"ts:amd": "tsc -t es5 -m amd -d false --outFile ./dist/main.js",
+		"ts:esm": "tsc -t es2019 -m esnext -d false --outDir ./dist/esm/",
+		"build": "npm run lint && npm run clean && npm run ts:cjs && npm run ts:amd && npm run ts:esm",
+		"dev": "tsc -w & mocha -w ./test/*.js",
+		"pretest": "tsc -m commonjs",
+		"release": "yarn build && np",
+		"prepare": "npm run build"
+	},
+	"keywords": [
+		"parser",
+		"html",
+		"nodejs",
+		"typescript"
+	],
+	"author": "Xiaoyi Shi <ashi009@gmail.com>",
+	"contributors": [
+		"taoqf<tao_qiufeng@126.com>"
+	],
+	"license": "MIT",
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org"
+	},
+	"dependencies": {
+		"css-select": "^4.1.3",
+		"he": "1.2.0"
+	},
+	"devDependencies": {
+		"@types/entities": "latest",
+		"@types/he": "latest",
+		"@types/node": "latest",
+		"@typescript-eslint/eslint-plugin": "latest",
+		"@typescript-eslint/eslint-plugin-tslint": "latest",
+		"@typescript-eslint/parser": "latest",
+		"blanket": "latest",
+		"cheerio": "^1.0.0-rc.5",
+		"del-cli": "latest",
+		"eslint": "latest",
+		"eslint-config-prettier": "latest",
+		"eslint-plugin-import": "latest",
+		"high5": "^1.0.0",
+		"htmlparser": "^1.7.7",
+		"htmlparser-benchmark": "^1.1.3",
+		"htmlparser2": "^6.0.0",
+		"mocha": "latest",
+		"mocha-each": "^2.0.1",
+		"np": "latest",
+		"parse5": "^6.0.1",
+		"should": "latest",
+		"spec": "latest",
+		"travis-cov": "latest",
+		"typescript": "next"
+	},
+	"config": {
+		"blanket": {
+			"pattern": "./dist/index.js",
+			"data-cover-never": [
+				"node_modules"
+			]
+		},
+		"travis-cov": {
+			"threshold": 70
+		}
+	},
+	"directories": {
+		"test": "test"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/taoqf/node-fast-html-parser.git"
+	},
+	"bugs": {
+		"url": "https://github.com/taoqf/node-fast-html-parser/issues"
+	},
+	"homepage": "https://github.com/taoqf/node-fast-html-parser",
+	"sideEffects": false
+}