@opendesign-plus-test/components 0.0.1-rc.20 → 0.0.1-rc.201

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/dom.js.mjs

@@ -0,0 +1,1449 @@
+import { __exports as dom } from "./dom.js2.mjs";
+import { __require as requireConventions } from "./conventions.js.mjs";
+var hasRequiredDom;
+function requireDom() {
+  if (hasRequiredDom) return dom;
+  hasRequiredDom = 1;
+  var conventions = requireConventions();
+  var find = conventions.find;
+  var NAMESPACE = conventions.NAMESPACE;
+  function notEmptyString(input) {
+    return input !== "";
+  }
+  function splitOnASCIIWhitespace(input) {
+    return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
+  }
+  function orderedSetReducer(current, element) {
+    if (!current.hasOwnProperty(element)) {
+      current[element] = true;
+    }
+    return current;
+  }
+  function toOrderedSet(input) {
+    if (!input) return [];
+    var list = splitOnASCIIWhitespace(input);
+    return Object.keys(list.reduce(orderedSetReducer, {}));
+  }
+  function arrayIncludes(list) {
+    return function(element) {
+      return list && list.indexOf(element) !== -1;
+    };
+  }
+  function copy(src, dest) {
+    for (var p in src) {
+      if (Object.prototype.hasOwnProperty.call(src, p)) {
+        dest[p] = src[p];
+      }
+    }
+  }
+  function _extends(Class, Super) {
+    var pt = Class.prototype;
+    if (!(pt instanceof Super)) {
+      let t = function() {
+      };
+      t.prototype = Super.prototype;
+      t = new t();
+      copy(pt, t);
+      Class.prototype = pt = t;
+    }
+    if (pt.constructor != Class) {
+      if (typeof Class != "function") {
+        console.error("unknown Class:" + Class);
+      }
+      pt.constructor = Class;
+    }
+  }
+  var NodeType = {};
+  var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
+  var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
+  var TEXT_NODE = NodeType.TEXT_NODE = 3;
+  var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
+  var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
+  var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
+  var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
+  var COMMENT_NODE = NodeType.COMMENT_NODE = 8;
+  var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
+  var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
+  var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
+  var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
+  var ExceptionCode = {};
+  var ExceptionMessage = {};
+  ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
+  ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
+  var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
+  ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
+  var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
+  ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
+  ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
+  var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
+  ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
+  var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
+  ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
+  ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
+  ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
+  ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
+  ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = "Invalid access", 15);
+  function DOMException(code, message) {
+    if (message instanceof Error) {
+      var error = message;
+    } else {
+      error = this;
+      Error.call(this, ExceptionMessage[code]);
+      this.message = ExceptionMessage[code];
+      if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
+    }
+    error.code = code;
+    if (message) this.message = this.message + ": " + message;
+    return error;
+  }
+  DOMException.prototype = Error.prototype;
+  copy(ExceptionCode, DOMException);
+  function NodeList() {
+  }
+  NodeList.prototype = {
+    /**
+     * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
+     * @standard level1
+     */
+    length: 0,
+    /**
+     * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
+     * @standard level1
+     * @param index  unsigned long
+     *   Index into the collection.
+     * @return Node
+     * 	The node at the indexth position in the NodeList, or null if that is not a valid index.
+     */
+    item: function(index) {
+      return index >= 0 && index < this.length ? this[index] : null;
+    },
+    toString: function(isHTML, nodeFilter) {
+      for (var buf = [], i = 0; i < this.length; i++) {
+        serializeToString(this[i], buf, isHTML, nodeFilter);
+      }
+      return buf.join("");
+    },
+    /**
+     * @private
+     * @param {function (Node):boolean} predicate
+     * @returns {Node[]}
+     */
+    filter: function(predicate) {
+      return Array.prototype.filter.call(this, predicate);
+    },
+    /**
+     * @private
+     * @param {Node} item
+     * @returns {number}
+     */
+    indexOf: function(item) {
+      return Array.prototype.indexOf.call(this, item);
+    }
+  };
+  function LiveNodeList(node, refresh) {
+    this._node = node;
+    this._refresh = refresh;
+    _updateLiveList(this);
+  }
+  function _updateLiveList(list) {
+    var inc = list._node._inc || list._node.ownerDocument._inc;
+    if (list._inc !== inc) {
+      var ls = list._refresh(list._node);
+      __set__(list, "length", ls.length);
+      if (!list.$$length || ls.length < list.$$length) {
+        for (var i = ls.length; i in list; i++) {
+          if (Object.prototype.hasOwnProperty.call(list, i)) {
+            delete list[i];
+          }
+        }
+      }
+      copy(ls, list);
+      list._inc = inc;
+    }
+  }
+  LiveNodeList.prototype.item = function(i) {
+    _updateLiveList(this);
+    return this[i] || null;
+  };
+  _extends(LiveNodeList, NodeList);
+  function NamedNodeMap() {
+  }
+  function _findNodeIndex(list, node) {
+    var i = list.length;
+    while (i--) {
+      if (list[i] === node) {
+        return i;
+      }
+    }
+  }
+  function _addNamedNode(el, list, newAttr, oldAttr) {
+    if (oldAttr) {
+      list[_findNodeIndex(list, oldAttr)] = newAttr;
+    } else {
+      list[list.length++] = newAttr;
+    }
+    if (el) {
+      newAttr.ownerElement = el;
+      var doc = el.ownerDocument;
+      if (doc) {
+        oldAttr && _onRemoveAttribute(doc, el, oldAttr);
+        _onAddAttribute(doc, el, newAttr);
+      }
+    }
+  }
+  function _removeNamedNode(el, list, attr) {
+    var i = _findNodeIndex(list, attr);
+    if (i >= 0) {
+      var lastIndex = list.length - 1;
+      while (i < lastIndex) {
+        list[i] = list[++i];
+      }
+      list.length = lastIndex;
+      if (el) {
+        var doc = el.ownerDocument;
+        if (doc) {
+          _onRemoveAttribute(doc, el, attr);
+          attr.ownerElement = null;
+        }
+      }
+    } else {
+      throw new DOMException(NOT_FOUND_ERR, new Error(el.tagName + "@" + attr));
+    }
+  }
+  NamedNodeMap.prototype = {
+    length: 0,
+    item: NodeList.prototype.item,
+    getNamedItem: function(key) {
+      var i = this.length;
+      while (i--) {
+        var attr = this[i];
+        if (attr.nodeName == key) {
+          return attr;
+        }
+      }
+    },
+    setNamedItem: function(attr) {
+      var el = attr.ownerElement;
+      if (el && el != this._ownerElement) {
+        throw new DOMException(INUSE_ATTRIBUTE_ERR);
+      }
+      var oldAttr = this.getNamedItem(attr.nodeName);
+      _addNamedNode(this._ownerElement, this, attr, oldAttr);
+      return oldAttr;
+    },
+    /* returns Node */
+    setNamedItemNS: function(attr) {
+      var el = attr.ownerElement, oldAttr;
+      if (el && el != this._ownerElement) {
+        throw new DOMException(INUSE_ATTRIBUTE_ERR);
+      }
+      oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
+      _addNamedNode(this._ownerElement, this, attr, oldAttr);
+      return oldAttr;
+    },
+    /* returns Node */
+    removeNamedItem: function(key) {
+      var attr = this.getNamedItem(key);
+      _removeNamedNode(this._ownerElement, this, attr);
+      return attr;
+    },
+    // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+    //for level2
+    removeNamedItemNS: function(namespaceURI, localName) {
+      var attr = this.getNamedItemNS(namespaceURI, localName);
+      _removeNamedNode(this._ownerElement, this, attr);
+      return attr;
+    },
+    getNamedItemNS: function(namespaceURI, localName) {
+      var i = this.length;
+      while (i--) {
+        var node = this[i];
+        if (node.localName == localName && node.namespaceURI == namespaceURI) {
+          return node;
+        }
+      }
+      return null;
+    }
+  };
+  function DOMImplementation() {
+  }
+  DOMImplementation.prototype = {
+    /**
+     * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
+     * The different implementations fairly diverged in what kind of features were reported.
+     * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.
+     *
+     * @deprecated It is deprecated and modern browsers return true in all cases.
+     *
+     * @param {string} feature
+     * @param {string} [version]
+     * @returns {boolean} always true
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN
+     * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
+     */
+    hasFeature: function(feature, version) {
+      return true;
+    },
+    /**
+     * Creates an XML Document object of the specified type with its document element.
+     *
+     * __It behaves slightly different from the description in the living standard__:
+     * - There is no interface/class `XMLDocument`, it returns a `Document` instance.
+     * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+     * - this implementation is not validating names or qualified names
+     *   (when parsing XML strings, the SAX parser takes care of that)
+     *
+     * @param {string|null} namespaceURI
+     * @param {string} qualifiedName
+     * @param {DocumentType=null} doctype
+     * @returns {Document}
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN
+     * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core
+     *
+     * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+     * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+     * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+     */
+    createDocument: function(namespaceURI, qualifiedName, doctype) {
+      var doc = new Document();
+      doc.implementation = this;
+      doc.childNodes = new NodeList();
+      doc.doctype = doctype || null;
+      if (doctype) {
+        doc.appendChild(doctype);
+      }
+      if (qualifiedName) {
+        var root = doc.createElementNS(namespaceURI, qualifiedName);
+        doc.appendChild(root);
+      }
+      return doc;
+    },
+    /**
+     * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+     *
+     * __This behavior is slightly different from the in the specs__:
+     * - this implementation is not validating names or qualified names
+     *   (when parsing XML strings, the SAX parser takes care of that)
+     *
+     * @param {string} qualifiedName
+     * @param {string} [publicId]
+     * @param {string} [systemId]
+     * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
+     * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN
+     * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard
+     *
+     * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+     * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+     * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+     */
+    createDocumentType: function(qualifiedName, publicId, systemId) {
+      var node = new DocumentType();
+      node.name = qualifiedName;
+      node.nodeName = qualifiedName;
+      node.publicId = publicId || "";
+      node.systemId = systemId || "";
+      return node;
+    }
+  };
+  function Node() {
+  }
+  Node.prototype = {
+    firstChild: null,
+    lastChild: null,
+    previousSibling: null,
+    nextSibling: null,
+    attributes: null,
+    parentNode: null,
+    childNodes: null,
+    ownerDocument: null,
+    nodeValue: null,
+    namespaceURI: null,
+    prefix: null,
+    localName: null,
+    // Modified in DOM Level 2:
+    insertBefore: function(newChild, refChild) {
+      return _insertBefore(this, newChild, refChild);
+    },
+    replaceChild: function(newChild, oldChild) {
+      _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
+      if (oldChild) {
+        this.removeChild(oldChild);
+      }
+    },
+    removeChild: function(oldChild) {
+      return _removeChild(this, oldChild);
+    },
+    appendChild: function(newChild) {
+      return this.insertBefore(newChild, null);
+    },
+    hasChildNodes: function() {
+      return this.firstChild != null;
+    },
+    cloneNode: function(deep) {
+      return cloneNode(this.ownerDocument || this, this, deep);
+    },
+    // Modified in DOM Level 2:
+    normalize: function() {
+      var child = this.firstChild;
+      while (child) {
+        var next = child.nextSibling;
+        if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {
+          this.removeChild(next);
+          child.appendData(next.data);
+        } else {
+          child.normalize();
+          child = next;
+        }
+      }
+    },
+    // Introduced in DOM Level 2:
+    isSupported: function(feature, version) {
+      return this.ownerDocument.implementation.hasFeature(feature, version);
+    },
+    // Introduced in DOM Level 2:
+    hasAttributes: function() {
+      return this.attributes.length > 0;
+    },
+    /**
+     * Look up the prefix associated to the given namespace URI, starting from this node.
+     * **The default namespace declarations are ignored by this method.**
+     * See Namespace Prefix Lookup for details on the algorithm used by this method.
+     *
+     * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._
+     *
+     * @param {string | null} namespaceURI
+     * @returns {string | null}
+     * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix
+     * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo
+     * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix
+     * @see https://github.com/xmldom/xmldom/issues/322
+     */
+    lookupPrefix: function(namespaceURI) {
+      var el = this;
+      while (el) {
+        var map = el._nsMap;
+        if (map) {
+          for (var n in map) {
+            if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) {
+              return n;
+            }
+          }
+        }
+        el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    lookupNamespaceURI: function(prefix) {
+      var el = this;
+      while (el) {
+        var map = el._nsMap;
+        if (map) {
+          if (Object.prototype.hasOwnProperty.call(map, prefix)) {
+            return map[prefix];
+          }
+        }
+        el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    isDefaultNamespace: function(namespaceURI) {
+      var prefix = this.lookupPrefix(namespaceURI);
+      return prefix == null;
+    }
+  };
+  function _xmlEncoder(c) {
+    return c == "<" && "&lt;" || c == ">" && "&gt;" || c == "&" && "&amp;" || c == '"' && "&quot;" || "&#" + c.charCodeAt() + ";";
+  }
+  copy(NodeType, Node);
+  copy(NodeType, Node.prototype);
+  function _visitNode(node, callback) {
+    if (callback(node)) {
+      return true;
+    }
+    if (node = node.firstChild) {
+      do {
+        if (_visitNode(node, callback)) {
+          return true;
+        }
+      } while (node = node.nextSibling);
+    }
+  }
+  function Document() {
+    this.ownerDocument = this;
+  }
+  function _onAddAttribute(doc, el, newAttr) {
+    doc && doc._inc++;
+    var ns = newAttr.namespaceURI;
+    if (ns === NAMESPACE.XMLNS) {
+      el._nsMap[newAttr.prefix ? newAttr.localName : ""] = newAttr.value;
+    }
+  }
+  function _onRemoveAttribute(doc, el, newAttr, remove) {
+    doc && doc._inc++;
+    var ns = newAttr.namespaceURI;
+    if (ns === NAMESPACE.XMLNS) {
+      delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];
+    }
+  }
+  function _onUpdateChild(doc, el, newChild) {
+    if (doc && doc._inc) {
+      doc._inc++;
+      var cs = el.childNodes;
+      if (newChild) {
+        cs[cs.length++] = newChild;
+      } else {
+        var child = el.firstChild;
+        var i = 0;
+        while (child) {
+          cs[i++] = child;
+          child = child.nextSibling;
+        }
+        cs.length = i;
+        delete cs[cs.length];
+      }
+    }
+  }
+  function _removeChild(parentNode, child) {
+    var previous = child.previousSibling;
+    var next = child.nextSibling;
+    if (previous) {
+      previous.nextSibling = next;
+    } else {
+      parentNode.firstChild = next;
+    }
+    if (next) {
+      next.previousSibling = previous;
+    } else {
+      parentNode.lastChild = previous;
+    }
+    child.parentNode = null;
+    child.previousSibling = null;
+    child.nextSibling = null;
+    _onUpdateChild(parentNode.ownerDocument, parentNode);
+    return child;
+  }
+  function hasValidParentNodeType(node) {
+    return node && (node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE);
+  }
+  function hasInsertableNodeType(node) {
+    return node && (isElementNode(node) || isTextNode(node) || isDocTypeNode(node) || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.COMMENT_NODE || node.nodeType === Node.PROCESSING_INSTRUCTION_NODE);
+  }
+  function isDocTypeNode(node) {
+    return node && node.nodeType === Node.DOCUMENT_TYPE_NODE;
+  }
+  function isElementNode(node) {
+    return node && node.nodeType === Node.ELEMENT_NODE;
+  }
+  function isTextNode(node) {
+    return node && node.nodeType === Node.TEXT_NODE;
+  }
+  function isElementInsertionPossible(doc, child) {
+    var parentChildNodes = doc.childNodes || [];
+    if (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) {
+      return false;
+    }
+    var docTypeNode = find(parentChildNodes, isDocTypeNode);
+    return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
+  }
+  function isElementReplacementPossible(doc, child) {
+    var parentChildNodes = doc.childNodes || [];
+    function hasElementChildThatIsNotChild(node) {
+      return isElementNode(node) && node !== child;
+    }
+    if (find(parentChildNodes, hasElementChildThatIsNotChild)) {
+      return false;
+    }
+    var docTypeNode = find(parentChildNodes, isDocTypeNode);
+    return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
+  }
+  function assertPreInsertionValidity1to5(parent, node, child) {
+    if (!hasValidParentNodeType(parent)) {
+      throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);
+    }
+    if (child && child.parentNode !== parent) {
+      throw new DOMException(NOT_FOUND_ERR, "child not in parent");
+    }
+    if (
+      // 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
+      !hasInsertableNodeType(node) || // 5. If either `node` is a Text node and `parent` is a document,
+      // the sax parser currently adds top level text nodes, this will be fixed in 0.9.0
+      // || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)
+      // or `node` is a doctype and `parent` is not a document, then throw a "HierarchyRequestError" DOMException.
+      isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE
+    ) {
+      throw new DOMException(
+        HIERARCHY_REQUEST_ERR,
+        "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType
+      );
+    }
+  }
+  function assertPreInsertionValidityInDocument(parent, node, child) {
+    var parentChildNodes = parent.childNodes || [];
+    var nodeChildNodes = node.childNodes || [];
+    if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      var nodeChildElements = nodeChildNodes.filter(isElementNode);
+      if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
+      }
+      if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
+      }
+    }
+    if (isElementNode(node)) {
+      if (!isElementInsertionPossible(parent, child)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
+      }
+    }
+    if (isDocTypeNode(node)) {
+      if (find(parentChildNodes, isDocTypeNode)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
+      }
+      var parentElementChild = find(parentChildNodes, isElementNode);
+      if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
+      }
+      if (!child && parentElementChild) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");
+      }
+    }
+  }
+  function assertPreReplacementValidityInDocument(parent, node, child) {
+    var parentChildNodes = parent.childNodes || [];
+    var nodeChildNodes = node.childNodes || [];
+    if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      var nodeChildElements = nodeChildNodes.filter(isElementNode);
+      if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
+      }
+      if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
+      }
+    }
+    if (isElementNode(node)) {
+      if (!isElementReplacementPossible(parent, child)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
+      }
+    }
+    if (isDocTypeNode(node)) {
+      let hasDoctypeChildThatIsNotChild = function(node2) {
+        return isDocTypeNode(node2) && node2 !== child;
+      };
+      if (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
+      }
+      var parentElementChild = find(parentChildNodes, isElementNode);
+      if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
+        throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
+      }
+    }
+  }
+  function _insertBefore(parent, node, child, _inDocumentAssertion) {
+    assertPreInsertionValidity1to5(parent, node, child);
+    if (parent.nodeType === Node.DOCUMENT_NODE) {
+      (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
+    }
+    var cp = node.parentNode;
+    if (cp) {
+      cp.removeChild(node);
+    }
+    if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+      var newFirst = node.firstChild;
+      if (newFirst == null) {
+        return node;
+      }
+      var newLast = node.lastChild;
+    } else {
+      newFirst = newLast = node;
+    }
+    var pre = child ? child.previousSibling : parent.lastChild;
+    newFirst.previousSibling = pre;
+    newLast.nextSibling = child;
+    if (pre) {
+      pre.nextSibling = newFirst;
+    } else {
+      parent.firstChild = newFirst;
+    }
+    if (child == null) {
+      parent.lastChild = newLast;
+    } else {
+      child.previousSibling = newLast;
+    }
+    do {
+      newFirst.parentNode = parent;
+      var targetDoc = parent.ownerDocument || parent;
+      _updateOwnerDocument(newFirst, targetDoc);
+    } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
+    _onUpdateChild(parent.ownerDocument || parent, parent);
+    if (node.nodeType == DOCUMENT_FRAGMENT_NODE) {
+      node.firstChild = node.lastChild = null;
+    }
+    return node;
+  }
+  function _updateOwnerDocument(node, newOwnerDocument) {
+    if (node.ownerDocument === newOwnerDocument) {
+      return;
+    }
+    node.ownerDocument = newOwnerDocument;
+    if (node.nodeType === ELEMENT_NODE && node.attributes) {
+      for (var i = 0; i < node.attributes.length; i++) {
+        var attr = node.attributes.item(i);
+        if (attr) {
+          attr.ownerDocument = newOwnerDocument;
+        }
+      }
+    }
+    var child = node.firstChild;
+    while (child) {
+      _updateOwnerDocument(child, newOwnerDocument);
+      child = child.nextSibling;
+    }
+  }
+  function _appendSingleChild(parentNode, newChild) {
+    if (newChild.parentNode) {
+      newChild.parentNode.removeChild(newChild);
+    }
+    newChild.parentNode = parentNode;
+    newChild.previousSibling = parentNode.lastChild;
+    newChild.nextSibling = null;
+    if (newChild.previousSibling) {
+      newChild.previousSibling.nextSibling = newChild;
+    } else {
+      parentNode.firstChild = newChild;
+    }
+    parentNode.lastChild = newChild;
+    _onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
+    var targetDoc = parentNode.ownerDocument || parentNode;
+    _updateOwnerDocument(newChild, targetDoc);
+    return newChild;
+  }
+  Document.prototype = {
+    //implementation : null,
+    nodeName: "#document",
+    nodeType: DOCUMENT_NODE,
+    /**
+     * The DocumentType node of the document.
+     *
+     * @readonly
+     * @type DocumentType
+     */
+    doctype: null,
+    documentElement: null,
+    _inc: 1,
+    insertBefore: function(newChild, refChild) {
+      if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
+        var child = newChild.firstChild;
+        while (child) {
+          var next = child.nextSibling;
+          this.insertBefore(child, refChild);
+          child = next;
+        }
+        return newChild;
+      }
+      _insertBefore(this, newChild, refChild);
+      _updateOwnerDocument(newChild, this);
+      if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {
+        this.documentElement = newChild;
+      }
+      return newChild;
+    },
+    removeChild: function(oldChild) {
+      if (this.documentElement == oldChild) {
+        this.documentElement = null;
+      }
+      return _removeChild(this, oldChild);
+    },
+    replaceChild: function(newChild, oldChild) {
+      _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
+      _updateOwnerDocument(newChild, this);
+      if (oldChild) {
+        this.removeChild(oldChild);
+      }
+      if (isElementNode(newChild)) {
+        this.documentElement = newChild;
+      }
+    },
+    // Introduced in DOM Level 2:
+    importNode: function(importedNode, deep) {
+      return importNode(this, importedNode, deep);
+    },
+    // Introduced in DOM Level 2:
+    getElementById: function(id) {
+      var rtv = null;
+      _visitNode(this.documentElement, function(node) {
+        if (node.nodeType == ELEMENT_NODE) {
+          if (node.getAttribute("id") == id) {
+            rtv = node;
+            return true;
+          }
+        }
+      });
+      return rtv;
+    },
+    /**
+     * The `getElementsByClassName` method of `Document` interface returns an array-like object
+     * of all child elements which have **all** of the given class name(s).
+     *
+     * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.
+     *
+     *
+     * Warning: This is a live LiveNodeList.
+     * Changes in the DOM will reflect in the array as the changes occur.
+     * If an element selected by this array no longer qualifies for the selector,
+     * it will automatically be removed. Be aware of this for iteration purposes.
+     *
+     * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
+     * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
+     */
+    getElementsByClassName: function(classNames) {
+      var classNamesSet = toOrderedSet(classNames);
+      return new LiveNodeList(this, function(base) {
+        var ls = [];
+        if (classNamesSet.length > 0) {
+          _visitNode(base.documentElement, function(node) {
+            if (node !== base && node.nodeType === ELEMENT_NODE) {
+              var nodeClassNames = node.getAttribute("class");
+              if (nodeClassNames) {
+                var matches = classNames === nodeClassNames;
+                if (!matches) {
+                  var nodeClassNamesSet = toOrderedSet(nodeClassNames);
+                  matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
+                }
+                if (matches) {
+                  ls.push(node);
+                }
+              }
+            }
+          });
+        }
+        return ls;
+      });
+    },
+    //document factory method:
+    createElement: function(tagName) {
+      var node = new Element();
+      node.ownerDocument = this;
+      node.nodeName = tagName;
+      node.tagName = tagName;
+      node.localName = tagName;
+      node.childNodes = new NodeList();
+      var attrs = node.attributes = new NamedNodeMap();
+      attrs._ownerElement = node;
+      return node;
+    },
+    createDocumentFragment: function() {
+      var node = new DocumentFragment();
+      node.ownerDocument = this;
+      node.childNodes = new NodeList();
+      return node;
+    },
+    createTextNode: function(data) {
+      var node = new Text();
+      node.ownerDocument = this;
+      node.appendData(data);
+      return node;
+    },
+    createComment: function(data) {
+      var node = new Comment();
+      node.ownerDocument = this;
+      node.appendData(data);
+      return node;
+    },
+    /**
+     * Returns a new CDATASection node whose data is `data`.
+     *
+     * __This implementation differs from the specification:__
+     * - calling this method on an HTML document does not throw `NotSupportedError`.
+     *
+     * @param {string} data
+     * @returns {CDATASection}
+     * @throws DOMException with code `INVALID_CHARACTER_ERR` if `data` contains `"]]>"`.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createCDATASection
+     * @see https://dom.spec.whatwg.org/#dom-document-createcdatasection
+     */
+    createCDATASection: function(data) {
+      if (data.indexOf("]]>") !== -1) {
+        throw new DOMException(INVALID_CHARACTER_ERR, 'data contains "]]>"');
+      }
+      var node = new CDATASection();
+      node.ownerDocument = this;
+      node.appendData(data);
+      return node;
+    },
+    createProcessingInstruction: function(target, data) {
+      var node = new ProcessingInstruction();
+      node.ownerDocument = this;
+      node.tagName = node.nodeName = node.target = target;
+      node.nodeValue = node.data = data;
+      return node;
+    },
+    createAttribute: function(name) {
+      var node = new Attr();
+      node.ownerDocument = this;
+      node.name = name;
+      node.nodeName = name;
+      node.localName = name;
+      node.specified = true;
+      return node;
+    },
+    createEntityReference: function(name) {
+      var node = new EntityReference();
+      node.ownerDocument = this;
+      node.nodeName = name;
+      return node;
+    },
+    // Introduced in DOM Level 2:
+    createElementNS: function(namespaceURI, qualifiedName) {
+      var node = new Element();
+      var pl = qualifiedName.split(":");
+      var attrs = node.attributes = new NamedNodeMap();
+      node.childNodes = new NodeList();
+      node.ownerDocument = this;
+      node.nodeName = qualifiedName;
+      node.tagName = qualifiedName;
+      node.namespaceURI = namespaceURI;
+      if (pl.length == 2) {
+        node.prefix = pl[0];
+        node.localName = pl[1];
+      } else {
+        node.localName = qualifiedName;
+      }
+      attrs._ownerElement = node;
+      return node;
+    },
+    // Introduced in DOM Level 2:
+    createAttributeNS: function(namespaceURI, qualifiedName) {
+      var node = new Attr();
+      var pl = qualifiedName.split(":");
+      node.ownerDocument = this;
+      node.nodeName = qualifiedName;
+      node.name = qualifiedName;
+      node.namespaceURI = namespaceURI;
+      node.specified = true;
+      if (pl.length == 2) {
+        node.prefix = pl[0];
+        node.localName = pl[1];
+      } else {
+        node.localName = qualifiedName;
+      }
+      return node;
+    }
+  };
+  _extends(Document, Node);
+  function Element() {
+    this._nsMap = {};
+  }
+  Element.prototype = {
+    nodeType: ELEMENT_NODE,
+    hasAttribute: function(name) {
+      return this.getAttributeNode(name) != null;
+    },
+    getAttribute: function(name) {
+      var attr = this.getAttributeNode(name);
+      return attr && attr.value || "";
+    },
+    getAttributeNode: function(name) {
+      return this.attributes.getNamedItem(name);
+    },
+    setAttribute: function(name, value) {
+      var attr = this.ownerDocument.createAttribute(name);
+      attr.value = attr.nodeValue = "" + value;
+      this.setAttributeNode(attr);
+    },
+    removeAttribute: function(name) {
+      var attr = this.getAttributeNode(name);
+      attr && this.removeAttributeNode(attr);
+    },
+    //four real opeartion method
+    appendChild: function(newChild) {
+      if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
+        return this.insertBefore(newChild, null);
+      } else {
+        return _appendSingleChild(this, newChild);
+      }
+    },
+    setAttributeNode: function(newAttr) {
+      return this.attributes.setNamedItem(newAttr);
+    },
+    setAttributeNodeNS: function(newAttr) {
+      return this.attributes.setNamedItemNS(newAttr);
+    },
+    removeAttributeNode: function(oldAttr) {
+      return this.attributes.removeNamedItem(oldAttr.nodeName);
+    },
+    //get real attribute name,and remove it by removeAttributeNode
+    removeAttributeNS: function(namespaceURI, localName) {
+      var old = this.getAttributeNodeNS(namespaceURI, localName);
+      old && this.removeAttributeNode(old);
+    },
+    hasAttributeNS: function(namespaceURI, localName) {
+      return this.getAttributeNodeNS(namespaceURI, localName) != null;
+    },
+    getAttributeNS: function(namespaceURI, localName) {
+      var attr = this.getAttributeNodeNS(namespaceURI, localName);
+      return attr && attr.value || "";
+    },
+    setAttributeNS: function(namespaceURI, qualifiedName, value) {
+      var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
+      attr.value = attr.nodeValue = "" + value;
+      this.setAttributeNode(attr);
+    },
+    getAttributeNodeNS: function(namespaceURI, localName) {
+      return this.attributes.getNamedItemNS(namespaceURI, localName);
+    },
+    getElementsByTagName: function(tagName) {
+      return new LiveNodeList(this, function(base) {
+        var ls = [];
+        _visitNode(base, function(node) {
+          if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === "*" || node.tagName == tagName)) {
+            ls.push(node);
+          }
+        });
+        return ls;
+      });
+    },
+    getElementsByTagNameNS: function(namespaceURI, localName) {
+      return new LiveNodeList(this, function(base) {
+        var ls = [];
+        _visitNode(base, function(node) {
+          if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === "*" || node.namespaceURI === namespaceURI) && (localName === "*" || node.localName == localName)) {
+            ls.push(node);
+          }
+        });
+        return ls;
+      });
+    }
+  };
+  Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
+  Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
+  _extends(Element, Node);
+  function Attr() {
+  }
+  Attr.prototype.nodeType = ATTRIBUTE_NODE;
+  _extends(Attr, Node);
+  function CharacterData() {
+  }
+  CharacterData.prototype = {
+    data: "",
+    substringData: function(offset, count) {
+      return this.data.substring(offset, offset + count);
+    },
+    appendData: function(text) {
+      text = this.data + text;
+      this.nodeValue = this.data = text;
+      this.length = text.length;
+    },
+    insertData: function(offset, text) {
+      this.replaceData(offset, 0, text);
+    },
+    appendChild: function(newChild) {
+      throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
+    },
+    deleteData: function(offset, count) {
+      this.replaceData(offset, count, "");
+    },
+    replaceData: function(offset, count, text) {
+      var start = this.data.substring(0, offset);
+      var end = this.data.substring(offset + count);
+      text = start + text + end;
+      this.nodeValue = this.data = text;
+      this.length = text.length;
+    }
+  };
+  _extends(CharacterData, Node);
+  function Text() {
+  }
+  Text.prototype = {
+    nodeName: "#text",
+    nodeType: TEXT_NODE,
+    splitText: function(offset) {
+      var text = this.data;
+      var newText = text.substring(offset);
+      text = text.substring(0, offset);
+      this.data = this.nodeValue = text;
+      this.length = text.length;
+      var newNode = this.ownerDocument.createTextNode(newText);
+      if (this.parentNode) {
+        this.parentNode.insertBefore(newNode, this.nextSibling);
+      }
+      return newNode;
+    }
+  };
+  _extends(Text, CharacterData);
+  function Comment() {
+  }
+  Comment.prototype = {
+    nodeName: "#comment",
+    nodeType: COMMENT_NODE
+  };
+  _extends(Comment, CharacterData);
+  function CDATASection() {
+  }
+  CDATASection.prototype = {
+    nodeName: "#cdata-section",
+    nodeType: CDATA_SECTION_NODE
+  };
+  _extends(CDATASection, CharacterData);
+  function DocumentType() {
+  }
+  DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
+  _extends(DocumentType, Node);
+  function Notation() {
+  }
+  Notation.prototype.nodeType = NOTATION_NODE;
+  _extends(Notation, Node);
+  function Entity() {
+  }
+  Entity.prototype.nodeType = ENTITY_NODE;
+  _extends(Entity, Node);
+  function EntityReference() {
+  }
+  EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
+  _extends(EntityReference, Node);
+  function DocumentFragment() {
+  }
+  DocumentFragment.prototype.nodeName = "#document-fragment";
+  DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
+  _extends(DocumentFragment, Node);
+  function ProcessingInstruction() {
+  }
+  ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
+  _extends(ProcessingInstruction, Node);
+  function XMLSerializer() {
+  }
+  XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {
+    return nodeSerializeToString.call(node, isHtml, nodeFilter);
+  };
+  Node.prototype.toString = nodeSerializeToString;
+  function nodeSerializeToString(isHtml, nodeFilter) {
+    var buf = [];
+    var refNode = this.nodeType == 9 && this.documentElement || this;
+    var prefix = refNode.prefix;
+    var uri = refNode.namespaceURI;
+    if (uri && prefix == null) {
+      var prefix = refNode.lookupPrefix(uri);
+      if (prefix == null) {
+        var visibleNamespaces = [
+          { namespace: uri, prefix: null }
+          //{namespace:uri,prefix:''}
+        ];
+      }
+    }
+    serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);
+    return buf.join("");
+  }
+  function needNamespaceDefine(node, isHTML, visibleNamespaces) {
+    var prefix = node.prefix || "";
+    var uri = node.namespaceURI;
+    if (!uri) {
+      return false;
+    }
+    if (prefix === "xml" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {
+      return false;
+    }
+    var i = visibleNamespaces.length;
+    while (i--) {
+      var ns = visibleNamespaces[i];
+      if (ns.prefix === prefix) {
+        return ns.namespace !== uri;
+      }
+    }
+    return true;
+  }
+  function addSerializedAttribute(buf, qualifiedName, value) {
+    buf.push(" ", qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
+  }
+  function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {
+    if (!visibleNamespaces) {
+      visibleNamespaces = [];
+    }
+    if (nodeFilter) {
+      node = nodeFilter(node);
+      if (node) {
+        if (typeof node == "string") {
+          buf.push(node);
+          return;
+        }
+      } else {
+        return;
+      }
+    }
+    switch (node.nodeType) {
+      case ELEMENT_NODE:
+        var attrs = node.attributes;
+        var len = attrs.length;
+        var child = node.firstChild;
+        var nodeName = node.tagName;
+        isHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML;
+        var prefixedNodeName = nodeName;
+        if (!isHTML && !node.prefix && node.namespaceURI) {
+          var defaultNS;
+          for (var ai = 0; ai < attrs.length; ai++) {
+            if (attrs.item(ai).name === "xmlns") {
+              defaultNS = attrs.item(ai).value;
+              break;
+            }
+          }
+          if (!defaultNS) {
+            for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+              var namespace = visibleNamespaces[nsi];
+              if (namespace.prefix === "" && namespace.namespace === node.namespaceURI) {
+                defaultNS = namespace.namespace;
+                break;
+              }
+            }
+          }
+          if (defaultNS !== node.namespaceURI) {
+            for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+              var namespace = visibleNamespaces[nsi];
+              if (namespace.namespace === node.namespaceURI) {
+                if (namespace.prefix) {
+                  prefixedNodeName = namespace.prefix + ":" + nodeName;
+                }
+                break;
+              }
+            }
+          }
+        }
+        buf.push("<", prefixedNodeName);
+        for (var i = 0; i < len; i++) {
+          var attr = attrs.item(i);
+          if (attr.prefix == "xmlns") {
+            visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
+          } else if (attr.nodeName == "xmlns") {
+            visibleNamespaces.push({ prefix: "", namespace: attr.value });
+          }
+        }
+        for (var i = 0; i < len; i++) {
+          var attr = attrs.item(i);
+          if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
+            var prefix = attr.prefix || "";
+            var uri = attr.namespaceURI;
+            addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
+            visibleNamespaces.push({ prefix, namespace: uri });
+          }
+          serializeToString(attr, buf, isHTML, nodeFilter, visibleNamespaces);
+        }
+        if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
+          var prefix = node.prefix || "";
+          var uri = node.namespaceURI;
+          addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
+          visibleNamespaces.push({ prefix, namespace: uri });
+        }
+        if (child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {
+          buf.push(">");
+          if (isHTML && /^script$/i.test(nodeName)) {
+            while (child) {
+              if (child.data) {
+                buf.push(child.data);
+              } else {
+                serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+              }
+              child = child.nextSibling;
+            }
+          } else {
+            while (child) {
+              serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+              child = child.nextSibling;
+            }
+          }
+          buf.push("</", prefixedNodeName, ">");
+        } else {
+          buf.push("/>");
+        }
+        return;
+      case DOCUMENT_NODE:
+      case DOCUMENT_FRAGMENT_NODE:
+        var child = node.firstChild;
+        while (child) {
+          serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+          child = child.nextSibling;
+        }
+        return;
+      case ATTRIBUTE_NODE:
+        return addSerializedAttribute(buf, node.name, node.value);
+      case TEXT_NODE:
+        return buf.push(
+          node.data.replace(/[<&>]/g, _xmlEncoder)
+        );
+      case CDATA_SECTION_NODE:
+        return buf.push("<![CDATA[", node.data.replace(/]]>/g, "]]]]><![CDATA[>"), "]]>");
+      case COMMENT_NODE:
+        return buf.push("<!--", node.data, "-->");
+      case DOCUMENT_TYPE_NODE:
+        var pubid = node.publicId;
+        var sysid = node.systemId;
+        buf.push("<!DOCTYPE ", node.name);
+        if (pubid) {
+          buf.push(" PUBLIC ", pubid);
+          if (sysid && sysid != ".") {
+            buf.push(" ", sysid);
+          }
+          buf.push(">");
+        } else if (sysid && sysid != ".") {
+          buf.push(" SYSTEM ", sysid, ">");
+        } else {
+          var sub = node.internalSubset;
+          if (sub) {
+            buf.push(" [", sub, "]");
+          }
+          buf.push(">");
+        }
+        return;
+      case PROCESSING_INSTRUCTION_NODE:
+        return buf.push("<?", node.target, " ", node.data, "?>");
+      case ENTITY_REFERENCE_NODE:
+        return buf.push("&", node.nodeName, ";");
+      //case ENTITY_NODE:
+      //case NOTATION_NODE:
+      default:
+        buf.push("??", node.nodeName);
+    }
+  }
+  function importNode(doc, node, deep) {
+    var node2;
+    switch (node.nodeType) {
+      case ELEMENT_NODE:
+        node2 = node.cloneNode(false);
+        node2.ownerDocument = doc;
+      //var attrs = node2.attributes;
+      //var len = attrs.length;
+      //for(var i=0;i<len;i++){
+      //node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
+      //}
+      case DOCUMENT_FRAGMENT_NODE:
+        break;
+      case ATTRIBUTE_NODE:
+        deep = true;
+        break;
+    }
+    if (!node2) {
+      node2 = node.cloneNode(false);
+    }
+    node2.ownerDocument = doc;
+    node2.parentNode = null;
+    if (deep) {
+      var child = node.firstChild;
+      while (child) {
+        node2.appendChild(importNode(doc, child, deep));
+        child = child.nextSibling;
+      }
+    }
+    return node2;
+  }
+  function cloneNode(doc, node, deep) {
+    var node2 = new node.constructor();
+    for (var n in node) {
+      if (Object.prototype.hasOwnProperty.call(node, n)) {
+        var v = node[n];
+        if (typeof v != "object") {
+          if (v != node2[n]) {
+            node2[n] = v;
+          }
+        }
+      }
+    }
+    if (node.childNodes) {
+      node2.childNodes = new NodeList();
+    }
+    node2.ownerDocument = doc;
+    switch (node2.nodeType) {
+      case ELEMENT_NODE:
+        var attrs = node.attributes;
+        var attrs2 = node2.attributes = new NamedNodeMap();
+        var len = attrs.length;
+        attrs2._ownerElement = node2;
+        for (var i = 0; i < len; i++) {
+          node2.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+        }
+        break;
+      case ATTRIBUTE_NODE:
+        deep = true;
+    }
+    if (deep) {
+      var child = node.firstChild;
+      while (child) {
+        node2.appendChild(cloneNode(doc, child, deep));
+        child = child.nextSibling;
+      }
+    }
+    return node2;
+  }
+  function __set__(object, key, value) {
+    object[key] = value;
+  }
+  try {
+    if (Object.defineProperty) {
+      let getTextContent = function(node) {
+        switch (node.nodeType) {
+          case ELEMENT_NODE:
+          case DOCUMENT_FRAGMENT_NODE:
+            var buf = [];
+            node = node.firstChild;
+            while (node) {
+              if (node.nodeType !== 7 && node.nodeType !== 8) {
+                buf.push(getTextContent(node));
+              }
+              node = node.nextSibling;
+            }
+            return buf.join("");
+          default:
+            return node.nodeValue;
+        }
+      };
+      Object.defineProperty(LiveNodeList.prototype, "length", {
+        get: function() {
+          _updateLiveList(this);
+          return this.$$length;
+        }
+      });
+      Object.defineProperty(Node.prototype, "textContent", {
+        get: function() {
+          return getTextContent(this);
+        },
+        set: function(data) {
+          switch (this.nodeType) {
+            case ELEMENT_NODE:
+            case DOCUMENT_FRAGMENT_NODE:
+              while (this.firstChild) {
+                this.removeChild(this.firstChild);
+              }
+              if (data || String(data)) {
+                this.appendChild(this.ownerDocument.createTextNode(data));
+              }
+              break;
+            default:
+              this.data = data;
+              this.value = data;
+              this.nodeValue = data;
+          }
+        }
+      });
+      __set__ = function(object, key, value) {
+        object["$$" + key] = value;
+      };
+    }
+  } catch (e) {
+  }
+  dom.DocumentType = DocumentType;
+  dom.DOMException = DOMException;
+  dom.DOMImplementation = DOMImplementation;
+  dom.Element = Element;
+  dom.Node = Node;
+  dom.NodeList = NodeList;
+  dom.XMLSerializer = XMLSerializer;
+  return dom;
+}
+export {
+  requireDom as __require
+};