@d1g1tal/transportr 1.4.4 → 2.0.0

package/dist/iife/transportr.js

@@ -1,2656 +0,0 @@
-(() => {
-	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}.
-	   * If the value already exists in the {@link Set}, it will not be added again.
-	   *
-	   * @param {K} key The key to set.
-	   * @param {V} value The value to add to the SetMultiMap
-	   * @returns {SetMultiMap<K, V>} The SetMultiMap with the updated key and value.
-	   */
-	  set(key, value) {
-	    super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
-	    return this;
-	  }
-	  /**
-	   * Checks if a specific key has a specific value.
-	   *
-	   * @param {K} key The key to check.
-	   * @param {V} value The value to check.
-	   * @returns {boolean} True if the key has the value, false otherwise.
-	   */
-	  hasValue(key, value) {
-	    const values = super.get(key);
-	    return values ? values.has(value) : false;
-	  }
-	  /**
-	   * Removes a specific value from a specific key.
-	   *
-	   * @param {K} key The key to remove the value from.
-	   * @param {V} value The value to remove.
-	   * @returns {boolean} True if the value was removed, false otherwise.
-	   */
-	  deleteValue(key, value) {
-	    const values = super.get(key);
-	    if (values) {
-	      return values.delete(value);
-	    }
-	    return false;
-	  }
-	  get [Symbol.toStringTag]() {
-	    return "SetMultiMap";
-	  }
-	};
-	var ContextEventHandler = class {
-	  #context;
-	  #eventHandler;
-	  /**
-	   * @param {*} context The context to bind to the event handler.
-	   * @param {function(*): void} eventHandler The event handler to call when the event is published.
-	   */
-	  constructor(context, eventHandler) {
-	    this.#context = context;
-	    this.#eventHandler = eventHandler;
-	  }
-	  /**
-	   * Call the event handler for the provided event.
-	   *
-	   * @param {Event} event The event to handle
-	   * @param {*} [data] The value to be passed to the event handler as a parameter.
-	   */
-	  handle(event, data) {
-	    this.#eventHandler.call(this.#context, event, data);
-	  }
-	  get [Symbol.toStringTag]() {
-	    return "ContextEventHandler";
-	  }
-	};
-	var Subscription = class {
-	  #eventName;
-	  #contextEventHandler;
-	  /**
-	   * @param {string} eventName The event name.
-	   * @param {ContextEventHandler} contextEventHandler Then context event handler.
-	   */
-	  constructor(eventName, contextEventHandler) {
-	    this.#eventName = eventName;
-	    this.#contextEventHandler = contextEventHandler;
-	  }
-	  /**
-	   * Gets the event name for the subscription.
-	   *
-	   * @returns {string} The event name.
-	   */
-	  get eventName() {
-	    return this.#eventName;
-	  }
-	  /**
-	   * Gets the context event handler.
-	   *
-	   * @returns {ContextEventHandler} The context event handler
-	   */
-	  get contextEventHandler() {
-	    return this.#contextEventHandler;
-	  }
-	  get [Symbol.toStringTag]() {
-	    return "Subscription";
-	  }
-	};
-	var Subscribr = class {
-	  /** @type {SetMultiMap<string, ContextEventHandler>} */
-	  #subscribers;
-	  constructor() {
-	    this.#subscribers = new SetMultiMap();
-	  }
-	  /**
-	   * Subscribe to an event
-	   *
-	   * @param {string} eventName The event name to subscribe to.
-	   * @param {function(Event, *): void} eventHandler The event handler to call when the event is published.
-	   * @param {*} [context] The context to bind to the event handler.
-	   * @returns {Subscription} An object used to check if the subscription still exists and to unsubscribe from the event.
-	   */
-	  subscribe(eventName, eventHandler, context = eventHandler) {
-	    const contextEventHandler = new ContextEventHandler(context, eventHandler);
-	    this.#subscribers.set(eventName, contextEventHandler);
-	    return new Subscription(eventName, contextEventHandler);
-	  }
-	  /**
-	   * Unsubscribe from the event
-	   *
-	   * @param {Subscription} subscription The subscription to unsubscribe.
-	   * @param {string} subscription.eventName The event name to subscribe to.
-	   * @param {ContextEventHandler} subscription.contextEventHandler The event handler to call when the event is published.
-	   * @returns {boolean} true if eventListener has been removed successfully. false if the value is not found or if the value is not an object.
-	   */
-	  unsubscribe({ eventName, contextEventHandler }) {
-	    const contextEventHandlers = this.#subscribers.get(eventName);
-	    const removed = contextEventHandlers?.delete(contextEventHandler);
-	    if (removed && contextEventHandlers.size == 0) {
-	      this.#subscribers.delete(eventName);
-	    }
-	    return removed;
-	  }
-	  /**
-	   * Publish an event
-	   *
-	   * @param {string} eventName The name of the event.
-	   * @param {Event} [event=new CustomEvent(eventName)] The event to be handled.
-	   * @param {*} [data] The value to be passed to the event handler as a parameter.
-	   */
-	  publish(eventName, event = new CustomEvent(eventName), data) {
-	    if (data == null && !(event instanceof Event)) {
-	      [data, event] = [event, new CustomEvent(eventName)];
-	    }
-	    this.#subscribers.get(eventName)?.forEach((contextEventHandler) => contextEventHandler.handle(event, data));
-	  }
-	  /**
-	   * Check if the event and handler are subscribed.
-	   *
-	   * @param {Subscription} subscription The subscription object.
-	   * @param {string} subscription.eventName The name of the event to check.
-	   * @param {ContextEventHandler} subscription.contextEventHandler The event handler to check.
-	   * @returns {boolean} true if the event name and handler are subscribed, false otherwise.
-	   */
-	  isSubscribed({ eventName, contextEventHandler }) {
-	    return this.#subscribers.get(eventName)?.has(contextEventHandler);
-	  }
-	  get [Symbol.toStringTag]() {
-	    return "Subscribr";
-	  }
-	};
-	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;
-	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;
-	  }
-	  /**
-	   * A String value that is used in the creation of the default string
-	   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
-	   *
-	   * @override
-	   * @returns {string} The default string description of this object.
-	   */
-	  get [Symbol.toStringTag]() {
-	    return "ResponseStatus";
-	  }
-	  /**
-	   * tostring method for the class.
-	   *
-	   * @override
-	   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString|Object.prototype.toString}
-	   * @returns {string} The status code and status text.
-	   */
-	  toString() {
-	    return `${this.#code} ${this.#text}`;
-	  }
-	};
-	var _type = (object) => object?.constructor ?? object?.prototype?.constructor ?? globalThis[Object.prototype.toString.call(object).slice(8, -1)] ?? object;
-	var object_type_default = _type;
-	var _objectMerge = (...objects) => {
-	  const target = {};
-	  for (const source of objects) {
-	    if (object_type_default(source) != Object)
-	      return void 0;
-	    let descriptor, sourceType;
-	    for (const property of Object.getOwnPropertyNames(source)) {
-	      descriptor = Object.getOwnPropertyDescriptor(source, property);
-	      if (descriptor.enumerable) {
-	        sourceType = object_type_default(source[property]);
-	        if (sourceType == Object) {
-	          descriptor.value = object_type_default(target[property]) == Object ? _objectMerge(target[property], source[property]) : { ...source[property] };
-	        } else if (sourceType == Array) {
-	          descriptor.value = Array.isArray(target[property]) ? [.../* @__PURE__ */ new Set([...source[property], ...target[property]])] : [...source[property]];
-	        }
-	        target[property] = descriptor.value;
-	      }
-	    }
-	  }
-	  return target;
-	};
-	var object_merge_default = _objectMerge;
-	var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
-	var utils_default = httpTokenCodePoints;
-	var matcher = /(["\\])/ug;
-	var httpQuotedStringTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
-	var MediaTypeParameters = class _MediaTypeParameters extends Map {
-	  /**
-	   * Create a new MediaTypeParameters instance.
-	   *
-	   * @param {Array<[string, string]>} entries An array of [name, value] tuples.
-	   */
-	  constructor(entries = []) {
-	    super(entries);
-	  }
-	  /**
-	   * Indicates whether the supplied name and value are valid media type parameters.
-	   *
-	   * @static
-	   * @param {string} name The name of the media type parameter to validate.
-	   * @param {string} value The media type parameter value to validate.
-	   * @returns {boolean} true if the media type parameter is valid, false otherwise.
-	   */
-	  static isValid(name, value) {
-	    return utils_default.test(name) && httpQuotedStringTokenCodePoints.test(value);
-	  }
-	  /**
-	   * 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 super.get(name.toLowerCase());
-	  }
-	  /**
-	   * 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 super.has(name.toLowerCase());
-	  }
-	  /**
-	   * 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) {
-	    if (!_MediaTypeParameters.isValid(name, value)) {
-	      throw new Error(`Invalid media type parameter name/value: ${name}/${value}`);
-	    }
-	    super.set(name.toLowerCase(), value);
-	    return this;
-	  }
-	  /**
-	   * 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) {
-	    return super.delete(name.toLowerCase());
-	  }
-	  /**
-	   * Returns a string representation of the media type parameters.
-	   *
-	   * @override
-	   * @returns {string} The string representation of the media type parameters.
-	   */
-	  toString() {
-	    return Array.from(this).map(([name, value]) => `;${name}=${!value || !utils_default.test(value) ? `"${value.replace(matcher, "\\$1")}"` : value}`).join("");
-	  }
-	  /**
-	   * Returns the name of this class.
-	   *
-	   * @override
-	   * @returns {string} The name of this class.
-	   */
-	  [Symbol.toStringTag]() {
-	    return "MediaTypeParameters";
-	  }
-	};
-	var whitespaceCharacters = [" ", "	", "\n", "\r"];
-	var trailingWhitespace = /[ \t\n\r]+$/u;
-	var leadingAndTrailingWhitespace = /^[ \t\n\r]+|[ \t\n\r]+$/ug;
-	var MediaTypeParser = class _MediaTypeParser {
-	  /**
-	   * Function to parse a media type.
-	   *
-	   * @static
-	   * @param {string} input The media type to parse
-	   * @returns {{ type: string, subtype: string, parameters: MediaTypeParameters }} An object populated with the parsed media type properties and any parameters.
-	   */
-	  static parse(input) {
-	    input = input.replace(leadingAndTrailingWhitespace, "");
-	    const length = input.length, trim = true, lowerCase = false;
-	    let { position, result: type, subtype = "" } = _MediaTypeParser.#filterComponent({ input }, "/");
-	    if (!type.length || position >= length || !utils_default.test(type)) {
-	      throw new TypeError(_MediaTypeParser.#generateErrorMessage("type", type));
-	    }
-	    ({ position, result: subtype } = _MediaTypeParser.#filterComponent({ position: ++position, input, trim }, ";"));
-	    if (!subtype.length || !utils_default.test(subtype)) {
-	      throw new TypeError(_MediaTypeParser.#generateErrorMessage("subtype", subtype));
-	    }
-	    let parameterName = "", parameterValue = null;
-	    const parameters = new MediaTypeParameters();
-	    while (position++ < length) {
-	      while (whitespaceCharacters.includes(input[position])) {
-	        ++position;
-	      }
-	      ({ position, result: parameterName } = _MediaTypeParser.#filterComponent({ position, input, lowerCase }, ";", "="));
-	      if (position < length) {
-	        if (input[position] == ";") {
-	          continue;
-	        }
-	        ++position;
-	      }
-	      if (input[position] == '"') {
-	        [parameterValue, position] = _MediaTypeParser.#collectHttpQuotedString(input, position);
-	        while (position < length && input[position] != ";") {
-	          ++position;
-	        }
-	      } else {
-	        ({ position, result: parameterValue } = _MediaTypeParser.#filterComponent({ position, input, lowerCase, trim }, ";"));
-	        if (!parameterValue) {
-	          continue;
-	        }
-	      }
-	      if (parameterName && MediaTypeParameters.isValid(parameterName, parameterValue) && !parameters.has(parameterName)) {
-	        parameters.set(parameterName, parameterValue);
-	      }
-	    }
-	    return { type, subtype, parameters };
-	  }
-	  /**
-	   * Filters a component from the input string.
-	   *
-	   * @private
-	   * @static
-	   * @param {Object} options The options.
-	   * @param {number} [options.position] The starting position.
-	   * @param {string} options.input The input string.
-	   * @param {boolean} [options.lowerCase] Indicates whether the result should be lowercased.
-	   * @param {boolean} [options.trim] Indicates whether the result should be trimmed.
-	   * @param {string[]} charactersToFilter The characters to filter.
-	   * @returns {{ position: number, result: string }} An object that includes the resulting string and updated position.
-	   */
-	  static #filterComponent({ position = 0, input, lowerCase = true, trim = false }, ...charactersToFilter) {
-	    let result = "";
-	    for (const length = input.length; position < length && !charactersToFilter.includes(input[position]); position++) {
-	      result += input[position];
-	    }
-	    if (lowerCase) {
-	      result = result.toLowerCase();
-	    }
-	    if (trim) {
-	      result = result.replace(trailingWhitespace, "");
-	    }
-	    return { position, result };
-	  }
-	  /**
-	   * Collects all the HTTP quoted strings.
-	   * This variant only implements it with the extract-value flag set.
-	   *
-	   * @private
-	   * @static
-	   * @param {string} input The string to process.
-	   * @param {number} position The starting position.
-	   * @returns {Array<string|number>} An array that includes the resulting string and updated position.
-	   */
-	  static #collectHttpQuotedString(input, position) {
-	    let value = "";
-	    for (let length = input.length, char; ++position < length; ) {
-	      if ((char = input[position]) == '"') {
-	        break;
-	      }
-	      value += char == "\\" && ++position < length ? input[position] : char;
-	    }
-	    return [value, position];
-	  }
-	  /**
-	   * Generates an error message.
-	   *
-	   * @private
-	   * @static
-	   * @param {string} component The component name.
-	   * @param {string} value The component value.
-	   * @returns {string} The error message.
-	   */
-	  static #generateErrorMessage(component, value) {
-	    return `Invalid ${component} "${value}": only HTTP token code points are valid.`;
-	  }
-	};
-	var MediaType = class _MediaType {
-	  /** @type {string} */
-	  #type;
-	  /** @type {string} */
-	  #subtype;
-	  /** @type {MediaTypeParameters} */
-	  #parameters;
-	  /**
-	   * Create a new MediaType instance from a string representation.
-	   *
-	   * @param {string} mediaType The media type to parse.
-	   * @param {Object} [parameters] Optional parameters.
-	   */
-	  constructor(mediaType, parameters = {}) {
-	    if (object_type_default(parameters) != Object) {
-	      throw new TypeError("The parameters argument must be an object");
-	    }
-	    ({ type: this.#type, subtype: this.#subtype, parameters: this.#parameters } = MediaTypeParser.parse(mediaType));
-	    for (const [name, value] of Object.entries(parameters)) {
-	      this.#parameters.set(name, value);
-	    }
-	  }
-	  static parse(mediaType) {
-	    try {
-	      return new _MediaType(mediaType);
-	    } catch (e) {
-	    }
-	    return null;
-	  }
-	  /**
-	   * Gets the type.
-	   *
-	   * @returns {string} The type.
-	   */
-	  get type() {
-	    return this.#type;
-	  }
-	  /**
-	   * Gets the subtype.
-	   *
-	   * @returns {string} The subtype.
-	   */
-	  get subtype() {
-	    return this.#subtype;
-	  }
-	  /**
-	   * Gets the media type essence (type/subtype).
-	   *
-	   * @returns {string} The media type without any parameters
-	   */
-	  get essence() {
-	    return `${this.#type}/${this.#subtype}`;
-	  }
-	  /**
-	   * Gets the parameters.
-	   *
-	   * @returns {MediaTypeParameters} The media type parameters.
-	   */
-	  get parameters() {
-	    return this.#parameters;
-	  }
-	  /**
-	   * Checks if the media type matches the specified type.
-	   *
-	   * @todo Fix string handling to parse the type and subtype from the string.
-	   * @param {MediaType|string} type The media type to check.
-	   * @returns {boolean} true if the media type matches the specified type, false otherwise.
-	   */
-	  matches(type) {
-	    return this.#type == type?.type && this.#subtype == type?.subtype || this.essence.includes(type);
-	  }
-	  /**
-	   * Gets the serialized version of the media type.
-	   *
-	   * @returns {string} The serialized media type.
-	   */
-	  toString() {
-	    return `${this.essence}${this.#parameters.toString()}`;
-	  }
-	  /**
-	   * Gets the name of the class.
-	   *
-	   * @returns {string} The class name
-	   */
-	  get [Symbol.toStringTag]() {
-	    return "MediaType";
-	  }
-	};
-	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",
-	  /** JavaScript Object Notation (JSON) Merge Patch */
-	  JSON_MERGE_PATCH: "application/merge-patch+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",
-	  /** Form - Encoded */
-	  FORM: "application/x-www-form-urlencoded",
-	  /** Multipart FormData */
-	  MULTIPART_FORM_DATA: "multipart/form-data",
-	  /** 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;
-	var defaultCharset = "utf-8";
-	var endsWithSlashRegEx = /\/$/;
-	var mediaTypes = /* @__PURE__ */ new Map([
-	  [http_media_type_default.PNG, new MediaType(http_media_type_default.PNG)],
-	  [http_media_type_default.TEXT, new MediaType(http_media_type_default.TEXT, { defaultCharset })],
-	  [http_media_type_default.JSON, new MediaType(http_media_type_default.JSON, { defaultCharset })],
-	  [http_media_type_default.HTML, new MediaType(http_media_type_default.HTML, { defaultCharset })],
-	  [http_media_type_default.JAVA_SCRIPT, new MediaType(http_media_type_default.JAVA_SCRIPT, { defaultCharset })],
-	  [http_media_type_default.CSS, new MediaType(http_media_type_default.CSS, { defaultCharset })],
-	  [http_media_type_default.XML, new MediaType(http_media_type_default.XML, { defaultCharset })],
-	  [http_media_type_default.BIN, new MediaType(http_media_type_default.BIN)]
-	]);
-	var RequestEvents = Object.freeze({
-	  CONFIGURED: "configured",
-	  SUCCESS: "success",
-	  ERROR: "error",
-	  ABORTED: "aborted",
-	  TIMEOUT: "timeout",
-	  COMPLETE: "complete",
-	  ALL_COMPLETE: "all-complete"
-	});
-	var SignalEvents = Object.freeze({
-	  ABORT: "abort",
-	  TIMEOUT: "timeout"
-	});
-	var _abortEvent = new CustomEvent(SignalEvents.ABORT, { detail: { cause: new DOMException("The request was aborted", "AbortError") } });
-	var requestBodyMethods = [http_request_methods_default.POST, http_request_methods_default.PUT, http_request_methods_default.PATCH];
-	var internalServerError = new ResponseStatus(500, "Internal Server Error");
-	var eventResponseStatuses = Object.freeze({
-	  [RequestEvents.ABORTED]: new ResponseStatus(499, "Aborted"),
-	  [RequestEvents.TIMEOUT]: new ResponseStatus(504, "Request Timeout")
-	});
-	var abortSignalProxyHandler = { get: (target, property) => property == "signal" ? target.signal.timeout(target.timeout) : Reflect.get(target, property) };
-	var AbortSignal = class {
-	  /** @type {AbortController} */
-	  #abortController;
-	  /** @type {number} */
-	  #timeoutId;
-	  /**
-	   * @param {NativeAbortSignal} signal The signal to chain.
-	   * This signal will be able to abort the request, but will not be notified if the request is aborted by the timeout.
-	   */
-	  constructor(signal) {
-	    this.#abortController = new AbortController();
-	    signal?.addEventListener(SignalEvents.ABORT, (event) => this.#abort(event));
-	  }
-	  /**
-	   * The aborted property is a Boolean that indicates whether the request has been aborted (true) or not (false).
-	   *
-	   * @returns {boolean} Whether the signal was aborted or not
-	   */
-	  get aborted() {
-	    return this.#abortController.signal.aborted;
-	  }
-	  /**
-	   * The reason property returns a DOMException object indicating the reason the operation was aborted, or null if the operation is not aborted.
-	   *
-	   * @returns {DOMException} The reason the signal was aborted
-	   */
-	  get reason() {
-	    return this.#abortController.signal.reason;
-	  }
-	  /**
-	   * Returns an AbortSignal instance that will be aborted when the provided amount of milliseconds have passed.
-	   * A value of {@link Infinity} means there is no timeout.
-	   * Note: You can't set this property to a value less than 0.
-	   *
-	   * @param {number} timeout The timeout in milliseconds
-	   * @returns {AbortSignal} The abort signal
-	   */
-	  timeout(timeout) {
-	    if (timeout < 0) {
-	      throw new RangeError("The timeout cannot be negative");
-	    }
-	    if (timeout != Infinity) {
-	      this.#timeoutId ??= setTimeout(() => this.#abort(new CustomEvent(SignalEvents.TIMEOUT, { detail: { timeout, cause: new DOMException(`The request timed-out after ${timeout / 1e3} seconds`, "TimeoutError") } }), true), timeout);
-	    }
-	    return this.#abortController.signal;
-	  }
-	  /**
-	   * Clears the timeout.
-	   * Note: This does not abort the signal, dispatch the timeout event, or reset the timeout.
-	   *
-	   * @returns {void}
-	   */
-	  clearTimeout() {
-	    clearTimeout(this.#timeoutId);
-	  }
-	  /**
-	   * Adds an event listener for the 'abort' event.
-	   *
-	   * @param {EventListener} listener The listener to add
-	   * @returns {AbortSignal} The AbortSignal
-	   */
-	  onAbort(listener) {
-	    this.#abortController.signal.addEventListener(SignalEvents.ABORT, listener);
-	    return this;
-	  }
-	  /**
-	   * Adds an event listener for the 'timeout' event.
-	   *
-	   * @param {EventListener} listener The listener to add
-	   * @returns {AbortSignal} The AbortSignal
-	   */
-	  onTimeout(listener) {
-	    this.#abortController.signal.addEventListener(SignalEvents.TIMEOUT, listener);
-	    return this;
-	  }
-	  /**
-	   * Aborts the signal. This is so naughty. ¯\_(ツ)_/¯
-	   *
-	   * @param {Event} event The event to abort with
-	   * @returns {void}
-	   */
-	  abort(event) {
-	    this.#abort(event);
-	  }
-	  /**
-	   * Aborts the signal.
-	   *
-	   * @private
-	   * @param {Event} event The event to abort with
-	   * @param {boolean} [dispatchEvent = false] Whether to dispatch the event or not
-	   * @returns {void}
-	   * @fires SignalEvents.ABORT When the signal is aborted
-	   * @fires SignalEvents.TIMEOUT When the signal times out
-	   */
-	  #abort(event = _abortEvent, dispatchEvent = false) {
-	    clearTimeout(this.#timeoutId);
-	    this.#abortController.abort(event.detail?.cause);
-	    if (dispatchEvent) {
-	      this.#abortController.signal.dispatchEvent(event);
-	    }
-	  }
-	};
-	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;
-	  }
-	  get name() {
-	    return "HttpError";
-	  }
-	  /**
-	   * A String value that is used in the creation of the default string
-	   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
-	   *
-	   * @returns {string} The default string description of this object.
-	   */
-	  get [Symbol.toStringTag]() {
-	    return "HttpError";
-	  }
-	};
-	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;
-	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;
-	var ParameterMap = class _ParameterMap extends Map {
-	  /**
-	   * @param {Iterable<[string, *]>|Object} parameters The initial parameters to set.
-	   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
-	   */
-	  constructor(parameters = {}) {
-	    super();
-	    for (const [key, value] of _ParameterMap.#entries(parameters)) {
-	      this.append(key, value);
-	    }
-	  }
-	  /**
-	   * Adds a new element with a specified key and value to the ParameterMap.
-	   * If an element with the same key already exists, the value will be replaced in the underlying {@link Set}.
-	   *
-	   * @override
-	   * @param {string} key The key to set.
-	   * @param {*} value The value to add to the ParameterMap
-	   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
-	   */
-	  set(key, value) {
-	    const array = super.get(key);
-	    if (array?.length > 0) {
-	      array.length = 0;
-	      array[0] = value;
-	    } else {
-	      super.set(key, [value]);
-	    }
-	    return this;
-	  }
-	  /**
-	   * Adds all key-value pairs from an iterable or object to the ParameterMap.
-	   * If a key already exists, the value will be replaced in the underlying {@link Array}.
-	   *
-	   * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
-	   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
-	   */
-	  setAll(parameters) {
-	    for (const [key, value] of _ParameterMap.#entries(parameters)) {
-	      this.set(key, value);
-	    }
-	    return this;
-	  }
-	  /**
-	   * Returns the value associated to the key, or undefined if there is none.
-	   * If the key has multiple values, the first value will be returned.
-	   * If the key has no values, undefined will be returned.
-	   *
-	   * @override
-	   * @param {string} key The key to get.
-	   * @returns {*} The value associated to the key, or undefined if there is none.
-	   */
-	  get(key) {
-	    return super.get(key)?.[0];
-	  }
-	  /**
-	   * Returns an array of all values associated to the key, or undefined if there are none.
-	   *
-	   * @param {string} key The key to get.
-	   * @returns {Array<*>} An array of all values associated to the key, or undefined if there are none.
-	   */
-	  getAll(key) {
-	    return super.get(key);
-	  }
-	  /**
-	   * Appends a new value to an existing key inside a ParameterMap, or adds the new key if it does not exist.
-	   *
-	   * @param {string} key The key to append.
-	   * @param {*} value The value to append.
-	   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value to allow chaining.
-	   */
-	  append(key, value) {
-	    const array = super.get(key);
-	    if (array?.length > 0) {
-	      array.push(value);
-	    } else {
-	      super.set(key, [value]);
-	    }
-	    return this;
-	  }
-	  /**
-	   * Appends all key-value pairs from an iterable or object to the ParameterMap.
-	   * If a key already exists, the value will be appended to the underlying {@link Array}.
-	   * If a key does not exist, the key and value will be added to the ParameterMap.
-	   *
-	   * @param {Iterable<[string, *]>|Object} parameters The parameters to append.
-	   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
-	   */
-	  appendAll(parameters) {
-	    for (const [key, value] of _ParameterMap.#entries(parameters)) {
-	      this.append(key, value);
-	    }
-	    return this;
-	  }
-	  /**
-	   * Checks if a specific key has a specific value.
-	   *
-	   * @param {*} value The value to check.
-	   * @returns {boolean} True if the key has the value, false otherwise.
-	   */
-	  hasValue(value) {
-	    for (const array of super.values()) {
-	      if (array.includes(value)) {
-	        return true;
-	      }
-	    }
-	    return false;
-	  }
-	  /**
-	   * Removes a specific value from a specific key.
-	   *
-	   * @param {*} value The value to remove.
-	   * @returns {boolean} True if the value was removed, false otherwise.
-	   */
-	  deleteValue(value) {
-	    for (const array of this.values()) {
-	      if (array.includes(value)) {
-	        return array.splice(array.indexOf(value), 1).length > 0;
-	      }
-	    }
-	    return false;
-	  }
-	  /**
-	   * Determines whether the ParameterMap contains anything.
-	   *
-	   * @returns {boolean} True if the ParameterMap size is greater than 0, false otherwise.
-	   */
-	  isEmpty() {
-	    return this.size === 0;
-	  }
-	  /**
-	   * Returns an Object that can be serialized to JSON.
-	   * If a key has only one value, the value will be a single value.
-	   * If a key has multiple values, the value will be an array of values.
-	   * If a key has no values, the value will be undefined.
-	   *
-	   * @override
-	   * @returns {Object} The Object to be serialized to JSON.
-	   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON_behavior}
-	   */
-	  toJSON() {
-	    const obj = /* @__PURE__ */ Object.create(null);
-	    for (const [key, values] of super.entries()) {
-	      obj[key] = values.length === 1 ? values[0] : values;
-	    }
-	    return obj;
-	  }
-	  /**
-	   * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
-	   *
-	   * @override
-	   * @yields {[string, *]} An iterator for the key-value pairs in the map.
-	   */
-	  *entries() {
-	    for (const [key, array] of super.entries()) {
-	      for (const value of array) {
-	        yield [key, value];
-	      }
-	    }
-	  }
-	  /**
-	   * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
-	   *
-	   * @override
-	   * @yields {[string, *]} An iterator for the key-value pairs in the map.
-	   */
-	  *[Symbol.iterator]() {
-	    yield* this.entries();
-	  }
-	  /**
-	   * Returns an iterable of key, value pairs for every entry in the parameters object.
-	   *
-	   * @private
-	   * @static
-	   * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
-	   * @returns {Iterable<[string, *]>} An iterable of key, value pairs for every entry in the parameters object.
-	   */
-	  static #entries(parameters) {
-	    return parameters[Symbol.iterator] ? parameters : Object.entries(parameters);
-	  }
-	  /**
-	   * A String value that is used in the creation of the default string description of an object.
-	   * Called by the built-in method {@link Object.prototype.toString}.
-	   *
-	   * @override
-	   * @returns {string} The default string description of this object.
-	   */
-	  get [Symbol.toStringTag]() {
-	    return "ParameterMap";
-	  }
-	};
-	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(), http_media_type_default.XML);
-	var _handleHtml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.HTML);
-	var _handleHtmlFragment = async (response) => document.createRange().createContextualFragment(await response.text());
-	var Transportr = class _Transportr {
-	  /** @type {URL} */
-	  #baseUrl;
-	  /** @type {RequestOptions} */
-	  #options;
-	  /** @type {Subscribr} */
-	  #subscribr;
-	  /** @type {Subscribr} */
-	  static #globalSubscribr = new Subscribr();
-	  /** @type {Set<AbortSignal>} */
-	  static #activeRequests = /* @__PURE__ */ new Set();
-	  /** @type {Map<ResponseHandler<ResponseBody>, string>} */
-	  static #contentTypeHandlers = /* @__PURE__ */ new Map([
-	    [_handleImage, mediaTypes.get(http_media_type_default.PNG).type],
-	    [_handleText, mediaTypes.get(http_media_type_default.TEXT).type],
-	    [_handleJson, mediaTypes.get(http_media_type_default.JSON).subtype],
-	    [_handleHtml, mediaTypes.get(http_media_type_default.HTML).subtype],
-	    [_handleScript, mediaTypes.get(http_media_type_default.JAVA_SCRIPT).subtype],
-	    [_handleCss, mediaTypes.get(http_media_type_default.CSS).subtype],
-	    [_handleXml, mediaTypes.get(http_media_type_default.XML).subtype],
-	    [_handleReadableStream, mediaTypes.get(http_media_type_default.BIN).subtype]
-	  ]);
-	  /**
-	   * 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={}] The default {@link RequestOptions} for this instance.
-	   */
-	  constructor(url = globalThis.location.origin, options = {}) {
-	    if (object_type_default(url) == Object) {
-	      [url, options] = [globalThis.location.origin, url];
-	    }
-	    this.#baseUrl = _Transportr.#getBaseUrl(url);
-	    this.#options = _Transportr.#createOptions(options, _Transportr.#defaultRequestOptions);
-	    this.#subscribr = new Subscribr();
-	  }
-	  /**
-	   * @static
-	   * @constant {Object<string, HttpRequestMethod>}
-	   */
-	  static Method = Object.freeze(http_request_methods_default);
-	  /**
-	   * @static
-	   * @constant {Object<string, HttpMediaType>}
-	   */
-	  static MediaType = Object.freeze(http_media_type_default);
-	  /**
-	   * @static
-	   * @see {@link HttpRequestHeader}
-	   * @constant {Object<string, HttpRequestHeader>}
-	   */
-	  static RequestHeader = Object.freeze(http_request_headers_default);
-	  /**
-	   * @static
-	   * @constant {Object<string, HttpResponseHeader>}
-	   */
-	  static ResponseHeader = Object.freeze(http_response_headers_default);
-	  /**
-	   * @static
-	   * @constant {Object<string, RequestCache>}
-	   */
-	  static 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"
-	  });
-	  /**
-	   * @static
-	   * @constant {Object<string, RequestCredentials>}
-	   */
-	  static CredentialsPolicy = Object.freeze({
-	    INCLUDE: "include",
-	    OMIT: "omit",
-	    SAME_ORIGIN: "same-origin"
-	  });
-	  /**
-	   * @static
-	   * @constant {Object<string, RequestMode>}
-	   */
-	  static RequestMode = Object.freeze({
-	    CORS: "cors",
-	    NAVIGATE: "navigate",
-	    NO_CORS: "no-cors",
-	    SAME_ORIGIN: "same-origin"
-	  });
-	  /**
-	   * @static
-	   * @constant {Object<string, RequestRedirect>}
-	   */
-	  static RedirectPolicy = Object.freeze({
-	    ERROR: "error",
-	    FOLLOW: "follow",
-	    MANUAL: "manual"
-	  });
-	  /**
-	   * @static
-	   * @constant {Object<string, ReferrerPolicy>}
-	   */
-	  static ReferrerPolicy = Object.freeze({
-	    NO_REFERRER: "no-referrer",
-	    NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
-	    ORIGIN: "origin",
-	    ORIGIN_WHEN_CROSS_ORIGIN: "origin-when-cross-origin",
-	    SAME_ORIGIN: "same-origin",
-	    STRICT_ORIGIN: "strict-origin",
-	    STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
-	    UNSAFE_URL: "unsafe-url"
-	  });
-	  /**
-	   * @static
-	   * @constant {Object<string, TransportrEvent>}
-	   */
-	  static Events = RequestEvents;
-	  /**
-	   * @private
-	   * @static
-	   * @type {RequestOptions}
-	   */
-	  static #defaultRequestOptions = Object.freeze({
-	    body: null,
-	    cache: _Transportr.CachingPolicy.NO_STORE,
-	    credentials: _Transportr.CredentialsPolicy.SAME_ORIGIN,
-	    headers: { [http_request_headers_default.CONTENT_TYPE]: `${mediaTypes.get(http_media_type_default.JSON)}`, [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.JSON)}` },
-	    searchParams: {},
-	    integrity: void 0,
-	    keepalive: 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: void 0,
-	    timeout: 3e4,
-	    global: true,
-	    window: null
-	  });
-	  /**
-	   * Returns a {@link EventRegistration} used for subscribing to global events.
-	   *
-	   * @static
-	   * @param {TransportrEvent} event The event to subscribe to.
-	   * @param {function(Event, *): void} handler The event handler.
-	   * @param {*} context The context to bind the handler to.
-	   * @returns {EventRegistration} A new {@link EventRegistration} instance.
-	   */
-	  static register(event, handler, context) {
-	    return _Transportr.#globalSubscribr.subscribe(event, handler, context);
-	  }
-	  /**
-	   * Removes a {@link EventRegistration} from the global event handler.
-	   *
-	   * @static
-	   * @param {EventRegistration} eventRegistration The {@link EventRegistration} to remove.
-	   * @returns {boolean} True if the {@link EventRegistration} was removed, false otherwise.
-	   */
-	  static unregister(eventRegistration) {
-	    return _Transportr.#globalSubscribr.unsubscribe(eventRegistration);
-	  }
-	  /**
-	   * Aborts all active requests.
-	   * This is useful for when the user navigates away from the current page.
-	   * This will also clear the {@link Transportr#activeRequests} set.
-	   *
-	   * @static
-	   * @returns {void}
-	   */
-	  static abortAll() {
-	    for (const abortSignal of this.#activeRequests) {
-	      abortSignal.abort(_abortEvent);
-	    }
-	    this.#activeRequests.clear();
-	  }
-	  /**
-	   * It returns the base {@link URL} for the API.
-	   *
-	   * @returns {URL} The baseUrl property.
-	   */
-	  get baseUrl() {
-	    return this.#baseUrl;
-	  }
-	  /**
-	   * Registers an event handler with a {@link Transportr} instance.
-	   *
-	   * @param {TransportrEvent} event The name of the event to listen for.
-	   * @param {function(Event, *): void} handler The function to call when the event is triggered.
-	   * @param {*} [context] The context to bind to the handler.
-	   * @returns {EventRegistration} An object that can be used to remove the event handler.
-	   */
-	  register(event, handler, context) {
-	    return this.#subscribr.subscribe(event, handler, context);
-	  }
-	  /**
-	   * Unregisters an event handler from a {@link Transportr} instance.
-	   *
-	   * @param {EventRegistration} eventRegistration The event registration to remove.
-	   * @returns {void}
-	   */
-	  unregister(eventRegistration) {
-	    this.#subscribr.unsubscribe(eventRegistration);
-	  }
-	  /**
-	   * 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 this.#get(path, options);
-	  }
-	  /**
-	   * 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 {RequestBody} 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 = {}) {
-	    if (object_type_default(path) != String) {
-	      [path, body, options] = [void 0, path, body];
-	    }
-	    return this.#request(path, Object.assign(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 this.#request(path, 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 this.#request(path, 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 this.#request(path, 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 this.#request(path, options, { method: http_request_methods_default.HEAD });
-	  }
-	  /**
-	   * It returns a promise that resolves to the allowed request methods for the given resource path.
-	   *
-	   * @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 array of allowed request methods for this resource.
-	   */
-	  async options(path, options) {
-	    const response = await this.#request(path, options, { method: http_request_methods_default.OPTIONS });
-	    return response.headers.get("allow").split(",").map((method) => method.trim());
-	  }
-	  /**
-	   * 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} [userOptions] 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, userOptions) {
-	    return this.#request(path, userOptions, {}, (response) => response);
-	  }
-	  /**
-	   * 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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.XML)}` } }, _handleXml);
-	  }
-	  /**
-	   * 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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(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 this.#get(path, 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|RequestOptions} [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 this.#get(path, 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 this.#get(path, 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 this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleReadableStream);
-	  }
-	  /**
-	   * 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.
-	   */
-	  async #get(path, userOptions, options = {}, responseHandler) {
-	    return this.#request(path, userOptions, Object.assign(options, { method: http_request_methods_default.GET }), responseHandler);
-	  }
-	  /**
-	   * 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.
-	   */
-	  async #request(path, userOptions = {}, options = {}, responseHandler) {
-	    if (object_type_default(path) == Object) {
-	      [path, userOptions] = [void 0, path];
-	    }
-	    options = this.#processRequestOptions(userOptions, options);
-	    let response;
-	    const url = _Transportr.#createUrl(this.#baseUrl, path, options.searchParams);
-	    try {
-	      _Transportr.#activeRequests.add(options.signal);
-	      response = await fetch(url, new Proxy(options, abortSignalProxyHandler));
-	      if (!responseHandler && response.status != 204) {
-	        responseHandler = this.#getResponseHandler(response.headers.get(http_response_headers_default.CONTENT_TYPE));
-	      }
-	      const result = await responseHandler?.(response) ?? response;
-	      if (!response.ok) {
-	        return Promise.reject(this.#handleError(url, { status: _Transportr.#generateResponseStatusFromError("ResponseError", response), entity: result }));
-	      }
-	      this.#publish({ name: RequestEvents.SUCCESS, data: result, global: options.global });
-	      return result;
-	    } catch (cause) {
-	      return Promise.reject(this.#handleError(url, { cause, status: _Transportr.#generateResponseStatusFromError(cause.name, response) }));
-	    } finally {
-	      options.signal.clearTimeout();
-	      if (!options.signal.aborted) {
-	        this.#publish({ name: RequestEvents.COMPLETE, data: response, global: options.global });
-	        _Transportr.#activeRequests.delete(options.signal);
-	        if (_Transportr.#activeRequests.size == 0) {
-	          this.#publish({ name: RequestEvents.ALL_COMPLETE, global: options.global });
-	        }
-	      }
-	    }
-	  }
-	  /**
-	   * Creates the options for a {@link Transportr} instance.
-	   *
-	   * @private
-	   * @static
-	   * @param {RequestOptions} userOptions The {@link RequestOptions} to convert.
-	   * @param {RequestOptions} options The default {@link RequestOptions}.
-	   * @returns {RequestOptions} The converted {@link RequestOptions}.
-	   */
-	  static #createOptions({ body, headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
-	    return object_merge_default(options, userOptions, {
-	      body: [FormData, URLSearchParams, Object].includes(object_type_default(body)) ? new ParameterMap(body) : body,
-	      headers: _Transportr.#mergeOptions(new Headers(), userHeaders, headers),
-	      searchParams: _Transportr.#mergeOptions(new URLSearchParams(), userSearchParams, searchParams)
-	    });
-	  }
-	  /**
-	   * Merge the user options and request options into the target.
-	   *
-	   * @private
-	   * @static
-	   * @param {Headers|URLSearchParams|FormData} target The target to merge the options into.
-	   * @param {Headers|URLSearchParams|FormData|Object} userOption The user options to merge into the target.
-	   * @param {Headers|URLSearchParams|FormData|Object} requestOption The request options to merge into the target.
-	   * @returns {Headers|URLSearchParams} The target.
-	   */
-	  static #mergeOptions(target, userOption = {}, requestOption = {}) {
-	    for (const option of [userOption, requestOption]) {
-	      for (const [name, value] of option.entries?.() ?? Object.entries(option)) {
-	        target.set(name, value);
-	      }
-	    }
-	    return target;
-	  }
-	  /**
-	   * Merges the user options and request options with the instance options into a new object that is used for the request.
-	   *
-	   * @private
-	   * @param {RequestOptions} userOptions The user options to merge into the request options.
-	   * @param {RequestOptions} options The request options to merge into the user options.
-	   * @returns {RequestOptions} The merged options.
-	   */
-	  #processRequestOptions({ body: userBody, headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
-	    const requestOptions = object_merge_default(this.#options, userOptions, options, {
-	      headers: _Transportr.#mergeOptions(new Headers(this.#options.headers), userHeaders, headers),
-	      searchParams: _Transportr.#mergeOptions(new URLSearchParams(this.#options.searchParams), userSearchParams, searchParams)
-	    });
-	    if (requestBodyMethods.includes(requestOptions.method)) {
-	      if ([ParameterMap, FormData, URLSearchParams, Object].includes(object_type_default(userBody))) {
-	        const contentType = requestOptions.headers.get(http_request_headers_default.CONTENT_TYPE);
-	        const mediaType = (mediaTypes.get(contentType) ?? MediaType.parse(contentType))?.subtype;
-	        if (mediaType == http_media_type_default.MULTIPART_FORM_DATA) {
-	          requestOptions.body = _Transportr.#mergeOptions(new FormData(requestOptions.body), userBody);
-	        } else if (mediaType == http_media_type_default.FORM) {
-	          requestOptions.body = _Transportr.#mergeOptions(new URLSearchParams(requestOptions.body), userBody);
-	        } else if (mediaType.includes("json")) {
-	          requestOptions.body = JSON.stringify(_Transportr.#mergeOptions(new ParameterMap(requestOptions.body), userBody));
-	        } else {
-	          requestOptions.body = _Transportr.#mergeOptions(new ParameterMap(requestOptions.body), userBody);
-	        }
-	      } else {
-	        requestOptions.body = userBody;
-	      }
-	    } else {
-	      requestOptions.headers.delete(http_request_headers_default.CONTENT_TYPE);
-	      if (requestOptions.body) {
-	        _Transportr.#mergeOptions(requestOptions.searchParams, requestOptions.body);
-	      }
-	      requestOptions.body = void 0;
-	    }
-	    requestOptions.signal = new AbortSignal(requestOptions.signal).onAbort((event) => this.#publish({ name: RequestEvents.ABORTED, event, global: requestOptions.global })).onTimeout((event) => this.#publish({ name: RequestEvents.TIMEOUT, event, global: requestOptions.global }));
-	    this.#publish({ name: RequestEvents.CONFIGURED, data: requestOptions, global: requestOptions.global });
-	    return requestOptions;
-	  }
-	  /**
-	   * It takes a url or a string, and returns a {@link URL} instance.
-	   * If the url is a string and starts with a slash, then the origin of the current page is used as the base url.
-	   *
-	   * @private
-	   * @static
-	   * @param {URL|string} url The URL to convert to a {@link URL} instance.
-	   * @returns {URL} A {@link URL} instance.
-	   * @throws {TypeError} If the url is not a string or {@link URL} instance.
-	   */
-	  static #getBaseUrl(url) {
-	    switch (object_type_default(url)) {
-	      case URL:
-	        return url;
-	      case String:
-	        return new URL(url, url.startsWith("/") ? globalThis.location.origin : void 0);
-	      default:
-	        throw new TypeError("Invalid URL");
-	    }
-	  }
-	  /**
-	   * 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 optional, relative path to the resource. This MUST be a relative path, otherwise, you should create a new {@link Transportr} instance.
-	   * @param {URLSearchParams} [searchParams] The optional search parameters to append 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.
-	   */
-	  static #createUrl(url, path, searchParams) {
-	    const requestUrl = path ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(url);
-	    searchParams?.forEach((value, name) => requestUrl.searchParams.append(name, value));
-	    return requestUrl;
-	  }
-	  /**
-	   * Generates a ResponseStatus object based on the error name and the response.
-	   *
-	   * @private
-	   * @static
-	   * @param {string} errorName The name of the error.
-	   * @param {Response} response The response object returned by the fetch API.
-	   * @returns {ResponseStatus} The response status object.
-	   */
-	  static #generateResponseStatusFromError(errorName, response) {
-	    switch (errorName) {
-	      case "AbortError":
-	        return eventResponseStatuses[RequestEvents.ABORTED];
-	      case "TimeoutError":
-	        return eventResponseStatuses[RequestEvents.TIMEOUT];
-	      default:
-	        return response ? new ResponseStatus(response.status, response.statusText) : internalServerError;
-	    }
-	  }
-	  /**
-	   * Handles an error by logging it and throwing it.
-	   *
-	   * @private
-	   * @param {URL} url The path to the resource you want to access.
-	   * @param {import('./http-error.js').HttpErrorOptions} options The options for the HttpError.
-	   * @returns {HttpError} The HttpError.
-	   */
-	  #handleError(url, options) {
-	    const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
-	    this.#publish({ name: RequestEvents.ERROR, data: error });
-	    return error;
-	  }
-	  /**
-	   * Publishes an event to the global and instance subscribers.
-	   *
-	   * @private
-	   * @param {Object} options The options for the event.
-	   * @param {string} options.name The name of the event.
-	   * @param {Event} [options.event] The event object.
-	   * @param {*} [options.data] The data to pass to the subscribers.
-	   * @param {boolean} [options.global=true] Whether or not to publish the event to the global subscribers.
-	   * @returns {void}
-	   */
-	  #publish({ name, event = new CustomEvent(name), data, global = true } = {}) {
-	    if (global) {
-	      _Transportr.#globalSubscribr.publish(name, event, data);
-	    }
-	    this.#subscribr.publish(name, event, data);
-	  }
-	  /**
-	   * Returns a response handler for the given content type.
-	   *
-	   * @private
-	   * @param {string} contentType The content type of the response.
-	   * @returns {ResponseHandler<ResponseBody>} The response handler.
-	   */
-	  #getResponseHandler(contentType) {
-	    const mediaType = MediaType.parse(contentType);
-	    if (mediaType) {
-	      for (const [responseHandler, contentType2] of _Transportr.#contentTypeHandlers) {
-	        if (mediaType.matches(contentType2)) {
-	          return responseHandler;
-	        }
-	      }
-	    }
-	    return void 0;
-	  }
-	  /**
-	   * A String value that is used in the creation of the default string
-	   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
-	   *
-	   * @returns {string} The default string description of this object.
-	   */
-	  get [Symbol.toStringTag]() {
-	    return "Transportr";
-	  }
-	};
-	globalThis.Transportr = Transportr;
-})();