@d1g1tal/transportr 0.1.2 → 0.1.4

package/dist/transportr.js

@@ -1,9 +1,14 @@
 var Transportr = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,6 +21,14 @@ var Transportr = (() => {
     }
     return to;
   };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
   var __publicField = (obj, key, value) => {
     __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -44,6 +57,2605 @@ var Transportr = (() => {
     return method;
   };
 
+  // node_modules/@xmldom/xmldom/lib/conventions.js
+  var require_conventions = __commonJS({
+    "node_modules/@xmldom/xmldom/lib/conventions.js"(exports) {
+      "use strict";
+      function find(list, predicate, ac) {
+        if (ac === void 0) {
+          ac = Array.prototype;
+        }
+        if (list && typeof ac.find === "function") {
+          return ac.find.call(list, predicate);
+        }
+        for (var i = 0; i < list.length; i++) {
+          if (Object.prototype.hasOwnProperty.call(list, i)) {
+            var item = list[i];
+            if (predicate.call(void 0, item, i, list)) {
+              return item;
+            }
+          }
+        }
+      }
+      function freeze(object, oc) {
+        if (oc === void 0) {
+          oc = Object;
+        }
+        return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
+      }
+      function assign(target, source) {
+        if (target === null || typeof target !== "object") {
+          throw new TypeError("target is not an object");
+        }
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+        return target;
+      }
+      var MIME_TYPE = freeze({
+        /**
+         * `text/html`, the only mime type that triggers treating an XML document as HTML.
+         *
+         * @see DOMParser.SupportedType.isHTML
+         * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+         * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+         * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+         */
+        HTML: "text/html",
+        /**
+         * Helper method to check a mime type if it indicates an HTML document
+         *
+         * @param {string} [value]
+         * @returns {boolean}
+         *
+         * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+         * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+         * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
+        isHTML: function(value) {
+          return value === MIME_TYPE.HTML;
+        },
+        /**
+         * `application/xml`, the standard mime type for XML documents.
+         *
+         * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+         * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+         * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+         */
+        XML_APPLICATION: "application/xml",
+        /**
+         * `text/html`, an alias for `application/xml`.
+         *
+         * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+         * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+         * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+         */
+        XML_TEXT: "text/xml",
+        /**
+         * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+         * but is parsed as an XML document.
+         *
+         * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+         * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+         * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+         */
+        XML_XHTML_APPLICATION: "application/xhtml+xml",
+        /**
+         * `image/svg+xml`,
+         *
+         * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+         * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+         * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+         */
+        XML_SVG_IMAGE: "image/svg+xml"
+      });
+      var NAMESPACE = freeze({
+        /**
+         * The XHTML namespace.
+         *
+         * @see http://www.w3.org/1999/xhtml
+         */
+        HTML: "http://www.w3.org/1999/xhtml",
+        /**
+         * Checks if `uri` equals `NAMESPACE.HTML`.
+         *
+         * @param {string} [uri]
+         *
+         * @see NAMESPACE.HTML
+         */
+        isHTML: function(uri) {
+          return uri === NAMESPACE.HTML;
+        },
+        /**
+         * The SVG namespace.
+         *
+         * @see http://www.w3.org/2000/svg
+         */
+        SVG: "http://www.w3.org/2000/svg",
+        /**
+         * The `xml:` namespace.
+         *
+         * @see http://www.w3.org/XML/1998/namespace
+         */
+        XML: "http://www.w3.org/XML/1998/namespace",
+        /**
+         * The `xmlns:` namespace
+         *
+         * @see https://www.w3.org/2000/xmlns/
+         */
+        XMLNS: "http://www.w3.org/2000/xmlns/"
+      });
+      exports.assign = assign;
+      exports.find = find;
+      exports.freeze = freeze;
+      exports.MIME_TYPE = MIME_TYPE;
+      exports.NAMESPACE = NAMESPACE;
+    }
+  });
+
+  // node_modules/@xmldom/xmldom/lib/dom.js
+  var require_dom = __commonJS({
+    "node_modules/@xmldom/xmldom/lib/dom.js"(exports) {
+      var conventions = require_conventions();
+      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 t2 = function() {
+          };
+          var t = t2;
+          ;
+          t2.prototype = Super.prototype;
+          t2 = new t2();
+          copy(pt, t2);
+          Class.prototype = pt = t2;
+        }
+        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 = {};
+      var INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
+      var DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
+      var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
+      var WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
+      var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
+      var NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
+      var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
+      var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
+      var NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
+      var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
+      var INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
+      var SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
+      var INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
+      var NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
+      var INVALID_ACCESS_ERR = 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 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);
+          copy(ls, list);
+          list._inc = inc;
+        }
+      }
+      LiveNodeList.prototype.item = function(i) {
+        _updateLiveList(this);
+        return this[i];
+      };
+      _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 hasDoctypeChildThatIsNotChild2 = function(node2) {
+            return isDocTypeNode(node2) && node2 !== child;
+          };
+          var hasDoctypeChildThatIsNotChild = hasDoctypeChildThatIsNotChild2;
+          if (find(parentChildNodes, hasDoctypeChildThatIsNotChild2)) {
+            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;
+        } 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 _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);
+        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);
+          newChild.ownerDocument = 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);
+          newChild.ownerDocument = 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;
+        },
+        createCDATASection: function(data) {
+          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.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, "]]>");
+          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, ";");
+          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;
+          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 getTextContent2 = 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(getTextContent2(node));
+                  }
+                  node = node.nextSibling;
+                }
+                return buf.join("");
+              default:
+                return node.nodeValue;
+            }
+          };
+          getTextContent = getTextContent2;
+          Object.defineProperty(LiveNodeList.prototype, "length", {
+            get: function() {
+              _updateLiveList(this);
+              return this.$$length;
+            }
+          });
+          Object.defineProperty(Node.prototype, "textContent", {
+            get: function() {
+              return getTextContent2(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) {
+      }
+      var getTextContent;
+      exports.DocumentType = DocumentType;
+      exports.DOMException = DOMException;
+      exports.DOMImplementation = DOMImplementation;
+      exports.Element = Element;
+      exports.Node = Node;
+      exports.NodeList = NodeList;
+      exports.XMLSerializer = XMLSerializer;
+    }
+  });
+
+  // node_modules/@xmldom/xmldom/lib/entities.js
+  var require_entities = __commonJS({
+    "node_modules/@xmldom/xmldom/lib/entities.js"(exports) {
+      var freeze = require_conventions().freeze;
+      exports.XML_ENTITIES = freeze({ amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' });
+      exports.HTML_ENTITIES = freeze({
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        Agrave: "\xC0",
+        Aacute: "\xC1",
+        Acirc: "\xC2",
+        Atilde: "\xC3",
+        Auml: "\xC4",
+        Aring: "\xC5",
+        AElig: "\xC6",
+        Ccedil: "\xC7",
+        Egrave: "\xC8",
+        Eacute: "\xC9",
+        Ecirc: "\xCA",
+        Euml: "\xCB",
+        Igrave: "\xCC",
+        Iacute: "\xCD",
+        Icirc: "\xCE",
+        Iuml: "\xCF",
+        ETH: "\xD0",
+        Ntilde: "\xD1",
+        Ograve: "\xD2",
+        Oacute: "\xD3",
+        Ocirc: "\xD4",
+        Otilde: "\xD5",
+        Ouml: "\xD6",
+        Oslash: "\xD8",
+        Ugrave: "\xD9",
+        Uacute: "\xDA",
+        Ucirc: "\xDB",
+        Uuml: "\xDC",
+        Yacute: "\xDD",
+        THORN: "\xDE",
+        szlig: "\xDF",
+        agrave: "\xE0",
+        aacute: "\xE1",
+        acirc: "\xE2",
+        atilde: "\xE3",
+        auml: "\xE4",
+        aring: "\xE5",
+        aelig: "\xE6",
+        ccedil: "\xE7",
+        egrave: "\xE8",
+        eacute: "\xE9",
+        ecirc: "\xEA",
+        euml: "\xEB",
+        igrave: "\xEC",
+        iacute: "\xED",
+        icirc: "\xEE",
+        iuml: "\xEF",
+        eth: "\xF0",
+        ntilde: "\xF1",
+        ograve: "\xF2",
+        oacute: "\xF3",
+        ocirc: "\xF4",
+        otilde: "\xF5",
+        ouml: "\xF6",
+        oslash: "\xF8",
+        ugrave: "\xF9",
+        uacute: "\xFA",
+        ucirc: "\xFB",
+        uuml: "\xFC",
+        yacute: "\xFD",
+        thorn: "\xFE",
+        yuml: "\xFF",
+        nbsp: "\xA0",
+        iexcl: "\xA1",
+        cent: "\xA2",
+        pound: "\xA3",
+        curren: "\xA4",
+        yen: "\xA5",
+        brvbar: "\xA6",
+        sect: "\xA7",
+        uml: "\xA8",
+        copy: "\xA9",
+        ordf: "\xAA",
+        laquo: "\xAB",
+        not: "\xAC",
+        shy: "\xAD\xAD",
+        reg: "\xAE",
+        macr: "\xAF",
+        deg: "\xB0",
+        plusmn: "\xB1",
+        sup2: "\xB2",
+        sup3: "\xB3",
+        acute: "\xB4",
+        micro: "\xB5",
+        para: "\xB6",
+        middot: "\xB7",
+        cedil: "\xB8",
+        sup1: "\xB9",
+        ordm: "\xBA",
+        raquo: "\xBB",
+        frac14: "\xBC",
+        frac12: "\xBD",
+        frac34: "\xBE",
+        iquest: "\xBF",
+        times: "\xD7",
+        divide: "\xF7",
+        forall: "\u2200",
+        part: "\u2202",
+        exist: "\u2203",
+        empty: "\u2205",
+        nabla: "\u2207",
+        isin: "\u2208",
+        notin: "\u2209",
+        ni: "\u220B",
+        prod: "\u220F",
+        sum: "\u2211",
+        minus: "\u2212",
+        lowast: "\u2217",
+        radic: "\u221A",
+        prop: "\u221D",
+        infin: "\u221E",
+        ang: "\u2220",
+        and: "\u2227",
+        or: "\u2228",
+        cap: "\u2229",
+        cup: "\u222A",
+        "int": "\u222B",
+        there4: "\u2234",
+        sim: "\u223C",
+        cong: "\u2245",
+        asymp: "\u2248",
+        ne: "\u2260",
+        equiv: "\u2261",
+        le: "\u2264",
+        ge: "\u2265",
+        sub: "\u2282",
+        sup: "\u2283",
+        nsub: "\u2284",
+        sube: "\u2286",
+        supe: "\u2287",
+        oplus: "\u2295",
+        otimes: "\u2297",
+        perp: "\u22A5",
+        sdot: "\u22C5",
+        Alpha: "\u0391",
+        Beta: "\u0392",
+        Gamma: "\u0393",
+        Delta: "\u0394",
+        Epsilon: "\u0395",
+        Zeta: "\u0396",
+        Eta: "\u0397",
+        Theta: "\u0398",
+        Iota: "\u0399",
+        Kappa: "\u039A",
+        Lambda: "\u039B",
+        Mu: "\u039C",
+        Nu: "\u039D",
+        Xi: "\u039E",
+        Omicron: "\u039F",
+        Pi: "\u03A0",
+        Rho: "\u03A1",
+        Sigma: "\u03A3",
+        Tau: "\u03A4",
+        Upsilon: "\u03A5",
+        Phi: "\u03A6",
+        Chi: "\u03A7",
+        Psi: "\u03A8",
+        Omega: "\u03A9",
+        alpha: "\u03B1",
+        beta: "\u03B2",
+        gamma: "\u03B3",
+        delta: "\u03B4",
+        epsilon: "\u03B5",
+        zeta: "\u03B6",
+        eta: "\u03B7",
+        theta: "\u03B8",
+        iota: "\u03B9",
+        kappa: "\u03BA",
+        lambda: "\u03BB",
+        mu: "\u03BC",
+        nu: "\u03BD",
+        xi: "\u03BE",
+        omicron: "\u03BF",
+        pi: "\u03C0",
+        rho: "\u03C1",
+        sigmaf: "\u03C2",
+        sigma: "\u03C3",
+        tau: "\u03C4",
+        upsilon: "\u03C5",
+        phi: "\u03C6",
+        chi: "\u03C7",
+        psi: "\u03C8",
+        omega: "\u03C9",
+        thetasym: "\u03D1",
+        upsih: "\u03D2",
+        piv: "\u03D6",
+        OElig: "\u0152",
+        oelig: "\u0153",
+        Scaron: "\u0160",
+        scaron: "\u0161",
+        Yuml: "\u0178",
+        fnof: "\u0192",
+        circ: "\u02C6",
+        tilde: "\u02DC",
+        ensp: "\u2002",
+        emsp: "\u2003",
+        thinsp: "\u2009",
+        zwnj: "\u200C",
+        zwj: "\u200D",
+        lrm: "\u200E",
+        rlm: "\u200F",
+        ndash: "\u2013",
+        mdash: "\u2014",
+        lsquo: "\u2018",
+        rsquo: "\u2019",
+        sbquo: "\u201A",
+        ldquo: "\u201C",
+        rdquo: "\u201D",
+        bdquo: "\u201E",
+        dagger: "\u2020",
+        Dagger: "\u2021",
+        bull: "\u2022",
+        hellip: "\u2026",
+        permil: "\u2030",
+        prime: "\u2032",
+        Prime: "\u2033",
+        lsaquo: "\u2039",
+        rsaquo: "\u203A",
+        oline: "\u203E",
+        euro: "\u20AC",
+        trade: "\u2122",
+        larr: "\u2190",
+        uarr: "\u2191",
+        rarr: "\u2192",
+        darr: "\u2193",
+        harr: "\u2194",
+        crarr: "\u21B5",
+        lceil: "\u2308",
+        rceil: "\u2309",
+        lfloor: "\u230A",
+        rfloor: "\u230B",
+        loz: "\u25CA",
+        spades: "\u2660",
+        clubs: "\u2663",
+        hearts: "\u2665",
+        diams: "\u2666"
+      });
+      exports.entityMap = exports.HTML_ENTITIES;
+    }
+  });
+
+  // node_modules/@xmldom/xmldom/lib/sax.js
+  var require_sax = __commonJS({
+    "node_modules/@xmldom/xmldom/lib/sax.js"(exports) {
+      var NAMESPACE = require_conventions().NAMESPACE;
+      var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+      var nameChar = new RegExp("[\\-\\.0-9" + nameStartChar.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+      var tagNamePattern = new RegExp("^" + nameStartChar.source + nameChar.source + "*(?::" + nameStartChar.source + nameChar.source + "*)?$");
+      var S_TAG = 0;
+      var S_ATTR = 1;
+      var S_ATTR_SPACE = 2;
+      var S_EQ = 3;
+      var S_ATTR_NOQUOT_VALUE = 4;
+      var S_ATTR_END = 5;
+      var S_TAG_SPACE = 6;
+      var S_TAG_CLOSE = 7;
+      function ParseError(message, locator) {
+        this.message = message;
+        this.locator = locator;
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, ParseError);
+      }
+      ParseError.prototype = new Error();
+      ParseError.prototype.name = ParseError.name;
+      function XMLReader() {
+      }
+      XMLReader.prototype = {
+        parse: function(source, defaultNSMap, entityMap) {
+          var domBuilder = this.domBuilder;
+          domBuilder.startDocument();
+          _copy(defaultNSMap, defaultNSMap = {});
+          parse2(
+            source,
+            defaultNSMap,
+            entityMap,
+            domBuilder,
+            this.errorHandler
+          );
+          domBuilder.endDocument();
+        }
+      };
+      function parse2(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
+        function fixedFromCharCode(code) {
+          if (code > 65535) {
+            code -= 65536;
+            var surrogate1 = 55296 + (code >> 10), surrogate2 = 56320 + (code & 1023);
+            return String.fromCharCode(surrogate1, surrogate2);
+          } else {
+            return String.fromCharCode(code);
+          }
+        }
+        function entityReplacer(a2) {
+          var k = a2.slice(1, -1);
+          if (Object.hasOwnProperty.call(entityMap, k)) {
+            return entityMap[k];
+          } else if (k.charAt(0) === "#") {
+            return fixedFromCharCode(parseInt(k.substr(1).replace("x", "0x")));
+          } else {
+            errorHandler.error("entity not found:" + a2);
+            return a2;
+          }
+        }
+        function appendText(end2) {
+          if (end2 > start) {
+            var xt = source.substring(start, end2).replace(/&#?\w+;/g, entityReplacer);
+            locator && position(start);
+            domBuilder.characters(xt, 0, end2 - start);
+            start = end2;
+          }
+        }
+        function position(p, m) {
+          while (p >= lineEnd && (m = linePattern.exec(source))) {
+            lineStart = m.index;
+            lineEnd = lineStart + m[0].length;
+            locator.lineNumber++;
+          }
+          locator.columnNumber = p - lineStart + 1;
+        }
+        var lineStart = 0;
+        var lineEnd = 0;
+        var linePattern = /.*(?:\r\n?|\n)|.*$/g;
+        var locator = domBuilder.locator;
+        var parseStack = [{ currentNSMap: defaultNSMapCopy }];
+        var closeMap = {};
+        var start = 0;
+        while (true) {
+          try {
+            var tagStart = source.indexOf("<", start);
+            if (tagStart < 0) {
+              if (!source.substr(start).match(/^\s*$/)) {
+                var doc = domBuilder.doc;
+                var text = doc.createTextNode(source.substr(start));
+                doc.appendChild(text);
+                domBuilder.currentElement = text;
+              }
+              return;
+            }
+            if (tagStart > start) {
+              appendText(tagStart);
+            }
+            switch (source.charAt(tagStart + 1)) {
+              case "/":
+                var end = source.indexOf(">", tagStart + 3);
+                var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, "");
+                var config = parseStack.pop();
+                if (end < 0) {
+                  tagName = source.substring(tagStart + 2).replace(/[\s<].*/, "");
+                  errorHandler.error("end tag name: " + tagName + " is not complete:" + config.tagName);
+                  end = tagStart + 1 + tagName.length;
+                } else if (tagName.match(/\s</)) {
+                  tagName = tagName.replace(/[\s<].*/, "");
+                  errorHandler.error("end tag name: " + tagName + " maybe not complete");
+                  end = tagStart + 1 + tagName.length;
+                }
+                var localNSMap = config.localNSMap;
+                var endMatch = config.tagName == tagName;
+                var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();
+                if (endIgnoreCaseMach) {
+                  domBuilder.endElement(config.uri, config.localName, tagName);
+                  if (localNSMap) {
+                    for (var prefix in localNSMap) {
+                      if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+                        domBuilder.endPrefixMapping(prefix);
+                      }
+                    }
+                  }
+                  if (!endMatch) {
+                    errorHandler.fatalError("end tag name: " + tagName + " is not match the current start tagName:" + config.tagName);
+                  }
+                } else {
+                  parseStack.push(config);
+                }
+                end++;
+                break;
+              case "?":
+                locator && position(tagStart);
+                end = parseInstruction(source, tagStart, domBuilder);
+                break;
+              case "!":
+                locator && position(tagStart);
+                end = parseDCC(source, tagStart, domBuilder, errorHandler);
+                break;
+              default:
+                locator && position(tagStart);
+                var el = new ElementAttributes();
+                var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;
+                var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);
+                var len = el.length;
+                if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {
+                  el.closed = true;
+                  if (!entityMap.nbsp) {
+                    errorHandler.warning("unclosed xml attribute");
+                  }
+                }
+                if (locator && len) {
+                  var locator2 = copyLocator(locator, {});
+                  for (var i = 0; i < len; i++) {
+                    var a = el[i];
+                    position(a.offset);
+                    a.locator = copyLocator(locator, {});
+                  }
+                  domBuilder.locator = locator2;
+                  if (appendElement(el, domBuilder, currentNSMap)) {
+                    parseStack.push(el);
+                  }
+                  domBuilder.locator = locator;
+                } else {
+                  if (appendElement(el, domBuilder, currentNSMap)) {
+                    parseStack.push(el);
+                  }
+                }
+                if (NAMESPACE.isHTML(el.uri) && !el.closed) {
+                  end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
+                } else {
+                  end++;
+                }
+            }
+          } catch (e) {
+            if (e instanceof ParseError) {
+              throw e;
+            }
+            errorHandler.error("element parse error: " + e);
+            end = -1;
+          }
+          if (end > start) {
+            start = end;
+          } else {
+            appendText(Math.max(tagStart, start) + 1);
+          }
+        }
+      }
+      function copyLocator(f, t) {
+        t.lineNumber = f.lineNumber;
+        t.columnNumber = f.columnNumber;
+        return t;
+      }
+      function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+        function addAttribute(qname, value2, startIndex) {
+          if (el.attributeNames.hasOwnProperty(qname)) {
+            errorHandler.fatalError("Attribute " + qname + " redefined");
+          }
+          el.addValue(
+            qname,
+            // @see https://www.w3.org/TR/xml/#AVNormalize
+            // since the xmldom sax parser does not "interpret" DTD the following is not implemented:
+            // - recursive replacement of (DTD) entity references
+            // - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA
+            value2.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, entityReplacer),
+            startIndex
+          );
+        }
+        var attrName;
+        var value;
+        var p = ++start;
+        var s = S_TAG;
+        while (true) {
+          var c = source.charAt(p);
+          switch (c) {
+            case "=":
+              if (s === S_ATTR) {
+                attrName = source.slice(start, p);
+                s = S_EQ;
+              } else if (s === S_ATTR_SPACE) {
+                s = S_EQ;
+              } else {
+                throw new Error("attribute equal must after attrName");
+              }
+              break;
+            case "'":
+            case '"':
+              if (s === S_EQ || s === S_ATTR) {
+                if (s === S_ATTR) {
+                  errorHandler.warning('attribute value must after "="');
+                  attrName = source.slice(start, p);
+                }
+                start = p + 1;
+                p = source.indexOf(c, start);
+                if (p > 0) {
+                  value = source.slice(start, p);
+                  addAttribute(attrName, value, start - 1);
+                  s = S_ATTR_END;
+                } else {
+                  throw new Error("attribute value no end '" + c + "' match");
+                }
+              } else if (s == S_ATTR_NOQUOT_VALUE) {
+                value = source.slice(start, p);
+                addAttribute(attrName, value, start);
+                errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c + ")!!");
+                start = p + 1;
+                s = S_ATTR_END;
+              } else {
+                throw new Error('attribute value must after "="');
+              }
+              break;
+            case "/":
+              switch (s) {
+                case S_TAG:
+                  el.setTagName(source.slice(start, p));
+                case S_ATTR_END:
+                case S_TAG_SPACE:
+                case S_TAG_CLOSE:
+                  s = S_TAG_CLOSE;
+                  el.closed = true;
+                case S_ATTR_NOQUOT_VALUE:
+                case S_ATTR:
+                case S_ATTR_SPACE:
+                  break;
+                default:
+                  throw new Error("attribute invalid close char('/')");
+              }
+              break;
+            case "":
+              errorHandler.error("unexpected end of input");
+              if (s == S_TAG) {
+                el.setTagName(source.slice(start, p));
+              }
+              return p;
+            case ">":
+              switch (s) {
+                case S_TAG:
+                  el.setTagName(source.slice(start, p));
+                case S_ATTR_END:
+                case S_TAG_SPACE:
+                case S_TAG_CLOSE:
+                  break;
+                case S_ATTR_NOQUOT_VALUE:
+                case S_ATTR:
+                  value = source.slice(start, p);
+                  if (value.slice(-1) === "/") {
+                    el.closed = true;
+                    value = value.slice(0, -1);
+                  }
+                case S_ATTR_SPACE:
+                  if (s === S_ATTR_SPACE) {
+                    value = attrName;
+                  }
+                  if (s == S_ATTR_NOQUOT_VALUE) {
+                    errorHandler.warning('attribute "' + value + '" missed quot(")!');
+                    addAttribute(attrName, value, start);
+                  } else {
+                    if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
+                      errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
+                    }
+                    addAttribute(value, value, start);
+                  }
+                  break;
+                case S_EQ:
+                  throw new Error("attribute value missed!!");
+              }
+              return p;
+            case "\x80":
+              c = " ";
+            default:
+              if (c <= " ") {
+                switch (s) {
+                  case S_TAG:
+                    el.setTagName(source.slice(start, p));
+                    s = S_TAG_SPACE;
+                    break;
+                  case S_ATTR:
+                    attrName = source.slice(start, p);
+                    s = S_ATTR_SPACE;
+                    break;
+                  case S_ATTR_NOQUOT_VALUE:
+                    var value = source.slice(start, p);
+                    errorHandler.warning('attribute "' + value + '" missed quot(")!!');
+                    addAttribute(attrName, value, start);
+                  case S_ATTR_END:
+                    s = S_TAG_SPACE;
+                    break;
+                }
+              } else {
+                switch (s) {
+                  case S_ATTR_SPACE:
+                    var tagName = el.tagName;
+                    if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
+                      errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
+                    }
+                    addAttribute(attrName, attrName, start);
+                    start = p;
+                    s = S_ATTR;
+                    break;
+                  case S_ATTR_END:
+                    errorHandler.warning('attribute space is required"' + attrName + '"!!');
+                  case S_TAG_SPACE:
+                    s = S_ATTR;
+                    start = p;
+                    break;
+                  case S_EQ:
+                    s = S_ATTR_NOQUOT_VALUE;
+                    start = p;
+                    break;
+                  case S_TAG_CLOSE:
+                    throw new Error("elements closed character '/' and '>' must be connected to");
+                }
+              }
+          }
+          p++;
+        }
+      }
+      function appendElement(el, domBuilder, currentNSMap) {
+        var tagName = el.tagName;
+        var localNSMap = null;
+        var i = el.length;
+        while (i--) {
+          var a = el[i];
+          var qName = a.qName;
+          var value = a.value;
+          var nsp = qName.indexOf(":");
+          if (nsp > 0) {
+            var prefix = a.prefix = qName.slice(0, nsp);
+            var localName = qName.slice(nsp + 1);
+            var nsPrefix = prefix === "xmlns" && localName;
+          } else {
+            localName = qName;
+            prefix = null;
+            nsPrefix = qName === "xmlns" && "";
+          }
+          a.localName = localName;
+          if (nsPrefix !== false) {
+            if (localNSMap == null) {
+              localNSMap = {};
+              _copy(currentNSMap, currentNSMap = {});
+            }
+            currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
+            a.uri = NAMESPACE.XMLNS;
+            domBuilder.startPrefixMapping(nsPrefix, value);
+          }
+        }
+        var i = el.length;
+        while (i--) {
+          a = el[i];
+          var prefix = a.prefix;
+          if (prefix) {
+            if (prefix === "xml") {
+              a.uri = NAMESPACE.XML;
+            }
+            if (prefix !== "xmlns") {
+              a.uri = currentNSMap[prefix || ""];
+            }
+          }
+        }
+        var nsp = tagName.indexOf(":");
+        if (nsp > 0) {
+          prefix = el.prefix = tagName.slice(0, nsp);
+          localName = el.localName = tagName.slice(nsp + 1);
+        } else {
+          prefix = null;
+          localName = el.localName = tagName;
+        }
+        var ns = el.uri = currentNSMap[prefix || ""];
+        domBuilder.startElement(ns, localName, tagName, el);
+        if (el.closed) {
+          domBuilder.endElement(ns, localName, tagName);
+          if (localNSMap) {
+            for (prefix in localNSMap) {
+              if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+                domBuilder.endPrefixMapping(prefix);
+              }
+            }
+          }
+        } else {
+          el.currentNSMap = currentNSMap;
+          el.localNSMap = localNSMap;
+          return true;
+        }
+      }
+      function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
+        if (/^(?:script|textarea)$/i.test(tagName)) {
+          var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
+          var text = source.substring(elStartEnd + 1, elEndStart);
+          if (/[&<]/.test(text)) {
+            if (/^script$/i.test(tagName)) {
+              domBuilder.characters(text, 0, text.length);
+              return elEndStart;
+            }
+            text = text.replace(/&#?\w+;/g, entityReplacer);
+            domBuilder.characters(text, 0, text.length);
+            return elEndStart;
+          }
+        }
+        return elStartEnd + 1;
+      }
+      function fixSelfClosed(source, elStartEnd, tagName, closeMap) {
+        var pos = closeMap[tagName];
+        if (pos == null) {
+          pos = source.lastIndexOf("</" + tagName + ">");
+          if (pos < elStartEnd) {
+            pos = source.lastIndexOf("</" + tagName);
+          }
+          closeMap[tagName] = pos;
+        }
+        return pos < elStartEnd;
+      }
+      function _copy(source, target) {
+        for (var n in source) {
+          if (Object.prototype.hasOwnProperty.call(source, n)) {
+            target[n] = source[n];
+          }
+        }
+      }
+      function parseDCC(source, start, domBuilder, errorHandler) {
+        var next = source.charAt(start + 2);
+        switch (next) {
+          case "-":
+            if (source.charAt(start + 3) === "-") {
+              var end = source.indexOf("-->", start + 4);
+              if (end > start) {
+                domBuilder.comment(source, start + 4, end - start - 4);
+                return end + 3;
+              } else {
+                errorHandler.error("Unclosed comment");
+                return -1;
+              }
+            } else {
+              return -1;
+            }
+          default:
+            if (source.substr(start + 3, 6) == "CDATA[") {
+              var end = source.indexOf("]]>", start + 9);
+              domBuilder.startCDATA();
+              domBuilder.characters(source, start + 9, end - start - 9);
+              domBuilder.endCDATA();
+              return end + 3;
+            }
+            var matchs = split(source, start);
+            var len = matchs.length;
+            if (len > 1 && /!doctype/i.test(matchs[0][0])) {
+              var name = matchs[1][0];
+              var pubid = false;
+              var sysid = false;
+              if (len > 3) {
+                if (/^public$/i.test(matchs[2][0])) {
+                  pubid = matchs[3][0];
+                  sysid = len > 4 && matchs[4][0];
+                } else if (/^system$/i.test(matchs[2][0])) {
+                  sysid = matchs[3][0];
+                }
+              }
+              var lastMatch = matchs[len - 1];
+              domBuilder.startDTD(name, pubid, sysid);
+              domBuilder.endDTD();
+              return lastMatch.index + lastMatch[0].length;
+            }
+        }
+        return -1;
+      }
+      function parseInstruction(source, start, domBuilder) {
+        var end = source.indexOf("?>", start);
+        if (end) {
+          var match = source.substring(start, end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+          if (match) {
+            var len = match[0].length;
+            domBuilder.processingInstruction(match[1], match[2]);
+            return end + 2;
+          } else {
+            return -1;
+          }
+        }
+        return -1;
+      }
+      function ElementAttributes() {
+        this.attributeNames = {};
+      }
+      ElementAttributes.prototype = {
+        setTagName: function(tagName) {
+          if (!tagNamePattern.test(tagName)) {
+            throw new Error("invalid tagName:" + tagName);
+          }
+          this.tagName = tagName;
+        },
+        addValue: function(qName, value, offset) {
+          if (!tagNamePattern.test(qName)) {
+            throw new Error("invalid attribute:" + qName);
+          }
+          this.attributeNames[qName] = this.length;
+          this[this.length++] = { qName, value, offset };
+        },
+        length: 0,
+        getLocalName: function(i) {
+          return this[i].localName;
+        },
+        getLocator: function(i) {
+          return this[i].locator;
+        },
+        getQName: function(i) {
+          return this[i].qName;
+        },
+        getURI: function(i) {
+          return this[i].uri;
+        },
+        getValue: function(i) {
+          return this[i].value;
+        }
+        //	,getIndex:function(uri, localName)){
+        //		if(localName){
+        //
+        //		}else{
+        //			var qName = uri
+        //		}
+        //	},
+        //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+        //	getType:function(uri,localName){}
+        //	getType:function(i){},
+      };
+      function split(source, start) {
+        var match;
+        var buf = [];
+        var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+        reg.lastIndex = start;
+        reg.exec(source);
+        while (match = reg.exec(source)) {
+          buf.push(match);
+          if (match[1])
+            return buf;
+        }
+      }
+      exports.XMLReader = XMLReader;
+      exports.ParseError = ParseError;
+    }
+  });
+
+  // node_modules/@xmldom/xmldom/lib/dom-parser.js
+  var require_dom_parser = __commonJS({
+    "node_modules/@xmldom/xmldom/lib/dom-parser.js"(exports) {
+      var conventions = require_conventions();
+      var dom = require_dom();
+      var entities = require_entities();
+      var sax = require_sax();
+      var DOMImplementation = dom.DOMImplementation;
+      var NAMESPACE = conventions.NAMESPACE;
+      var ParseError = sax.ParseError;
+      var XMLReader = sax.XMLReader;
+      function normalizeLineEndings(input) {
+        return input.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028]/g, "\n");
+      }
+      function DOMParser2(options) {
+        this.options = options || { locator: {} };
+      }
+      DOMParser2.prototype.parseFromString = function(source, mimeType) {
+        var options = this.options;
+        var sax2 = new XMLReader();
+        var domBuilder = options.domBuilder || new DOMHandler();
+        var errorHandler = options.errorHandler;
+        var locator = options.locator;
+        var defaultNSMap = options.xmlns || {};
+        var isHTML = /\/x?html?$/.test(mimeType);
+        var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
+        if (locator) {
+          domBuilder.setDocumentLocator(locator);
+        }
+        sax2.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
+        sax2.domBuilder = options.domBuilder || domBuilder;
+        if (isHTML) {
+          defaultNSMap[""] = NAMESPACE.HTML;
+        }
+        defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
+        var normalize = options.normalizeLineEndings || normalizeLineEndings;
+        if (source && typeof source === "string") {
+          sax2.parse(
+            normalize(source),
+            defaultNSMap,
+            entityMap
+          );
+        } else {
+          sax2.errorHandler.error("invalid doc source");
+        }
+        return domBuilder.doc;
+      };
+      function buildErrorHandler(errorImpl, domBuilder, locator) {
+        if (!errorImpl) {
+          if (domBuilder instanceof DOMHandler) {
+            return domBuilder;
+          }
+          errorImpl = domBuilder;
+        }
+        var errorHandler = {};
+        var isCallback = errorImpl instanceof Function;
+        locator = locator || {};
+        function build(key) {
+          var fn = errorImpl[key];
+          if (!fn && isCallback) {
+            fn = errorImpl.length == 2 ? function(msg) {
+              errorImpl(key, msg);
+            } : errorImpl;
+          }
+          errorHandler[key] = fn && function(msg) {
+            fn("[xmldom " + key + "]	" + msg + _locator(locator));
+          } || function() {
+          };
+        }
+        build("warning");
+        build("error");
+        build("fatalError");
+        return errorHandler;
+      }
+      function DOMHandler() {
+        this.cdata = false;
+      }
+      function position(locator, node) {
+        node.lineNumber = locator.lineNumber;
+        node.columnNumber = locator.columnNumber;
+      }
+      DOMHandler.prototype = {
+        startDocument: function() {
+          this.doc = new DOMImplementation().createDocument(null, null, null);
+          if (this.locator) {
+            this.doc.documentURI = this.locator.systemId;
+          }
+        },
+        startElement: function(namespaceURI, localName, qName, attrs) {
+          var doc = this.doc;
+          var el = doc.createElementNS(namespaceURI, qName || localName);
+          var len = attrs.length;
+          appendElement(this, el);
+          this.currentElement = el;
+          this.locator && position(this.locator, el);
+          for (var i = 0; i < len; i++) {
+            var namespaceURI = attrs.getURI(i);
+            var value = attrs.getValue(i);
+            var qName = attrs.getQName(i);
+            var attr = doc.createAttributeNS(namespaceURI, qName);
+            this.locator && position(attrs.getLocator(i), attr);
+            attr.value = attr.nodeValue = value;
+            el.setAttributeNode(attr);
+          }
+        },
+        endElement: function(namespaceURI, localName, qName) {
+          var current = this.currentElement;
+          var tagName = current.tagName;
+          this.currentElement = current.parentNode;
+        },
+        startPrefixMapping: function(prefix, uri) {
+        },
+        endPrefixMapping: function(prefix) {
+        },
+        processingInstruction: function(target, data) {
+          var ins = this.doc.createProcessingInstruction(target, data);
+          this.locator && position(this.locator, ins);
+          appendElement(this, ins);
+        },
+        ignorableWhitespace: function(ch, start, length) {
+        },
+        characters: function(chars, start, length) {
+          chars = _toString.apply(this, arguments);
+          if (chars) {
+            if (this.cdata) {
+              var charNode = this.doc.createCDATASection(chars);
+            } else {
+              var charNode = this.doc.createTextNode(chars);
+            }
+            if (this.currentElement) {
+              this.currentElement.appendChild(charNode);
+            } else if (/^\s*$/.test(chars)) {
+              this.doc.appendChild(charNode);
+            }
+            this.locator && position(this.locator, charNode);
+          }
+        },
+        skippedEntity: function(name) {
+        },
+        endDocument: function() {
+          this.doc.normalize();
+        },
+        setDocumentLocator: function(locator) {
+          if (this.locator = locator) {
+            locator.lineNumber = 0;
+          }
+        },
+        //LexicalHandler
+        comment: function(chars, start, length) {
+          chars = _toString.apply(this, arguments);
+          var comm = this.doc.createComment(chars);
+          this.locator && position(this.locator, comm);
+          appendElement(this, comm);
+        },
+        startCDATA: function() {
+          this.cdata = true;
+        },
+        endCDATA: function() {
+          this.cdata = false;
+        },
+        startDTD: function(name, publicId, systemId) {
+          var impl = this.doc.implementation;
+          if (impl && impl.createDocumentType) {
+            var dt = impl.createDocumentType(name, publicId, systemId);
+            this.locator && position(this.locator, dt);
+            appendElement(this, dt);
+            this.doc.doctype = dt;
+          }
+        },
+        /**
+         * @see org.xml.sax.ErrorHandler
+         * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+         */
+        warning: function(error) {
+          console.warn("[xmldom warning]	" + error, _locator(this.locator));
+        },
+        error: function(error) {
+          console.error("[xmldom error]	" + error, _locator(this.locator));
+        },
+        fatalError: function(error) {
+          throw new ParseError(error, this.locator);
+        }
+      };
+      function _locator(l) {
+        if (l) {
+          return "\n@" + (l.systemId || "") + "#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";
+        }
+      }
+      function _toString(chars, start, length) {
+        if (typeof chars == "string") {
+          return chars.substr(start, length);
+        } else {
+          if (chars.length >= start + length || start) {
+            return new java.lang.String(chars, start, length) + "";
+          }
+          return chars;
+        }
+      }
+      "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
+        DOMHandler.prototype[key] = function() {
+          return null;
+        };
+      });
+      function appendElement(hander, node) {
+        if (!hander.currentElement) {
+          hander.doc.appendChild(node);
+        } else {
+          hander.currentElement.appendChild(node);
+        }
+      }
+      exports.__DOMHandler = DOMHandler;
+      exports.normalizeLineEndings = normalizeLineEndings;
+      exports.DOMParser = DOMParser2;
+    }
+  });
+
+  // node_modules/@xmldom/xmldom/lib/index.js
+  var require_lib = __commonJS({
+    "node_modules/@xmldom/xmldom/lib/index.js"(exports) {
+      var dom = require_dom();
+      exports.DOMImplementation = dom.DOMImplementation;
+      exports.XMLSerializer = dom.XMLSerializer;
+      exports.DOMParser = require_dom_parser().DOMParser;
+    }
+  });
+
   // src/transportr.js
   var transportr_exports = {};
   __export(transportr_exports, {
@@ -60,25 +2672,35 @@ var Transportr = (() => {
 
   // node_modules/@d1g1tal/chrysalis/src/esm/object-merge.js
   var _objectMerge = (...objects) => {
-    return objects.reduce((prev, obj) => {
-      Object.keys(obj).forEach((key) => {
-        const pVal = prev[key];
-        const oVal = obj[key];
-        if (Array.isArray(pVal) && Array.isArray(oVal)) {
-          prev[key] = [.../* @__PURE__ */ new Set([...oVal, ...pVal])];
-        } else if (object_is_type_default(pVal, Object) && object_is_type_default(oVal, Object)) {
-          prev[key] = _objectMerge(pVal, oVal);
-        } else {
-          prev[key] = oVal;
+    return objects.reduce((previousValue, currentValue) => {
+      for (const [key, value] of Object.entries(currentValue)) {
+        switch (true) {
+          case (Array.isArray(value) && Array.isArray(previousValue[key])): {
+            previousValue[key] = [.../* @__PURE__ */ new Set([...value, ...previousValue[key]])];
+            break;
+          }
+          case (object_is_type_default(value, Object) && object_is_type_default(previousValue[key], Object)): {
+            previousValue[key] = _objectMerge(previousValue[key], value);
+            break;
+          }
+          default:
+            previousValue[key] = value;
         }
-      });
-      return prev;
+      }
+      return previousValue;
     }, {});
   };
   var object_merge_default = _objectMerge;
 
   // node_modules/@d1g1tal/collections/src/set-multi-map.js
   var SetMultiMap = class extends Map {
+    /**
+     * Adds a new element with a specified key and value to the SetMultiMap. If an element with the same key already exists, the value will be added to the underlying {@link Set}.
+     *
+     * @param {K} key The key to set.
+     * @param {V} value The value to add to the SetMultiMap
+     * @returns {SetMultiMap} The SetMultiMap with the updated key and value.
+     */
     set(key, value) {
       super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
       return this;
@@ -124,18 +2746,48 @@ var Transportr = (() => {
 
   // node_modules/@d1g1tal/media-type/src/media-type-parameters.js
   var MediaTypeParameters = class {
+    /**
+     * Create a new MediaTypeParameters instance.
+     *
+     * @param {Map.<string, string>} map The map of parameters for a media type.
+     */
     constructor(map) {
       this._map = map;
     }
+    /**
+     * Gets the number of media type parameters.
+     *
+     * @returns {number} The number of media type parameters
+     */
     get size() {
       return this._map.size;
     }
+    /**
+     * Gets the media type parameter value for the supplied name.
+     *
+     * @param {string} name The name of the media type parameter to retrieve.
+     * @returns {string} The media type parameter value.
+     */
     get(name) {
       return this._map.get(asciiLowercase(String(name)));
     }
+    /**
+     * Indicates whether the media type parameter with the specified name exists or not.
+     *
+     * @param {string} name The name of the media type parameter to check.
+     * @returns {boolean} true if the media type parameter exists, false otherwise.
+     */
     has(name) {
       return this._map.has(asciiLowercase(String(name)));
     }
+    /**
+     * Adds a new media type parameter using the specified name and value to the MediaTypeParameters.
+     * If an parameter with the same name already exists, the parameter will be updated.
+     *
+     * @param {string} name The name of the media type parameter to set.
+     * @param {string} value The media type parameter value.
+     * @returns {MediaTypeParameters} This instance.
+     */
     set(name, value) {
       name = asciiLowercase(String(name));
       value = String(value);
@@ -148,25 +2800,60 @@ var Transportr = (() => {
       this._map.set(name, value);
       return this;
     }
+    /**
+     * Clears all the media type parameters.
+     */
     clear() {
       this._map.clear();
     }
+    /**
+     * Removes the media type parameter using the specified name.
+     *
+     * @param {string} name The name of the media type parameter to delete.
+     * @returns {boolean} true if the parameter existed and has been removed, or false if the parameter does not exist.
+     */
     delete(name) {
       name = asciiLowercase(String(name));
       return this._map.delete(name);
     }
+    /**
+     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
+     *
+     * @param {function(string, string): void} callback The function called on each iteration.
+     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
+     */
     forEach(callback, thisArg) {
       this._map.forEach(callback, thisArg);
     }
+    /**
+     * Returns an iterable of parameter names.
+     *
+     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
+     */
     keys() {
       return this._map.keys();
     }
+    /**
+     * Returns an iterable of parameter values.
+     *
+     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
+     */
     values() {
       return this._map.values();
     }
+    /**
+     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
+     *
+     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
+     */
     entries() {
       return this._map.entries();
     }
+    /**
+     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
+     *
+     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
+     */
     [Symbol.iterator]() {
       return this._map[Symbol.iterator]();
     }
@@ -266,6 +2953,11 @@ var Transportr = (() => {
 
   // node_modules/@d1g1tal/media-type/src/media-type.js
   var MediaType = class {
+    /**
+     * Create a new MediaType instance from a string representation.
+     *
+     * @param {string} string The media type to parse
+     */
     constructor(string) {
       string = String(string);
       const result = parser_default(string);
@@ -276,6 +2968,12 @@ var Transportr = (() => {
       this._subtype = result.subtype;
       this._parameters = new MediaTypeParameters(result.parameters);
     }
+    /**
+     * Static factor method for parsing a media type.
+     *
+     * @param {string} string The media type to parse
+     * @returns {MediaType} The parsed {@link MediaType} object
+     */
     static parse(string) {
       try {
         return new this(string);
@@ -283,12 +2981,25 @@ var Transportr = (() => {
         return null;
       }
     }
+    /**
+     * Gets the media type essence (type/subtype).
+     *
+     * @returns {string} The media type without any parameters
+     */
     get essence() {
       return `${this.type}/${this.subtype}`;
     }
+    /**
+     * Gets the type.
+     *
+     * @returns {string} The type.
+     */
     get type() {
       return this._type;
     }
+    /**
+     * Sets the type.
+     */
     set type(value) {
       value = asciiLowercase(String(value));
       if (value.length === 0) {
@@ -299,9 +3010,17 @@ var Transportr = (() => {
       }
       this._type = value;
     }
+    /**
+     * Gets the subtype.
+     *
+     * @returns {string} The subtype.
+     */
     get subtype() {
       return this._subtype;
     }
+    /**
+     * Sets the subtype.
+     */
     set subtype(value) {
       value = asciiLowercase(String(value));
       if (value.length === 0) {
@@ -312,12 +3031,29 @@ var Transportr = (() => {
       }
       this._subtype = value;
     }
+    /**
+     * Gets the parameters.
+     *
+     * @returns {MediaTypeParameters} The media type parameters.
+     */
     get parameters() {
       return this._parameters;
     }
+    /**
+     * Gets the serialized version of the media type.
+     *
+     * @returns {string} The serialized media type.
+     */
     toString() {
       return serializer_default(this);
     }
+    /**
+     * Determines if this instance is a JavaScript media type.
+     *
+     * @param {Object} [options] Optional options.
+     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
+     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
+     */
     isJavaScript({ prohibitParameters = false } = {}) {
       switch (this._type) {
         case "text": {
@@ -354,231 +3090,1247 @@ var Transportr = (() => {
           return false;
       }
     }
+    /**
+     * Determines if this instance is an XML media type.
+     *
+     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
+     */
     isXML() {
       return this._subtype === "xml" && (this._type === "text" || this._type === "application") || this._subtype.endsWith("+xml");
     }
+    /**
+     * Determines if this instance is an HTML media type.
+     *
+     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
+     */
     isHTML() {
       return this._subtype === "html" && this._type === "text";
     }
+    /**
+     * Gets the name of the class.
+     *
+     * @returns {string} The class name
+     */
     get [Symbol.toStringTag]() {
       return "MediaType";
     }
   };
 
+  // src/http-error.js
+  var HttpError = class extends Error {
+    /** @type {ResponseBody} */
+    #entity;
+    /** @type {ResponseStatus} */
+    #responseStatus;
+    /**
+     * @param {string} [message] The error message.
+     * @param {HttpErrorOptions} [httpErrorOptions] The http error options.
+     * @param {any} [httpErrorOptions.cause] The cause of the error.
+     * @param {ResponseStatus} [httpErrorOptions.status] The response status.
+     * @param {ResponseBody} [httpErrorOptions.entity] The error entity from the server, if any.
+     */
+    constructor(message, { cause, status, entity }) {
+      super(message, { cause });
+      this.#entity = entity;
+      this.#responseStatus = status;
+    }
+    /**
+     * It returns the value of the private variable #entity.
+     *
+     * @returns {ResponseBody} The entity property of the class.
+     */
+    get entity() {
+      return this.#entity;
+    }
+    /**
+     * It returns the status code of the {@link Response}.
+     *
+     * @returns {number} The status code of the {@link Response}.
+     */
+    get statusCode() {
+      return this.#responseStatus?.code;
+    }
+    /**
+     * It returns the status text of the {@link Response}.
+     *
+     * @returns {string} The status code and status text of the {@link Response}.
+     */
+    get statusText() {
+      return this.#responseStatus?.text;
+    }
+  };
+
   // src/http-media-type.js
   var HttpMediaType = {
+    /** Advanced Audio Coding (AAC) */
     AAC: "audio/aac",
+    /** AbiWord */
     ABW: "application/x-abiword",
+    /** Archive document (multiple files embedded) */
     ARC: "application/x-freearc",
+    /** AVIF image */
     AVIF: "image/avif",
+    /** Audio Video Interleave (AVI) */
     AVI: "video/x-msvideo",
+    /** Amazon Kindle eBook format */
     AZW: "application/vnd.amazon.ebook",
+    /** Binary Data */
     BIN: "application/octet-stream",
+    /** Windows OS/2 Bitmap Graphics */
     BMP: "image/bmp",
+    /** Bzip Archive */
     BZIP: "application/x-bzip",
+    /** Bzip2 Archive */
     BZIP2: "application/x-bzip2",
+    /** CD audio */
     CDA: "application/x-cdf",
+    /** C Shell Script */
     CSH: "application/x-csh",
+    /** Cascading Style Sheets (CSS) */
     CSS: "text/css",
+    /** Comma-Separated Values */
     CSV: "text/csv",
+    /** Microsoft Office Word Document */
     DOC: "application/msword",
+    /** Microsoft Office Word Document (OpenXML) */
     DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    /** Microsoft Embedded OpenType */
     EOT: "application/vnd.ms-fontobject",
+    /** Electronic Publication (EPUB) */
     EPUB: "application/epub+zip",
+    /** GZip Compressed Archive */
     GZIP: "application/gzip",
+    /** Graphics Interchange Format */
     GIF: "image/gif",
+    /** HyperText Markup Language (HTML) */
     HTML: "text/html",
+    /** Icon Format */
     ICO: "image/vnd.microsoft.icon",
+    /** iCalendar Format */
     ICS: "text/calendar",
+    /** Java Archive (JAR) */
     JAR: "application/java-archive",
+    /** JPEG Image */
     JPEG: "image/jpeg",
+    /** JavaScript */
     JAVA_SCRIPT: "text/javascript",
+    /** JavaScript Object Notation Format (JSON) */
     JSON: "application/json",
+    /** JavaScript Object Notation LD Format */
     JSON_LD: "application/ld+json",
+    /** Musical Instrument Digital Interface (MIDI) */
     MID: "audio/midi",
+    /** Musical Instrument Digital Interface (MIDI) */
     X_MID: "audio/x-midi",
+    /** MP3 Audio */
     MP3: "audio/mpeg",
+    /** MPEG-4 Audio */
     MP4A: "audio/mp4",
+    /** MPEG-4 Video */
     MP4: "video/mp4",
+    /** MPEG Video */
     MPEG: "video/mpeg",
+    /** Apple Installer Package */
     MPKG: "application/vnd.apple.installer+xml",
+    /** OpenDocument Presentation Document */
     ODP: "application/vnd.oasis.opendocument.presentation",
+    /** OpenDocument Spreadsheet Document */
     ODS: "application/vnd.oasis.opendocument.spreadsheet",
+    /** OpenDocument Text Document */
     ODT: "application/vnd.oasis.opendocument.text",
+    /** Ogg Audio */
     OGA: "audio/ogg",
+    /** Ogg Video */
     OGV: "video/ogg",
+    /** Ogg */
     OGX: "application/ogg",
+    /** Opus audio */
     OPUS: "audio/opus",
+    /** OpenType Font File */
     OTF: "font/otf",
+    /** Portable Network Graphics (PNG) */
     PNG: "image/png",
+    /** Adobe Portable Document Format */
     PDF: "application/pdf",
+    /** Hypertext Preprocessor (Personal Home Page) */
     PHP: "application/x-httpd-php",
+    /** Microsoft PowerPoint */
     PPT: "application/vnd.ms-powerpoint",
+    /** Microsoft Office Presentation (OpenXML) */
     PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    /** RAR Archive */
     RAR: "application/vnd.rar",
+    /** Rich Text Format */
     RTF: "application/rtf",
+    /** Bourne Shell Script */
     SH: "application/x-sh",
+    /** Scalable Vector Graphics (SVG) */
     SVG: "image/svg+xml",
+    /** Tape Archive (TAR) */
     TAR: "application/x-tar",
+    /** Tagged Image File Format (TIFF) */
     TIFF: "image/tiff",
+    /** MPEG transport stream */
     TRANSPORT_STREAM: "video/mp2t",
+    /** TrueType Font */
     TTF: "font/ttf",
+    /** Text, (generally ASCII or ISO 8859-n) */
     TEXT: "text/plain",
+    /** Microsoft Visio */
     VSD: "application/vnd.visio",
+    /** Waveform Audio Format (WAV) */
     WAV: "audio/wav",
+    /** Open Web Media Project - Audio */
     WEBA: "audio/webm",
+    /** Open Web Media Project - Video */
     WEBM: "video/webm",
+    /** WebP Image */
     WEBP: "image/webp",
+    /** Web Open Font Format */
     WOFF: "font/woff",
+    /** Web Open Font Format */
     WOFF2: "font/woff2",
+    /** XHTML - The Extensible HyperText Markup Language */
     XHTML: "application/xhtml+xml",
+    /** Microsoft Excel Document */
     XLS: "application/vnd.ms-excel",
+    /** Microsoft Office Spreadsheet Document (OpenXML) */
     XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    /** Extensible Markup Language (XML) */
     XML: "application/xml",
+    /** XML User Interface Language (XUL) */
     XUL: "application/vnd.mozilla.xul+xml",
+    /** Zip Archive */
     ZIP: "application/zip",
+    /** 3GPP audio/video container */
     "3GP": "video/3gpp",
+    /** 3GPP2 audio/video container */
     "3G2": "video/3gpp2",
+    /** 7-Zip Archive */
     "7Z": "application/x-7z-compressed"
   };
   var http_media_type_default = HttpMediaType;
 
   // src/http-request-headers.js
   var HttpRequestHeader = {
+    /**
+     * Content-Types that are acceptable for the response. See Content negotiation. Permanent.
+     *
+     * @example
+     * <code>Accept: text/plain</code>
+     */
     ACCEPT: "accept",
+    /**
+     * Character sets that are acceptable. Permanent.
+     *
+     * @example
+     * <code>Accept-Charset: utf-8</code>
+     */
     ACCEPT_CHARSET: "accept-charset",
+    /**
+     * List of acceptable encodings. See HTTP compression. Permanent.
+     *
+     * @example
+     * <code>Accept-Encoding: gzip, deflate</code>
+     */
     ACCEPT_ENCODING: "accept-encoding",
+    /**
+     * List of acceptable human languages for response. See Content negotiation. Permanent.
+     *
+     * @example
+     * <code>Accept-Language: en-US</code>
+     */
     ACCEPT_LANGUAGE: "accept-language",
+    /**
+     * Authentication credentials for HTTP authentication. Permanent.
+     *
+     * @example
+     * <code>Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==</code>
+     */
     AUTHORIZATION: "authorization",
+    /**
+     * Used to specify directives that must be obeyed by all caching mechanisms along the request-response chain.
+     * Permanent.
+     *
+     * @example
+     * <code>Cache-Control: no-cache</code>
+     */
     CACHE_CONTROL: "cache-control",
+    /**
+     * Control options for the current connection and list of hop-by-hop request fields. Permanent.
+     *
+     * @example
+     * <code>Connection: keep-alive</code>
+     * <code>Connection: Upgrade</code>
+     */
     CONNECTION: "connection",
+    /**
+     * An HTTP cookie previously sent by the server with Set-Cookie (below). Permanent: standard.
+     *
+     * @example
+     * <code>Cookie: $Version=1, Skin=new,</code>
+     */
     COOKIE: "cookie",
+    /**
+     * The length of the request body in octets (8-bit bytes). Permanent.
+     *
+     * @example
+     * <code>Content-Length: 348</code>
+     */
     CONTENT_LENGTH: "content-length",
+    /**
+     * A Base64-encoded binary MD5 sum of the content of the request body. Obsolete.
+     *
+     * @example
+     * <code>Content-MD5: Q2hlY2sgSW50ZWdyaXR5IQ==</code>
+     */
     CONTENT_MD5: "content-md5",
+    /**
+     * The MIME type of the body of the request (used with POST and PUT requests). Permanent.
+     * <code>Content-Type: application/x-www-form-urlencoded</code>
+     */
     CONTENT_TYPE: "content-type",
+    /**
+     * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231 Date/Time Formats).
+     * Permanent.
+     *
+     * @example
+     * <code>Date: Tue, 15 Nov 1994 08:12:31 GMT</code>
+     */
     DATE: "date",
+    /**
+     * Indicates that particular server behaviors are required by the client. Permanent.
+     *
+     * @example
+     * <code>Expect: 100-continue</code>
+     */
     EXPECT: "expect",
+    /**
+     * The email address of the user making the request. Permanent.
+     *
+     * @example
+     * <code>From: user@example.com</code>
+     */
     FROM: "from",
+    /**
+     * The domain name of the server (for virtual hosting), and the TCP port number on which the server is listening. The
+     * port number may be omitted if the port is the standard port for the service requested. Permanent. Mandatory since
+     * HTTP/1.1.
+     *
+     * @example
+     * <code>Host: en.wikipedia.org:80</code>
+     * <code>Host: en.wikipedia.org</code>
+     */
     HOST: "host",
+    /**
+     * Only perform the action if the client supplied entity matches the same entity on the server. This is mainly for
+     * methods like PUT to only update a resource if it has not been modified since the user last updated it. Permanent.
+     *
+     * @example
+     * <code>If-Match: "737060cd8c284d8af7ad3082f209582d"</code>
+     */
     IF_MATCH: "if-match",
+    /**
+     * Allows a 304 Not Modified to be returned if content is unchanged. Permanent.
+     *
+     * @example
+     * <code>If-Modified-Since: Sat, 29 Oct 1994 19:43:31 GMT</code>
+     */
     IF_MODIFIED_SINCE: "if-modified-since",
+    /**
+     * Allows a 304 Not Modified to be returned if content is unchanged, see HTTP ETag. Permanent.
+     *
+     * @example
+     * <code>If-None-Match: "737060cd8c284d8af7ad3082f209582d"</code>
+     */
     IF_NONE_MATCH: "if-none-match",
+    /**
+     * If the entity is unchanged, send me the part(s) that I am missing, otherwise, send me the entire new entity.
+     * Permanent.
+     *
+     * @example
+     * <code>If-Range: "737060cd8c284d8af7ad3082f209582d"</code>
+     */
     IF_RANGE: "if-range",
+    /**
+     * Only send the response if the entity has not been modified since a specific time. Permanent.
+     *
+     * @example
+     * <code>If-Unmodified-Since: Sat, 29 Oct 1994 19:43:31 GMT</code>
+     */
     IF_UNMODIFIED_SINCE: "if-unmodified-since",
+    /**
+     * Limit the number of times the message can be forwarded through proxies or gateways. Permanent.
+     *
+     * @example
+     * <code>Max-Forwards: 10</code>
+     */
     MAX_FORWARDS: "max-forwards",
+    /**
+     * Initiates a request for cross-origin resource sharing (asks server for an 'Access-Control-Allow-Origin' response
+     * field). Permanent: standard.
+     *
+     * @example
+     * <code>Origin: http://www.example-social-network.com</code>
+     */
     ORIGIN: "origin",
+    /**
+     * Implementation-specific fields that may have various effects anywhere along the request-response chain. Permanent.
+     *
+     * @example
+     * <code>Pragma: no-cache</code>
+     */
     PRAGMA: "pragma",
+    /**
+     * Authorization credentials for connecting to a proxy. Permanent.
+     *
+     * @example
+     * <code>Proxy-Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==</code>
+     */
     PROXY_AUTHORIZATION: "proxy-authorization",
+    /**
+     * Request only part of an entity. Bytes are numbered from 0. See Byte serving. Permanent.
+     *
+     * @example
+     * <code>Range: bytes=500-999</code>
+     */
     RANGE: "range",
+    /**
+     * This is the address of the previous web page from which a link to the currently requested page was followed. (The
+     * word "referrer" has been misspelled in the RFC as well as in most implementations to the point that it has become
+     * standard usage and is considered correct terminology). Permanent.
+     *
+     * @example
+     * <code>Referer: http://en.wikipedia.org/wiki/Main_Page</code>
+     */
     REFERER: "referer",
+    /**
+     * The transfer encodings the user agent is willing to accept: the same values as for the response header field
+     * Transfer-Encoding can be used, plus the "trailers" value (related to the "chunked" transfer method) to notify the
+     * server it expects to receive additional fields in the trailer after the last, zero-sized, chunk. Permanent.
+     *
+     * @example
+     * <code>TE: trailers, deflate</code>
+     */
     TE: "te",
+    /**
+     * The user agent string of the user agent. Permanent.
+     *
+     * @example
+     * <code>User-Agent: Mozilla/5.0 (X11, Linux x86_64, rv:12.0) Gecko/20100101 Firefox/21.0</code>
+     */
     USER_AGENT: "user-agent",
+    /**
+     * Ask the server to upgrade to another protocol. Permanent.
+     *
+     * @example
+     * <code>Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11</code>
+     */
     UPGRADE: "upgrade",
+    /**
+     * Informs the server of proxies through which the request was sent. Permanent.
+     *
+     * @example
+     * <code>Via: 1.0 fred, 1.1 example.com (Apache/1.1)</code>
+     */
     VIA: "via",
+    /**
+     * A general warning about possible problems with the entity body. Permanent.
+     *
+     * @example
+     * <code>Warning: 199 Miscellaneous warning</code>
+     */
     WARNING: "warning",
+    /**
+     * mainly used to identify Ajax requests. Most JavaScript frameworks send this field with value of XMLHttpRequest.
+     *
+     * @example
+     * <code>X-Requested-With: XMLHttpRequest</code>
+     */
     X_REQUESTED_WITH: "x-requested-with",
+    /**
+     * Requests a web application to disable their tracking of a user. This is Mozilla's version of the X-Do-Not-Track
+     * header field (since Firefox 4.0 Beta 11). Safari and IE9 also have support for this field. On March 7, 2011, a
+     * draft proposal was submitted to IETF. The W3C Tracking Protection Working Group is producing a specification.
+     *
+     * @example
+     * <code>DNT: 1 (Do Not Track Enabled)</code>
+     * <code>DNT: 0 (Do Not Track Disabled)</code>
+     */
     DNT: "dnt",
+    /**
+     * A de facto standard for identifying the originating IP address of a client connecting to a web server through an
+     * HTTP proxy or load balancer.
+     *
+     * @example
+     * <code>X-Forwarded-For: client1, proxy1, proxy2</code>
+     * <code>X-Forwarded-For: 129.78.138.66, 129.78.64.103</code>
+     */
     X_FORWARDED_FOR: "x-forwarded-for",
+    /**
+     * A de facto standard for identifying the original host requested by the client in the Host HTTP request header, since
+     * the host name and/or port of the reverse proxy (load balancer) may differ from the origin server handling the
+     * request.
+     *
+     * @example
+     * <code>X-Forwarded-Host: en.wikipedia.org:80</code>
+     * <code>X-Forwarded-Host: en.wikipedia.org</code>
+     */
     X_FORWARDED_HOST: "x-forwarded-host",
+    /**
+     * A de facto standard for identifying the originating protocol of an HTTP request, since a reverse proxy (load
+     * balancer) may communicate with a web server using HTTP even if the request to the reverse proxy is HTTPS. An
+     * alternative form of the header (X-ProxyUser-Ip) is used by Google clients talking to Google servers.
+     *
+     * @example
+     * <code>X-Forwarded-Proto: https</code>
+     */
     X_FORWARDED_PROTO: "x-forwarded-proto",
+    /**
+     * Non-standard header field used by Microsoft applications and load-balancers.
+     *
+     * @example
+     * <code>Front-End-Https: on</code>
+     */
     FRONT_END_HTTPS: "front-end-https",
+    /**
+     * Requests a web application override the method specified in the request (typically POST) with the method given in
+     * the header field (typically PUT or DELETE). Can be used when a user agent or firewall prevents PUT or DELETE methods
+     * from being sent directly (note that this either a bug in the software component, which ought to be fixed, or an
+     * intentional configuration, in which case bypassing it may be the wrong thing to do).
+     *
+     * @example
+     * <code>X-HTTP-Method-Override: DELETE</code>
+     */
     X_HTTP_METHOD_OVERRIDE: "x-http-method-override",
+    /**
+     * Allows easier parsing of the MakeModel/Firmware that is usually found in the User-Agent String of AT&T Devices.
+     *
+     * @example
+     * <code>X-Att-Deviceid: GT-P7320/P7320XXLPG</code>
+     */
     X_ATT_DEVICE_ID: "x-att-deviceid",
+    /**
+     * Links to an XML file on the Internet with a full description and details about the device currently connecting. In the example to the right is an XML file for an AT&T Samsung Galaxy S2.
+     * x-wap-profile: http://wap.samsungmobile.com/uaprof/SGH-I777.xml
+     */
     X_WAP_PROFILE: "x-wap-profile"
   };
   var http_request_headers_default = HttpRequestHeader;
 
   // src/http-request-methods.js
   var HttpRequestMethod = {
+    /**
+     * The OPTIONS method represents a request for information about the communication options available on the
+     * request/response chain identified by the Request-URI. This method allows the client to determine the options and/or
+     * requirements associated with a resource, or the capabilities of a server, without implying a resource action or
+     * initiating a resource retrieval.
+     *
+     * Responses to this method are not cacheable.
+     *
+     * If the OPTIONS request includes an entity-body (as indicated by the presence of Content-Length or
+     * Transfer-Encoding), then the media type MUST be indicated by a Content-Type field. Although this specification does
+     * not define any use for such a body, future extensions to HTTP might use the OPTIONS body to make more detailed
+     * queries on the server. A server that does not support such an extension MAY discard the request body.
+     *
+     * If the Request-URI is an asterisk ("*"), the OPTIONS request is intended to apply to the server in general rather
+     * than to a specific resource. Since a server's communication options typically depend on the resource, the "*"
+     * request is only useful as a "ping" or "no-op" type of method, it does nothing beyond allowing the client to test the
+     * capabilities of the server. For example, this can be used to test a proxy for HTTP/1.1 compliance (or lack thereof).
+     *
+     * If the Request-URI is not an asterisk, the OPTIONS request applies only to the options that are available when
+     * communicating with that resource.
+     *
+     * A 200 response SHOULD include any header fields that indicate optional features implemented by the server and
+     * applicable to that resource (e.g., Allow), possibly including extensions not defined by this specification. The
+     * response body, if any, SHOULD also include information about the communication options. The format for such a body
+     * is not defined by this specification, but might be defined by future extensions to HTTP. Content negotiation MAY be
+     * used to select the appropriate response format. If no response body is included, the response MUST include a
+     * Content-Length field with a field-value of "0".
+     *
+     * The Max-Forwards request-header field MAY be used to target a specific proxy in the request chain. When a proxy
+     * receives an OPTIONS request on an absoluteURI for which request forwarding is permitted, the proxy MUST check for a
+     * Max-Forwards field. If the Max-Forwards field-value is zero ("0"), the proxy MUST NOT forward the message, instead,
+     * the proxy SHOULD respond with its own communication options. If the Max-Forwards field-value is an integer greater
+     * than zero, the proxy MUST decrement the field-value when it forwards the request. If no Max-Forwards field is
+     * present in the request, then the forwarded request MUST NOT include a Max-Forwards field.
+     */
     OPTIONS: "OPTIONS",
+    /**
+     * The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI. If
+     * the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity in
+     * the response and not the source text of the process, unless that text happens to be the output of the process.
+     *
+     * The semantics of the GET method change to a "conditional GET" if the request message includes an If-Modified-Since;
+     * If-Unmodified-Since, If-Match, If-None-Match, or If-Range header field. A conditional GET method requests that the
+     * entity be transferred only under the circumstances described by the conditional header field(s). The conditional GET
+     * method is intended to reduce unnecessary network usage by allowing cached entities to be refreshed without requiring
+     * multiple requests or transferring data already held by the client.
+     *
+     * The semantics of the GET method change to a "partial GET" if the request message includes a Range header field. A
+     * partial GET requests that only part of the entity be transferred, as described in section 14.35. The partial GET
+     * method is intended to reduce unnecessary network usage by allowing partially-retrieved entities to be completed
+     * without transferring data already held by the client.
+     *
+     * The response to a GET request is cacheable if and only if it meets the requirements for HTTP caching described in
+     * section 13.
+     *
+     * See section 15.1.3 for security considerations when used for forms.
+     */
     GET: "GET",
+    /**
+     * The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. The
+     * meta information contained in the HTTP headers in response to a HEAD request SHOULD be identical to the information
+     * sent in response to a GET request. This method can be used for obtaining meta information about the entity implied by
+     * the request without transferring the entity-body itself. This method is often used for testing hypertext links for
+     * validity, accessibility, and recent modification.
+     *
+     * The response to a HEAD request MAY be cacheable in the sense that the information contained in the response MAY be
+     * used to update a previously cached entity from that resource. If the new field values indicate that the cached
+     * entity differs from the current entity (as would be indicated by a change in Content-Length, Content-MD5, ETag or
+     * Last-Modified), then the cache MUST treat the cache entry as stale.
+     */
     HEAD: "HEAD",
+    /**
+     * The POST method is used to request that the origin server accept the entity enclosed in the request as a new
+     * subordinate of the resource identified by the Request-URI in the Request-Line. POST is designed to allow a uniform
+     * method to cover the following functions:
+     * <ul>
+     *     <li>Annotation of existing resources,</li>
+     *     <li>Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles,</li>
+     *     <li>Providing a block of data, such as the result of submitting a form, to a data-handling process,</li>
+     *     <li>Extending a database through an append operation.</li>
+     * </ul>
+     *
+     * The actual function performed by the POST method is determined by the server and is usually dependent on the
+     * Request-URI. The posted entity is subordinate to that URI in the same way that a file is subordinate to a directory
+     * containing it, a news article is subordinate to a newsgroup to which it is posted, or a record is subordinate to a
+     * database.
+     *
+     * The action performed by the POST method might not result in a resource that can be identified by a URI. In this
+     * case, either 200 (OK) or 204 (No Content) is the appropriate response status, depending on whether or not the
+     * response includes an entity that describes the result.
+     *
+     * If a resource has been created on the origin server, the response SHOULD be 201 (Created) and contain an entity
+     * which describes the status of the request and refers to the new resource, and a Location header (see section 14.30).
+     *
+     * Responses to this method are not cacheable, unless the response includes appropriate Cache-Control or Expires header
+     * fields. However, the 303 (See Other) response can be used to direct the user agent to retrieve a cacheable resource.
+     *
+     * POST requests MUST obey the message transmission requirements set out in section 8.2.
+     *
+     * See section 15.1.3 for security considerations.
+     */
     POST: "POST",
+    /**
+     * The PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers
+     * to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing
+     * on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being
+     * defined as a new resource by the requesting user agent, the origin server can create the resource with that URI. If
+     * a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. If an
+     * existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate
+     * successful completion of the request. If the resource could not be created or modified with the Request-URI, an
+     * appropriate error response SHOULD be given that reflects the nature of the problem. The recipient of the entity MUST
+     * \NOT ignore any Content-* (e.g. Content-Range) headers that it does not understand or implement and MUST return a
+     * 501 (Not Implemented) response in such cases.
+     *
+     * If the request passes through a cache and the Request-URI identifies one or more currently cached entities, those
+     * entries SHOULD be treated as stale. Responses to this method are not cacheable.
+     *
+     * The fundamental difference between the POST and PUT requests is reflected in the different meaning of the
+     * Request-URI. The URI in a POST request identifies the resource that will handle the enclosed entity. That resource
+     * might be a data-accepting process, a gateway to some other protocol, or a separate entity that accepts annotations.
+     * In contrast, the URI in a PUT request identifies the entity enclosed with the request -- the user agent knows what
+     * URI is intended and the server MUST NOT attempt to apply the request to some other resource. If the server desires
+     * that the request be applied to a different URI, it MUST send a 301 (Moved Permanently) response, the user agent MAY
+     * then make its own decision regarding whether or not to redirect the request.
+     *
+     * A single resource MAY be identified by many different URIs. For example, an article might have a URI for identifying
+     * "the current version" which is separate from the URI identifying each particular version. In this case, a PUT
+     * request on a general URI might result in several other URIs being defined by the origin server.
+     *
+     * HTTP/1.1 does not define how a PUT method affects the state of an origin server.
+     *
+     * PUT requests MUST obey the message transmission requirements set out in section 8.2.
+     *
+     * Unless otherwise specified for a particular entity-header, the entity-headers in the PUT request SHOULD be applied
+     * to the resource created or modified by the PUT.
+     */
     PUT: "PUT",
+    /**
+     * The DELETE method requests that the origin server delete the resource identified by the Request-URI. This method MAY
+     * be overridden by human intervention (or other means) on the origin server. The client cannot be guaranteed that the
+     * operation has been carried out, even if the status code returned from the origin server indicates that the action
+     * has been completed successfully. However, the server SHOULD NOT indicate success unless, at the time the response
+     * is given, it intends to delete the resource or move it to an inaccessible location.
+     *
+     * A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 202 (Accepted) if
+     * the action has not yet been enacted, or 204 (No Content) if the action has been enacted but the response does not
+     * include an entity.
+     *
+     * If the request passes through a cache and the Request-URI identifies one or more currently cached entities, those
+     * entries SHOULD be treated as stale. Responses to this method are not cacheable.
+     */
     DELETE: "DELETE",
+    /**
+     * The TRACE method is used to invoke a remote, application-layer loop- back of the request message. The final
+     * recipient of the request SHOULD reflect the message received back to the client as the entity-body of a 200 (OK)
+     * response. The final recipient is either the origin server or the first proxy or gateway to receive a Max-Forwards
+     * value of zero (0) in the request (see section 14.31). A TRACE request MUST NOT include an entity.
+     *
+     * TRACE allows the client to see what is being received at the other end of the request chain and use that data for
+     * testing or diagnostic information. The value of the Via header field (section 14.45) is of particular interest,
+     * since it acts as a trace of the request chain. Use of the Max-Forwards header field allows the client to limit the
+     * length of the request chain, which is useful for testing a chain of proxies forwarding messages in an infinite loop.
+     *
+     * If the request is valid, the response SHOULD contain the entire request message in the entity-body, with a
+     * Content-Type of "message/http". Responses to this method MUST NOT be cached.
+     */
     TRACE: "TRACE",
+    /**
+     * This specification reserves the method name CONNECT for use with a proxy that can dynamically switch to being a
+     * tunnel (e.g. SSL tunneling [44]).
+     */
     CONNECT: "CONNECT",
+    /**
+     * The PATCH method requests that a set of changes described in the
+     * request entity be applied to the resource identified by the Request-
+     * URI.  The set of changes is represented in a format called a "patch
+     * document" identified by a media type.  If the Request-URI does not
+     * point to an existing resource, the server MAY create a new resource,
+     * depending on the patch document type (whether it can logically modify
+     * a null resource) and permissions, etc.
+     *
+     * The difference between the PUT and PATCH requests is reflected in the
+     * way the server processes the enclosed entity to modify the resource
+     * identified by the Request-URI.  In a PUT request, the enclosed entity
+     * is considered to be a modified version of the resource stored on the
+     * origin server, and the client is requesting that the stored version
+     * be replaced.  With PATCH, however, the enclosed entity contains a set
+     * of instructions describing how a resource currently residing on the
+     * origin server should be modified to produce a new version.  The PATCH
+     * method affects the resource identified by the Request-URI, and it
+     * also MAY have side effects on other resources; i.e., new resources
+     * may be created, or existing ones modified, by the application of a
+     * PATCH.
+     *
+     * PATCH is neither safe nor idempotent as defined by [RFC2616], Section
+     * 9.1.
+     *
+     * A PATCH request can be issued in such a way as to be idempotent,
+     * which also helps prevent bad outcomes from collisions between two
+     * PATCH requests on the same resource in a similar time frame.
+     * Collisions from multiple PATCH requests may be more dangerous than
+     * PUT collisions because some patch formats need to operate from a
+     * known base-point or else they will corrupt the resource.  Clients
+     * using this kind of patch application SHOULD use a conditional request
+     * such that the request will fail if the resource has been updated
+     * since the client last accessed the resource.  For example, the client
+     * can use a strong ETag [RFC2616] in an If-Match header on the PATCH
+     * request.
+     *
+     * There are also cases where patch formats do not need to operate from
+     * a known base-point (e.g., appending text lines to log files, or non-
+     * colliding rows to database tables), in which case the same care in
+     * client requests is not needed.
+     *
+     * The server MUST apply the entire set of changes atomically and never
+     * provide (e.g., in response to a GET during this operation) a
+     * partially modified representation.  If the entire patch document
+     * cannot be successfully applied, then the server MUST NOT apply any of
+     * the changes.  The determination of what constitutes a successful
+     * PATCH can vary depending on the patch document and the type of
+     * resource(s) being modified.  For example, the common 'diff' utility
+     * can generate a patch document that applies to multiple files in a
+     * directory hierarchy.  The atomicity requirement holds for all
+     * directly affected files.  See "Error Handling", Section 2.2, for
+     * details on status codes and possible error conditions.
+     *
+     * If the request passes through a cache and the Request-URI identifies
+     * one or more currently cached entities, those entries SHOULD be
+     * treated as stale.  A response to this method is only cacheable if it
+     * contains explicit freshness information (such as an Expires header or
+     * "Cache-Control: max-age" directive) as well as the Content-Location
+     * header matching the Request-URI, indicating that the PATCH response
+     * body is a resource representation.  A cached PATCH response can only
+     * be used to respond to subsequent GET and HEAD requests; it MUST NOT
+     * be used to respond to other methods (in particular, PATCH).
+     *
+     * Note that entity-headers contained in the request apply only to the
+     * contained patch document and MUST NOT be applied to the resource
+     * being modified.  Thus, a Content-Language header could be present on
+     * the request, but it would only mean (for whatever that's worth) that
+     * the patch document had a language.  Servers SHOULD NOT store such
+     * headers except as trace information, and SHOULD NOT use such header
+     * values the same way they might be used on PUT requests.  Therefore,
+     * this document does not specify a way to modify a document's Content-
+     * Type or Content-Language value through headers, though a mechanism
+     * could well be designed to achieve this goal through a patch document.
+     *
+     * There is no guarantee that a resource can be modified with PATCH.
+     * Further, it is expected that different patch document formats will be
+     * appropriate for different types of resources and that no single
+     * format will be appropriate for all types of resources.  Therefore,
+     * there is no single default patch document format that implementations
+     * are required to support.  Servers MUST ensure that a received patch
+     * document is appropriate for the type of resource identified by the
+     * Request-URI.
+     *
+     * Clients need to choose when to use PATCH rather than PUT.  For
+     * example, if the patch document size is larger than the size of the
+     * new resource data that would be used in a PUT, then it might make
+     * sense to use PUT instead of PATCH.  A comparison to POST is even more
+     * difficult, because POST is used in widely varying ways and can
+     * encompass PUT and PATCH-like operations if the server chooses.  If
+     * the operation does not modify the resource identified by the Request-
+     * URI in a predictable way, POST should be considered instead of PATCH
+     * or PUT.
+     */
     PATCH: "PATCH"
   };
   var http_request_methods_default = HttpRequestMethod;
 
   // src/http-response-headers.js
   var HttpResponseHeader = {
+    /**
+     * Implemented as a misunderstanding of the HTTP specifications. Common because of mistakes in implementations of early HTTP versions. Has exactly the same functionality as standard Connection field.
+     *
+     * @example
+     * proxy-connection: keep-alive
+     */
     PROXY_CONNECTION: "proxy-connection",
+    /**
+     * Server-side deep packet insertion of a unique ID identifying customers of Verizon Wireless, also known as "perma-cookie" or "supercookie"
+     *
+     * @example
+     * x-uidh: ...
+     */
     X_UIDH: "x-uidh",
+    /**
+     * Used to prevent cross-site request forgery. Alternative header names are: X-CSRFToken and X-XSRF-TOKEN
+     *
+     * @example
+     * x-csrf-token: i8XNjC4b8KVok4uw5RftR38Wgp2BFwql
+     */
     X_CSRF_TOKEN: "x-csrf-token",
+    /**
+     * Specifying which web sites can participate in cross-origin resource sharing
+     *
+     * @example
+     * access-control-allow-origin: *
+     * Provisional
+     */
     ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
+    /**
+     * Specifies which patch document formats this server supports
+     *
+     * @example
+     * accept-patch: text/example,charset=utf-8
+     * Permanent
+     */
     ACCEPT_PATCH: "accept-patch",
+    /**
+     * What partial content range types this server supports via byte serving
+     *
+     * @example
+     * accept-ranges: bytes
+     * Permanent
+     */
     ACCEPT_RANGES: "accept-ranges",
+    /**
+     * The age the object has been in a proxy cache in seconds
+     *
+     * @example
+     * age: 12
+     * Permanent
+     */
     AGE: "age",
+    /**
+     * Valid actions for a specified resource. To be used for a 405 Method not allowed
+     *
+     * @example
+     * allow: GET, HEAD
+     * Permanent
+     */
     ALLOW: "allow",
+    /**
+     * Tells all caching mechanisms from server to client whether they may cache this object. It is measured in seconds
+     *
+     * @example
+     * cache-control: max-age=3600
+     * Permanent
+     */
     CACHE_CONTROL: "cache-control",
+    /**
+     * Control options for the current connection and list of hop-by-hop response fields
+     *
+     * @example
+     * connection: close
+     * Permanent
+     */
     CONNECTION: "connection",
+    /**
+     * An opportunity to raise a "File Download" dialogue box for a known MIME type with binary format or suggest a filename for dynamic content. Quotes are necessary with special characters.
+     *
+     * @example
+     * content-disposition: attachment, filename="fname.ext"
+     * Permanent
+     */
     CONTENT_DISPOSITION: "content-disposition",
+    /**
+     * The type of encoding used on the data. See HTTP compression.
+     *
+     * @example
+     * content-encoding: gzip
+     * Permanent
+     */
     CONTENT_ENCODING: "content-encoding",
+    /**
+     * The natural language or languages of the intended audience for the enclosed content
+     *
+     * @example
+     * content-language: da
+     * Permanent
+     */
     CONTENT_LANGUAGE: "content-language",
+    /**
+     * The length of the response body in octets (8-bit bytes)
+     *
+     * @example
+     * content-length: 348
+     * Permanent
+     */
     CONTENT_LENGTH: "content-length",
+    /**
+     * An alternate location for the returned data
+     *
+     * @example
+     * content-location: /index.htm
+     * Permanent
+     */
     CONTENT_LOCATION: "content-location",
+    /**
+     * Where in a full body message this partial message belongs
+     *
+     * @example
+     * content-range: bytes 21010-47021/47022
+     * Permanent
+     */
     CONTENT_RANGE: "content-range",
+    /**
+     * The MIME type of this content
+     *
+     * @example
+     * content-type: text/html, charset=utf-8
+     * Permanent
+     */
     CONTENT_TYPE: "content-type",
+    /**
+     * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231)
+     *
+     * @example
+     * date: Tue, 15 Nov 1994 08:12:31 GMT
+     * Permanent
+     */
     DATE: "date",
+    /**
+     * An identifier for a specific version of a resource, often a message digest
+     *
+     * @example
+     * etag: "737060cd8c284d8af7ad3082f209582d"
+     * Permanent
+     */
     ETAG: "etag",
+    /**
+     * Gives the date/time after which the response is considered stale (in "HTTP-date" format as defined by RFC 7231)
+     *
+     * @example
+     * expires: Thu, 01 Dec 1994 16:00:00 GMT
+     * Permanent
+     */
     EXPIRES: "expires",
+    /**
+     * The last modified date for the requested object (in "HTTP-date" format as defined by RFC 7231)
+     *
+     * @example
+     * last-modified: Tue, 15 Nov 1994 12:45:26 GMT
+     * Permanent
+     */
     LAST_MODIFIED: "last-modified",
+    /**
+     * Used to express a typed relationship with another resource, where the relation type is defined by RFC 5988
+     *
+     * @example
+     * link: </feed>, rel="alternate"
+     * Permanent
+     */
     LINK: "link",
+    /**
+     * Used in redirection, or when a new resource has been created.
+     *
+     * @example
+     * location: http://www.w3.org/pub/WWW/People.html
+     * Permanent
+     */
     LOCATION: "location",
+    /**
+     * This field is supposed to set P3P policy, in the form of P3P:CP="your_compact_policy". However, P3P did not take off, most browsers have never fully
+     * implemented it, a lot of websites set this field with fake policy text, that was enough to fool browsers the existence of P3P policy and grant permissions for third party cookies.
+     *
+     * @example
+     * p3p: CP="This is not a P3P policy! See http://www.google.com/support/accounts/bin/answer.py?hl=en&answer=151657 for more info."
+     * Permanent
+     */
     P3P: "p3p",
+    /**
+     * Implementation-specific fields that may have various effects anywhere along the request-response chain.
+     *
+     * @example
+     * pragma: no-cache
+     * Permanent
+     */
     PRAGMA: "pragma",
+    /**
+     * Request authentication to access the proxy.
+     *
+     * @example
+     * proxy-authenticate: Basic
+     * Permanent
+     */
     PROXY_AUTHENTICATION: "proxy-authenticate",
+    /**
+     * HTTP Public Key Pinning, announces hash of website's authentic TLS certificate
+     *
+     * @example
+     * public-key-pins: max-age=2592000, pin-sha256="E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=",
+     * Permanent
+     */
     PUBLIC_KEY_PINS: "public-key-pins",
+    /**
+     * If an entity is temporarily unavailable, this instructs the client to try again later. Value could be a specified period of time (in seconds) or a HTTP-date.
+     *
+     * @example
+     * retry-after: 120
+     * retry-after: Fri, 07 Nov 2014 23:59:59 GMT
+     * Permanent
+     */
     RETRY_AFTER: "retry-after",
+    /**
+     * A name for the server
+     *
+     * @example
+     * server: Apache/2.4.1 (Unix)
+     * Permanent
+     */
     SERVER: "server",
+    /**
+     * An HTTP cookie
+     *
+     * @example
+     * set-cookie: UserID=JohnDoe, Max-Age=3600, Version=1
+     * Permanent
+     */
     SET_COOKIE: "set-cookie",
+    /**
+     * CGI header field specifying the status of the HTTP response. Normal HTTP responses use a separate "Status-Line" instead, defined by RFC 7230.
+     *
+     * @example
+     * status: 200 OK
+     */
     STATUS: "status",
+    /**
+     * A HSTS Policy informing the HTTP client how long to cache the HTTPS only policy and whether this applies to subdomains.
+     *
+     * @example
+     * strict-transport-security: max-age=16070400, includeSubDomains
+     * Permanent
+     */
     STRICT_TRANSPORT_SECURITY: "strict-transport-security",
+    /**
+     * The Trailer general field value indicates that the given set of header fields is present in the trailer of a message encoded with chunked transfer coding.
+     *
+     * @example
+     * trailer: Max-Forwards
+     * Permanent
+     */
     TRAILER: "trailer",
+    /**
+     * The form of encoding used to safely transfer the entity to the user. Currently defined methods are: chunked, compress, deflate, gzip, identity.
+     *
+     * @example
+     * transfer-encoding: chunked
+     * Permanent
+     */
     TRANSFER_ENCODING: "transfer-encoding",
+    /**
+     * Ask the client to upgrade to another protocol.
+     *
+     * @example
+     * upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
+     * Permanent
+     */
     UPGRADE: "upgrade",
+    /**
+     * Tells downstream proxies how to match future request headers to decide whether the cached response can be used rather than requesting a fresh one from the origin server.
+     *
+     * @example
+     * vary: *
+     * Permanent
+     */
     VARY: "vary",
+    /**
+     * Informs the client of proxies through which the response was sent.
+     *
+     * @example
+     * via: 1.0 fred, 1.1 example.com (Apache/1.1)
+     * Permanent
+     */
     VIA: "via",
+    /**
+     * A general warning about possible problems with the entity body.
+     *
+     * @example
+     * warning: 199 Miscellaneous warning
+     * Permanent
+     */
     WARNING: "warning",
+    /**
+     * Indicates the authentication scheme that should be used to access the requested entity.
+     *
+     * @example
+     * www-authenticate: Basic
+     * Permanent
+     */
     WWW_AUTHENTICATE: "www-authenticate",
+    /**
+     * Cross-site scripting (XSS) filter
+     *
+     * @example
+     * x-xss-protection: 1, mode=block
+     */
     X_XSS_PROTECTION: "x-xss-protection",
+    /**
+     * The HTTP Content-Security-Policy response header allows web site administrators to control resources the user agent is allowed
+     * to load for a given page. With a few exceptions, policies mostly involve specifying server origins and script endpoints.
+     * This helps guard against cross-site scripting attacks (Cross-site_scripting).
+     *
+     * @example
+     * content-security-policy: default-src
+     */
     CONTENT_SECURITY_POLICY: "content-security-policy",
+    /**
+     * The only defined value, "nosniff", prevents Internet Explorer from MIME-sniffing a response away from the declared content-type. This also applies to Google Chrome, when downloading extensions.
+     *
+     * @example
+     * x-content-type-options: nosniff
+     */
     X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
+    /**
+     * specifies the technology (e.g. ASP.NET, PHP, JBoss) supporting the web application (version details are often in X-Runtime, X-Version, or X-AspNet-Version)
+     *
+     * @example
+     * x-powered-by: PHP/5.4.0
+     */
     X_POWERED_BY: "x-powered-by"
   };
   var http_response_headers_default = HttpResponseHeader;
 
-  // src/transportr.js
-  var HttpError = class extends Error {
+  // src/response-status.js
+  var ResponseStatus = class {
+    /** @type {number} */
+    #code;
+    /** @type {string} */
+    #text;
+    /**
+     *
+     * @param {number} code The status code from the {@link Response}
+     * @param {string} text The status text from the {@link Response}
+     */
+    constructor(code, text) {
+      this.#code = code;
+      this.#text = text;
+    }
+    /**
+     * Returns the status code from the {@link Response}
+     *
+     * @returns {number} The status code.
+     */
+    get code() {
+      return this.#code;
+    }
+    /**
+     * Returns the status text from the {@link Response}.
+     *
+     * @returns {string} The status text.
+     */
+    get text() {
+      return this.#text;
+    }
   };
+
+  // src/transportr.js
+  var import_xmldom = __toESM(require_lib(), 1);
   var endsWithSlashRegEx = /\/$/;
   var _handleText = async (response) => await response.text();
   var _handleScript = async (response) => {
     const objectURL = URL.createObjectURL(await response.blob());
     document.head.removeChild(document.head.appendChild(Object.assign(document.createElement("script"), { src: objectURL, type: http_media_type_default.JAVA_SCRIPT, async: true })));
     URL.revokeObjectURL(objectURL);
+    return Promise.resolve();
   };
   var _handleCss = async (response) => {
     const objectURL = URL.createObjectURL(await response.blob());
     document.head.appendChild(Object.assign(document.createElement("link"), { href: objectURL, type: http_media_type_default.CSS, rel: "stylesheet" }));
     URL.revokeObjectURL(objectURL);
+    return Promise.resolve();
   };
   var _handleJson = async (response) => await response.json();
   var _handleBlob = async (response) => await response.blob();
   var _handleImage = async (response) => URL.createObjectURL(await response.blob());
   var _handleBuffer = async (response) => await response.arrayBuffer();
   var _handleReadableStream = async (response) => response.body;
-  var _handleXml = async (response) => new DOMParser().parseFromString(await response.text(), Transportr.MediaType.XML.essence);
-  var _handleHtml = async (response) => new DOMParser().parseFromString(await response.text(), Transportr.MediaType.HTML.essence);
+  var _handleXml = async (response) => new import_xmldom.DOMParser().parseFromString(await response.text(), http_media_type_default.XML.essence);
+  var _handleHtml = async (response) => new import_xmldom.DOMParser().parseFromString(await response.text(), http_media_type_default.HTML.essence);
   var _handleHtmlFragment = async (response) => document.createRange().createContextualFragment(await response.text());
-  var _baseUrl, _options, _contentTypeHandlers, _contentSubtypeHandlers, _defaultRequestOptions, _get, get_fn, _request, request_fn, _createUrl, createUrl_fn, _processResponse, processResponse_fn;
+  var _baseUrl, _options, _contentTypeHandlers, _defaultRequestOptions, _get, get_fn, _request, request_fn, _processResponse, processResponse_fn, _createUrl, createUrl_fn, _needsSerialization, needsSerialization_fn;
   var _Transportr = class {
+    /**
+     * Create a new Transportr instance with the provided location or origin and context path.
+     *
+     * @param {URL | string | RequestOptions} [url=location.origin] The URL for {@link fetch} requests.
+     * @param {RequestOptions} [options=Transportr.#defaultRequestOptions] The default {@link RequestOptions} for this instance.
+     */
     constructor(url = location.origin, options = __privateGet(_Transportr, _defaultRequestOptions)) {
+      /**
+       * Makes a GET request to the given path, using the given options, and then calls the
+       * given response handler with the response.
+       *
+       * @private
+       * @async
+       * @param {string} path - The path to the endpoint you want to call.
+       * @param {RequestOptions} [userOptions] - The options passed to the public function to use for the request.
+       * @param {RequestOptions} [options] - The options for the request.
+       * @param {ResponseHandler<ResponseBody>} [responseHandler] - A function that will be called with the response object.
+       * @returns {Promise<ResponseBody>} The result of the #request method.
+       */
       __privateAdd(this, _get);
+      /**
+       * It takes a path, options, and a response handler, and returns a promise that resolves to the
+       * response entity.
+       *
+       * @private
+       * @async
+       * @param {string} path - The path to the resource you want to access.
+       * @param {RequestOptions} [userOptions={}] - The options passed to the public function to use for the request.
+       * @param {RequestOptions} [options={}] - The options to use for the request.
+       * @param {ResponseHandler<ResponseBody>} [responseHandler] - A function that will be called with the response body as a parameter. This
+       * is useful if you want to do something with the response body before returning it.
+       * @returns {Promise<ResponseBody>} The response from the API call.
+       */
       __privateAdd(this, _request);
+      /** @type {URL} */
       __privateAdd(this, _baseUrl, void 0);
+      /** @type {RequestOptions} */
       __privateAdd(this, _options, void 0);
       const type = object_type_default(url);
       if (type == Object) {
@@ -590,135 +4342,331 @@ var Transportr = (() => {
       __privateSet(this, _baseUrl, url);
       __privateSet(this, _options, options);
     }
+    /**
+     * It returns the base {@link URL} for the API.
+     *
+     * @returns {URL} The baseUrl property.
+     */
     get baseUrl() {
       return __privateGet(this, _baseUrl);
     }
-    async get(path, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.GET }));
+    /**
+     * This function returns a promise that resolves to the result of a request to the specified path with
+     * the specified options, where the method is GET.
+     *
+     * @async
+     * @param {string} path - The path to the resource you want to get.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} A promise that resolves to the response of the request.
+     */
+    async get(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options);
     }
-    async post(path, body, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { body, method: http_request_methods_default.POST }));
+    /**
+     * This function makes a POST request to the given path with the given body and options.
+     *
+     * @async
+     * @param {string} path - The path to the endpoint you want to call.
+     * @param {Object} body - The body of the request.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} A promise that resolves to the response body.
+     */
+    async post(path, body, options) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options, { body, method: http_request_methods_default.POST });
     }
-    async put(path, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.PUT }));
+    /**
+     * This function returns a promise that resolves to the result of a request to the specified path with
+     * the specified options, where the method is PUT.
+     *
+     * @async
+     * @param {string} path - The path to the endpoint you want to call.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} The return value of the #request method.
+     */
+    async put(path, options) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.PUT });
     }
-    async patch(path, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.PATCH }));
+    /**
+     * It takes a path and options, and returns a request with the method set to PATCH.
+     *
+     * @async
+     * @param {string} path - The path to the endpoint you want to hit.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} A promise that resolves to the response of the request.
+     */
+    async patch(path, options) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.PATCH });
     }
-    async delete(path, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.DELETE }));
+    /**
+     * It takes a path and options, and returns a request with the method set to DELETE.
+     *
+     * @async
+     * @param {string} path - The path to the resource you want to access.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} The result of the request.
+     */
+    async delete(path, options) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.DELETE });
     }
-    async head(path, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.HEAD }));
+    /**
+     * Returns the response headers of a request to the given path.
+     *
+     * @async
+     * @param {string} path - The path to the resource you want to access.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} A promise that resolves to the response object.
+     */
+    async head(path, options) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.HEAD });
     }
-    async options(path, options = {}) {
-      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.OPTIONS }));
+    /**
+     * It takes a path and options, and returns a request with the method set to OPTIONS.
+     *
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} The return value of the #request method.
+     */
+    async options(path, options) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.OPTIONS });
     }
-    async request(path, options = {}) {
+    /**
+     * It takes a path and options, and makes a request to the server.
+     *
+     * @async
+     * @param {string} path - The path to the endpoint you want to hit.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ResponseBody>} The return value of the function is the return value of the function that is passed to the `then` method of the promise returned by the `fetch` method.
+     */
+    async request(path, options) {
       return __privateMethod(this, _request, request_fn).call(this, path, options);
     }
-    async getJson(path, options = {}) {
-      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: _Transportr.MediaType.JSON } }), _handleJson);
+    /**
+     * It gets a JSON resource from the server.
+     *
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options object to pass to the request.
+     * @returns {Promise<JsonObject>} A promise that resolves to the response body as a JSON object.
+     */
+    async getJson(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.JSON } }, _handleJson);
     }
