@d1g1tal/transportr 1.3.2 → 1.4.1

package/dist/transportr.js

@@ -23,54 +23,8 @@ var Transportr = (() => {
     default: () => Transportr
   });
 
-  // node_modules/@d1g1tal/collections/src/set-multi-map.js
-  var SetMultiMap = class extends Map {
-    /**
-     * Adds a new element with a specified key and value to the SetMultiMap.
-     * If an element with the same key already exists, the value will be added to the underlying {@link Set}.
-     * 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 set_multi_map_default = SetMultiMap;
-
   // node_modules/@d1g1tal/subscribr/node_modules/@d1g1tal/collections/src/set-multi-map.js
-  var SetMultiMap2 = class extends Map {
+  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}.
      *
@@ -151,7 +105,7 @@ var Transportr = (() => {
     /** @type {SetMultiMap<string, ContextEventHandler>} */
     #subscribers;
     constructor() {
-      this.#subscribers = new SetMultiMap2();
+      this.#subscribers = new SetMultiMap();
     }
     /**
      * Subscribe to an event
@@ -211,1994 +165,1951 @@ var Transportr = (() => {
     }
   };
 
-  // src/http-error.js
-  var HttpError = class extends Error {
-    /** @type {ResponseBody} */
-    #entity;
-    /** @type {ResponseStatus} */
-    #responseStatus;
+  // src/http-request-methods.js
+  var HttpRequestMethod = {
     /**
-     * @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.
+     * 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.
      */
-    constructor(message, { cause, status, entity }) {
-      super(message, { cause });
-      this.#entity = entity;
-      this.#responseStatus = status;
-    }
+    OPTIONS: "OPTIONS",
     /**
-     * It returns the value of the private variable #entity.
+     * 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.
      *
-     * @returns {ResponseBody} The entity property of the class.
+     * 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 entity() {
-      return this.#entity;
-    }
+    GET: "GET",
     /**
-     * It returns the status code of the {@link Response}.
+     * 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.
      *
-     * @returns {number} The status code of the {@link Response}.
+     * 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.
      */
-    get statusCode() {
-      return this.#responseStatus?.code;
-    }
+    HEAD: "HEAD",
     /**
-     * It returns the status text of the {@link Response}.
+     * 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>
      *
-     * @returns {string} The status code and status text of the {@link Response}.
+     * 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.
      */
-    get statusText() {
-      return this.#responseStatus?.text;
-    }
-    get name() {
-      return "HttpError";
-    }
+    POST: "POST",
     /**
-     * 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}.
+     * 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.
      *
-     * @returns {string} The default string description of this object.
+     * 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.
      */
-    get [Symbol.toStringTag]() {
-      return "HttpError";
-    }
-  };
-
-  // src/http-media-type.js
-  var HttpMediaType = {
-    /** Advanced Audio Coding (AAC) */
-    AAC: "audio/aac",
-    /** AbiWord */
-    ABW: "application/x-abiword",
-    /** Archive document (multiple files embedded) */
-    ARC: "application/x-freearc",
-    /** AVIF image */
-    AVIF: "image/avif",
-    /** Audio Video Interleave (AVI) */
-    AVI: "video/x-msvideo",
-    /** Amazon Kindle eBook format */
-    AZW: "application/vnd.amazon.ebook",
-    /** Binary Data */
-    BIN: "application/octet-stream",
-    /** Windows OS/2 Bitmap Graphics */
-    BMP: "image/bmp",
-    /** Bzip Archive */
-    BZIP: "application/x-bzip",
-    /** Bzip2 Archive */
-    BZIP2: "application/x-bzip2",
-    /** CD audio */
-    CDA: "application/x-cdf",
-    /** C Shell Script */
-    CSH: "application/x-csh",
-    /** Cascading Style Sheets (CSS) */
-    CSS: "text/css",
-    /** Comma-Separated Values */
-    CSV: "text/csv",
-    /** Microsoft Office Word Document */
-    DOC: "application/msword",
-    /** Microsoft Office Word Document (OpenXML) */
-    DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    /** Microsoft Embedded OpenType */
-    EOT: "application/vnd.ms-fontobject",
-    /** Electronic Publication (EPUB) */
-    EPUB: "application/epub+zip",
-    /** GZip Compressed Archive */
-    GZIP: "application/gzip",
-    /** Graphics Interchange Format */
-    GIF: "image/gif",
-    /** HyperText Markup Language (HTML) */
-    HTML: "text/html",
-    /** Icon Format */
-    ICO: "image/vnd.microsoft.icon",
-    /** iCalendar Format */
-    ICS: "text/calendar",
-    /** Java Archive (JAR) */
-    JAR: "application/java-archive",
-    /** JPEG Image */
-    JPEG: "image/jpeg",
-    /** JavaScript */
-    JAVA_SCRIPT: "text/javascript",
-    /** JavaScript Object Notation Format (JSON) */
-    JSON: "application/json",
-    /** JavaScript Object Notation LD Format */
-    JSON_LD: "application/ld+json",
-    /** 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;
-
-  // src/http-request-headers.js
-  var HttpRequestHeader = {
-    /**
-     * Content-Types that are acceptable for the response. See Content negotiation. Permanent.
-     *
-     * @example
-     * <code>Accept: text/plain</code>
-     */
-    ACCEPT: "accept",
+    PUT: "PUT",
     /**
-     * Character sets that are acceptable. Permanent.
+     * 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.
      *
-     * @example
-     * <code>Accept-Charset: utf-8</code>
-     */
-    ACCEPT_CHARSET: "accept-charset",
-    /**
-     * List of acceptable encodings. See HTTP compression. Permanent.
+     * 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.
      *
-     * @example
-     * <code>Accept-Encoding: gzip, deflate</code>
+     * 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.
      */
-    ACCEPT_ENCODING: "accept-encoding",
+    DELETE: "DELETE",
     /**
-     * List of acceptable human languages for response. See Content negotiation. Permanent.
+     * 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.
      *
-     * @example
-     * <code>Accept-Language: en-US</code>
-     */
-    ACCEPT_LANGUAGE: "accept-language",
-    /**
-     * Authentication credentials for HTTP authentication. Permanent.
+     * 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.
      *
-     * @example
-     * <code>Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==</code>
+     * 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.
      */
-    AUTHORIZATION: "authorization",
+    TRACE: "TRACE",
     /**
-     * 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>
+     * 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]).
      */
-    CACHE_CONTROL: "cache-control",
+    CONNECT: "CONNECT",
     /**
-     * Control options for the current connection and list of hop-by-hop request fields. Permanent.
+     * 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.
      *
-     * @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.
+     * 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.
      *
-     * @example
-     * <code>Cookie: $Version=1, Skin=new,</code>
-     */
-    COOKIE: "cookie",
-    /**
-     * The length of the request body in octets (8-bit bytes). Permanent.
+     * PATCH is neither safe nor idempotent as defined by [RFC2616], Section
+     * 9.1.
      *
-     * @example
-     * <code>Content-Length: 348</code>
-     */
-    CONTENT_LENGTH: "content-length",
-    /**
-     * A Base64-encoded binary MD5 sum of the content of the request body. Obsolete.
+     * 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.
      *
-     * @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.
+     * 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.
      *
-     * @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.
+     * 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.
      *
-     * @example
-     * <code>Expect: 100-continue</code>
-     */
-    EXPECT: "expect",
-    /**
-     * The email address of the user making the request. Permanent.
+     * 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).
      *
-     * @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.
+     * 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.
      *
-     * @example
-     * <code>Host: en.wikipedia.org:80</code>
-     * <code>Host: en.wikipedia.org</code>
+     * 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.
      */
-    HOST: "host",
+    PATCH: "PATCH"
+  };
+  var http_request_methods_default = HttpRequestMethod;
+
+  // src/response-status.js
+  var ResponseStatus = class {
+    /** @type {number} */
+    #code;
+    /** @type {string} */
+    #text;
     /**
-     * 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>
+     * @param {number} code The status code from the {@link Response}
+     * @param {string} text The status text from the {@link Response}
      */
-    IF_MATCH: "if-match",
+    constructor(code, text) {
+      this.#code = code;
+      this.#text = text;
+    }
     /**
-     * Allows a 304 Not Modified to be returned if content is unchanged. Permanent.
+     * Returns the status code from the {@link Response}
      *
-     * @example
-     * <code>If-Modified-Since: Sat, 29 Oct 1994 19:43:31 GMT</code>
+     * @returns {number} The status code.
      */
-    IF_MODIFIED_SINCE: "if-modified-since",
+    get code() {
+      return this.#code;
+    }
     /**
-     * Allows a 304 Not Modified to be returned if content is unchanged, see HTTP ETag. Permanent.
+     * Returns the status text from the {@link Response}.
      *
-     * @example
-     * <code>If-None-Match: "737060cd8c284d8af7ad3082f209582d"</code>
+     * @returns {string} The status text.
      */
-    IF_NONE_MATCH: "if-none-match",
+    get text() {
+      return this.#text;
+    }
     /**
-     * If the entity is unchanged, send me the part(s) that I am missing, otherwise, send me the entire new entity.
-     * Permanent.
+     * 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}.
      *
-     * @example
-     * <code>If-Range: "737060cd8c284d8af7ad3082f209582d"</code>
+     * @override
+     * @returns {string} The default string description of this object.
      */
-    IF_RANGE: "if-range",
+    get [Symbol.toStringTag]() {
+      return "ResponseStatus";
+    }
     /**
-     * Only send the response if the entity has not been modified since a specific time. Permanent.
+     * tostring method for the class.
      *
-     * @example
-     * <code>If-Unmodified-Since: Sat, 29 Oct 1994 19:43:31 GMT</code>
+     * @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.
      */
-    IF_UNMODIFIED_SINCE: "if-unmodified-since",
+    toString() {
+      return `${this.#code} ${this.#text}`;
+    }
+  };
+
+  // node_modules/@d1g1tal/media-type/src/utils.js
+  var whitespaceCharacters = [" ", "	", "\n", "\r"];
+  var leadingWhitespace = /^[ \t\n\r]+/u;
+  var trailingWhitespace = /[ \t\n\r]+$/u;
+  var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
+  var httpQuotedTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
+  var removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(leadingWhitespace, "").replace(trailingWhitespace, "");
+  var removeTrailingHTTPWhitespace = (string) => string.replace(trailingWhitespace, "");
+  var isHTTPWhitespaceChar = (char) => whitespaceCharacters.includes(char);
+  var solelyContainsHTTPTokenCodePoints = (string) => httpTokenCodePoints.test(string);
+  var solelyContainsHTTPQuotedStringTokenCodePoints = (string) => httpQuotedTokenCodePoints.test(string);
+  var asciiLowercase = (string) => {
+    let result = "";
+    for (const [char, charCode = char.charCodeAt(0)] of string) {
+      result += charCode >= 65 && charCode <= 90 ? String.fromCharCode(charCode + 32) : char;
+    }
+    return result;
+  };
+  var collectAnHTTPQuotedString = (input, position) => {
+    let value = "";
+    for (let length = input.length, char; ++position < length; ) {
+      char = input[position];
+      if (char == "\\") {
+        value += ++position < length ? input[position] : char;
+      } else if (char == '"') {
+        break;
+      } else {
+        value += char;
+      }
+    }
+    return [value, position];
+  };
+
+  // node_modules/@d1g1tal/media-type/src/media-type-parameters.js
+  var MediaTypeParameters = class {
+    /** @type {Map<string, string>} */
+    #map;
     /**
-     * Limit the number of times the message can be forwarded through proxies or gateways. Permanent.
+     * Create a new MediaTypeParameters instance.
      *
-     * @example
-     * <code>Max-Forwards: 10</code>
+     * @param {Array<Array<string>>} entries An array of [name, value] tuples.
      */
-    MAX_FORWARDS: "max-forwards",
+    constructor(entries) {
+      this.#map = new Map(entries);
+    }
     /**
-     * Initiates a request for cross-origin resource sharing (asks server for an 'Access-Control-Allow-Origin' response
-     * field). Permanent: standard.
+     * Gets the number of media type parameters.
      *
-     * @example
-     * <code>Origin: http://www.example-social-network.com</code>
+     * @returns {number} The number of media type parameters
      */
-    ORIGIN: "origin",
+    get size() {
+      return this.#map.size;
+    }
     /**
-     * Implementation-specific fields that may have various effects anywhere along the request-response chain. Permanent.
+     * Gets the media type parameter value for the supplied name.
      *
-     * @example
-     * <code>Pragma: no-cache</code>
+     * @param {string} name The name of the media type parameter to retrieve.
+     * @returns {string} The media type parameter value.
      */
-    PRAGMA: "pragma",
+    get(name) {
+      return this.#map.get(asciiLowercase(String(name)));
+    }
     /**
-     * Authorization credentials for connecting to a proxy. Permanent.
+     * Indicates whether the media type parameter with the specified name exists or not.
      *
-     * @example
-     * <code>Proxy-Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==</code>
+     * @param {string} name The name of the media type parameter to check.
+     * @returns {boolean} true if the media type parameter exists, false otherwise.
      */
-    PROXY_AUTHORIZATION: "proxy-authorization",
+    has(name) {
+      return this.#map.has(asciiLowercase(String(name)));
+    }
     /**
-     * Request only part of an entity. Bytes are numbered from 0. See Byte serving. Permanent.
+     * 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.
      *
-     * @example
-     * <code>Range: bytes=500-999</code>
+     * @param {string} name The name of the media type parameter to set.
+     * @param {string} value The media type parameter value.
+     * @returns {MediaTypeParameters} This instance.
      */
-    RANGE: "range",
+    set(name, value) {
+      name = asciiLowercase(String(name));
+      value = String(value);
+      if (!solelyContainsHTTPTokenCodePoints(name)) {
+        throw new Error(`Invalid media type parameter name "${name}": only HTTP token code points are valid.`);
+      }
+      if (!solelyContainsHTTPQuotedStringTokenCodePoints(value)) {
+        throw new Error(`Invalid media type parameter value "${value}": only HTTP quoted-string token code points are valid.`);
+      }
+      this.#map.set(name, value);
+      return this;
+    }
     /**
-     * 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>
+     * Clears all the media type parameters.
      */
-    REFERER: "referer",
+    clear() {
+      this.#map.clear();
+    }
     /**
-     * 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.
+     * Removes the media type parameter using the specified name.
      *
-     * @example
-     * <code>TE: trailers, deflate</code>
+     * @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.
      */
-    TE: "te",
+    delete(name) {
+      name = asciiLowercase(String(name));
+      return this.#map.delete(name);
+    }
     /**
-     * The user agent string of the user agent. Permanent.
+     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
      *
-     * @example
-     * <code>User-Agent: Mozilla/5.0 (X11, Linux x86_64, rv:12.0) Gecko/20100101 Firefox/21.0</code>
+     * @param {function(string, string): void} callback The function called on each iteration.
+     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
      */
-    USER_AGENT: "user-agent",
+    forEach(callback, thisArg) {
+      this.#map.forEach(callback, thisArg);
+    }
     /**
-     * Ask the server to upgrade to another protocol. Permanent.
+     * Returns an iterable of parameter names.
      *
-     * @example
-     * <code>Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11</code>
+     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
      */
-    UPGRADE: "upgrade",
+    keys() {
+      return this.#map.keys();
+    }
     /**
-     * Informs the server of proxies through which the request was sent. Permanent.
+     * Returns an iterable of parameter values.
      *
-     * @example
-     * <code>Via: 1.0 fred, 1.1 example.com (Apache/1.1)</code>
+     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
      */
-    VIA: "via",
+    values() {
+      return this.#map.values();
+    }
     /**
-     * A general warning about possible problems with the entity body. Permanent.
+     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
      *
-     * @example
-     * <code>Warning: 199 Miscellaneous warning</code>
+     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
      */
-    WARNING: "warning",
+    entries() {
+      return this.#map.entries();
+    }
     /**
-     * mainly used to identify Ajax requests. Most JavaScript frameworks send this field with value of XMLHttpRequest.
+     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
      *
-     * @example
-     * <code>X-Requested-With: XMLHttpRequest</code>
+     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
      */
-    X_REQUESTED_WITH: "x-requested-with",
+    [Symbol.iterator]() {
+      return this.#map[Symbol.iterator]();
+    }
     /**
-     * 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.
+     * Returns a string representation of the media type parameters.
+     * This method is called by the `String()` function.
      *
      * @example
-     * <code>DNT: 1 (Do Not Track Enabled)</code>
-     * <code>DNT: 0 (Do Not Track Disabled)</code>
+     * const parameters = new MediaTypeParameters(new Map([['charset', 'utf-8']]));
+     * String(parameters); // 'charset=utf-8'
+     * parameters.toString(); // 'charset=utf-8'
+     * parameters + ''; // 'charset=utf-8'
+     * `${parameters}`; // 'charset=utf-8'
+     * parameters[Symbol.toStringTag]; // 'MediaTypeParameters'
+     * parameters[Symbol.toStringTag](); // 'MediaTypeParameters'
+     * Object.prototype.toString.call(parameters); // '[object MediaTypeParameters]'
+     * parameters + ''; // 'charset=utf-8'
+     * @returns {string} The string representation of the media type parameters.
      */
-    DNT: "dnt",
+    [Symbol.toStringTag]() {
+      return "MediaTypeParameters";
+    }
+  };
+
+  // node_modules/@d1g1tal/media-type/src/parser.js
+  var parse = (input) => {
+    input = removeLeadingAndTrailingHTTPWhitespace(input);
+    let position = 0;
+    let type = "";
+    while (position < input.length && input[position] != "/") {
+      type += input[position];
+      ++position;
+    }
+    if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
+      return null;
+    }
+    if (position >= input.length) {
+      return null;
+    }
+    ++position;
+    let subtype = "";
+    while (position < input.length && input[position] != ";") {
+      subtype += input[position];
+      ++position;
+    }
+    subtype = removeTrailingHTTPWhitespace(subtype);
+    if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
+      return null;
+    }
+    const mediaType = {
+      type: asciiLowercase(type),
+      subtype: asciiLowercase(subtype),
+      parameters: /* @__PURE__ */ new Map()
+    };
+    while (position < input.length) {
+      ++position;
+      while (isHTTPWhitespaceChar(input[position])) {
+        ++position;
+      }
+      let parameterName = "";
+      while (position < input.length && input[position] != ";" && input[position] != "=") {
+        parameterName += input[position];
+        ++position;
+      }
+      parameterName = asciiLowercase(parameterName);
+      if (position < input.length) {
+        if (input[position] == ";") {
+          continue;
+        }
+        ++position;
+      }
+      let parameterValue = null;
+      if (input[position] == '"') {
+        [parameterValue, position] = collectAnHTTPQuotedString(input, position);
+        while (position < input.length && input[position] != ";") {
+          ++position;
+        }
+      } else {
+        parameterValue = "";
+        while (position < input.length && input[position] != ";") {
+          parameterValue += input[position];
+          ++position;
+        }
+        parameterValue = removeTrailingHTTPWhitespace(parameterValue);
+        if (parameterValue === "") {
+          continue;
+        }
+      }
+      if (parameterName.length > 0 && solelyContainsHTTPTokenCodePoints(parameterName) && solelyContainsHTTPQuotedStringTokenCodePoints(parameterValue) && !mediaType.parameters.has(parameterName)) {
+        mediaType.parameters.set(parameterName, parameterValue);
+      }
+    }
+    return mediaType;
+  };
+  var parser_default = parse;
+
+  // node_modules/@d1g1tal/media-type/src/serializer.js
+  var serialize = (mediaType) => {
+    let serialization = `${mediaType.type}/${mediaType.subtype}`;
+    if (mediaType.parameters.size === 0) {
+      return serialization;
+    }
+    for (let [name, value] of mediaType.parameters) {
+      serialization += `;${name}=`;
+      if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
+        value = `"${value.replace(/(["\\])/ug, "\\$1")}"`;
+      }
+      serialization += value;
+    }
+    return serialization;
+  };
+  var serializer_default = serialize;
+
+  // node_modules/@d1g1tal/media-type/src/media-type.js
+  var MediaType = class _MediaType {
+    /** @type {string} */
+    #type;
+    /** @type {string} */
+    #subtype;
+    /** @type {MediaTypeParameters} */
+    #parameters;
     /**
-     * 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.
+     * Create a new MediaType instance from a string representation.
      *
-     * @example
-     * <code>X-Forwarded-For: client1, proxy1, proxy2</code>
-     * <code>X-Forwarded-For: 129.78.138.66, 129.78.64.103</code>
+     * @param {string} mediaType The media type to parse.
+     * @param {Object} [parameters] Optional parameters.
      */
-    X_FORWARDED_FOR: "x-forwarded-for",
+    constructor(mediaType, parameters = {}) {
+      const { type, subtype, parameters: parsedParameters } = parser_default(mediaType);
+      this.#type = type;
+      this.#subtype = subtype;
+      this.#parameters = new MediaTypeParameters([...parsedParameters, ...Object.entries(parameters).map(([name, value]) => [asciiLowercase(name), asciiLowercase(value)])]);
+    }
     /**
-     * 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.
+     * Static factory method for parsing a media type.
      *
-     * @example
-     * <code>X-Forwarded-Host: en.wikipedia.org:80</code>
-     * <code>X-Forwarded-Host: en.wikipedia.org</code>
+     * @param {string} string The media type to parse.
+     * @returns {MediaType} The parsed {@link MediaType} object or null if the string could not be parsed.
      */
-    X_FORWARDED_HOST: "x-forwarded-host",
+    static parse(string) {
+      try {
+        return new _MediaType(string);
+      } catch (e) {
+        throw new Error(`Could not parse media type string '${string}'`);
+      }
+    }
     /**
-     * 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.
+     * Gets the media type essence (type/subtype).
      *
-     * @example
-     * <code>X-Forwarded-Proto: https</code>
+     * @returns {string} The media type without any parameters
      */
-    X_FORWARDED_PROTO: "x-forwarded-proto",
+    get essence() {
+      return `${this.#type}/${this.#subtype}`;
+    }
     /**
-     * Non-standard header field used by Microsoft applications and load-balancers.
+     * Gets the type.
      *
-     * @example
-     * <code>Front-End-Https: on</code>
+     * @returns {string} The type.
      */
-    FRONT_END_HTTPS: "front-end-https",
+    get type() {
+      return this.#type;
+    }
     /**
-     * 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>
+     * Sets the type.
      */
-    X_HTTP_METHOD_OVERRIDE: "x-http-method-override",
+    set type(value) {
+      value = asciiLowercase(String(value));
+      if (value.length === 0) {
+        throw new Error("Invalid type: must be a non-empty string");
+      }
+      if (!solelyContainsHTTPTokenCodePoints(value)) {
+        throw new Error(`Invalid type ${value}: must contain only HTTP token code points`);
+      }
+      this.#type = value;
+    }
     /**
-     * Allows easier parsing of the MakeModel/Firmware that is usually found in the User-Agent String of AT&T Devices.
+     * Gets the subtype.
      *
-     * @example
-     * <code>X-Att-Deviceid: GT-P7320/P7320XXLPG</code>
+     * @returns {string} The subtype.
      */
-    X_ATT_DEVICE_ID: "x-att-deviceid",
+    get subtype() {
+      return this.#subtype;
+    }
     /**
-     * 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
+     * Sets the subtype.
      */
-    X_WAP_PROFILE: "x-wap-profile"
-  };
-  var http_request_headers_default = HttpRequestHeader;
-
-  // src/http-request-methods.js
-  var HttpRequestMethod = {
+    set subtype(value) {
+      value = asciiLowercase(String(value));
+      if (value.length === 0) {
+        throw new Error("Invalid subtype: must be a non-empty string");
+      }
+      if (!solelyContainsHTTPTokenCodePoints(value)) {
+        throw new Error(`Invalid subtype ${value}: must contain only HTTP token code points`);
+      }
+      this.#subtype = value;
+    }
     /**
-     * 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.
+     * Gets the parameters.
      *
-     * 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.
+     * @returns {MediaTypeParameters} The media type parameters.
+     */
+    get parameters() {
+      return this.#parameters;
+    }
+    /**
+     * Gets the serialized version of the media type.
      *
-     * 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.
+     * @returns {string} The serialized media type.
      */
-    POST: "POST",
+    toString() {
+      return serializer_default(this);
+    }
     /**
-     * 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.
+     * Determines if this instance is a JavaScript media type.
      *
-     * 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.
+     * @param {Object} [options] Optional options.
+     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
+     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
      */
-    PUT: "PUT",
+    isJavaScript({ prohibitParameters = false } = {}) {
+      switch (this.#type) {
+        case "text": {
+          switch (this.#subtype) {
+            case "ecmascript":
+            case "javascript":
+            case "javascript1.0":
+            case "javascript1.1":
+            case "javascript1.2":
+            case "javascript1.3":
+            case "javascript1.4":
+            case "javascript1.5":
+            case "jscript":
+            case "livescript":
+            case "x-ecmascript":
+            case "x-javascript":
+              return !prohibitParameters || this.#parameters.size === 0;
+            default:
+              return false;
+          }
+        }
+        case "application": {
+          switch (this.#subtype) {
+            case "ecmascript":
+            case "javascript":
+            case "x-ecmascript":
+            case "x-javascript":
+              return !prohibitParameters || this.#parameters.size === 0;
+            default:
+              return false;
+          }
+        }
+        default:
+          return false;
+      }
+    }
     /**
-     * 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.
+     * Determines if this instance is an XML media type.
      *
-     * 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.
+     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
      */
-    DELETE: "DELETE",
+    isXML() {
+      return this.#subtype === "xml" && (this.#type === "text" || this.#type === "application") || this.#subtype.endsWith("+xml");
+    }
     /**
-     * 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.
+     * Determines if this instance is an HTML media type.
      *
-     * 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]).
+     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
      */
-    CONNECT: "CONNECT",
+    isHTML() {
+      return this.#subtype === "html" && this.#type === "text";
+    }
     /**
-     * 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.
+     * Gets the name of the class.
      *
-     * 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.
+     * @returns {string} The class name
      */
-    PATCH: "PATCH"
+    get [Symbol.toStringTag]() {
+      return "MediaType";
+    }
   };
