{"version":3,"file":"npm.domhandler.js","mappings":"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","sources":["webpack://giveeasy.cloud/./node_modules/domhandler/lib/index.js","webpack://giveeasy.cloud/./node_modules/domhandler/lib/node.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DomHandler = void 0;\nvar node_1 = require(\"./node\");\n__exportStar(require(\"./node\"), exports);\nvar reWhitespace = /\\s+/g;\n// Default options\nvar defaultOpts = {\n    normalizeWhitespace: false,\n    withStartIndices: false,\n    withEndIndices: false,\n};\nvar DomHandler = /** @class */ (function () {\n    /**\n     * @param callback Called once parsing has completed.\n     * @param options Settings for the handler.\n     * @param elementCB Callback whenever a tag is closed.\n     */\n    function DomHandler(callback, options, elementCB) {\n        /** The constructed DOM */\n        this.dom = [];\n        /** Indicated whether parsing has been completed. */\n        this._done = false;\n        /** Stack of open tags. */\n        this._tagStack = [];\n        /** A data node that is still being written to. */\n        this._lastNode = null;\n        /** Reference to the parser instance. Used for location information. */\n        this._parser = null;\n        // Make it possible to skip arguments, for backwards-compatibility\n        if (typeof options === \"function\") {\n            elementCB = options;\n            options = defaultOpts;\n        }\n        if (typeof callback === \"object\") {\n            options = callback;\n            callback = undefined;\n        }\n        this._callback = callback !== null && callback !== void 0 ? callback : null;\n        this._options = options !== null && options !== void 0 ? options : defaultOpts;\n        this._elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;\n    }\n    DomHandler.prototype.onparserinit = function (parser) {\n        this._parser = parser;\n    };\n    // Resets the handler back to starting state\n    DomHandler.prototype.onreset = function () {\n        var _a;\n        this.dom = [];\n        this._done = false;\n        this._tagStack = [];\n        this._lastNode = null;\n        this._parser = (_a = this._parser) !== null && _a !== void 0 ? _a : null;\n    };\n    // Signals the handler that parsing is done\n    DomHandler.prototype.onend = function () {\n        if (this._done)\n            return;\n        this._done = true;\n        this._parser = null;\n        this.handleCallback(null);\n    };\n    DomHandler.prototype.onerror = function (error) {\n        this.handleCallback(error);\n    };\n    DomHandler.prototype.onclosetag = function () {\n        this._lastNode = null;\n        var elem = this._tagStack.pop();\n        if (!elem || !this._parser) {\n            return;\n        }\n        if (this._options.withEndIndices) {\n            elem.endIndex = this._parser.endIndex;\n        }\n        if (this._elementCB)\n            this._elementCB(elem);\n    };\n    DomHandler.prototype.onopentag = function (name, attribs) {\n        var element = new node_1.Element(name, attribs);\n        this.addNode(element);\n        this._tagStack.push(element);\n    };\n    DomHandler.prototype.ontext = function (data) {\n        var normalize = this._options.normalizeWhitespace;\n        var _lastNode = this._lastNode;\n        if (_lastNode && _lastNode.type === \"text\" /* Text */) {\n            if (normalize) {\n                _lastNode.data = (_lastNode.data + data).replace(reWhitespace, \" \");\n            }\n            else {\n                _lastNode.data += data;\n            }\n        }\n        else {\n            if (normalize) {\n                data = data.replace(reWhitespace, \" \");\n            }\n            var node = new node_1.Text(data);\n            this.addNode(node);\n            this._lastNode = node;\n        }\n    };\n    DomHandler.prototype.oncomment = function (data) {\n        if (this._lastNode && this._lastNode.type === \"comment\" /* Comment */) {\n            this._lastNode.data += data;\n            return;\n        }\n        var node = new node_1.Comment(data);\n        this.addNode(node);\n        this._lastNode = node;\n    };\n    DomHandler.prototype.oncommentend = function () {\n        this._lastNode = null;\n    };\n    DomHandler.prototype.oncdatastart = function () {\n        var text = new node_1.Text(\"\");\n        var node = new node_1.NodeWithChildren(\"cdata\" /* CDATA */, [text]);\n        this.addNode(node);\n        text.parent = node;\n        this._lastNode = text;\n    };\n    DomHandler.prototype.oncdataend = function () {\n        this._lastNode = null;\n    };\n    DomHandler.prototype.onprocessinginstruction = function (name, data) {\n        var node = new node_1.ProcessingInstruction(name, data);\n        this.addNode(node);\n    };\n    DomHandler.prototype.handleCallback = function (error) {\n        if (typeof this._callback === \"function\") {\n            this._callback(error, this.dom);\n        }\n        else if (error) {\n            throw error;\n        }\n    };\n    DomHandler.prototype.addNode = function (node) {\n        var parent = this._tagStack[this._tagStack.length - 1];\n        var siblings = parent ? parent.children : this.dom;\n        var previousSibling = siblings[siblings.length - 1];\n        if (this._parser) {\n            if (this._options.withStartIndices) {\n                node.startIndex = this._parser.startIndex;\n            }\n            if (this._options.withEndIndices) {\n                node.endIndex = this._parser.endIndex;\n            }\n        }\n        siblings.push(node);\n        if (previousSibling) {\n            node.prev = previousSibling;\n            previousSibling.next = node;\n        }\n        if (parent) {\n            node.parent = parent;\n        }\n        this._lastNode = null;\n    };\n    DomHandler.prototype.addDataNode = function (node) {\n        this.addNode(node);\n        this._lastNode = node;\n    };\n    return DomHandler;\n}());\nexports.DomHandler = DomHandler;\nexports.default = DomHandler;\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cloneNode = exports.Element = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;\nvar nodeTypes = new Map([\n    [\"tag\" /* Tag */, 1],\n    [\"script\" /* Script */, 1],\n    [\"style\" /* Style */, 1],\n    [\"directive\" /* Directive */, 1],\n    [\"text\" /* Text */, 3],\n    [\"cdata\" /* CDATA */, 4],\n    [\"comment\" /* Comment */, 8],\n]);\n/**\n * This object will be used as the prototype for Nodes when creating a\n * DOM-Level-1-compliant structure.\n */\nvar Node = /** @class */ (function () {\n    /**\n     *\n     * @param type The type of the node.\n     */\n    function Node(type) {\n        this.type = type;\n        /** Parent of the node */\n        this.parent = null;\n        /** Previous sibling */\n        this.prev = null;\n        /** Next sibling */\n        this.next = null;\n        /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */\n        this.startIndex = null;\n        /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */\n        this.endIndex = null;\n    }\n    Object.defineProperty(Node.prototype, \"nodeType\", {\n        // Read-only aliases\n        get: function () {\n            var _a;\n            return (_a = nodeTypes.get(this.type)) !== null && _a !== void 0 ? _a : 1;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"parentNode\", {\n        // Read-write aliases for properties\n        get: function () {\n            return this.parent;\n        },\n        set: function (parent) {\n            this.parent = parent;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"previousSibling\", {\n        get: function () {\n            return this.prev;\n        },\n        set: function (prev) {\n            this.prev = prev;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"nextSibling\", {\n        get: function () {\n            return this.next;\n        },\n        set: function (next) {\n            this.next = next;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Clone this node, and optionally its children.\n     *\n     * @param recursive Clone child nodes as well.\n     * @returns A clone of the node.\n     */\n    Node.prototype.cloneNode = function (recursive) {\n        if (recursive === void 0) { recursive = false; }\n        return cloneNode(this, recursive);\n    };\n    return Node;\n}());\nexports.Node = Node;\nvar DataNode = /** @class */ (function (_super) {\n    __extends(DataNode, _super);\n    /**\n     * @param type The type of the node\n     * @param data The content of the data node\n     */\n    function DataNode(type, data) {\n        var _this = _super.call(this, type) || this;\n        _this.data = data;\n        return _this;\n    }\n    Object.defineProperty(DataNode.prototype, \"nodeValue\", {\n        get: function () {\n            return this.data;\n        },\n        set: function (data) {\n            this.data = data;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return DataNode;\n}(Node));\nexports.DataNode = DataNode;\nvar Text = /** @class */ (function (_super) {\n    __extends(Text, _super);\n    function Text(data) {\n        return _super.call(this, \"text\" /* Text */, data) || this;\n    }\n    return Text;\n}(DataNode));\nexports.Text = Text;\nvar Comment = /** @class */ (function (_super) {\n    __extends(Comment, _super);\n    function Comment(data) {\n        return _super.call(this, \"comment\" /* Comment */, data) || this;\n    }\n    return Comment;\n}(DataNode));\nexports.Comment = Comment;\nvar ProcessingInstruction = /** @class */ (function (_super) {\n    __extends(ProcessingInstruction, _super);\n    function ProcessingInstruction(name, data) {\n        var _this = _super.call(this, \"directive\" /* Directive */, data) || this;\n        _this.name = name;\n        return _this;\n    }\n    return ProcessingInstruction;\n}(DataNode));\nexports.ProcessingInstruction = ProcessingInstruction;\nvar NodeWithChildren = /** @class */ (function (_super) {\n    __extends(NodeWithChildren, _super);\n    /**\n     *\n     * @param type Type of the node.\n     * @param children Children of the node. Only certain node types can have children.\n     */\n    function NodeWithChildren(type, children) {\n        var _this = _super.call(this, type) || this;\n        _this.children = children;\n        return _this;\n    }\n    Object.defineProperty(NodeWithChildren.prototype, \"firstChild\", {\n        // Aliases\n        get: function () {\n            var _a;\n            return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(NodeWithChildren.prototype, \"lastChild\", {\n        get: function () {\n            return this.children.length > 0\n                ? this.children[this.children.length - 1]\n                : null;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(NodeWithChildren.prototype, \"childNodes\", {\n        get: function () {\n            return this.children;\n        },\n        set: function (children) {\n            this.children = children;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return NodeWithChildren;\n}(Node));\nexports.NodeWithChildren = NodeWithChildren;\nvar Element = /** @class */ (function (_super) {\n    __extends(Element, _super);\n    /**\n     * @param name Name of the tag, eg. `div`, `span`.\n     * @param attribs Object mapping attribute names to attribute values.\n     * @param children Children of the node.\n     */\n    function Element(name, attribs, children) {\n        if (children === void 0) { children = []; }\n        var _this = _super.call(this, name === \"script\"\n            ? \"script\" /* Script */\n            : name === \"style\"\n                ? \"style\" /* Style */\n                : \"tag\" /* Tag */, children) || this;\n        _this.name = name;\n        _this.attribs = attribs;\n        _this.attribs = attribs;\n        return _this;\n    }\n    Object.defineProperty(Element.prototype, \"tagName\", {\n        // DOM Level 1 aliases\n        get: function () {\n            return this.name;\n        },\n        set: function (name) {\n            this.name = name;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Element.prototype, \"attributes\", {\n        get: function () {\n            var _this = this;\n            return Object.keys(this.attribs).map(function (name) { return ({\n                name: name,\n                value: _this.attribs[name],\n            }); });\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Element;\n}(NodeWithChildren));\nexports.Element = Element;\n/**\n * Clone a node, and optionally its children.\n *\n * @param recursive Clone child nodes as well.\n * @returns A clone of the node.\n */\nfunction cloneNode(node, recursive) {\n    if (recursive === void 0) { recursive = false; }\n    switch (node.type) {\n        case \"text\" /* Text */:\n            return new Text(node.data);\n        case \"directive\" /* Directive */: {\n            var instr = node;\n            return new ProcessingInstruction(instr.name, instr.data);\n        }\n        case \"comment\" /* Comment */:\n            return new Comment(node.data);\n        case \"tag\" /* Tag */:\n        case \"script\" /* Script */:\n        case \"style\" /* Style */: {\n            var elem = node;\n            var children = recursive ? cloneChildren(elem.children) : [];\n            var clone_1 = new Element(elem.name, __assign({}, elem.attribs), children);\n            children.forEach(function (child) { return (child.parent = clone_1); });\n            return clone_1;\n        }\n        case \"cdata\" /* CDATA */: {\n            var cdata = node;\n            var children = recursive ? cloneChildren(cdata.children) : [];\n            var clone_2 = new NodeWithChildren(\"cdata\" /* CDATA */, children);\n            children.forEach(function (child) { return (child.parent = clone_2); });\n            return clone_2;\n        }\n        case \"doctype\" /* Doctype */: {\n            // This type isn't used yet.\n            throw new Error(\"Not implemented yet: ElementType.Doctype case\");\n        }\n    }\n}\nexports.cloneNode = cloneNode;\nfunction cloneChildren(childs) {\n    var children = childs.map(function (child) { return cloneNode(child, true); });\n    for (var i = 1; i < children.length; i++) {\n        children[i].prev = children[i - 1];\n        children[i - 1].next = children[i];\n    }\n    return children;\n}\n"],"names":["__createBinding","this","Object","create","o","m","k","k2","undefined","defineProperty","enumerable","get","__exportStar","exports","p","prototype","hasOwnProperty","call","value","DomHandler","node_1","reWhitespace","defaultOpts","normalizeWhitespace","withStartIndices","withEndIndices","callback","options","elementCB","dom","_done","_tagStack","_lastNode","_parser","_callback","_options","_elementCB","onparserinit","parser","onreset","_a","onend","handleCallback","onerror","error","onclosetag","elem","pop","endIndex","onopentag","name","attribs","element","Element","addNode","push","ontext","data","normalize","type","replace","node","Text","oncomment","Comment","oncommentend","oncdatastart","text","NodeWithChildren","parent","oncdataend","onprocessinginstruction","ProcessingInstruction","length","siblings","children","previousSibling","startIndex","prev","next","addDataNode","default","extendStatics","__extends","d","b","setPrototypeOf","__proto__","Array","__","constructor","__assign","assign","t","s","i","n","arguments","apply","cloneNode","DataNode","Node","nodeTypes","Map","configurable","set","recursive","_super","_this","keys","map","instr","cloneChildren","clone_1","forEach","child","clone_2","Error","childs"],"sourceRoot":""}