-    async getXml(path, options = {}) {
-      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: _Transportr.MediaType.XML } }), _handleXml);
+    /**
+     * It gets the XML representation of the resource at the given path.
+     *
+     * @async
+     * @param {string} path - The path to the resource you want to get.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<Document>} The result of the function call to #get.
+     */
+    async getXml(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.XML } }, _handleXml);
     }
-    async getHtml(path, options = {}) {
-      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }), _handleHtml);
+    /**
+     * Get the HTML content of the specified path.
+     *
+     * @todo Add way to return portion of the retrieved HTML using a selector. Like jQuery.
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<Document>} The return value of the function is the return value of the function passed to the `then`
+     * method of the promise returned by the `#get` method.
+     */
+    async getHtml(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }, _handleHtml);
     }
-    async getHtmlFragment(path, options = {}) {
-      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }), _handleHtmlFragment);
+    /**
+     * It returns a promise that resolves to the HTML fragment at the given path.
+     *
+     * @todo - Add way to return portion of the retrieved HTML using a selector. Like jQuery.
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<DocumentFragment>} A promise that resolves to an HTML fragment.
+     */
+    async getHtmlFragment(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }, _handleHtmlFragment);
     }
-    async getScript(path, options = {}) {
-      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.JAVA_SCRIPT } }), _handleScript);
+    /**
+     * It gets a script from the server, and appends the script to the {@link Document} {@link HTMLHeadElement}
+     * CORS is enabled by default.
+     *
+     * @async
+     * @param {string} path - The path to the script.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<void>} A promise that has been resolved.
+     */
+    async getScript(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.JAVA_SCRIPT } }, _handleScript);
     }
