@d1g1tal/transportr 0.1.2 → 0.1.3

package/dist/transportr.js

@@ -60,25 +60,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 +134,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 +188,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 +341,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 +356,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 +369,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 +398,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 +419,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,216 +478,1199 @@ 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} [options] The error options.
+     * @param {Error} [options.cause] The cause of the error.
+     * @param {ResponseStatus} [options.status] The response status.
+     * @param {ResponseBody} [options.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;
+    }
+  };
+  var http_error_default = HttpError;
+
   // 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 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();
@@ -573,12 +1680,43 @@ var Transportr = (() => {
   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 _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, _createUrl, createUrl_fn, _request, request_fn, _processResponse, processResponse_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} 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} 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,60 +1728,224 @@ 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);
     }
+    /**
+     * 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, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.GET }));
     }
+    /**
+     * 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, object_merge_default(options, { body, method: http_request_methods_default.POST }));
     }
+    /**
+     * 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, object_merge_default(options, { method: http_request_methods_default.PUT }));
     }
+    /**
+     * 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, 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 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, object_merge_default(options, { method: http_request_methods_default.DELETE }));
     }
+    /**
+     * 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, object_merge_default(options, { method: http_request_methods_default.HEAD }));
     }
+    /**
+     * 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, object_merge_default(options, { method: http_request_methods_default.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);
     }
+    /**
+     * 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, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: _Transportr.MediaType.JSON } }), _handleJson);
     }
+    /**
+     * 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 await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: _Transportr.MediaType.XML } }), _handleXml);
     }
+    /**
+     * TODO - Add way to return portion of the retrieved HTML using a selector. Like jQuery.
+     *
+     * @async
+     * @param {string} path
+     * @param {RequestOptions} [options = {}]
+     * @returns {Promise<Document>}
+     */
+    /**
+     * 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, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }), _handleHtml);
     }
+    /**
+     * 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, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }), _handleHtmlFragment);
     }
+    /**
+     * 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, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.JAVA_SCRIPT } }), _handleScript);
     }
+    /**
+     * 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, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.CSS } }), _handleCss);
     }
+    /**
+     * 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 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 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 await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }), _handleBlob);
-    }
+      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }), _handleImage);
+    }
+    /**
+     * 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 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 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 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);
     }
@@ -652,73 +1954,112 @@ var 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);
   };
+  _createUrl = new WeakSet();
+  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 searchParams) {
+      url.searchParams.append(name, value);
+    }
+    return url;
+  };
   _request = new WeakSet();
   request_fn = async function(path, options, responseHandler) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const requestOptions = object_merge_default(__privateGet(this, _options), options);
     const 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, options.method, headers)) {
       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 http_error_default(errorMessage, { cause: error, status: new ResponseStatus(response.status, response.statusText) });
     }
     if (!response.ok) {
-      throw new HttpError(`${errorMessage}. Response: ${response.status} - ${await response.text()}`);
-    }
-    try {
-      return await (responseHandler ? responseHandler(response) : __privateMethod(_b = _Transportr, _processResponse, processResponse_fn).call(_b, response));
-    } catch (error) {
-      console.error(errorMessage, error);
-      throw new HttpError(errorMessage);
+      throw new http_error_default(errorMessage, { status: new ResponseStatus(response.status, response.statusText), entity: await __privateMethod(_c = _Transportr, _processResponse, processResponse_fn).call(_c, response) });
     }
-  };
-  _createUrl = new WeakSet();
-  createUrl_fn = function(url, path, searchParams = {}) {
-    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);
-      }
-    }
-    return url;
+    return await __privateMethod(_d = _Transportr, _processResponse, processResponse_fn).call(_d, response, responseHandler);
   };
   _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);
+  processResponse_fn = async function(response, handler) {
+    try {
+      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) {
+      const errorMessage = "Unable to process response.";
+      console.error(errorMessage, error, response);
+      throw new http_error_default(errorMessage, { cause: error });
     }
-    console.warn("Unable to process response. Unknown content-type or no response handler defined.");
-    return response;
   };
+  _needsSerialization = new WeakSet();
+  needsSerialization_fn = function(method, headers) {
+    return [http_request_methods_default.POST, http_request_methods_default.PUT, http_request_methods_default.PATCH].includes(method) && headers.get(_Transportr.RequestHeader.CONTENT_TYPE) == _Transportr.MediaType.JSON;
+  };
+  /**
+   * 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);
+  /**
+   * 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);
+  /**
+   * 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 {RequestHeaders} headers - 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,10 +2067,30 @@ var Transportr = (() => {
     [_handleXml, new MediaType(http_media_type_default.XML).subtype],
     [_handleReadableStream, new MediaType(http_media_type_default.BIN).subtype]
   ]));
+  /**
+   * @static
+   * @constant {Object<string, RequestMethod>}
+   */
   __publicField(Transportr, "Method", Object.freeze(http_request_methods_default));
+  /**
+   * @static
+   * @constant {Object<string, string>}
+   */
   __publicField(Transportr, "MediaType", http_media_type_default);
+  /**
+   * @static
+   * @constant {Object<string, string>}
+   */
   __publicField(Transportr, "RequestHeader", http_request_headers_default);
+  /**
+   * @static
+   * @constant {Object<string, string>}
+   */
   __publicField(Transportr, "ResponseHeader", Object.freeze(http_response_headers_default));
+  /**
+   * @static
+   * @constant {Object<string, RequestCache>}
+   */
   __publicField(Transportr, "CachingPolicy", {
     DEFAULT: "default",
     FORCE_CACHE: "force-cache",
@@ -738,22 +2099,38 @@ var Transportr = (() => {
     ONLY_IF_CACHED: "only-if-cached",
     RELOAD: "reload"
   });
+  /**
+   * @static
+   * @constant {Object<string, RequestCredentials>}
+   */
   __publicField(Transportr, "CredentialsPolicy", {
     INCLUDE: "include",
     OMIT: "omit",
     SAME_ORIGIN: "same-origin"
   });
+  /**
+   * @static
+   * @constant {Object<string, RequestMode>}
+   */
   __publicField(Transportr, "RequestMode", {
     CORS: "cors",
     NAVIGATE: "navigate",
     NO_CORS: "no-cors",
     SAME_ORIGIN: "same-origin"
   });
+  /**
+   * @static
+   * @constant {Object<string, RequestRedirect>}
+   */
   __publicField(Transportr, "RedirectPolicy", {
     ERROR: "error",
     FOLLOW: "follow",
     MANUAL: "manual"
   });
+  /**
+   * @static
+   * @constant {Object<string, ReferrerPolicy>}
+   */
   __publicField(Transportr, "ReferrerPolicy", {
     NO_REFERRER: "no-referrer",
     NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
@@ -764,6 +2141,10 @@ var Transportr = (() => {
     STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
     UNSAFE_URL: "unsafe-url"
   });
+  /**
+   * @static
+   * @type {RequestOptions}
+   */
   __privateAdd(Transportr, _defaultRequestOptions, {
     body: null,
     cache: _Transportr.CachingPolicy.NO_STORE,