-  var http_request_methods_default = HttpRequestMethod;
 
-  // src/http-response-headers.js
-  var HttpResponseHeader = {
-    /**
-     * Implemented as a misunderstanding of the HTTP specifications. Common because of mistakes in implementations of early HTTP versions. Has exactly the same functionality as standard Connection field.
-     *
-     * @example
-     * proxy-connection: keep-alive
-     */
-    PROXY_CONNECTION: "proxy-connection",
-    /**
-     * Server-side deep packet insertion of a unique ID identifying customers of Verizon Wireless, also known as "perma-cookie" or "supercookie"
-     *
-     * @example
-     * x-uidh: ...
-     */
-    X_UIDH: "x-uidh",
-    /**
-     * Used to prevent cross-site request forgery. Alternative header names are: X-CSRFToken and X-XSRF-TOKEN
-     *
-     * @example
-     * x-csrf-token: i8XNjC4b8KVok4uw5RftR38Wgp2BFwql
-     */
-    X_CSRF_TOKEN: "x-csrf-token",
-    /**
-     * Specifying which web sites can participate in cross-origin resource sharing
-     *
-     * @example
-     * access-control-allow-origin: *
-     * Provisional
-     */
-    ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
-    /**
-     * Specifies which patch document formats this server supports
-     *
-     * @example
-     * accept-patch: text/example,charset=utf-8
-     * Permanent
-     */
-    ACCEPT_PATCH: "accept-patch",
+  // src/http-media-type.js
+  var HttpMediaType = {
+    /** Advanced Audio Coding (AAC) */
+    AAC: "audio/aac",
+    /** AbiWord */
+    ABW: "application/x-abiword",
+    /** Archive document (multiple files embedded) */
+    ARC: "application/x-freearc",
+    /** AVIF image */
+    AVIF: "image/avif",
+    /** Audio Video Interleave (AVI) */
+    AVI: "video/x-msvideo",
+    /** Amazon Kindle eBook format */
+    AZW: "application/vnd.amazon.ebook",
+    /** Binary Data */
+    BIN: "application/octet-stream",
+    /** Windows OS/2 Bitmap Graphics */
+    BMP: "image/bmp",
+    /** Bzip Archive */
+    BZIP: "application/x-bzip",
+    /** Bzip2 Archive */
+    BZIP2: "application/x-bzip2",
+    /** CD audio */
+    CDA: "application/x-cdf",
+    /** C Shell Script */
+    CSH: "application/x-csh",
+    /** Cascading Style Sheets (CSS) */
+    CSS: "text/css",
+    /** Comma-Separated Values */
+    CSV: "text/csv",
+    /** Microsoft Office Word Document */
+    DOC: "application/msword",
+    /** Microsoft Office Word Document (OpenXML) */
+    DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    /** Microsoft Embedded OpenType */
+    EOT: "application/vnd.ms-fontobject",
+    /** Electronic Publication (EPUB) */
+    EPUB: "application/epub+zip",
+    /** GZip Compressed Archive */
+    GZIP: "application/gzip",
+    /** Graphics Interchange Format */
+    GIF: "image/gif",
+    /** HyperText Markup Language (HTML) */
+    HTML: "text/html",
+    /** Icon Format */
+    ICO: "image/vnd.microsoft.icon",
+    /** iCalendar Format */
+    ICS: "text/calendar",
+    /** Java Archive (JAR) */
+    JAR: "application/java-archive",
+    /** JPEG Image */
+    JPEG: "image/jpeg",
+    /** JavaScript */
+    JAVA_SCRIPT: "text/javascript",
+    /** JavaScript Object Notation Format (JSON) */
+    JSON: "application/json",
+    /** JavaScript Object Notation LD Format */
+    JSON_LD: "application/ld+json",
+    /** 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;
+
+  // src/constants.js
+  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) };
+
+  // src/abort-signal.js
+  var AbortSignal = class extends EventTarget {
+    /** @type {AbortController} */
+    #abortController;
+    /** @type {number} */
+    #timeoutId;
     /**
-     * What partial content range types this server supports via byte serving
-     *
-     * @example
-     * accept-ranges: bytes
-     * Permanent
+     * @param {AbortSignal} signal The signal to listen to
      */
-    ACCEPT_RANGES: "accept-ranges",
+    constructor(signal) {
+      super();
+      this.#abortController = new AbortController();
+      signal?.addEventListener(SignalEvents.ABORT, (event) => this.#abort(event));
+    }
     /**
-     * The age the object has been in a proxy cache in seconds
+     * The aborted property is a Boolean that indicates whether the request has been aborted (true) or not (false).
      *
-     * @example
-     * age: 12
-     * Permanent
+     * @returns {boolean} Whether the signal was aborted or not
      */
-    AGE: "age",
+    get aborted() {
+      return this.#abortController.signal.aborted;
+    }
     /**
-     * Valid actions for a specified resource. To be used for a 405 Method not allowed
+     * The reason property returns a DOMException object indicating the reason the operation was aborted, or null if the operation is not aborted.
      *
-     * @example
-     * allow: GET, HEAD
-     * Permanent
+     * @returns {DOMException} The reason the signal was aborted
      */
-    ALLOW: "allow",
+    get reason() {
+      return this.#abortController.signal.reason;
+    }
     /**
-     * Tells all caching mechanisms from server to client whether they may cache this object. It is measured in seconds
+     * 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.
      *
-     * @example
-     * cache-control: max-age=3600
-     * Permanent
+     * @param {number} timeout The timeout in milliseconds
+     * @returns {AbortSignal} The abort signal
      */
-    CACHE_CONTROL: "cache-control",
+    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;
+    }
     /**
-     * Control options for the current connection and list of hop-by-hop response fields
+     * Clears the timeout.
+     * Note: This does not abort the signal, dispatch the timeout event, or reset the timeout.
      *
-     * @example
-     * connection: close
-     * Permanent
+     * @returns {void}
      */
-    CONNECTION: "connection",
+    clearTimeout() {
+      clearTimeout(this.#timeoutId);
+    }
     /**
-     * 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.
+     * Adds an event listener for the 'abort' event.
      *
-     * @example
-     * content-disposition: attachment, filename="fname.ext"
-     * Permanent
+     * @param {EventListener} listener The listener to add
+     * @returns {AbortSignal} The AbortSignal
      */
-    CONTENT_DISPOSITION: "content-disposition",
+    onAbort(listener) {
+      this.#abortController.signal.addEventListener(SignalEvents.ABORT, listener);
+      return this;
+    }
     /**
-     * The type of encoding used on the data. See HTTP compression.
+     * Adds an event listener for the 'timeout' event.
      *
-     * @example
-     * content-encoding: gzip
-     * Permanent
+     * @param {EventListener} listener The listener to add
+     * @returns {AbortSignal} The AbortSignal
      */
-    CONTENT_ENCODING: "content-encoding",
+    onTimeout(listener) {
+      this.#abortController.signal.addEventListener(SignalEvents.TIMEOUT, listener);
+      return this;
+    }
     /**
-     * The natural language or languages of the intended audience for the enclosed content
+     * Aborts the signal. This is so naughty. ¯\_(ツ)_/¯
      *
-     * @example
-     * content-language: da
-     * Permanent
+     * @param {Event} event The event to abort with
+     * @returns {void}
      */
-    CONTENT_LANGUAGE: "content-language",
+    abort(event) {
+      this.#abort(event);
+    }
     /**
-     * The length of the response body in octets (8-bit bytes)
+     * Aborts the signal.
      *
-     * @example
-     * content-length: 348
-     * Permanent
+     * @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
      */
-    CONTENT_LENGTH: "content-length",
+    #abort(event = _abortEvent, dispatchEvent = false) {
+      clearTimeout(this.#timeoutId);
+      this.#abortController.abort(event.detail?.cause);
+      if (dispatchEvent) {
+        this.#abortController.signal.dispatchEvent(event);
+      }
+    }
+  };
+
+  // src/http-error.js
+  var HttpError = class extends Error {
+    /** @type {ResponseBody} */
+    #entity;
+    /** @type {ResponseStatus} */
+    #responseStatus;
     /**
-     * An alternate location for the returned data
-     *
-     * @example
-     * content-location: /index.htm
-     * Permanent
+     * @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.
      */
-    CONTENT_LOCATION: "content-location",
+    constructor(message, { cause, status, entity }) {
+      super(message, { cause });
+      this.#entity = entity;
+      this.#responseStatus = status;
+    }
     /**
-     * Where in a full body message this partial message belongs
+     * It returns the value of the private variable #entity.
      *
-     * @example
-     * content-range: bytes 21010-47021/47022
-     * Permanent
+     * @returns {ResponseBody} The entity property of the class.
      */
-    CONTENT_RANGE: "content-range",
+    get entity() {
+      return this.#entity;
+    }
     /**
-     * The MIME type of this content
+     * It returns the status code of the {@link Response}.
      *
-     * @example
-     * content-type: text/html, charset=utf-8
-     * Permanent
+     * @returns {number} The status code of the {@link Response}.
      */
-    CONTENT_TYPE: "content-type",
+    get statusCode() {
+      return this.#responseStatus?.code;
+    }
     /**
-     * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231)
+     * It returns the status text of the {@link Response}.
      *
-     * @example
-     * date: Tue, 15 Nov 1994 08:12:31 GMT
-     * Permanent
+     * @returns {string} The status code and status text of the {@link Response}.
      */
-    DATE: "date",
+    get statusText() {
+      return this.#responseStatus?.text;
+    }
+    get name() {
+      return "HttpError";
+    }
     /**
-     * An identifier for a specific version of a resource, often a message digest
+     * 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}.
      *
-     * @example
-     * etag: "737060cd8c284d8af7ad3082f209582d"
-     * Permanent
+     * @returns {string} The default string description of this object.
      */
-    ETAG: "etag",
+    get [Symbol.toStringTag]() {
+      return "HttpError";
+    }
+  };
+
+  // src/http-request-headers.js
+  var HttpRequestHeader = {
     /**
-     * Gives the date/time after which the response is considered stale (in "HTTP-date" format as defined by RFC 7231)
+     * Content-Types that are acceptable for the response. See Content negotiation. Permanent.
      *
      * @example
-     * expires: Thu, 01 Dec 1994 16:00:00 GMT
-     * Permanent
+     * <code>Accept: text/plain</code>
      */
-    EXPIRES: "expires",
+    ACCEPT: "accept",
     /**
-     * The last modified date for the requested object (in "HTTP-date" format as defined by RFC 7231)
+     * Character sets that are acceptable. Permanent.
      *
      * @example
-     * last-modified: Tue, 15 Nov 1994 12:45:26 GMT
-     * Permanent
+     * <code>Accept-Charset: utf-8</code>
      */
-    LAST_MODIFIED: "last-modified",
+    ACCEPT_CHARSET: "accept-charset",
     /**
-     * Used to express a typed relationship with another resource, where the relation type is defined by RFC 5988
+     * List of acceptable encodings. See HTTP compression. Permanent.
      *
      * @example
-     * link: </feed>, rel="alternate"
-     * Permanent
+     * <code>Accept-Encoding: gzip, deflate</code>
      */
-    LINK: "link",
+    ACCEPT_ENCODING: "accept-encoding",
     /**
-     * Used in redirection, or when a new resource has been created.
+     * List of acceptable human languages for response. See Content negotiation. Permanent.
      *
      * @example
-     * location: http://www.w3.org/pub/WWW/People.html
-     * Permanent
+     * <code>Accept-Language: en-US</code>
      */
-    LOCATION: "location",
+    ACCEPT_LANGUAGE: "accept-language",
     /**
-     * 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.
+     * Authentication credentials for HTTP authentication. Permanent.
      *
      * @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
+     * <code>Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==</code>
      */
-    P3P: "p3p",
+    AUTHORIZATION: "authorization",
     /**
-     * Implementation-specific fields that may have various effects anywhere along the request-response chain.
+     * Used to specify directives that must be obeyed by all caching mechanisms along the request-response chain.
+     * Permanent.
      *
      * @example
-     * pragma: no-cache
-     * Permanent
+     * <code>Cache-Control: no-cache</code>
      */
-    PRAGMA: "pragma",
+    CACHE_CONTROL: "cache-control",
     /**
-     * Request authentication to access the proxy.
+     * Control options for the current connection and list of hop-by-hop request fields. Permanent.
      *
      * @example
-     * proxy-authenticate: Basic
-     * Permanent
+     * <code>Connection: keep-alive</code>
+     * <code>Connection: Upgrade</code>
      */
-    PROXY_AUTHENTICATION: "proxy-authenticate",
+    CONNECTION: "connection",
     /**
-     * HTTP Public Key Pinning, announces hash of website's authentic TLS certificate
+     * An HTTP cookie previously sent by the server with Set-Cookie (below). Permanent: standard.
      *
      * @example
-     * public-key-pins: max-age=2592000, pin-sha256="E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=",
-     * Permanent
+     * <code>Cookie: $Version=1, Skin=new,</code>
      */
-    PUBLIC_KEY_PINS: "public-key-pins",
+    COOKIE: "cookie",
     /**
-     * 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.
+     * The length of the request body in octets (8-bit bytes). Permanent.
      *
      * @example
-     * retry-after: 120
-     * retry-after: Fri, 07 Nov 2014 23:59:59 GMT
-     * Permanent
+     * <code>Content-Length: 348</code>
      */
-    RETRY_AFTER: "retry-after",
+    CONTENT_LENGTH: "content-length",
     /**
-     * A name for the server
+     * A Base64-encoded binary MD5 sum of the content of the request body. Obsolete.
      *
      * @example
-     * server: Apache/2.4.1 (Unix)
-     * Permanent
+     * <code>Content-MD5: Q2hlY2sgSW50ZWdyaXR5IQ==</code>
      */
-    SERVER: "server",
+    CONTENT_MD5: "content-md5",
     /**
-     * An HTTP cookie
+     * 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
-     * set-cookie: UserID=JohnDoe, Max-Age=3600, Version=1
-     * Permanent
+     * <code>Date: Tue, 15 Nov 1994 08:12:31 GMT</code>
      */
-    SET_COOKIE: "set-cookie",
+    DATE: "date",
     /**
-     * CGI header field specifying the status of the HTTP response. Normal HTTP responses use a separate "Status-Line" instead, defined by RFC 7230.
+     * Indicates that particular server behaviors are required by the client. Permanent.
      *
      * @example
-     * status: 200 OK
+     * <code>Expect: 100-continue</code>
      */
-    STATUS: "status",
+    EXPECT: "expect",
     /**
-     * A HSTS Policy informing the HTTP client how long to cache the HTTPS only policy and whether this applies to subdomains.
+     * The email address of the user making the request. Permanent.
      *
      * @example
-     * strict-transport-security: max-age=16070400, includeSubDomains
-     * Permanent
+     * <code>From: user@example.com</code>
      */
-    STRICT_TRANSPORT_SECURITY: "strict-transport-security",
+    FROM: "from",
     /**
-     * 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.
+     * 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
-     * trailer: Max-Forwards
-     * Permanent
+     * <code>Host: en.wikipedia.org:80</code>
+     * <code>Host: en.wikipedia.org</code>
      */
-    TRAILER: "trailer",
+    HOST: "host",
     /**
-     * The form of encoding used to safely transfer the entity to the user. Currently defined methods are: chunked, compress, deflate, gzip, identity.
+     * 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
-     * transfer-encoding: chunked
-     * Permanent
+     * <code>If-Match: "737060cd8c284d8af7ad3082f209582d"</code>
      */
-    TRANSFER_ENCODING: "transfer-encoding",
+    IF_MATCH: "if-match",
     /**
-     * Ask the client to upgrade to another protocol.
+     * Allows a 304 Not Modified to be returned if content is unchanged. Permanent.
      *
      * @example
-     * upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
-     * Permanent
+     * <code>If-Modified-Since: Sat, 29 Oct 1994 19:43:31 GMT</code>
      */
-    UPGRADE: "upgrade",
+    IF_MODIFIED_SINCE: "if-modified-since",
     /**
-     * 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.
+     * Allows a 304 Not Modified to be returned if content is unchanged, see HTTP ETag. Permanent.
      *
      * @example
-     * vary: *
-     * Permanent
+     * <code>If-None-Match: "737060cd8c284d8af7ad3082f209582d"</code>
      */
-    VARY: "vary",
+    IF_NONE_MATCH: "if-none-match",
     /**
-     * Informs the client of proxies through which the response was sent.
+     * If the entity is unchanged, send me the part(s) that I am missing, otherwise, send me the entire new entity.
+     * Permanent.
      *
      * @example
-     * via: 1.0 fred, 1.1 example.com (Apache/1.1)
-     * Permanent
+     * <code>If-Range: "737060cd8c284d8af7ad3082f209582d"</code>
      */
-    VIA: "via",
+    IF_RANGE: "if-range",
     /**
-     * A general warning about possible problems with the entity body.
+     * Only send the response if the entity has not been modified since a specific time. Permanent.
      *
      * @example
-     * warning: 199 Miscellaneous warning
-     * Permanent
+     * <code>If-Unmodified-Since: Sat, 29 Oct 1994 19:43:31 GMT</code>
      */
-    WARNING: "warning",
+    IF_UNMODIFIED_SINCE: "if-unmodified-since",
     /**
-     * Indicates the authentication scheme that should be used to access the requested entity.
+     * Limit the number of times the message can be forwarded through proxies or gateways. Permanent.
      *
      * @example
-     * www-authenticate: Basic
-     * Permanent
+     * <code>Max-Forwards: 10</code>
      */
-    WWW_AUTHENTICATE: "www-authenticate",
+    MAX_FORWARDS: "max-forwards",
     /**
-     * Cross-site scripting (XSS) filter
+     * Initiates a request for cross-origin resource sharing (asks server for an 'Access-Control-Allow-Origin' response
+     * field). Permanent: standard.
      *
      * @example
-     * x-xss-protection: 1, mode=block
+     * <code>Origin: http://www.example-social-network.com</code>
      */
-    X_XSS_PROTECTION: "x-xss-protection",
+    ORIGIN: "origin",
     /**
-     * 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).
+     * Implementation-specific fields that may have various effects anywhere along the request-response chain. Permanent.
      *
      * @example
-     * content-security-policy: default-src
+     * <code>Pragma: no-cache</code>
      */
-    CONTENT_SECURITY_POLICY: "content-security-policy",
+    PRAGMA: "pragma",
     /**
-     * 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.
+     * Authorization credentials for connecting to a proxy. Permanent.
      *
      * @example
-     * x-content-type-options: nosniff
+     * <code>Proxy-Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==</code>
      */
-    X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
+    PROXY_AUTHORIZATION: "proxy-authorization",
     /**
-     * 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)
+     * Request only part of an entity. Bytes are numbered from 0. See Byte serving. Permanent.
      *
      * @example
-     * x-powered-by: PHP/5.4.0
+     * <code>Range: bytes=500-999</code>
      */
-    X_POWERED_BY: "x-powered-by"
-  };
-  var http_response_headers_default = HttpResponseHeader;
-
-  // src/response-status.js
-  var ResponseStatus = class {
-    /** @type {number} */
-    #code;
-    /** @type {string} */
-    #text;
+    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.
      *
-     * @param {number} code The status code from the {@link Response}
-     * @param {string} text The status text from the {@link Response}
+     * @example
+     * <code>Referer: http://en.wikipedia.org/wiki/Main_Page</code>
      */
-    constructor(code, text) {
-      this.#code = code;
-      this.#text = text;
-    }
+    REFERER: "referer",
     /**
-     * Returns the status code from the {@link Response}
+     * 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.
      *
-     * @returns {number} The status code.
+     * @example
+     * <code>TE: trailers, deflate</code>
      */
-    get code() {
-      return this.#code;
-    }
+    TE: "te",
     /**
-     * Returns the status text from the {@link Response}.
+     * The user agent string of the user agent. Permanent.
      *
-     * @returns {string} The status text.
+     * @example
+     * <code>User-Agent: Mozilla/5.0 (X11, Linux x86_64, rv:12.0) Gecko/20100101 Firefox/21.0</code>
      */
-    get text() {
-      return this.#text;
-    }
+    USER_AGENT: "user-agent",
     /**
-     * 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}.
+     * Ask the server to upgrade to another protocol. Permanent.
      *
-     * @override
-     * @returns {string} The default string description of this object.
+     * @example
+     * <code>Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11</code>
      */
-    get [Symbol.toStringTag]() {
-      return "ResponseStatus";
-    }
+    UPGRADE: "upgrade",
     /**
-     * tostring method for the class.
+     * Informs the server of proxies through which the request was sent. Permanent.
      *
-     * @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.
+     * @example
+     * <code>Via: 1.0 fred, 1.1 example.com (Apache/1.1)</code>
      */
-    toString() {
-      return `${this.#code} ${this.#text}`;
-    }
-  };
-
-  // src/parameter-map.js
-  var ParameterMap = class _ParameterMap extends Map {
+    VIA: "via",
     /**
-     * @param {Iterable<[string, *]>|Object} parameters The initial parameters to set.
-     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     * A general warning about possible problems with the entity body. Permanent.
+     *
+     * @example
+     * <code>Warning: 199 Miscellaneous warning</code>
      */
-    constructor(parameters = {}) {
-      super();
-      for (const [key, value] of _ParameterMap.#entries(parameters)) {
-        this.append(key, value);
-      }
-    }
+    WARNING: "warning",
     /**
-     * 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}.
+     * mainly used to identify Ajax requests. Most JavaScript frameworks send this field with value of XMLHttpRequest.
      *
-     * @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.
+     * @example
+     * <code>X-Requested-With: XMLHttpRequest</code>
      */
-    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;
-    }
+    X_REQUESTED_WITH: "x-requested-with",
     /**
-     * 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}.
+     * 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.
      *
-     * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
-     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     * @example
+     * <code>DNT: 1 (Do Not Track Enabled)</code>
+     * <code>DNT: 0 (Do Not Track Disabled)</code>
      */
-    setAll(parameters) {
-      for (const [key, value] of _ParameterMap.#entries(parameters)) {
-        this.set(key, value);
-      }
-      return this;
-    }
+    DNT: "dnt",
     /**
-     * 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.
+     * 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.
      *
-     * @override
-     * @param {string} key The key to get.
-     * @returns {*} The value associated to the key, or undefined if there is none.
+     * @example
+     * <code>X-Forwarded-For: client1, proxy1, proxy2</code>
+     * <code>X-Forwarded-For: 129.78.138.66, 129.78.64.103</code>
      */
-    get(key) {
-      return super.get(key)?.[0];
-    }
+    X_FORWARDED_FOR: "x-forwarded-for",
     /**
-     * Returns an array of all values associated to the key, or undefined if there are none.
+     * 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.
      *
-     * @param {string} key The key to get.
-     * @returns {Array<*>} An array of all values associated to the key, or undefined if there are none.
+     * @example
+     * <code>X-Forwarded-Host: en.wikipedia.org:80</code>
+     * <code>X-Forwarded-Host: en.wikipedia.org</code>
      */
-    getAll(key) {
-      return super.get(key);
-    }
+    X_FORWARDED_HOST: "x-forwarded-host",
     /**
-     * Appends a new value to an existing key inside a ParameterMap, or adds the new key if it does not exist.
+     * 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.
      *
-     * @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.
+     * @example
+     * <code>X-Forwarded-Proto: https</code>
      */
-    append(key, value) {
-      const array = super.get(key);
-      if (array?.length > 0) {
-        array.push(value);
-      } else {
-        super.set(key, [value]);
-      }
-      return this;
-    }
+    X_FORWARDED_PROTO: "x-forwarded-proto",
     /**
-     * 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.
+     * Non-standard header field used by Microsoft applications and load-balancers.
      *
-     * @param {Iterable<[string, *]>|Object} parameters The parameters to append.
-     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     * @example
+     * <code>Front-End-Https: on</code>
      */
-    appendAll(parameters) {
-      for (const [key, value] of _ParameterMap.#entries(parameters)) {
-        this.append(key, value);
-      }
-      return this;
-    }
+    FRONT_END_HTTPS: "front-end-https",
     /**
-     * Checks if a specific key has a specific value.
+     * 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).
      *
-     * @param {*} value The value to check.
-     * @returns {boolean} True if the key has the value, false otherwise.
+     * @example
+     * <code>X-HTTP-Method-Override: DELETE</code>
      */
-    hasValue(value) {
-      for (const array of super.values()) {
-        if (array.includes(value)) {
-          return true;
-        }
-      }
-      return false;
-    }
+    X_HTTP_METHOD_OVERRIDE: "x-http-method-override",
     /**
-     * Removes a specific value from a specific key.
+     * Allows easier parsing of the MakeModel/Firmware that is usually found in the User-Agent String of AT&T Devices.
      *
-     * @param {*} value The value to remove.
-     * @returns {boolean} True if the value was removed, false otherwise.
+     * @example
+     * <code>X-Att-Deviceid: GT-P7320/P7320XXLPG</code>
      */
-    deleteValue(value) {
-      for (const array of this.values()) {
-        if (array.includes(value)) {
-          return array.splice(array.indexOf(value), 1).length > 0;
-        }
-      }
-      return false;
-    }
+    X_ATT_DEVICE_ID: "x-att-deviceid",
     /**
-     * Determines whether the ParameterMap contains anything.
+     * Links to an XML file on the Internet with a full description and details about the device currently connecting. In the example to the right is an XML file for an AT&T Samsung Galaxy S2.
+     * x-wap-profile: http://wap.samsungmobile.com/uaprof/SGH-I777.xml
+     */
+    X_WAP_PROFILE: "x-wap-profile"
+  };
+  var http_request_headers_default = HttpRequestHeader;
+
+  // src/http-response-headers.js
+  var HttpResponseHeader = {
+    /**
+     * Implemented as a misunderstanding of the HTTP specifications. Common because of mistakes in implementations of early HTTP versions. Has exactly the same functionality as standard Connection field.
      *
-     * @returns {boolean} True if the ParameterMap size is greater than 0, false otherwise.
+     * @example
+     * proxy-connection: keep-alive
      */
-    isEmpty() {
-      return this.size === 0;
-    }
+    PROXY_CONNECTION: "proxy-connection",
     /**
-     * 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.
+     * Server-side deep packet insertion of a unique ID identifying customers of Verizon Wireless, also known as "perma-cookie" or "supercookie"
      *
-     * @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}
+     * @example
+     * x-uidh: ...
      */
-    toJSON() {
-      const obj = /* @__PURE__ */ Object.create(null);
-      for (const [key, values] of super.entries()) {
-        obj[key] = values.length === 1 ? values[0] : values;
-      }
-      return obj;
-    }
+    X_UIDH: "x-uidh",
     /**
-     * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
+     * Used to prevent cross-site request forgery. Alternative header names are: X-CSRFToken and X-XSRF-TOKEN
      *
-     * @override
-     * @yields {[string, *]} An iterator for the key-value pairs in the map.
+     * @example
+     * x-csrf-token: i8XNjC4b8KVok4uw5RftR38Wgp2BFwql
      */
-    *entries() {
-      for (const [key, array] of super.entries()) {
-        for (const value of array) {
-          yield [key, value];
-        }
-      }
-    }
+    X_CSRF_TOKEN: "x-csrf-token",
     /**
-     * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
+     * Specifying which web sites can participate in cross-origin resource sharing
      *
-     * @override
-     * @yields {[string, *]} An iterator for the key-value pairs in the map.
+     * @example
+     * access-control-allow-origin: *
+     * Provisional
      */
-    *[Symbol.iterator]() {
-      yield* this.entries();
-    }
+    ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
     /**
-     * Returns an iterable of key, value pairs for every entry in the parameters object.
+     * Specifies which patch document formats this server supports
      *
-     * @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.
+     * @example
+     * accept-patch: text/example,charset=utf-8
+     * Permanent
      */
-    static #entries(parameters) {
-      return parameters[Symbol.iterator] ? parameters : Object.entries(parameters);
-    }
+    ACCEPT_PATCH: "accept-patch",
     /**
-     * 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}.
+     * What partial content range types this server supports via byte serving
      *
-     * @override
-     * @returns {string} The default string description of this object.
+     * @example
+     * accept-ranges: bytes
+     * Permanent
      */
-    get [Symbol.toStringTag]() {
-      return "ParameterMap";
-    }
-  };
-
-  // node_modules/@d1g1tal/media-type/src/utils.js
-  var whitespaceCharacters = [" ", "	", "\n", "\r"];
-  var leadingWhitespace = /^[ \t\n\r]+/u;
-  var trailingWhitespace = /[ \t\n\r]+$/u;
-  var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
-  var httpQuotedTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
-  var removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(leadingWhitespace, "").replace(trailingWhitespace, "");
-  var removeTrailingHTTPWhitespace = (string) => string.replace(trailingWhitespace, "");
-  var isHTTPWhitespaceChar = (char) => whitespaceCharacters.includes(char);
-  var solelyContainsHTTPTokenCodePoints = (string) => httpTokenCodePoints.test(string);
-  var solelyContainsHTTPQuotedStringTokenCodePoints = (string) => httpQuotedTokenCodePoints.test(string);
-  var asciiLowercase = (string) => {
-    let result = "";
-    for (const [char, charCode = char.charCodeAt(0)] of string) {
-      result += charCode >= 65 && charCode <= 90 ? String.fromCharCode(charCode + 32) : char;
-    }
-    return result;
-  };
-  var collectAnHTTPQuotedString = (input, position) => {
-    let value = "";
-    for (let length = input.length, char; ++position < length; ) {
-      char = input[position];
-      if (char == "\\") {
-        value += ++position < length ? input[position] : char;
-      } else if (char == '"') {
-        break;
-      } else {
-        value += char;
-      }
-    }
-    return [value, position];
-  };
-
-  // node_modules/@d1g1tal/media-type/src/media-type-parameters.js
-  var MediaTypeParameters = class {
-    /** @type {Map<string, string>} */
-    #map;
+    ACCEPT_RANGES: "accept-ranges",
+    /**
+     * The age the object has been in a proxy cache in seconds
+     *
+     * @example
+     * age: 12
+     * Permanent
+     */
+    AGE: "age",
     /**
-     * Create a new MediaTypeParameters instance.
+     * Valid actions for a specified resource. To be used for a 405 Method not allowed
      *
-     * @param {Array<Array<string>>} entries An array of [name, value] tuples.
+     * @example
+     * allow: GET, HEAD
+     * Permanent
      */
-    constructor(entries) {
-      this.#map = new Map(entries);
-    }
+    ALLOW: "allow",
     /**
-     * Gets the number of media type parameters.
+     * Tells all caching mechanisms from server to client whether they may cache this object. It is measured in seconds
      *
-     * @returns {number} The number of media type parameters
+     * @example
+     * cache-control: max-age=3600
+     * Permanent
      */
-    get size() {
-      return this.#map.size;
-    }
+    CACHE_CONTROL: "cache-control",
     /**
-     * Gets the media type parameter value for the supplied name.
+     * Control options for the current connection and list of hop-by-hop response fields
      *
-     * @param {string} name The name of the media type parameter to retrieve.
-     * @returns {string} The media type parameter value.
+     * @example
+     * connection: close
+     * Permanent
      */
-    get(name) {
-      return this.#map.get(asciiLowercase(String(name)));
-    }
+    CONNECTION: "connection",
     /**
-     * Indicates whether the media type parameter with the specified name exists or not.
+     * 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.
      *
-     * @param {string} name The name of the media type parameter to check.
-     * @returns {boolean} true if the media type parameter exists, false otherwise.
+     * @example
+     * content-disposition: attachment, filename="fname.ext"
+     * Permanent
      */
-    has(name) {
-      return this.#map.has(asciiLowercase(String(name)));
-    }
+    CONTENT_DISPOSITION: "content-disposition",
     /**
-     * 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.
+     * The type of encoding used on the data. See HTTP compression.
      *
-     * @param {string} name The name of the media type parameter to set.
-     * @param {string} value The media type parameter value.
-     * @returns {MediaTypeParameters} This instance.
+     * @example
+     * content-encoding: gzip
+     * Permanent
      */
-    set(name, value) {
-      name = asciiLowercase(String(name));
-      value = String(value);
-      if (!solelyContainsHTTPTokenCodePoints(name)) {
-        throw new Error(`Invalid media type parameter name "${name}": only HTTP token code points are valid.`);
-      }
-      if (!solelyContainsHTTPQuotedStringTokenCodePoints(value)) {
-        throw new Error(`Invalid media type parameter value "${value}": only HTTP quoted-string token code points are valid.`);
-      }
-      this.#map.set(name, value);
-      return this;
-    }
+    CONTENT_ENCODING: "content-encoding",
     /**
-     * Clears all the media type parameters.
+     * The natural language or languages of the intended audience for the enclosed content
+     *
+     * @example
+     * content-language: da
+     * Permanent
      */
-    clear() {
-      this.#map.clear();
-    }
+    CONTENT_LANGUAGE: "content-language",
     /**
-     * Removes the media type parameter using the specified name.
+     * The length of the response body in octets (8-bit bytes)
      *
-     * @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.
+     * @example
+     * content-length: 348
+     * Permanent
      */
-    delete(name) {
-      name = asciiLowercase(String(name));
-      return this.#map.delete(name);
-    }
+    CONTENT_LENGTH: "content-length",
     /**
-     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
+     * An alternate location for the returned data
      *
-     * @param {function(string, string): void} callback The function called on each iteration.
-     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
+     * @example
+     * content-location: /index.htm
+     * Permanent
      */
-    forEach(callback, thisArg) {
-      this.#map.forEach(callback, thisArg);
-    }
+    CONTENT_LOCATION: "content-location",
     /**
-     * Returns an iterable of parameter names.
+     * Where in a full body message this partial message belongs
      *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
+     * @example
+     * content-range: bytes 21010-47021/47022
+     * Permanent
      */
-    keys() {
-      return this.#map.keys();
-    }
+    CONTENT_RANGE: "content-range",
     /**
-     * Returns an iterable of parameter values.
+     * The MIME type of this content
      *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
+     * @example
+     * content-type: text/html, charset=utf-8
+     * Permanent
      */
-    values() {
-      return this.#map.values();
-    }
+    CONTENT_TYPE: "content-type",
     /**
-     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
+     * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231)
      *
-     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
+     * @example
+     * date: Tue, 15 Nov 1994 08:12:31 GMT
+     * Permanent
      */
-    entries() {
-      return this.#map.entries();
-    }
+    DATE: "date",
     /**
-     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
+     * An identifier for a specific version of a resource, often a message digest
      *
-     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
+     * @example
+     * etag: "737060cd8c284d8af7ad3082f209582d"
+     * Permanent
      */
-    [Symbol.iterator]() {
-      return this.#map[Symbol.iterator]();
-    }
+    ETAG: "etag",
     /**
-     * Returns a string representation of the media type parameters.
-     * This method is called by the `String()` function.
+     * Gives the date/time after which the response is considered stale (in "HTTP-date" format as defined by RFC 7231)
      *
      * @example
-     * const parameters = new MediaTypeParameters(new Map([['charset', 'utf-8']]));
-     * String(parameters); // 'charset=utf-8'
-     * parameters.toString(); // 'charset=utf-8'
-     * parameters + ''; // 'charset=utf-8'
-     * `${parameters}`; // 'charset=utf-8'
-     * parameters[Symbol.toStringTag]; // 'MediaTypeParameters'
-     * parameters[Symbol.toStringTag](); // 'MediaTypeParameters'
-     * Object.prototype.toString.call(parameters); // '[object MediaTypeParameters]'
-     * parameters + ''; // 'charset=utf-8'
-     * @returns {string} The string representation of the media type parameters.
-     */
-    [Symbol.toStringTag]() {
-      return "MediaTypeParameters";
-    }
-  };
-
-  // node_modules/@d1g1tal/media-type/src/parser.js
-  var parse = (input) => {
-    input = removeLeadingAndTrailingHTTPWhitespace(input);
-    let position = 0;
-    let type = "";
-    while (position < input.length && input[position] != "/") {
-      type += input[position];
-      ++position;
-    }
-    if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
-      return null;
-    }
-    if (position >= input.length) {
-      return null;
-    }
-    ++position;
-    let subtype = "";
-    while (position < input.length && input[position] != ";") {
-      subtype += input[position];
-      ++position;
-    }
-    subtype = removeTrailingHTTPWhitespace(subtype);
-    if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
-      return null;
-    }
-    const mediaType = {
-      type: asciiLowercase(type),
-      subtype: asciiLowercase(subtype),
-      parameters: /* @__PURE__ */ new Map()
-    };
-    while (position < input.length) {
-      ++position;
-      while (isHTTPWhitespaceChar(input[position])) {
-        ++position;
-      }
-      let parameterName = "";
-      while (position < input.length && input[position] != ";" && input[position] != "=") {
-        parameterName += input[position];
-        ++position;
-      }
-      parameterName = asciiLowercase(parameterName);
-      if (position < input.length) {
-        if (input[position] == ";") {
-          continue;
-        }
-        ++position;
-      }
-      let parameterValue = null;
-      if (input[position] == '"') {
-        [parameterValue, position] = collectAnHTTPQuotedString(input, position);
-        while (position < input.length && input[position] != ";") {
-          ++position;
-        }
-      } else {
-        parameterValue = "";
-        while (position < input.length && input[position] != ";") {
-          parameterValue += input[position];
-          ++position;
-        }
-        parameterValue = removeTrailingHTTPWhitespace(parameterValue);
-        if (parameterValue === "") {
-          continue;
-        }
-      }
-      if (parameterName.length > 0 && solelyContainsHTTPTokenCodePoints(parameterName) && solelyContainsHTTPQuotedStringTokenCodePoints(parameterValue) && !mediaType.parameters.has(parameterName)) {
-        mediaType.parameters.set(parameterName, parameterValue);
-      }
-    }
-    return mediaType;
-  };
-  var parser_default = parse;
-
-  // node_modules/@d1g1tal/media-type/src/serializer.js
-  var serialize = (mediaType) => {
-    let serialization = `${mediaType.type}/${mediaType.subtype}`;
-    if (mediaType.parameters.size === 0) {
-      return serialization;
-    }
-    for (let [name, value] of mediaType.parameters) {
-      serialization += `;${name}=`;
-      if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
-        value = `"${value.replace(/(["\\])/ug, "\\$1")}"`;
-      }
-      serialization += value;
-    }
-    return serialization;
-  };
-  var serializer_default = serialize;
-
-  // node_modules/@d1g1tal/media-type/src/media-type.js
-  var MediaType = class _MediaType {
-    /** @type {string} */
-    #type;
-    /** @type {string} */
-    #subtype;
-    /** @type {MediaTypeParameters} */
-    #parameters;
+     * expires: Thu, 01 Dec 1994 16:00:00 GMT
+     * Permanent
+     */
+    EXPIRES: "expires",
     /**
-     * Create a new MediaType instance from a string representation.
+     * The last modified date for the requested object (in "HTTP-date" format as defined by RFC 7231)
      *
-     * @param {string} mediaType The media type to parse.
-     * @param {Object} [parameters] Optional parameters.
+     * @example
+     * last-modified: Tue, 15 Nov 1994 12:45:26 GMT
+     * Permanent
      */
-    constructor(mediaType, parameters = {}) {
-      const { type, subtype, parameters: parsedParameters } = parser_default(mediaType);
-      this.#type = type;
-      this.#subtype = subtype;
-      this.#parameters = new MediaTypeParameters([...parsedParameters, ...Object.entries(parameters).map(([name, value]) => [asciiLowercase(name), asciiLowercase(value)])]);
-    }
+    LAST_MODIFIED: "last-modified",
     /**
-     * Static factory method for parsing a media type.
+     * Used to express a typed relationship with another resource, where the relation type is defined by RFC 5988
      *
-     * @param {string} string The media type to parse.
-     * @returns {MediaType} The parsed {@link MediaType} object or null if the string could not be parsed.
+     * @example
+     * link: </feed>, rel="alternate"
+     * Permanent
      */
-    static parse(string) {
-      try {
-        return new _MediaType(string);
-      } catch (e) {
-        throw new Error(`Could not parse media type string '${string}'`);
-      }
-    }
+    LINK: "link",
     /**
-     * Gets the media type essence (type/subtype).
+     * Used in redirection, or when a new resource has been created.
      *
-     * @returns {string} The media type without any parameters
+     * @example
+     * location: http://www.w3.org/pub/WWW/People.html
+     * Permanent
      */
-    get essence() {
-      return `${this.#type}/${this.#subtype}`;
-    }
+    LOCATION: "location",
     /**
-     * Gets the type.
+     * 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.
      *
-     * @returns {string} The type.
+     * @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
      */
-    get type() {
-      return this.#type;
-    }
+    P3P: "p3p",
     /**
-     * Sets the type.
+     * Implementation-specific fields that may have various effects anywhere along the request-response chain.
+     *
+     * @example
+     * pragma: no-cache
+     * Permanent
      */
-    set type(value) {
-      value = asciiLowercase(String(value));
-      if (value.length === 0) {
-        throw new Error("Invalid type: must be a non-empty string");
-      }
-      if (!solelyContainsHTTPTokenCodePoints(value)) {
-        throw new Error(`Invalid type ${value}: must contain only HTTP token code points`);
-      }
-      this.#type = value;
-    }
+    PRAGMA: "pragma",
     /**
-     * Gets the subtype.
+     * Request authentication to access the proxy.
      *
-     * @returns {string} The subtype.
+     * @example
+     * proxy-authenticate: Basic
+     * Permanent
      */
-    get subtype() {
-      return this.#subtype;
-    }
+    PROXY_AUTHENTICATION: "proxy-authenticate",
     /**
-     * Sets the subtype.
+     * 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
      */
-    set subtype(value) {
-      value = asciiLowercase(String(value));
-      if (value.length === 0) {
-        throw new Error("Invalid subtype: must be a non-empty string");
-      }
-      if (!solelyContainsHTTPTokenCodePoints(value)) {
-        throw new Error(`Invalid subtype ${value}: must contain only HTTP token code points`);
-      }
-      this.#subtype = value;
-    }
+    PUBLIC_KEY_PINS: "public-key-pins",
     /**
-     * Gets the parameters.
+     * 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.
      *
-     * @returns {MediaTypeParameters} The media type parameters.
+     * @example
+     * retry-after: 120
+     * retry-after: Fri, 07 Nov 2014 23:59:59 GMT
+     * Permanent
      */
-    get parameters() {
-      return this.#parameters;
-    }
+    RETRY_AFTER: "retry-after",
     /**
-     * Gets the serialized version of the media type.
+     * A name for the server
      *
-     * @returns {string} The serialized media type.
+     * @example
+     * server: Apache/2.4.1 (Unix)
+     * Permanent
      */
-    toString() {
-      return serializer_default(this);
-    }
+    SERVER: "server",
     /**
-     * Determines if this instance is a JavaScript media type.
+     * An HTTP cookie
      *
-     * @param {Object} [options] Optional options.
-     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
-     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
+     * @example
+     * set-cookie: UserID=JohnDoe, Max-Age=3600, Version=1
+     * Permanent
      */
-    isJavaScript({ prohibitParameters = false } = {}) {
-      switch (this.#type) {
-        case "text": {
-          switch (this.#subtype) {
-            case "ecmascript":
-            case "javascript":
-            case "javascript1.0":
-            case "javascript1.1":
-            case "javascript1.2":
-            case "javascript1.3":
-            case "javascript1.4":
-            case "javascript1.5":
-            case "jscript":
-            case "livescript":
-            case "x-ecmascript":
-            case "x-javascript":
-              return !prohibitParameters || this.#parameters.size === 0;
-            default:
-              return false;
-          }
-        }
-        case "application": {
-          switch (this.#subtype) {
-            case "ecmascript":
-            case "javascript":
-            case "x-ecmascript":
-            case "x-javascript":
-              return !prohibitParameters || this.#parameters.size === 0;
-            default:
-              return false;
-          }
-        }
-        default:
-          return false;
-      }
-    }
+    SET_COOKIE: "set-cookie",
     /**
-     * Determines if this instance is an XML media type.
+     * CGI header field specifying the status of the HTTP response. Normal HTTP responses use a separate "Status-Line" instead, defined by RFC 7230.
      *
-     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
+     * @example
+     * status: 200 OK
      */
-    isXML() {
-      return this.#subtype === "xml" && (this.#type === "text" || this.#type === "application") || this.#subtype.endsWith("+xml");
-    }
+    STATUS: "status",
     /**
-     * Determines if this instance is an HTML media type.
+     * A HSTS Policy informing the HTTP client how long to cache the HTTPS only policy and whether this applies to subdomains.
      *
-     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
+     * @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
      */
-    isHTML() {
-      return this.#subtype === "html" && this.#type === "text";
-    }
+    X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
     /**
-     * Gets the name of the class.
+     * 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)
      *
-     * @returns {string} The class name
+     * @example
+     * x-powered-by: PHP/5.4.0
      */
-    get [Symbol.toStringTag]() {
-      return "MediaType";
-    }
+    X_POWERED_BY: "x-powered-by"
   };