-    async getStylesheet(path, options = {}) {
-      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.CSS } }), _handleCss);
+    /**
+     * Gets a stylesheet from the server, and adds it as a {@link Blob} {@link URL}.
+     *
+     * @async
+     * @param {string} path - The path to the stylesheet.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<void>} A promise that has been resolved.
+     */
+    async getStylesheet(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.CSS } }, _handleCss);
     }
-    async getBlob(path, options = {}) {
-      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }), _handleBlob);
+    /**
+     * It returns a blob from the specified path.
+     *
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<Blob>} A promise that resolves to a blob.
+     */
+    async getBlob(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBlob);
     }
-    async getImage(path, options = {}) {
-      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }), _handleBlob);
+    /**
+     * It returns a promise that resolves to an object URL.
+     *
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<string>} A promise that resolves to an object URL.
+     */
+    async getImage(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }, _handleImage);
     }
-    async getBuffer(path, options = {}) {
-      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }), _handleBuffer);
+    /**
+     * It gets a buffer from the specified path
+     *
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ArrayBuffer>} A promise that resolves to a buffer.
+     */
+    async getBuffer(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBuffer);
     }
-    async getStream(path, options = {}) {
-      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }), _handleReadableStream);
+    /**
+     * It returns a readable stream of the response body from the specified path.
+     *
+     * @async
+     * @param {string} path - The path to the resource.
+     * @param {RequestOptions} [options] - The options for the request.
+     * @returns {Promise<ReadableStream<Uint8Array>>} A readable stream.
+     */
+    async getStream(path, options) {
+      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleReadableStream);
     }
   };
   var Transportr = _Transportr;
   _baseUrl = new WeakMap();
   _options = new WeakMap();
   _contentTypeHandlers = new WeakMap();
