{"version":3,"sources":["webpack:///./node_modules/domhandler/lib/node.js","webpack:///./node_modules/domhandler/lib/index.js"],"names":["__extends","this","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","defineProperty","exports","value","cloneNode","hasChildren","isDocument","isDirective","isComment","isText","isCDATA","isTag","Element","Document","NodeWithChildren","ProcessingInstruction","Comment","Text","DataNode","Node","domelementtype_1","nodeTypes","Map","ElementType","Tag","Script","Style","Directive","CDATA","Root","type","parent","prev","next","startIndex","endIndex","get","_a","enumerable","configurable","set","recursive","_super","data","_this","name","children","attribs","keys","map","_b","namespace","prefix","node","result","cloneChildren","clone_1","forEach","child","clone_2","clone_3","Error","instruction","childs","__createBinding","o","m","k","k2","undefined","__exportStar","DomHandler","node_1","reWhitespace","defaultOpts","normalizeWhitespace","withStartIndices","withEndIndices","xmlMode","callback","options","elementCB","dom","root","done","tagStack","lastNode","parser","onparserinit","onreset","onend","handleCallback","onerror","error","onclosetag","elem","pop","onopentag","element","addNode","push","ontext","replace","oncomment","oncommentend","oncdatastart","text","oncdataend","onprocessinginstruction","previousSibling","default"],"mappings":"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","file":"js/npm.domhandler.868a6bf1.js","sourcesContent":["\"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        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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.hasChildren = exports.isDocument = exports.isDirective = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = exports.Element = exports.Document = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\nvar nodeTypes = new Map([\n    [domelementtype_1.ElementType.Tag, 1],\n    [domelementtype_1.ElementType.Script, 1],\n    [domelementtype_1.ElementType.Style, 1],\n    [domelementtype_1.ElementType.Directive, 1],\n    [domelementtype_1.ElementType.Text, 3],\n    [domelementtype_1.ElementType.CDATA, 4],\n    [domelementtype_1.ElementType.Comment, 8],\n    [domelementtype_1.ElementType.Root, 9],\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;\n/**\n * A node that contains some data.\n */\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;\n/**\n * Text within the document.\n */\nvar Text = /** @class */ (function (_super) {\n    __extends(Text, _super);\n    function Text(data) {\n        return _super.call(this, domelementtype_1.ElementType.Text, data) || this;\n    }\n    return Text;\n}(DataNode));\nexports.Text = Text;\n/**\n * Comments within the document.\n */\nvar Comment = /** @class */ (function (_super) {\n    __extends(Comment, _super);\n    function Comment(data) {\n        return _super.call(this, domelementtype_1.ElementType.Comment, data) || this;\n    }\n    return Comment;\n}(DataNode));\nexports.Comment = Comment;\n/**\n * Processing instructions, including doc types.\n */\nvar ProcessingInstruction = /** @class */ (function (_super) {\n    __extends(ProcessingInstruction, _super);\n    function ProcessingInstruction(name, data) {\n        var _this = _super.call(this, domelementtype_1.ElementType.Directive, data) || this;\n        _this.name = name;\n        return _this;\n    }\n    return ProcessingInstruction;\n}(DataNode));\nexports.ProcessingInstruction = ProcessingInstruction;\n/**\n * A `Node` that can have children.\n */\nvar NodeWithChildren = /** @class */ (function (_super) {\n    __extends(NodeWithChildren, _super);\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;\n/**\n * The root node of the document.\n */\nvar Document = /** @class */ (function (_super) {\n    __extends(Document, _super);\n    function Document(children) {\n        return _super.call(this, domelementtype_1.ElementType.Root, children) || this;\n    }\n    return Document;\n}(NodeWithChildren));\nexports.Document = Document;\n/**\n * An element within the DOM.\n */\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, type) {\n        if (children === void 0) { children = []; }\n        if (type === void 0) { type = name === \"script\"\n            ? domelementtype_1.ElementType.Script\n            : name === \"style\"\n                ? domelementtype_1.ElementType.Style\n                : domelementtype_1.ElementType.Tag; }\n        var _this = _super.call(this, type, children) || this;\n        _this.name = name;\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) {\n                var _a, _b;\n                return ({\n                    name: name,\n                    value: _this.attribs[name],\n                    namespace: (_a = _this[\"x-attribsNamespace\"]) === null || _a === void 0 ? void 0 : _a[name],\n                    prefix: (_b = _this[\"x-attribsPrefix\"]) === null || _b === void 0 ? void 0 : _b[name],\n                });\n            });\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Element;\n}(NodeWithChildren));\nexports.Element = Element;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `Element`, `false` otherwise.\n */\nfunction isTag(node) {\n    return (0, domelementtype_1.isTag)(node);\n}\nexports.isTag = isTag;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `CDATA`, `false` otherwise.\n */\nfunction isCDATA(node) {\n    return node.type === domelementtype_1.ElementType.CDATA;\n}\nexports.isCDATA = isCDATA;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Text`, `false` otherwise.\n */\nfunction isText(node) {\n    return node.type === domelementtype_1.ElementType.Text;\n}\nexports.isText = isText;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Comment`, `false` otherwise.\n */\nfunction isComment(node) {\n    return node.type === domelementtype_1.ElementType.Comment;\n}\nexports.isComment = isComment;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nfunction isDirective(node) {\n    return node.type === domelementtype_1.ElementType.Directive;\n}\nexports.isDirective = isDirective;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nfunction isDocument(node) {\n    return node.type === domelementtype_1.ElementType.Root;\n}\nexports.isDocument = isDocument;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `NodeWithChildren` (has children), `false` otherwise.\n */\nfunction hasChildren(node) {\n    return Object.prototype.hasOwnProperty.call(node, \"children\");\n}\nexports.hasChildren = hasChildren;\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    var result;\n    if (isText(node)) {\n        result = new Text(node.data);\n    }\n    else if (isComment(node)) {\n        result = new Comment(node.data);\n    }\n    else if (isTag(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_1 = new Element(node.name, __assign({}, node.attribs), children);\n        children.forEach(function (child) { return (child.parent = clone_1); });\n        if (node[\"x-attribsNamespace\"]) {\n            clone_1[\"x-attribsNamespace\"] = __assign({}, node[\"x-attribsNamespace\"]);\n        }\n        if (node[\"x-attribsPrefix\"]) {\n            clone_1[\"x-attribsPrefix\"] = __assign({}, node[\"x-attribsPrefix\"]);\n        }\n        result = clone_1;\n    }\n    else if (isCDATA(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_2 = new NodeWithChildren(domelementtype_1.ElementType.CDATA, children);\n        children.forEach(function (child) { return (child.parent = clone_2); });\n        result = clone_2;\n    }\n    else if (isDocument(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_3 = new Document(children);\n        children.forEach(function (child) { return (child.parent = clone_3); });\n        if (node[\"x-mode\"]) {\n            clone_3[\"x-mode\"] = node[\"x-mode\"];\n        }\n        result = clone_3;\n    }\n    else if (isDirective(node)) {\n        var instruction = new ProcessingInstruction(node.name, node.data);\n        if (node[\"x-name\"] != null) {\n            instruction[\"x-name\"] = node[\"x-name\"];\n            instruction[\"x-publicId\"] = node[\"x-publicId\"];\n            instruction[\"x-systemId\"] = node[\"x-systemId\"];\n        }\n        result = instruction;\n    }\n    else {\n        throw new Error(\"Not implemented yet: \" + node.type);\n    }\n    result.startIndex = node.startIndex;\n    result.endIndex = node.endIndex;\n    return result;\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","\"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 domelementtype_1 = require(\"domelementtype\");\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    xmlMode: 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 elements of the DOM */\n        this.dom = [];\n        /** The root element for the DOM */\n        this.root = new node_1.Document(this.dom);\n        /** Indicated whether parsing has been completed. */\n        this.done = false;\n        /** Stack of open tags. */\n        this.tagStack = [this.root];\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        this.dom = [];\n        this.root = new node_1.Document(this.dom);\n        this.done = false;\n        this.tagStack = [this.root];\n        this.lastNode = null;\n        this.parser = 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 (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 type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : undefined;\n        var element = new node_1.Element(name, attribs, undefined, type);\n        this.addNode(element);\n        this.tagStack.push(element);\n    };\n    DomHandler.prototype.ontext = function (data) {\n        var normalizeWhitespace = this.options.normalizeWhitespace;\n        var lastNode = this.lastNode;\n        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {\n            if (normalizeWhitespace) {\n                lastNode.data = (lastNode.data + data).replace(reWhitespace, \" \");\n            }\n            else {\n                lastNode.data += data;\n            }\n            if (this.options.withEndIndices) {\n                lastNode.endIndex = this.parser.endIndex;\n            }\n        }\n        else {\n            if (normalizeWhitespace) {\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 === domelementtype_1.ElementType.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(domelementtype_1.ElementType.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 previousSibling = parent.children[parent.children.length - 1];\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        parent.children.push(node);\n        if (previousSibling) {\n            node.prev = previousSibling;\n            previousSibling.next = node;\n        }\n        node.parent = parent;\n        this.lastNode = null;\n    };\n    return DomHandler;\n}());\nexports.DomHandler = DomHandler;\nexports.default = DomHandler;\n"],"sourceRoot":""}