+  var http_response_headers_default = HttpResponseHeader;
 
-  // src/constants.js
-  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];
-
-  // src/abort-signal.js
-  var NativeAbortSignal = globalThis.AbortSignal;
-  var AbortSignal = class _AbortSignal extends EventTarget {
-    /** @type {AbortController} */
-    #abortController;
-    /** @type {number} */
-    #timeoutId;
+  // src/parameter-map.js
+  var ParameterMap = class _ParameterMap extends Map {
     /**
-     * @param {AbortSignal} signal The signal to listen to
+     * @param {Iterable<[string, *]>|Object} parameters The initial parameters to set.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
      */
-    constructor(signal) {
+    constructor(parameters = {}) {
       super();
-      this.#abortController = new AbortController();
-      signal?.addEventListener(SignalEvents.ABORT, (event) => this.#abort(event));
+      for (const [key, value] of _ParameterMap.#entries(parameters)) {
+        this.append(key, value);
+      }
     }
     /**
-     * Returns an {@link AbortSignal} instance that is already set as aborted.
+     * 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}.
      *
-     * @static
-     * @returns {AbortSignal} The abort signal
+     * @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.
      */
-    static abort() {
-      return NativeAbortSignal.abort();
+    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;
     }
     /**
-     * Returns an AbortSignal instance that will automatically abort after a specified time.
+     * 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}.
      *
-     * @static
-     * @param {number} time The time in milliseconds to wait before aborting
-     * @returns {AbortSignal} The abort signal
+     * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
      */
-    static timeout(time) {
-      return NativeAbortSignal.timeout(time);
+    setAll(parameters) {
+      for (const [key, value] of _ParameterMap.#entries(parameters)) {
+        this.set(key, value);
+      }
+      return this;
     }
     /**
-     * The aborted property is a Boolean that indicates whether the request has been aborted (true) or not (false).
+     * 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.
      *
-     * @returns {boolean} Whether the signal was aborted or not
+     * @override
+     * @param {string} key The key to get.
+     * @returns {*} The value associated to the key, or undefined if there is none.
      */
-    get aborted() {
-      return this.#abortController.signal.aborted;
+    get(key) {
+      return super.get(key)?.[0];
     }
     /**
-     * The reason property returns a DOMException object indicating the reason the operation was aborted, or null if the operation is not aborted.
+     * Returns an array of all values associated to the key, or undefined if there are none.
      *
-     * @returns {DOMException} The reason the signal was aborted
+     * @param {string} key The key to get.
+     * @returns {Array<*>} An array of all values associated to the key, or undefined if there are none.
      */
-    get reason() {
-      return this.#abortController.signal.reason;
+    getAll(key) {
+      return super.get(key);
     }
     /**
-     * throws the signal's abort reason if the signal has been aborted; otherwise it does nothing.
+     * Appends a new value to an existing key inside a ParameterMap, or adds the new key if it does not exist.
      *
-     * @returns {void}
+     * @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.
      */
-    throwIfAborted() {
-      this.#abortController.signal.throwIfAborted();
+    append(key, value) {
+      const array = super.get(key);
+      if (array?.length > 0) {
+        array.push(value);
+      } else {
+        super.set(key, [value]);
+      }
+      return this;
     }
     /**
-     * Returns an AbortSignal instance that will be aborted when the provided amount of milliseconds have passed.
-     * A value of -1 (which is the default) means there is no timeout.
-     * Note: You can't set this property to a value less than 0.
+     * 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 {number} timeout The timeout in milliseconds
-     * @returns {AbortSignal} The abort signal
+     * @param {Iterable<[string, *]>|Object} parameters The parameters to append.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
      */
-    withTimeout(timeout) {
-      if (timeout < 0) {
-        throw new RangeError("The timeout cannot be negative");
+    appendAll(parameters) {
+      for (const [key, value] of _ParameterMap.#entries(parameters)) {
+        this.append(key, value);
       }
-      this.#timeoutId ??= setTimeout(() => this.#abort(_AbortSignal.#generateTimeoutEvent(timeout), true), timeout);
-      return this.#abortController.signal;
+      return this;
     }
     /**
-     * Clears the timeout.
-     * Note: This does not abort the signal, dispatch the timeout event, or reset the timeout.
+     * Checks if a specific key has a specific value.
      *
-     * @returns {void}
+     * @param {*} value The value to check.
+     * @returns {boolean} True if the key has the value, false otherwise.
      */
-    clearTimeout() {
-      clearTimeout(this.#timeoutId);
+    hasValue(value) {
+      for (const array of super.values()) {
+        if (array.includes(value)) {
+          return true;
+        }
+      }
+      return false;
     }
     /**
-     * Adds an event listener for the specified event type.
+     * Removes a specific value from a specific key.
      *
-     * @override
-     * @param {string} eventName The name of the event to listen to
-     * @param {EventListener} listener The listener to add
-     * @returns {void}
+     * @param {*} value The value to remove.
+     * @returns {boolean} True if the value was removed, false otherwise.
      */
-    addEventListener(eventName, listener) {
-      this.#abortController.signal.addEventListener(eventName, listener);
+    deleteValue(value) {
+      for (const array of this.values()) {
+        if (array.includes(value)) {
+          return array.splice(array.indexOf(value), 1).length > 0;
+        }
+      }
+      return false;
     }
     /**
-     * Dispatches an event to this EventTarget.
+     * Determines whether the ParameterMap contains anything.
      *
-     * @override
-     * @param {Event} event The event to dispatch
-     * @returns {boolean} Whether the event was dispatched or not
+     * @returns {boolean} True if the ParameterMap size is greater than 0, false otherwise.
      */
-    dispatchEvent(event) {
-      return this.#abortController.signal.dispatchEvent(event);
+    isEmpty() {
+      return this.size === 0;
     }
     /**
-     * Removes an event listener for the specified event type.
+     * 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
-     * @param {string} eventName The name of the event to listen to
-     * @param {EventListener} listener The listener to remove
-     * @returns {void}
+     * @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}
      */
-    removeEventListener(eventName, listener) {
-      this.#abortController.signal.removeEventListener(eventName, listener);
+    toJSON() {
+      const obj = /* @__PURE__ */ Object.create(null);
+      for (const [key, values] of super.entries()) {
+        obj[key] = values.length === 1 ? values[0] : values;
+      }
+      return obj;
     }
     /**
-     * Aborts the signal. This is so naughty. ¯\_(ツ)_/¯
+     * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
      *
-     * @param {Event} event The event to abort with
-     * @returns {void}
+     * @override
+     * @yields {[string, *]} An iterator for the key-value pairs in the map.
      */
-    abort(event) {
-      this.#abort(event);
+    *entries() {
+      for (const [key, array] of super.entries()) {
+        for (const value of array) {
+          yield [key, value];
+        }
+      }
     }
     /**
-     * Aborts the signal.
+     * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
      *
-     * @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
+     * @override
+     * @yields {[string, *]} An iterator for the key-value pairs in the map.
      */
-    #abort(event = _abortEvent, dispatchEvent = false) {
-      clearTimeout(this.#timeoutId);
-      this.#abortController.abort(event.detail?.cause);
-      if (dispatchEvent) {
-        this.#abortController.signal.dispatchEvent(event);
-      }
+    *[Symbol.iterator]() {
+      yield* this.entries();
     }
     /**
-     * Generates a timeout event.
+     * Returns an iterable of key, value pairs for every entry in the parameters object.
      *
      * @private
      * @static
-     * @param {number} timeout The timeout in milliseconds
-     * @returns {CustomEvent} The timeout event
+     * @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.
      */
-    static #generateTimeoutEvent(timeout) {
-      return new CustomEvent(SignalEvents.TIMEOUT, { detail: { timeout, cause: new DOMException(`The request timed-out after ${timeout / 1e3} seconds`, "TimeoutError") } });
+    get [Symbol.toStringTag]() {
+      return "ParameterMap";
     }
   };
 
@@ -2263,8 +2174,8 @@ var Transportr = (() => {
     static #globalSubscribr = new Subscribr();
     /** @type {Set<AbortSignal>} */
     static #activeRequests = /* @__PURE__ */ new Set();
-    /** @type {SetMultiMap<ResponseHandler<ResponseBody>, string>} */
-    static #contentTypeHandlers = new set_multi_map_default([
+    /** @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],
@@ -2391,24 +2302,6 @@ var Transportr = (() => {
       global: true,
       window: null
     });
-    /**
-     * @private
-     * @static
-     * @type {Map<TransportrEvent, ResponseStatus>}
-     */
-    static #eventResponseStatuses = /* @__PURE__ */ new Map([
-      [RequestEvents.ABORTED, new ResponseStatus(499, "Aborted")],
-      [RequestEvents.TIMEOUT, new ResponseStatus(504, "Gateway Timeout")]
-    ]);
-    /**
-     * Returns a {@link AbortSignal} used for aborting requests.
-     *
-     * @static
-     * @returns {AbortSignal} A new {@link AbortSignal} instance.
-     */
-    static abortSignal() {
-      return new AbortSignal();
-    }
     /**
      * Returns a {@link EventRegistration} used for subscribing to global events.
      *
@@ -2687,12 +2580,12 @@ var Transportr = (() => {
      * @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 {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, { ...options, method: http_request_methods_default.GET }, responseHandler);
+    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
@@ -2711,32 +2604,23 @@ var Transportr = (() => {
       if (object_type_default(path) == Object) {
         [path, userOptions] = [void 0, path];
       }
-      try {
-        options = this.#processRequestOptions(userOptions, options);
-      } catch (cause) {
-        return Promise.reject(new HttpError("Unable to process request options", { cause }));
-      }
-      this.#publish({ name: RequestEvents.CONFIGURED, data: options, global: options.global });
+      options = this.#processRequestOptions(userOptions, options);
+      let response;
       const url = _Transportr.#createUrl(this.#baseUrl, path, options.searchParams);
-      if (object_type_default(options.signal) != AbortSignal) {
-        options.signal = new AbortSignal(options.signal);
-      }
-      options.signal.addEventListener(SignalEvents.ABORT, (event) => this.#publish({ name: RequestEvents.ABORTED, event, global: options.global }));
-      options.signal.addEventListener(SignalEvents.TIMEOUT, (event) => this.#publish({ name: RequestEvents.TIMEOUT, event, global: options.global }));
-      _Transportr.#activeRequests.add(options.signal);
-      let response, result;
       try {
-        response = await fetch(url, new Proxy(options, { get: _Transportr.#requestOptionsProxyHandler(options.timeout) }));
-        if (!responseHandler && response.status != 204 && response.headers.has(http_response_headers_default.CONTENT_TYPE)) {
+        _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));
         }
-        result = await responseHandler?.(response) ?? response;
+        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 });
-      } catch (error) {
-        return Promise.reject(this.#handleError(url, { cause: error, status: _Transportr.#generateResponseStatusFromError(error.name, response) }));
+        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) {
@@ -2747,7 +2631,6 @@ var Transportr = (() => {
           }
         }
       }
-      return result;
     }
     /**
      * Creates the options for a {@link Transportr} instance.
@@ -2819,23 +2702,10 @@ var Transportr = (() => {
         }
         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;
     }
-    /**
-     * Returns a Proxy of the options object that traps for 'signal' access.
-     * If the signal has not been aborted, then it will return a new signal with a timeout.
-     *
-     * @private
-     * @static
-     * @param {number} timeout The timeout in milliseconds before the signal is aborted.
-     * @returns {Proxy<RequestOptions>} A proxy for the options object.
-     */
-    static #requestOptionsProxyHandler(timeout) {
-      return (target, property) => {
-        const value = Reflect.get(target, property);
-        return property == "signal" && !value.aborted ? value.withTimeout(timeout) : value;
-      };
-    }
     /**
      * 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.
@@ -2884,11 +2754,11 @@ var Transportr = (() => {
     static #generateResponseStatusFromError(errorName, response) {
       switch (errorName) {
         case "AbortError":
-          return _Transportr.#eventResponseStatuses.get(RequestEvents.ABORTED);
+          return eventResponseStatuses[RequestEvents.ABORTED];
         case "TimeoutError":
-          return _Transportr.#eventResponseStatuses.get(RequestEvents.TIMEOUT);
+          return eventResponseStatuses[RequestEvents.TIMEOUT];
         default:
-          return response ? new ResponseStatus(response.status, response.statusText) : new ResponseStatus(500, "Internal Server Error");
+          return response ? new ResponseStatus(response.status, response.statusText) : internalServerError;
       }
     }
     /**