{"version":3,"file":"js/1141-6b52bf8438aecb8d2073.chunk.js","mappings":"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","sources":["webpack://nodalview/./node_modules/domelementtype/lib/index.js","webpack://nodalview/./node_modules/domhandler/lib/index.js","webpack://nodalview/./node_modules/domhandler/lib/node.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = void 0;\n/** Types of elements found in htmlparser2's DOM */\nvar ElementType;\n(function (ElementType) {\n    /** Type for the root element of a document */\n    ElementType[\"Root\"] = \"root\";\n    /** Type for Text */\n    ElementType[\"Text\"] = \"text\";\n    /** Type for <? ... ?> */\n    ElementType[\"Directive\"] = \"directive\";\n    /** Type for <!-- ... --> */\n    ElementType[\"Comment\"] = \"comment\";\n    /** Type for <script> tags */\n    ElementType[\"Script\"] = \"script\";\n    /** Type for <style> tags */\n    ElementType[\"Style\"] = \"style\";\n    /** Type for Any tag */\n    ElementType[\"Tag\"] = \"tag\";\n    /** Type for <![CDATA[ ... ]]> */\n    ElementType[\"CDATA\"] = \"cdata\";\n    /** Type for <!doctype ...> */\n    ElementType[\"Doctype\"] = \"doctype\";\n})(ElementType = exports.ElementType || (exports.ElementType = {}));\n/**\n * Tests whether an element is a tag or not.\n *\n * @param elem Element to test\n */\nfunction isTag(elem) {\n    return (elem.type === ElementType.Tag ||\n        elem.type === ElementType.Script ||\n        elem.type === ElementType.Style);\n}\nexports.isTag = isTag;\n// Exports for backwards compatibility\n/** Type for the root element of a document */\nexports.Root = ElementType.Root;\n/** Type for Text */\nexports.Text = ElementType.Text;\n/** Type for <? ... ?> */\nexports.Directive = ElementType.Directive;\n/** Type for <!-- ... --> */\nexports.Comment = ElementType.Comment;\n/** Type for <script> tags */\nexports.Script = ElementType.Script;\n/** Type for <style> tags */\nexports.Style = ElementType.Style;\n/** Type for Any tag */\nexports.Tag = ElementType.Tag;\n/** Type for <![CDATA[ ... ]]> */\nexports.CDATA = ElementType.CDATA;\n/** Type for <!doctype ...> */\nexports.Doctype = ElementType.Doctype;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\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_js_1 = require(\"./node.js\");\n__exportStar(require(\"./node.js\"), exports);\n// Default options\nvar defaultOpts = {\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_js_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_js_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_js_1.Element(name, attribs, undefined, type);\n        this.addNode(element);\n        this.tagStack.push(element);\n    };\n    DomHandler.prototype.ontext = function (data) {\n        var lastNode = this.lastNode;\n        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {\n            lastNode.data += data;\n            if (this.options.withEndIndices) {\n                lastNode.endIndex = this.parser.endIndex;\n            }\n        }\n        else {\n            var node = new node_js_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_js_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_js_1.Text(\"\");\n        var node = new node_js_1.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_js_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","\"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.CDATA = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\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    function Node() {\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, \"parentNode\", {\n        // Read-write aliases for properties\n        /**\n         * Same as {@link parent}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\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        /**\n         * Same as {@link prev}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\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        /**\n         * Same as {@link next}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\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 data The content of the data node\n     */\n    function DataNode(data) {\n        var _this = _super.call(this) || this;\n        _this.data = data;\n        return _this;\n    }\n    Object.defineProperty(DataNode.prototype, \"nodeValue\", {\n        /**\n         * Same as {@link data}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\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() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Text;\n        return _this;\n    }\n    Object.defineProperty(Text.prototype, \"nodeType\", {\n        get: function () {\n            return 3;\n        },\n        enumerable: false,\n        configurable: true\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() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Comment;\n        return _this;\n    }\n    Object.defineProperty(Comment.prototype, \"nodeType\", {\n        get: function () {\n            return 8;\n        },\n        enumerable: false,\n        configurable: true\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, data) || this;\n        _this.name = name;\n        _this.type = domelementtype_1.ElementType.Directive;\n        return _this;\n    }\n    Object.defineProperty(ProcessingInstruction.prototype, \"nodeType\", {\n        get: function () {\n            return 1;\n        },\n        enumerable: false,\n        configurable: true\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 children Children of the node. Only certain node types can have children.\n     */\n    function NodeWithChildren(children) {\n        var _this = _super.call(this) || this;\n        _this.children = children;\n        return _this;\n    }\n    Object.defineProperty(NodeWithChildren.prototype, \"firstChild\", {\n        // Aliases\n        /** First child of the node. */\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        /** Last child of the node. */\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        /**\n         * Same as {@link children}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\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 CDATA = /** @class */ (function (_super) {\n    __extends(CDATA, _super);\n    function CDATA() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.CDATA;\n        return _this;\n    }\n    Object.defineProperty(CDATA.prototype, \"nodeType\", {\n        get: function () {\n            return 4;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return CDATA;\n}(NodeWithChildren));\nexports.CDATA = CDATA;\n/**\n * The root node of the document.\n */\nvar Document = /** @class */ (function (_super) {\n    __extends(Document, _super);\n    function Document() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Root;\n        return _this;\n    }\n    Object.defineProperty(Document.prototype, \"nodeType\", {\n        get: function () {\n            return 9;\n        },\n        enumerable: false,\n        configurable: true\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, children) || this;\n        _this.name = name;\n        _this.attribs = attribs;\n        _this.type = type;\n        return _this;\n    }\n    Object.defineProperty(Element.prototype, \"nodeType\", {\n        get: function () {\n            return 1;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Element.prototype, \"tagName\", {\n        // DOM Level 1 aliases\n        /**\n         * Same as {@link name}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\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 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.namespace != null) {\n            clone_1.namespace = node.namespace;\n        }\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 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: \".concat(node.type));\n    }\n    result.startIndex = node.startIndex;\n    result.endIndex = node.endIndex;\n    if (node.sourceCodeLocation != null) {\n        result.sourceCodeLocation = node.sourceCodeLocation;\n    }\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"],"names":["ElementType","Object","defineProperty","exports","value","Doctype","CDATA","Tag","Style","Script","Comment","Directive","Text","Root","isTag","elem","type","__createBinding","this","create","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","__exportStar","p","prototype","hasOwnProperty","call","DomHandler","domelementtype_1","node_js_1","defaultOpts","withStartIndices","withEndIndices","xmlMode","callback","options","elementCB","dom","root","Document","done","tagStack","lastNode","parser","onparserinit","onreset","onend","handleCallback","onerror","error","onclosetag","pop","endIndex","onopentag","name","attribs","element","Element","addNode","push","ontext","data","node","oncomment","oncommentend","oncdatastart","text","parent","oncdataend","onprocessinginstruction","ProcessingInstruction","length","previousSibling","children","startIndex","prev","next","extendStatics","__extends","d","b","setPrototypeOf","__proto__","Array","TypeError","String","__","constructor","__assign","assign","t","s","i","n","arguments","apply","cloneNode","hasChildren","isDocument","isDirective","isComment","isText","isCDATA","NodeWithChildren","DataNode","Node","set","recursive","_super","_this","_a","keys","map","_b","namespace","prefix","result","cloneChildren","clone_1","forEach","child","clone_2","clone_3","Error","concat","instruction","sourceCodeLocation","childs"],"sourceRoot":""}