-  _contentSubtypeHandlers = new WeakMap();
   _defaultRequestOptions = new WeakMap();
   _get = new WeakSet();
-  get_fn = async function(path, options, responseHandler) {
-    return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: _Transportr.Method.GET }), responseHandler);
+  get_fn = async function(path, userOptions, options, responseHandler) {
+    return __privateMethod(this, _request, request_fn).call(this, path, userOptions, options, responseHandler);
   };
   _request = new WeakSet();
-  request_fn = async function(path, options, responseHandler) {
-    var _a, _b;
-    const requestOptions = object_merge_default(__privateGet(this, _options), options);
-    const headers = new Headers(requestOptions.headers);
+  request_fn = async function(path, userOptions = {}, options = {}, responseHandler) {
+    var _a, _b, _c, _d;
+    if (object_type_default(userOptions.headers) == Headers) {
+      userOptions.headers = Object.fromEntries(userOptions.headers.entries());
+    }
+    const requestOptions = object_merge_default(__privateGet(this, _options), userOptions, options);
+    requestOptions.headers = new Headers(requestOptions.headers);
     const errorMessage = `An error has occurred with your Request: ${path}`;
-    if (headers.get(_Transportr.RequestHeader.CONTENT_TYPE) == _Transportr.MediaType.JSON) {
+    if (__privateMethod(_a = _Transportr, _needsSerialization, needsSerialization_fn).call(_a, requestOptions.method, requestOptions.headers.get(http_request_headers_default.CONTENT_TYPE))) {
       requestOptions.body = JSON.stringify(requestOptions.body);
     }
+    if (requestOptions.searchParams && !(requestOptions.searchParams instanceof URLSearchParams)) {
+      requestOptions.searchParams = new URLSearchParams(requestOptions.searchParams);
+    }
     let response;
     try {
-      response = await fetch(__privateMethod(_a = _Transportr, _createUrl, createUrl_fn).call(_a, __privateGet(this, _baseUrl), path, requestOptions.searchParams), requestOptions);
+      response = await fetch(__privateMethod(_b = _Transportr, _createUrl, createUrl_fn).call(_b, __privateGet(this, _baseUrl), path, requestOptions.searchParams), requestOptions);
     } catch (error) {
       console.error(errorMessage, error);
-      throw new HttpError(errorMessage);
+      throw new HttpError(errorMessage, { cause: error, status: new ResponseStatus(response.status, response.statusText) });
     }
     if (!response.ok) {
-      throw new HttpError(`${errorMessage}. Response: ${response.status} - ${await response.text()}`);
+      throw new HttpError(errorMessage, { status: new ResponseStatus(response.status, response.statusText), entity: await __privateMethod(_c = _Transportr, _processResponse, processResponse_fn).call(_c, response) });
     }
+    return await __privateMethod(_d = _Transportr, _processResponse, processResponse_fn).call(_d, response, responseHandler);
+  };
+  _processResponse = new WeakSet();
+  processResponse_fn = async function(response, handler) {
     try {
-      return await (responseHandler ? responseHandler(response) : __privateMethod(_b = _Transportr, _processResponse, processResponse_fn).call(_b, response));
+      if (!handler) {
+        const mediaType = new MediaType(response.headers.get(http_response_headers_default.CONTENT_TYPE));
+        if (mediaType) {
+          for (const [responseHandler, contentTypes] of __privateGet(_Transportr, _contentTypeHandlers)) {
+            if (contentTypes.has(mediaType.type) || contentTypes.has(mediaType.subtype)) {
+              handler = responseHandler;
+              break;
+            }
+          }
+        }
+      }
+      return (handler ?? _handleText)(response);
     } catch (error) {
-      console.error(errorMessage, error);
-      throw new HttpError(errorMessage);
+      const errorMessage = "Unable to process response.";
+      console.error(errorMessage, error, response);
+      throw new HttpError(errorMessage, { cause: error });
     }
   };
   _createUrl = new WeakSet();
-  createUrl_fn = function(url, path, searchParams = {}) {
+  createUrl_fn = function(url, path, searchParams = new URLSearchParams()) {
     url = path.startsWith("/") ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(path);
-    for (const [name, value] of Object.entries(searchParams)) {
-      if (Array.isArray(value)) {
-        value.forEach((v) => url.searchParams.set(name, v));
-      } else {
-        url.searchParams.append(name, value);
-      }
-    }
+    searchParams.forEach(([name, value]) => url.searchParams.append(name, value));
     return url;
   };
-  _processResponse = new WeakSet();
-  processResponse_fn = async function(response) {
-    const mediaType = new MediaType(response.headers.get(http_response_headers_default.CONTENT_TYPE));
-    for (const [responseHandler, contentTypes] of __privateGet(_Transportr, _contentSubtypeHandlers).entries()) {
-      if (contentTypes.has(mediaType.subtype)) {
-        return await responseHandler(response);
-      }
-    }
-    for (const [responseHandler, contentTypes] of __privateGet(_Transportr, _contentTypeHandlers).entries()) {
-      if (contentTypes.has(mediaType.type)) {
-        return await responseHandler(response);
-      }
-    }
-    console.warn("Unable to process response. Unknown content-type or no response handler defined.");
-    return response;
+  _needsSerialization = new WeakSet();
+  needsSerialization_fn = function(method, contentType) {
+    return contentType == http_media_type_default.JSON && [http_request_methods_default.POST, http_request_methods_default.PUT, http_request_methods_default.PATCH].includes(method);
   };
-  __privateAdd(Transportr, _createUrl);
+  /**
+   * It takes a response and a handler, and if the handler is not defined, it tries to find a handler
+   * based on the response's content type
+   *
+   * @private
+   * @static
+   * @async
+   * @param {Response} response - The response object returned by the fetch API.
+   * @param {ResponseHandler<ResponseBody>} [handler] - The handler to use for processing the response.
+   * @returns {Promise<ResponseBody>} The response is being returned.
+   */
   __privateAdd(Transportr, _processResponse);
+  /**
+   * It takes a URL, a path, and a set of search parameters, and returns a new URL with the path and
+   * search parameters applied.
+   *
+   * @private
+   * @static
+   * @param {URL} url - The URL to use as a base.
+   * @param {string} path - The path to the resource. This can be a relative path or a full URL.
+   * @param {URLSearchParams} [searchParams=new URLSearchParams()] - An object containing the query parameters to be added to the URL.
+   * @returns {URL} A new URL object with the pathname and origin of the url parameter, and the path parameter
+   * appended to the end of the pathname.
+   */
+  __privateAdd(Transportr, _createUrl);
+  /**
+   * If the request method is POST, PUT, or PATCH, and the content type is JSON, then the request body
+   * needs to be serialized.
+   *
+   * @private
+   * @static
+   * @param {RequestMethod} method - The HTTP request method.
+   * @param {HttpMediaType} contentType - The headers of the request.
+   * @returns {boolean} `true` if the request body needs to be serialized, `false` otherwise.
+   */
+  __privateAdd(Transportr, _needsSerialization);
+  /**
+   * @private
+   * @static
+   * @type {SetMultiMap<ResponseHandler<ResponseBody>, string>}
+   */
   __privateAdd(Transportr, _contentTypeHandlers, new SetMultiMap([
     [_handleImage, new MediaType(http_media_type_default.PNG).type],
-    [_handleText, new MediaType(http_media_type_default.TEXT).type]
-  ]));
-  __privateAdd(Transportr, _contentSubtypeHandlers, new SetMultiMap([
+    [_handleText, new MediaType(http_media_type_default.TEXT).type],
     [_handleJson, new MediaType(http_media_type_default.JSON).subtype],
     [_handleHtml, new MediaType(http_media_type_default.HTML).subtype],
     [_handleScript, new MediaType(http_media_type_default.JAVA_SCRIPT).subtype],
@@ -726,35 +4674,72 @@ var Transportr = (() => {
     [_handleXml, new MediaType(http_media_type_default.XML).subtype],
     [_handleReadableStream, new MediaType(http_media_type_default.BIN).subtype]
   ]));
+  /**
+   * @static
+   * @constant {Object<string, HttpRequestMethod>}
+   */
   __publicField(Transportr, "Method", Object.freeze(http_request_methods_default));
-  __publicField(Transportr, "MediaType", http_media_type_default);
-  __publicField(Transportr, "RequestHeader", http_request_headers_default);
+  /**
+   * @static
+   * @constant {Object<string, HttpMediaType>}
+   */
+  __publicField(Transportr, "MediaType", Object.freeze(http_media_type_default));
+  /**
+   * @static
+   * @see {@link HttpRequestHeader}
+   * @constant {Object<string, HttpRequestHeader>}
+   */
+  __publicField(Transportr, "RequestHeader", Object.freeze(http_request_headers_default));
+  /**
+   * @static
+   * @constant {Object<string, HttpResponseHeader>}
+   */
   __publicField(Transportr, "ResponseHeader", Object.freeze(http_response_headers_default));
-  __publicField(Transportr, "CachingPolicy", {
+  /**
+   * @static
+   * @constant {Object<string, RequestCache>}
+   */
+  __publicField(Transportr, "CachingPolicy", Object.freeze({
     DEFAULT: "default",
     FORCE_CACHE: "force-cache",
     NO_CACHE: "no-cache",
     NO_STORE: "no-store",
     ONLY_IF_CACHED: "only-if-cached",
     RELOAD: "reload"
-  });
-  __publicField(Transportr, "CredentialsPolicy", {
+  }));
+  /**
+   * @static
+   * @constant {Object<string, RequestCredentials>}
+   */
+  __publicField(Transportr, "CredentialsPolicy", Object.freeze({
     INCLUDE: "include",
     OMIT: "omit",
     SAME_ORIGIN: "same-origin"
-  });
-  __publicField(Transportr, "RequestMode", {
+  }));
+  /**
+   * @static
+   * @constant {Object<string, RequestMode>}
+   */
+  __publicField(Transportr, "RequestMode", Object.freeze({
     CORS: "cors",
     NAVIGATE: "navigate",
     NO_CORS: "no-cors",
     SAME_ORIGIN: "same-origin"
-  });
-  __publicField(Transportr, "RedirectPolicy", {
+  }));
+  /**
+   * @static
+   * @constant {Object<string, RequestRedirect>}
+   */
+  __publicField(Transportr, "RedirectPolicy", Object.freeze({
     ERROR: "error",
     FOLLOW: "follow",
     MANUAL: "manual"
-  });
-  __publicField(Transportr, "ReferrerPolicy", {
+  }));
+  /**
+   * @static
+   * @constant {Object<string, ReferrerPolicy>}
+   */
+  __publicField(Transportr, "ReferrerPolicy", Object.freeze({
     NO_REFERRER: "no-referrer",
     NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
     ORIGIN: "origin",
@@ -763,22 +4748,27 @@ var Transportr = (() => {
     STRICT_ORIGIN: "strict-origin",
     STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
     UNSAFE_URL: "unsafe-url"
-  });
-  __privateAdd(Transportr, _defaultRequestOptions, {
+  }));
+  /**
+   * @private
+   * @static
+   * @type {RequestOptions}
+   */
+  __privateAdd(Transportr, _defaultRequestOptions, Object.freeze({
     body: null,
     cache: _Transportr.CachingPolicy.NO_STORE,
     credentials: _Transportr.CredentialsPolicy.SAME_ORIGIN,
     headers: {},
     integrity: void 0,
     keepalive: void 0,
-    method: void 0,
+    method: http_request_methods_default.GET,
     mode: _Transportr.RequestMode.CORS,
     redirect: _Transportr.RedirectPolicy.FOLLOW,
     referrer: "about:client",
     referrerPolicy: _Transportr.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
     signal: null,
     window: null
-  });
+  }));
   return __toCommonJS(transportr_exports);
 })();
 window.Transportr = Transportr.default;