@d1g1tal/transportr 1.4.2 → 2.0.0

package/dist/transportr.js

@@ -1,818 +1,604 @@
-// node_modules/.pnpm/@d1g1tal+collections@0.2.5/node_modules/@d1g1tal/collections/src/set-multi-map.js
-var SetMultiMap = class extends Map {
+// node_modules/.pnpm/@d1g1tal+media-type@6.0.4/node_modules/@d1g1tal/media-type/dist/media-type.js
+var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
+var matcher = /(["\\])/ug;
+var httpQuotedStringTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
+var MediaTypeParameters = class _MediaTypeParameters 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.
+   * Create a new MediaTypeParameters instance.
    *
-   * @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.
+   * @param entries An array of [ name, value ] tuples.
    */
-  set(key, value) {
-    super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
-    return this;
+  constructor(entries2 = []) {
+    super(entries2);
   }
   /**
-   * Checks if a specific key has a specific value.
+   * Indicates whether the supplied name and value are valid media type parameters.
    *
-   * @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.
+   * @param name The name of the media type parameter to validate.
+   * @param value The media type parameter value to validate.
+   * @returns true if the media type parameter is valid, false otherwise.
    */
-  hasValue(key, value) {
-    const values = super.get(key);
-    return values ? values.has(value) : false;
+  static isValid(name, value) {
+    return httpTokenCodePoints.test(name) && httpQuotedStringTokenCodePoints.test(value);
   }
   /**
-   * Removes a specific value from a specific key.
+   * Gets the media type parameter value for the supplied name.
    *
-   * @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.
+   * @param name The name of the media type parameter to retrieve.
+   * @returns The media type parameter value.
    */
-  deleteValue(key, value) {
-    const values = super.get(key);
-    if (values) {
-      return values.delete(value);
-    }
-    return false;
-  }
-  get [Symbol.toStringTag]() {
-    return "SetMultiMap";
+  get(name) {
+    return super.get(name.toLowerCase());
   }
-};
-
-// node_modules/.pnpm/@d1g1tal+subscribr@3.0.2/node_modules/@d1g1tal/subscribr/src/context-event-handler.js
-var ContextEventHandler = class {
-  #context;
-  #eventHandler;
   /**
-   * @param {*} context The context to bind to the event handler.
-   * @param {function(*): void} eventHandler The event handler to call when the event is published.
+   * Indicates whether the media type parameter with the specified name exists or not.
+   *
+   * @param name The name of the media type parameter to check.
+   * @returns true if the media type parameter exists, false otherwise.
    */
-  constructor(context, eventHandler) {
-    this.#context = context;
-    this.#eventHandler = eventHandler;
+  has(name) {
+    return super.has(name.toLowerCase());
   }
   /**
-   * Call the event handler for the provided event.
+   * Adds a new media type parameter using the specified name and value to the MediaTypeParameters.
+   * If an parameter with the same name already exists, the parameter will be updated.
    *
-   * @param {Event} event The event to handle
-   * @param {*} [data] The value to be passed to the event handler as a parameter.
+   * @param name The name of the media type parameter to set.
+   * @param value The media type parameter value.
+   * @returns This instance.
    */
-  handle(event, data) {
-    this.#eventHandler.call(this.#context, event, data);
-  }
-  get [Symbol.toStringTag]() {
-    return "ContextEventHandler";
+  set(name, value) {
+    if (!_MediaTypeParameters.isValid(name, value)) {
+      throw new Error(`Invalid media type parameter name/value: ${name}/${value}`);
+    }
+    super.set(name.toLowerCase(), value);
+    return this;
   }
-};
-
-// node_modules/.pnpm/@d1g1tal+subscribr@3.0.2/node_modules/@d1g1tal/subscribr/src/subscription.js
-var Subscription = class {
-  #eventName;
-  #contextEventHandler;
   /**
-   * @param {string} eventName The event name.
-   * @param {ContextEventHandler} contextEventHandler Then context event handler.
+   * Removes the media type parameter using the specified name.
+   *
+   * @param name The name of the media type parameter to delete.
+   * @returns true if the parameter existed and has been removed, or false if the parameter does not exist.
    */
-  constructor(eventName, contextEventHandler) {
-    this.#eventName = eventName;
-    this.#contextEventHandler = contextEventHandler;
+  delete(name) {
+    return super.delete(name.toLowerCase());
   }
   /**
-   * Gets the event name for the subscription.
+   * Returns a string representation of the media type parameters.
    *
-   * @returns {string} The event name.
+   * @returns The string representation of the media type parameters.
    */
-  get eventName() {
-    return this.#eventName;
+  toString() {
+    return Array.from(this).map(([name, value]) => `;${name}=${!value || !httpTokenCodePoints.test(value) ? `"${value.replace(matcher, "\\$1")}"` : value}`).join("");
   }
   /**
-   * Gets the context event handler.
+   * Returns the name of this class.
    *
-   * @returns {ContextEventHandler} The context event handler
+   * @returns The name of this class.
    */
-  get contextEventHandler() {
-    return this.#contextEventHandler;
-  }
   get [Symbol.toStringTag]() {
-    return "Subscription";
+    return "MediaTypeParameters";
   }
 };
-
-// node_modules/.pnpm/@d1g1tal+subscribr@3.0.2/node_modules/@d1g1tal/subscribr/src/subscribr.js
-var Subscribr = class {
-  /** @type {SetMultiMap<string, ContextEventHandler>} */
-  #subscribers;
-  constructor() {
-    this.#subscribers = new SetMultiMap();
+var whitespaceChars = /* @__PURE__ */ new Set([" ", "	", "\n", "\r"]);
+var trailingWhitespace = /[ \t\n\r]+$/u;
+var leadingAndTrailingWhitespace = /^[ \t\n\r]+|[ \t\n\r]+$/ug;
+var MediaTypeParser = class _MediaTypeParser {
+  /**
+   * Function to parse a media type.
+   * @param input The media type to parse
+   * @returns An object populated with the parsed media type properties and any parameters.
+   */
+  static parse(input) {
+    input = input.replace(leadingAndTrailingWhitespace, "");
+    let position = 0;
+    const [type, typeEnd] = _MediaTypeParser.collect(input, position, ["/"]);
+    position = typeEnd;
+    if (!type.length || position >= input.length || !httpTokenCodePoints.test(type)) {
+      throw new TypeError(_MediaTypeParser.generateErrorMessage("type", type));
+    }
+    ++position;
+    const [subtype, subtypeEnd] = _MediaTypeParser.collect(input, position, [";"], true, true);
+    position = subtypeEnd;
+    if (!subtype.length || !httpTokenCodePoints.test(subtype)) {
+      throw new TypeError(_MediaTypeParser.generateErrorMessage("subtype", subtype));
+    }
+    const parameters = new MediaTypeParameters();
+    while (position < input.length) {
+      ++position;
+      while (whitespaceChars.has(input[position])) {
+        ++position;
+      }
+      let name;
+      [name, position] = _MediaTypeParser.collect(input, position, [";", "="], false);
+      if (position >= input.length || input[position] === ";") {
+        continue;
+      }
+      ++position;
+      let value;
+      if (input[position] === '"') {
+        [value, position] = _MediaTypeParser.collectHttpQuotedString(input, position);
+        while (position < input.length && input[position] !== ";") {
+          ++position;
+        }
+      } else {
+        [value, position] = _MediaTypeParser.collect(input, position, [";"], false, true);
+        if (!value) {
+          continue;
+        }
+      }
+      if (name && MediaTypeParameters.isValid(name, value) && !parameters.has(name)) {
+        parameters.set(name, value);
+      }
+    }
+    return { type, subtype, parameters };
   }
   /**
-   * Subscribe to an event
-   *
-   * @param {string} eventName The event name to subscribe to.
-   * @param {function(Event, *): void} eventHandler The event handler to call when the event is published.
-   * @param {*} [context] The context to bind to the event handler.
-   * @returns {Subscription} An object used to check if the subscription still exists and to unsubscribe from the event.
+   * Gets the name of this class.
+   * @returns The string tag of this class.
    */
-  subscribe(eventName, eventHandler, context = eventHandler) {
-    const contextEventHandler = new ContextEventHandler(context, eventHandler);
-    this.#subscribers.set(eventName, contextEventHandler);
-    return new Subscription(eventName, contextEventHandler);
+  get [Symbol.toStringTag]() {
+    return "MediaTypeParser";
   }
   /**
-   * Unsubscribe from the event
-   *
-   * @param {Subscription} subscription The subscription to unsubscribe.
-   * @param {string} subscription.eventName The event name to subscribe to.
-   * @param {ContextEventHandler} subscription.contextEventHandler The event handler to call when the event is published.
-   * @returns {boolean} true if eventListener has been removed successfully. false if the value is not found or if the value is not an object.
+   * Collects characters from `input` starting at `pos` until a stop character is found.
+   * @param input The input string.
+   * @param pos The starting position.
+   * @param stopChars Characters that end collection.
+   * @param lowerCase Whether to ASCII-lowercase the result.
+   * @param trim Whether to strip trailing HTTP whitespace.
+   * @returns A tuple of the collected string and the updated position.
    */
-  unsubscribe({ eventName, contextEventHandler }) {
-    const contextEventHandlers = this.#subscribers.get(eventName);
-    const removed = contextEventHandlers?.delete(contextEventHandler);
-    if (removed && contextEventHandlers.size == 0) {
-      this.#subscribers.delete(eventName);
+  static collect(input, pos, stopChars, lowerCase = true, trim = false) {
+    let result = "";
+    for (const { length } = input; pos < length && !stopChars.includes(input[pos]); pos++) {
+      result += input[pos];
     }
-    return removed;
+    if (lowerCase) {
+      result = result.toLowerCase();
+    }
+    if (trim) {
+      result = result.replace(trailingWhitespace, "");
+    }
+    return [result, pos];
   }
   /**
-   * Publish an event
-   *
-   * @param {string} eventName The name of the event.
-   * @param {Event} [event=new CustomEvent(eventName)] The event to be handled.
-   * @param {*} [data] The value to be passed to the event handler as a parameter.
+   * Collects all the HTTP quoted strings.
+   * This variant only implements it with the extract-value flag set.
+   * @param input The string to process.
+   * @param position The starting position.
+   * @returns An array that includes the resulting string and updated position.
    */
-  publish(eventName, event = new CustomEvent(eventName), data) {
-    if (data == null && !(event instanceof Event)) {
-      [data, event] = [event, new CustomEvent(eventName)];
+  static collectHttpQuotedString(input, position) {
+    let value = "";
+    for (let length = input.length, char; ++position < length; ) {
+      if ((char = input[position]) === '"') {
+        break;
+      }
+      value += char == "\\" && ++position < length ? input[position] : char;
     }
-    this.#subscribers.get(eventName)?.forEach((contextEventHandler) => contextEventHandler.handle(event, data));
+    return [value, position];
   }
   /**
-   * Check if the event and handler are subscribed.
-   *
-   * @param {Subscription} subscription The subscription object.
-   * @param {string} subscription.eventName The name of the event to check.
-   * @param {ContextEventHandler} subscription.contextEventHandler The event handler to check.
-   * @returns {boolean} true if the event name and handler are subscribed, false otherwise.
+   * Generates an error message.
+   * @param component The component name.
+   * @param value The component value.
+   * @returns The error message.
    */
-  isSubscribed({ eventName, contextEventHandler }) {
-    return this.#subscribers.get(eventName)?.has(contextEventHandler);
-  }
-  get [Symbol.toStringTag]() {
-    return "Subscribr";
+  static generateErrorMessage(component, value) {
+    return `Invalid ${component} "${value}": only HTTP token code points are valid.`;
   }
 };
-
-// src/http-request-methods.js
-var HttpRequestMethod = {
+var MediaType = class _MediaType {
+  _type;
+  _subtype;
+  _parameters;
   /**
-   * 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.
+   * Create a new MediaType instance from a string representation.
+   * @param mediaType The media type to parse.
+   * @param parameters Optional parameters.
    */
-  OPTIONS: "OPTIONS",
+  constructor(mediaType, parameters = {}) {
+    if (parameters === null || typeof parameters !== "object" || Array.isArray(parameters)) {
+      throw new TypeError("The parameters argument must be an object");
+    }
+    ({ type: this._type, subtype: this._subtype, parameters: this._parameters } = MediaTypeParser.parse(mediaType));
+    for (const [name, value] of Object.entries(parameters)) {
+      this._parameters.set(name, value);
+    }
+  }
   /**
-   * 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.
+   * Parses a media type string.
+   * @param mediaType The media type to parse.
+   * @returns The parsed media type or null if the mediaType cannot be parsed.
    */
-  GET: "GET",
+  static parse(mediaType) {
+    try {
+      return new _MediaType(mediaType);
+    } catch {
+    }
+    return null;
+  }
   /**
-   * 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.
+   * Gets the type.
+   * @returns The type.
    */
-  HEAD: "HEAD",
+  get type() {
+    return this._type;
+  }
   /**
-   * 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.
+   * Gets the subtype.
+   * @returns The subtype.
    */
-  POST: "POST",
+  get subtype() {
+    return this._subtype;
+  }
   /**
-   * The PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers
-   * to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing
-   * on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being
-   * defined as a new resource by the requesting user agent, the origin server can create the resource with that URI. If
-   * a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. If an
-   * existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate
-   * successful completion of the request. If the resource could not be created or modified with the Request-URI, an
-   * appropriate error response SHOULD be given that reflects the nature of the problem. The recipient of the entity MUST
-   * \NOT ignore any Content-* (e.g. Content-Range) headers that it does not understand or implement and MUST return a
-   * 501 (Not Implemented) response in such cases.
-   *
-   * If the request passes through a cache and the Request-URI identifies one or more currently cached entities, those
-   * entries SHOULD be treated as stale. Responses to this method are not cacheable.
-   *
-   * The fundamental difference between the POST and PUT requests is reflected in the different meaning of the
-   * Request-URI. The URI in a POST request identifies the resource that will handle the enclosed entity. That resource
-   * might be a data-accepting process, a gateway to some other protocol, or a separate entity that accepts annotations.
-   * In contrast, the URI in a PUT request identifies the entity enclosed with the request -- the user agent knows what
-   * URI is intended and the server MUST NOT attempt to apply the request to some other resource. If the server desires
-   * that the request be applied to a different URI, it MUST send a 301 (Moved Permanently) response, the user agent MAY
-   * then make its own decision regarding whether or not to redirect the request.
-   *
-   * A single resource MAY be identified by many different URIs. For example, an article might have a URI for identifying
-   * "the current version" which is separate from the URI identifying each particular version. In this case, a PUT
-   * request on a general URI might result in several other URIs being defined by the origin server.
-   *
-   * HTTP/1.1 does not define how a PUT method affects the state of an origin server.
-   *
-   * PUT requests MUST obey the message transmission requirements set out in section 8.2.
-   *
-   * Unless otherwise specified for a particular entity-header, the entity-headers in the PUT request SHOULD be applied
-   * to the resource created or modified by the PUT.
+   * Gets the media type essence (type/subtype).
+   * @returns The media type without any parameters
    */
-  PUT: "PUT",
+  get essence() {
+    return `${this._type}/${this._subtype}`;
+  }
   /**
-   * The DELETE method requests that the origin server delete the resource identified by the Request-URI. This method MAY
-   * be overridden by human intervention (or other means) on the origin server. The client cannot be guaranteed that the
-   * operation has been carried out, even if the status code returned from the origin server indicates that the action
-   * has been completed successfully. However, the server SHOULD NOT indicate success unless, at the time the response
-   * is given, it intends to delete the resource or move it to an inaccessible location.
-   *
-   * A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 202 (Accepted) if
-   * the action has not yet been enacted, or 204 (No Content) if the action has been enacted but the response does not
-   * include an entity.
-   *
-   * If the request passes through a cache and the Request-URI identifies one or more currently cached entities, those
-   * entries SHOULD be treated as stale. Responses to this method are not cacheable.
+   * Gets the parameters.
+   * @returns The media type parameters.
    */
-  DELETE: "DELETE",
+  get parameters() {
+    return this._parameters;
+  }
   /**
-   * 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.
+   * Checks if the media type matches the specified 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.
+   * @param mediaType The media type to check.
+   * @returns true if the media type matches the specified type, false otherwise.
    */
-  TRACE: "TRACE",
+  matches(mediaType) {
+    return typeof mediaType === "string" ? this.essence.includes(mediaType) : this._type === mediaType._type && this._subtype === mediaType._subtype;
+  }
   /**
-   * 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]).
+   * Gets the serialized version of the media type.
+   *
+   * @returns The serialized media type.
    */
-  CONNECT: "CONNECT",
+  toString() {
+    return `${this.essence}${this._parameters.toString()}`;
+  }
   /**
-   * The PATCH method requests that a set of changes described in the
-   * request entity be applied to the resource identified by the Request-
-   * URI.  The set of changes is represented in a format called a "patch
-   * document" identified by a media type.  If the Request-URI does not
-   * point to an existing resource, the server MAY create a new resource,
-   * depending on the patch document type (whether it can logically modify
-   * a null resource) and permissions, etc.
-   *
-   * The difference between the PUT and PATCH requests is reflected in the
-   * way the server processes the enclosed entity to modify the resource
-   * identified by the Request-URI.  In a PUT request, the enclosed entity
-   * is considered to be a modified version of the resource stored on the
-   * origin server, and the client is requesting that the stored version
-   * be replaced.  With PATCH, however, the enclosed entity contains a set
-   * of instructions describing how a resource currently residing on the
-   * origin server should be modified to produce a new version.  The PATCH
-   * method affects the resource identified by the Request-URI, and it
-   * also MAY have side effects on other resources; i.e., new resources
-   * may be created, or existing ones modified, by the application of a
-   * PATCH.
-   *
-   * PATCH is neither safe nor idempotent as defined by [RFC2616], Section
-   * 9.1.
-   *
-   * A PATCH request can be issued in such a way as to be idempotent,
-   * which also helps prevent bad outcomes from collisions between two
-   * PATCH requests on the same resource in a similar time frame.
-   * Collisions from multiple PATCH requests may be more dangerous than
-   * PUT collisions because some patch formats need to operate from a
-   * known base-point or else they will corrupt the resource.  Clients
-   * using this kind of patch application SHOULD use a conditional request
-   * such that the request will fail if the resource has been updated
-   * since the client last accessed the resource.  For example, the client
-   * can use a strong ETag [RFC2616] in an If-Match header on the PATCH
-   * request.
-   *
-   * There are also cases where patch formats do not need to operate from
-   * a known base-point (e.g., appending text lines to log files, or non-
-   * colliding rows to database tables), in which case the same care in
-   * client requests is not needed.
-   *
-   * The server MUST apply the entire set of changes atomically and never
-   * provide (e.g., in response to a GET during this operation) a
-   * partially modified representation.  If the entire patch document
-   * cannot be successfully applied, then the server MUST NOT apply any of
-   * the changes.  The determination of what constitutes a successful
-   * PATCH can vary depending on the patch document and the type of
-   * resource(s) being modified.  For example, the common 'diff' utility
-   * can generate a patch document that applies to multiple files in a
-   * directory hierarchy.  The atomicity requirement holds for all
-   * directly affected files.  See "Error Handling", Section 2.2, for
-   * details on status codes and possible error conditions.
-   *
-   * If the request passes through a cache and the Request-URI identifies
-   * one or more currently cached entities, those entries SHOULD be
-   * treated as stale.  A response to this method is only cacheable if it
-   * contains explicit freshness information (such as an Expires header or
-   * "Cache-Control: max-age" directive) as well as the Content-Location
-   * header matching the Request-URI, indicating that the PATCH response
-   * body is a resource representation.  A cached PATCH response can only
-   * be used to respond to subsequent GET and HEAD requests; it MUST NOT
-   * be used to respond to other methods (in particular, PATCH).
-   *
-   * Note that entity-headers contained in the request apply only to the
-   * contained patch document and MUST NOT be applied to the resource
-   * being modified.  Thus, a Content-Language header could be present on
-   * the request, but it would only mean (for whatever that's worth) that
-   * the patch document had a language.  Servers SHOULD NOT store such
-   * headers except as trace information, and SHOULD NOT use such header
-   * values the same way they might be used on PUT requests.  Therefore,
-   * this document does not specify a way to modify a document's Content-
-   * Type or Content-Language value through headers, though a mechanism
-   * could well be designed to achieve this goal through a patch document.
-   *
-   * There is no guarantee that a resource can be modified with PATCH.
-   * Further, it is expected that different patch document formats will be
-   * appropriate for different types of resources and that no single
-   * format will be appropriate for all types of resources.  Therefore,
-   * there is no single default patch document format that implementations
-   * are required to support.  Servers MUST ensure that a received patch
-   * document is appropriate for the type of resource identified by the
-   * Request-URI.
-   *
-   * Clients need to choose when to use PATCH rather than PUT.  For
-   * example, if the patch document size is larger than the size of the
-   * new resource data that would be used in a PUT, then it might make
-   * sense to use PUT instead of PATCH.  A comparison to POST is even more
-   * difficult, because POST is used in widely varying ways and can
-   * encompass PUT and PATCH-like operations if the server chooses.  If
-   * the operation does not modify the resource identified by the Request-
-   * URI in a predictable way, POST should be considered instead of PATCH
-   * or PUT.
+   * Gets the name of the class.
+   * @returns The class name
    */
-  PATCH: "PATCH"
+  get [Symbol.toStringTag]() {
+    return "MediaType";
+  }
 };
-var http_request_methods_default = HttpRequestMethod;
 
-// src/response-status.js
-var ResponseStatus = class {
-  /** @type {number} */
-  #code;
-  /** @type {string} */
-  #text;
+// node_modules/.pnpm/@d1g1tal+subscribr@4.1.8_typescript@5.9.3/node_modules/@d1g1tal/subscribr/dist/subscribr.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 {number} code The status code from the {@link Response}
-   * @param {string} text The status text from the {@link Response}
+   * @param key The key to set.
+   * @param value The value to add to the SetMultiMap
+   * @returns The SetMultiMap with the updated key and value.
    */
-  constructor(code, text) {
-    this.#code = code;
-    this.#text = text;
+  set(key, value) {
+    super.set(key, value instanceof Set ? value : (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
+    return this;
   }
   /**
-   * Returns the status code from the {@link Response}
-   *
-   * @returns {number} The status code.
+   * Finds a specific value for a specific key using an iterator function.
+   * @param key The key to find the value for.
+   * @param iterator The iterator function to use to find the value.
+   * @returns The value for the specified key
    */
-  get code() {
-    return this.#code;
+  find(key, iterator) {
+    const values = this.get(key);
+    if (values !== void 0) {
+      return Array.from(values).find(iterator);
+    }
+    return void 0;
   }
   /**
-   * Returns the status text from the {@link Response}.
+   * Checks if a specific key has a specific value.
    *
-   * @returns {string} The status text.
+   * @param key The key to check.
+   * @param value The value to check.
+   * @returns True if the key has the value, false otherwise.
    */
-  get text() {
-    return this.#text;
+  hasValue(key, value) {
+    const values = super.get(key);
+    return values ? values.has(value) : false;
   }
   /**
-   * 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.
+   * Removes a specific value from a specific key.
+   * @param key The key to remove the value from.
+   * @param value The value to remove.
+   * @returns True if the value was removed, false otherwise.
+   */
+  deleteValue(key, value) {
+    if (value === void 0) {
+      return this.delete(key);
+    }
+    const values = super.get(key);
+    if (values) {
+      const deleted = values.delete(value);
+      if (values.size === 0) {
+        super.delete(key);
+      }
+      return deleted;
+    }
+    return false;
+  }
+  /**
+   * The string tag of the SetMultiMap.
+   * @returns The string tag of the SetMultiMap.
    */
   get [Symbol.toStringTag]() {
-    return "ResponseStatus";
+    return "SetMultiMap";
   }
+};
+var ContextEventHandler = class {
+  context;
+  eventHandler;
   /**
-   * tostring method for the class.
+   * @param context The context to bind to the event handler.
+   * @param eventHandler The event handler to call when the event is published.
+   */
+  constructor(context, eventHandler) {
+    this.context = context;
+    this.eventHandler = eventHandler;
+  }
+  /**
+   * Call the event handler for the provided event.
    *
-   * @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.
+   * @param event The event to handle
+   * @param data The value to be passed to the event handler as a parameter.
    */
-  toString() {
-    return `${this.#code} ${this.#text}`;
+  handle(event, data) {
+    this.eventHandler.call(this.context, event, data);
   }
-};
-
-// node_modules/.pnpm/@d1g1tal+chrysalis@2.2.0/node_modules/@d1g1tal/chrysalis/src/esm/object-type.js
-var _type = (object) => object?.constructor ?? object?.prototype?.constructor ?? globalThis[Object.prototype.toString.call(object).slice(8, -1)] ?? object;
-var object_type_default = _type;
-
-// node_modules/.pnpm/@d1g1tal+chrysalis@2.2.0/node_modules/@d1g1tal/chrysalis/src/esm/object-merge.js
-var _objectMerge = (...objects) => {
-  const target = {};
-  for (const source of objects) {
-    if (object_type_default(source) != Object)
-      return void 0;
-    let descriptor, sourceType;
-    for (const property of Object.getOwnPropertyNames(source)) {
-      descriptor = Object.getOwnPropertyDescriptor(source, property);
-      if (descriptor.enumerable) {
-        sourceType = object_type_default(source[property]);
-        if (sourceType == Object) {
-          descriptor.value = object_type_default(target[property]) == Object ? _objectMerge(target[property], source[property]) : { ...source[property] };
-        } else if (sourceType == Array) {
-          descriptor.value = Array.isArray(target[property]) ? [.../* @__PURE__ */ new Set([...source[property], ...target[property]])] : [...source[property]];
-        }
-        target[property] = descriptor.value;
-      }
-    }
+  /**
+   * A String value that is used in the creation of the default string
+   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
+   *
+   * @returns The default string description of this object.
+   */
+  get [Symbol.toStringTag]() {
+    return "ContextEventHandler";
   }
-  return target;
-};
-var object_merge_default = _objectMerge;
-
-// node_modules/.pnpm/@d1g1tal+media-type@5.0.0/node_modules/@d1g1tal/media-type/src/utils.js
-var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
-var utils_default = httpTokenCodePoints;
-
-// node_modules/.pnpm/@d1g1tal+media-type@5.0.0/node_modules/@d1g1tal/media-type/src/media-type-parameters.js
-var matcher = /(["\\])/ug;
-var httpQuotedStringTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
-var MediaTypeParameters = class _MediaTypeParameters extends Map {
+};
+var Subscription = class {
+  _eventName;
+  _contextEventHandler;
   /**
-   * Create a new MediaTypeParameters instance.
-   *
-   * @param {Array<[string, string]>} entries An array of [name, value] tuples.
+   * @param eventName The event name.
+   * @param contextEventHandler The context event handler.
    */
-  constructor(entries = []) {
-    super(entries);
+  constructor(eventName, contextEventHandler) {
+    this._eventName = eventName;
+    this._contextEventHandler = contextEventHandler;
   }
   /**
-   * Indicates whether the supplied name and value are valid media type parameters.
+   * Gets the event name for the subscription.
    *
-   * @static
-   * @param {string} name The name of the media type parameter to validate.
-   * @param {string} value The media type parameter value to validate.
-   * @returns {boolean} true if the media type parameter is valid, false otherwise.
+   * @returns The event name.
    */
-  static isValid(name, value) {
-    return utils_default.test(name) && httpQuotedStringTokenCodePoints.test(value);
+  get eventName() {
+    return this._eventName;
   }
   /**
-   * Gets the media type parameter value for the supplied name.
+   * Gets the context event handler.
    *
-   * @param {string} name The name of the media type parameter to retrieve.
-   * @returns {string} The media type parameter value.
+   * @returns The context event handler
    */
-  get(name) {
-    return super.get(name.toLowerCase());
+  get contextEventHandler() {
+    return this._contextEventHandler;
   }
   /**
-   * Indicates whether the media type parameter with the specified name exists or not.
+   * 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}.
    *
-   * @param {string} name The name of the media type parameter to check.
-   * @returns {boolean} true if the media type parameter exists, false otherwise.
+   * @returns The default string description of this object.
    */
-  has(name) {
-    return super.has(name.toLowerCase());
+  get [Symbol.toStringTag]() {
+    return "Subscription";
   }
+};
+var Subscribr = class {
+  subscribers = new SetMultiMap();
+  errorHandler;
   /**
-   * 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.
+   * Set a custom error handler for handling errors that occur in event listeners.
+   * If not set, errors will be logged to the console.
    *
-   * @param {string} name The name of the media type parameter to set.
-   * @param {string} value The media type parameter value.
-   * @returns {MediaTypeParameters} This instance.
+   * @param errorHandler The error handler function to call when an error occurs in an event listener.
    */
-  set(name, value) {
-    if (!_MediaTypeParameters.isValid(name, value)) {
-      throw new Error(`Invalid media type parameter name/value: ${name}/${value}`);
-    }
-    super.set(name.toLowerCase(), value);
-    return this;
+  setErrorHandler(errorHandler) {
+    this.errorHandler = errorHandler;
   }
   /**
-   * Removes the media type parameter using the specified name.
+   * Subscribe to an event
    *
-   * @param {string} name The name of the media type parameter to delete.
-   * @returns {boolean} true if the parameter existed and has been removed, or false if the parameter does not exist.
-   */
-  delete(name) {
-    return super.delete(name.toLowerCase());
+   * @param eventName The event name to subscribe to.
+   * @param eventHandler The event handler to call when the event is published.
+   * @param context The context to bind to the event handler.
+   * @param options Subscription options.
+   * @returns An object used to check if the subscription still exists and to unsubscribe from the event.
+   */
+  subscribe(eventName, eventHandler, context = eventHandler, options) {
+    this.validateEventName(eventName);
+    if (options?.once) {
+      const originalHandler = eventHandler;
+      eventHandler = (event, data) => {
+        originalHandler.call(context, event, data);
+        this.unsubscribe(subscription);
+      };
+    }
+    const contextEventHandler = new ContextEventHandler(context, eventHandler);
+    this.subscribers.set(eventName, contextEventHandler);
+    const subscription = new Subscription(eventName, contextEventHandler);
+    return subscription;
   }
   /**
-   * Returns a string representation of the media type parameters.
+   * Unsubscribe from the event
    *
-   * @override
-   * @returns {string} The string representation of the media type parameters.
+   * @param subscription The subscription to unsubscribe.
+   * @returns true if eventListener has been removed successfully. false if the value is not found or if the value is not an object.
    */
-  toString() {
-    return Array.from(this).map(([name, value]) => `;${name}=${!value || !utils_default.test(value) ? `"${value.replace(matcher, "\\$1")}"` : value}`).join("");
+  unsubscribe({ eventName, contextEventHandler }) {
+    const contextEventHandlers = this.subscribers.get(eventName) ?? /* @__PURE__ */ new Set();
+    const removed = contextEventHandlers.delete(contextEventHandler);
+    if (removed && contextEventHandlers.size === 0) {
+      this.subscribers.delete(eventName);
+    }
+    return removed;
   }
   /**
-   * Returns the name of this class.
+   * Publish an event
    *
-   * @override
-   * @returns {string} The name of this class.
+   * @template T
+   * @param eventName The name of the event.
+   * @param event The event to be handled.
+   * @param data The value to be passed to the event handler as a parameter.
    */
-  [Symbol.toStringTag]() {
-    return "MediaTypeParameters";
+  publish(eventName, event = new CustomEvent(eventName), data) {
+    this.validateEventName(eventName);
+    this.subscribers.get(eventName)?.forEach((contextEventHandler) => {
+      try {
+        contextEventHandler.handle(event, data);
+      } catch (error) {
+        if (this.errorHandler) {
+          this.errorHandler(error, eventName, event, data);
+        } else {
+          console.error(`Error in event handler for '${eventName}':`, error);
+        }
+      }
+    });
   }
-};
-
-// node_modules/.pnpm/@d1g1tal+media-type@5.0.0/node_modules/@d1g1tal/media-type/src/media-type-parser.js
-var whitespaceCharacters = [" ", "	", "\n", "\r"];
-var trailingWhitespace = /[ \t\n\r]+$/u;
-var leadingAndTrailingWhitespace = /^[ \t\n\r]+|[ \t\n\r]+$/ug;
-var MediaTypeParser = class _MediaTypeParser {
   /**
-   * Function to parse a media type.
+   * Check if the event and handler are subscribed.
    *
-   * @static
-   * @param {string} input The media type to parse
-   * @returns {{ type: string, subtype: string, parameters: MediaTypeParameters }} An object populated with the parsed media type properties and any parameters.
+   * @param subscription The subscription object.
+   * @returns true if the event name and handler are subscribed, false otherwise.
    */
-  static parse(input) {
-    input = input.replace(leadingAndTrailingWhitespace, "");
-    const length = input.length, trim = true, lowerCase = false;
-    let { position, result: type, subtype = "" } = _MediaTypeParser.#filterComponent({ input }, "/");
-    if (!type.length || position >= length || !utils_default.test(type)) {
-      throw new TypeError(_MediaTypeParser.#generateErrorMessage("type", type));
-    }
-    ({ position, result: subtype } = _MediaTypeParser.#filterComponent({ position: ++position, input, trim }, ";"));
-    if (!subtype.length || !utils_default.test(subtype)) {
-      throw new TypeError(_MediaTypeParser.#generateErrorMessage("subtype", subtype));
-    }
-    let parameterName = "", parameterValue = null;
-    const parameters = new MediaTypeParameters();
-    while (position++ < length) {
-      while (whitespaceCharacters.includes(input[position])) {
-        ++position;
-      }
-      ({ position, result: parameterName } = _MediaTypeParser.#filterComponent({ position, input, lowerCase }, ";", "="));
-      if (position < length) {
-        if (input[position] == ";") {
-          continue;
-        }
-        ++position;
-      }
-      if (input[position] == '"') {
-        [parameterValue, position] = _MediaTypeParser.#collectHttpQuotedString(input, position);
-        while (position < length && input[position] != ";") {
-          ++position;
-        }
-      } else {
-        ({ position, result: parameterValue } = _MediaTypeParser.#filterComponent({ position, input, lowerCase, trim }, ";"));
-        if (!parameterValue) {
-          continue;
-        }
-      }
-      if (parameterName && MediaTypeParameters.isValid(parameterName, parameterValue) && !parameters.has(parameterName)) {
-        parameters.set(parameterName, parameterValue);
-      }
-    }
-    return { type, subtype, parameters };
+  isSubscribed({ eventName, contextEventHandler }) {
+    return this.subscribers.get(eventName)?.has(contextEventHandler) ?? false;
   }
   /**
-   * Filters a component from the input string.
+   * Validate the event name
    *
-   * @private
-   * @static
-   * @param {Object} options The options.
-   * @param {number} [options.position] The starting position.
-   * @param {string} options.input The input string.
-   * @param {boolean} [options.lowerCase] Indicates whether the result should be lowercased.
-   * @param {boolean} [options.trim] Indicates whether the result should be trimmed.
-   * @param {string[]} charactersToFilter The characters to filter.
-   * @returns {{ position: number, result: string }} An object that includes the resulting string and updated position.
+   * @param eventName The event name to validate.
+   * @throws {TypeError} If the event name is not a non-empty string.
+   * @throws {Error} If the event name has leading or trailing whitespace.
    */
-  static #filterComponent({ position = 0, input, lowerCase = true, trim = false }, ...charactersToFilter) {
-    let result = "";
-    for (const length = input.length; position < length && !charactersToFilter.includes(input[position]); position++) {
-      result += input[position];
-    }
-    if (lowerCase) {
-      result = result.toLowerCase();
+  validateEventName(eventName) {
+    if (!eventName || typeof eventName !== "string") {
+      throw new TypeError("Event name must be a non-empty string");
     }
-    if (trim) {
-      result = result.replace(trailingWhitespace, "");
+    if (eventName.trim() !== eventName) {
+      throw new Error("Event name cannot have leading or trailing whitespace");
     }
-    return { position, result };
   }
   /**
-   * Collects all the HTTP quoted strings.
-   * This variant only implements it with the extract-value flag set.
-   *
-   * @private
-   * @static
-   * @param {string} input The string to process.
-   * @param {number} position The starting position.
-   * @returns {Array<string|number>} An array that includes the resulting string and updated position.
+   * Clears all subscriptions. The instance should not be used after calling this method.
    */
-  static #collectHttpQuotedString(input, position) {
-    let value = "";
-    for (let length = input.length, char; ++position < length; ) {
-      if ((char = input[position]) == '"') {
-        break;
-      }
-      value += char == "\\" && ++position < length ? input[position] : char;
-    }
-    return [value, position];
+  destroy() {
+    this.subscribers.clear();
   }
   /**
-   * Generates an error message.
+   * 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}.
    *
-   * @private
-   * @static
-   * @param {string} component The component name.
-   * @param {string} value The component value.
-   * @returns {string} The error message.
+   * @returns The default string description of this object.
    */
-  static #generateErrorMessage(component, value) {
-    return `Invalid ${component} "${value}": only HTTP token code points are valid.`;
+  get [Symbol.toStringTag]() {
+    return "Subscribr";
   }
 };
 
-// node_modules/.pnpm/@d1g1tal+media-type@5.0.0/node_modules/@d1g1tal/media-type/src/media-type.js
-var MediaType = class _MediaType {
-  /** @type {string} */
-  #type;
-  /** @type {string} */
-  #subtype;
-  /** @type {MediaTypeParameters} */
-  #parameters;
+// src/http-error.ts
+var HttpError = class extends Error {
+  _entity;
+  responseStatus;
+  _url;
+  _method;
+  _timing;
   /**
-   * Create a new MediaType instance from a string representation.
-   *
-   * @param {string} mediaType The media type to parse.
-   * @param {Object} [parameters] Optional parameters.
+   * Creates an instance of HttpError.
+   * @param status The status code and status text of the {@link Response}.
+   * @param httpErrorOptions The http error options.
    */
-  constructor(mediaType, parameters = {}) {
-    if (object_type_default(parameters) != Object) {
-      throw new TypeError("The parameters argument must be an object");
-    }
-    ({ type: this.#type, subtype: this.#subtype, parameters: this.#parameters } = MediaTypeParser.parse(mediaType));
-    for (const [name, value] of Object.entries(parameters)) {
-      this.#parameters.set(name, value);
-    }
+  constructor(status, { message, cause, entity, url, method, timing } = {}) {
+    super(message, { cause });
+    this._entity = entity;
+    this.responseStatus = status;
+    this._url = url;
+    this._method = method;
+    this._timing = timing;
   }
-  static parse(mediaType) {
-    try {
-      return new _MediaType(mediaType);
-    } catch (e) {
-    }
-    return null;
+  /**
+   * It returns the value of the private variable #entity.
+   * @returns The entity property of the class.
+   */
+  get entity() {
+    return this._entity;
   }
   /**
-   * Gets the type.
-   *
-   * @returns {string} The type.
+   * It returns the status code of the {@link Response}.
+   * @returns The status code of the {@link Response}.
    */
-  get type() {
-    return this.#type;
+  get statusCode() {
+    return this.responseStatus.code;
   }
   /**
-   * Gets the subtype.
-   *
-   * @returns {string} The subtype.
+   * It returns the status text of the {@link Response}.
+   * @returns The status code and status text of the {@link Response}.
    */
-  get subtype() {
-    return this.#subtype;
+  get statusText() {
+    return this.responseStatus?.text;
   }
   /**
-   * Gets the media type essence (type/subtype).
-   *
-   * @returns {string} The media type without any parameters
+   * The request URL that caused the error.
+   * @returns The URL or undefined.
    */
-  get essence() {
-    return `${this.#type}/${this.#subtype}`;
+  get url() {
+    return this._url;
   }
   /**
-   * Gets the parameters.
-   *
-   * @returns {MediaTypeParameters} The media type parameters.
+   * The HTTP method that was used for the failed request.
+   * @returns The method string or undefined.
    */
-  get parameters() {
-    return this.#parameters;
+  get method() {
+    return this._method;
   }
   /**
-   * Checks if the media type matches the specified type.
-   *
-   * @todo Fix string handling to parse the type and subtype from the string.
-   * @param {MediaType|string} type The media type to check.
-   * @returns {boolean} true if the media type matches the specified type, false otherwise.
+   * Timing information for the failed request.
+   * @returns The timing object or undefined.
    */
-  matches(type) {
-    return this.#type == type?.type && this.#subtype == type?.subtype || this.essence.includes(type);
+  get timing() {
+    return this._timing;
   }
   /**
-   * Gets the serialized version of the media type.
-   *
-   * @returns {string} The serialized media type.
+   * A String value representing the name of the error.
+   * @returns The name of the error.
    */
-  toString() {
-    return `${this.essence}${this.#parameters.toString()}`;
+  get name() {
+    return "HttpError";
   }
   /**
-   * Gets the name of the class.
-   *
-   * @returns {string} The class name
+   * A String value that is used in the creation of the default string
+   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
+   * @returns The default string description of this object.
    */
   get [Symbol.toStringTag]() {
-    return "MediaType";
+    return this.name;
   }
 };
 
-// src/http-media-type.js
+// src/http-media-type.ts
 var HttpMediaType = {
   /** Advanced Audio Coding (AAC) */
   AAC: "audio/aac",
@@ -967,204 +753,8 @@ var HttpMediaType = {
   /** 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 {
-  /** @type {AbortController} */
-  #abortController;
-  /** @type {number} */
-  #timeoutId;
-  /**
-   * @param {NativeAbortSignal} signal The signal to chain.
-   * This signal will be able to abort the request, but will not be notified if the request is aborted by the timeout.
-   */
-  constructor(signal) {
-    this.#abortController = new AbortController();
-    signal?.addEventListener(SignalEvents.ABORT, (event) => this.#abort(event));
-  }
-  /**
-   * The aborted property is a Boolean that indicates whether the request has been aborted (true) or not (false).
-   *
-   * @returns {boolean} Whether the signal was aborted or not
-   */
-  get aborted() {
-    return this.#abortController.signal.aborted;
-  }
-  /**
-   * The reason property returns a DOMException object indicating the reason the operation was aborted, or null if the operation is not aborted.
-   *
-   * @returns {DOMException} The reason the signal was aborted
-   */
-  get reason() {
-    return this.#abortController.signal.reason;
-  }
-  /**
-   * Returns an AbortSignal instance that will be aborted when the provided amount of milliseconds have passed.
-   * A value of {@link Infinity} means there is no timeout.
-   * Note: You can't set this property to a value less than 0.
-   *
-   * @param {number} timeout The timeout in milliseconds
-   * @returns {AbortSignal} The abort signal
-   */
-  timeout(timeout) {
-    if (timeout < 0) {
-      throw new RangeError("The timeout cannot be negative");
-    }
-    if (timeout != Infinity) {
-      this.#timeoutId ??= setTimeout(() => this.#abort(new CustomEvent(SignalEvents.TIMEOUT, { detail: { timeout, cause: new DOMException(`The request timed-out after ${timeout / 1e3} seconds`, "TimeoutError") } }), true), timeout);
-    }
-    return this.#abortController.signal;
-  }
-  /**
-   * Clears the timeout.
-   * Note: This does not abort the signal, dispatch the timeout event, or reset the timeout.
-   *
-   * @returns {void}
-   */
-  clearTimeout() {
-    clearTimeout(this.#timeoutId);
-  }
-  /**
-   * Adds an event listener for the 'abort' event.
-   *
-   * @param {EventListener} listener The listener to add
-   * @returns {AbortSignal} The AbortSignal
-   */
-  onAbort(listener) {
-    this.#abortController.signal.addEventListener(SignalEvents.ABORT, listener);
-    return this;
-  }
-  /**
-   * Adds an event listener for the 'timeout' event.
-   *
-   * @param {EventListener} listener The listener to add
-   * @returns {AbortSignal} The AbortSignal
-   */
-  onTimeout(listener) {
-    this.#abortController.signal.addEventListener(SignalEvents.TIMEOUT, listener);
-    return this;
-  }
-  /**
-   * Aborts the signal. This is so naughty. ¯\_(ツ)_/¯
-   *
-   * @param {Event} event The event to abort with
-   * @returns {void}
-   */
-  abort(event) {
-    this.#abort(event);
-  }
-  /**
-   * Aborts the signal.
-   *
-   * @private
-   * @param {Event} event The event to abort with
-   * @param {boolean} [dispatchEvent = false] Whether to dispatch the event or not
-   * @returns {void}
-   * @fires SignalEvents.ABORT When the signal is aborted
-   * @fires SignalEvents.TIMEOUT When the signal times out
-   */
-  #abort(event = _abortEvent, dispatchEvent = false) {
-    clearTimeout(this.#timeoutId);
-    this.#abortController.abort(event.detail?.cause);
-    if (dispatchEvent) {
-      this.#abortController.signal.dispatchEvent(event);
-    }
-  }
-};
-
-// src/http-error.js
-var HttpError = class extends Error {
-  /** @type {ResponseBody} */
-  #entity;
-  /** @type {ResponseStatus} */
-  #responseStatus;
-  /**
-   * @param {string} [message] The error message.
-   * @param {HttpErrorOptions} [httpErrorOptions] The http error options.
-   * @param {any} [httpErrorOptions.cause] The cause of the error.
-   * @param {ResponseStatus} [httpErrorOptions.status] The response status.
-   * @param {ResponseBody} [httpErrorOptions.entity] The error entity from the server, if any.
-   */
-  constructor(message, { cause, status, entity }) {
-    super(message, { cause });
-    this.#entity = entity;
-    this.#responseStatus = status;
-  }
-  /**
-   * It returns the value of the private variable #entity.
-   *
-   * @returns {ResponseBody} The entity property of the class.
-   */
-  get entity() {
-    return this.#entity;
-  }
-  /**
-   * It returns the status code of the {@link Response}.
-   *
-   * @returns {number} The status code of the {@link Response}.
-   */
-  get statusCode() {
-    return this.#responseStatus?.code;
-  }
-  /**
-   * It returns the status text of the {@link Response}.
-   *
-   * @returns {string} The status code and status text of the {@link Response}.
-   */
-  get statusText() {
-    return this.#responseStatus?.text;
-  }
-  get name() {
-    return "HttpError";
-  }
-  /**
-   * A String value that is used in the creation of the default string
-   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
-   *
-   * @returns {string} The default string description of this object.
-   */
-  get [Symbol.toStringTag]() {
-    return "HttpError";
-  }
-};
 
-// src/http-request-headers.js
+// src/http-request-headers.ts
 var HttpRequestHeader = {
   /**
    * Content-Types that are acceptable for the response. See Content negotiation. Permanent.
@@ -1245,26 +835,12 @@ var HttpRequestHeader = {
   CONTENT_TYPE: "content-type",
   /**
    * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231 Date/Time Formats).
-   * Permanent.
-   *
-   * @example
-   * <code>Date: Tue, 15 Nov 1994 08:12:31 GMT</code>
-   */
-  DATE: "date",
-  /**
-   * Indicates that particular server behaviors are required by the client. Permanent.
-   *
-   * @example
-   * <code>Expect: 100-continue</code>
-   */
-  EXPECT: "expect",
-  /**
-   * The email address of the user making the request. Permanent.
+   * Permanent.
    *
    * @example
-   * <code>From: user@example.com</code>
+   * <code>Date: Tue, 15 Nov 1994 08:12:31 GMT</code>
    */
-  FROM: "from",
+  DATE: "date",
   /**
    * 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
@@ -1380,13 +956,6 @@ var HttpRequestHeader = {
    * <code>Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11</code>
    */
   UPGRADE: "upgrade",
-  /**
-   * Informs the server of proxies through which the request was sent. Permanent.
-   *
-   * @example
-   * <code>Via: 1.0 fred, 1.1 example.com (Apache/1.1)</code>
-   */
-  VIA: "via",
   /**
    * A general warning about possible problems with the entity body. Permanent.
    *
@@ -1401,16 +970,6 @@ var HttpRequestHeader = {
    * <code>X-Requested-With: XMLHttpRequest</code>
    */
   X_REQUESTED_WITH: "x-requested-with",
-  /**
-   * Requests a web application to disable their tracking of a user. This is Mozilla's version of the X-Do-Not-Track
-   * header field (since Firefox 4.0 Beta 11). Safari and IE9 also have support for this field. On March 7, 2011, a
-   * draft proposal was submitted to IETF. The W3C Tracking Protection Working Group is producing a specification.
-   *
-   * @example
-   * <code>DNT: 1 (Do Not Track Enabled)</code>
-   * <code>DNT: 0 (Do Not Track Disabled)</code>
-   */
-  DNT: "dnt",
   /**
    * A de facto standard for identifying the originating IP address of a client connecting to a web server through an
    * HTTP proxy or load balancer.
@@ -1438,40 +997,281 @@ var HttpRequestHeader = {
    * @example
    * <code>X-Forwarded-Proto: https</code>
    */
-  X_FORWARDED_PROTO: "x-forwarded-proto",
+  X_FORWARDED_PROTO: "x-forwarded-proto"
+};
+
+// src/http-request-methods.ts
+var HttpRequestMethod = {
   /**
-   * Non-standard header field used by Microsoft applications and load-balancers.
+   * 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.
    *
-   * @example
-   * <code>Front-End-Https: on</code>
+   * Responses to this method are not cacheable.
+   *
+   * If the OPTIONS request includes an entity-body (as indicated by the presence of Content-Length or
+   * Transfer-Encoding), then the media type MUST be indicated by a Content-Type field. Although this specification does
+   * not define any use for such a body, future extensions to HTTP might use the OPTIONS body to make more detailed
+   * queries on the server. A server that does not support such an extension MAY discard the request body.
+   *
+   * If the Request-URI is an asterisk ("*"), the OPTIONS request is intended to apply to the server in general rather
+   * than to a specific resource. Since a server's communication options typically depend on the resource, the "*"
+   * request is only useful as a "ping" or "no-op" type of method, it does nothing beyond allowing the client to test the
+   * capabilities of the server. For example, this can be used to test a proxy for HTTP/1.1 compliance (or lack thereof).
+   *
+   * If the Request-URI is not an asterisk, the OPTIONS request applies only to the options that are available when
+   * communicating with that resource.
+   *
+   * A 200 response SHOULD include any header fields that indicate optional features implemented by the server and
+   * applicable to that resource (e.g., Allow), possibly including extensions not defined by this specification. The
+   * response body, if any, SHOULD also include information about the communication options. The format for such a body
+   * is not defined by this specification, but might be defined by future extensions to HTTP. Content negotiation MAY be
+   * used to select the appropriate response format. If no response body is included, the response MUST include a
+   * Content-Length field with a field-value of "0".
+   *
+   * The Max-Forwards request-header field MAY be used to target a specific proxy in the request chain. When a proxy
+   * receives an OPTIONS request on an absoluteURI for which request forwarding is permitted, the proxy MUST check for a
+   * Max-Forwards field. If the Max-Forwards field-value is zero ("0"), the proxy MUST NOT forward the message, instead,
+   * the proxy SHOULD respond with its own communication options. If the Max-Forwards field-value is an integer greater
+   * than zero, the proxy MUST decrement the field-value when it forwards the request. If no Max-Forwards field is
+   * present in the request, then the forwarded request MUST NOT include a Max-Forwards field.
+   */
+  OPTIONS: "OPTIONS",
+  /**
+   * The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI. If
+   * the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity in
+   * the response and not the source text of the process, unless that text happens to be the output of the process.
+   *
+   * The semantics of the GET method change to a "conditional GET" if the request message includes an If-Modified-Since;
+   * If-Unmodified-Since, If-Match, If-None-Match, or If-Range header field. A conditional GET method requests that the
+   * entity be transferred only under the circumstances described by the conditional header field(s). The conditional GET
+   * method is intended to reduce unnecessary network usage by allowing cached entities to be refreshed without requiring
+   * multiple requests or transferring data already held by the client.
+   *
+   * The semantics of the GET method change to a "partial GET" if the request message includes a Range header field. A
+   * partial GET requests that only part of the entity be transferred, as described in section 14.35. The partial GET
+   * method is intended to reduce unnecessary network usage by allowing partially-retrieved entities to be completed
+   * without transferring data already held by the client.
+   *
+   * The response to a GET request is cacheable if and only if it meets the requirements for HTTP caching described in
+   * section 13.
+   *
+   * See section 15.1.3 for security considerations when used for forms.
+   */
+  GET: "GET",
+  /**
+   * The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. The
+   * meta information contained in the HTTP headers in response to a HEAD request SHOULD be identical to the information
+   * sent in response to a GET request. This method can be used for obtaining meta information about the entity implied by
+   * the request without transferring the entity-body itself. This method is often used for testing hypertext links for
+   * validity, accessibility, and recent modification.
+   *
+   * The response to a HEAD request MAY be cacheable in the sense that the information contained in the response MAY be
+   * used to update a previously cached entity from that resource. If the new field values indicate that the cached
+   * entity differs from the current entity (as would be indicated by a change in Content-Length, Content-MD5, ETag or
+   * Last-Modified), then the cache MUST treat the cache entry as stale.
+   */
+  HEAD: "HEAD",
+  /**
+   * The POST method is used to request that the origin server accept the entity enclosed in the request as a new
+   * subordinate of the resource identified by the Request-URI in the Request-Line. POST is designed to allow a uniform
+   * method to cover the following functions:
+   * <ul>
+   *     <li>Annotation of existing resources,</li>
+   *     <li>Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles,</li>
+   *     <li>Providing a block of data, such as the result of submitting a form, to a data-handling process,</li>
+   *     <li>Extending a database through an append operation.</li>
+   * </ul>
+   *
+   * The actual function performed by the POST method is determined by the server and is usually dependent on the
+   * Request-URI. The posted entity is subordinate to that URI in the same way that a file is subordinate to a directory
+   * containing it, a news article is subordinate to a newsgroup to which it is posted, or a record is subordinate to a
+   * database.
+   *
+   * The action performed by the POST method might not result in a resource that can be identified by a URI. In this
+   * case, either 200 (OK) or 204 (No Content) is the appropriate response status, depending on whether or not the
+   * response includes an entity that describes the result.
+   *
+   * If a resource has been created on the origin server, the response SHOULD be 201 (Created) and contain an entity
+   * which describes the status of the request and refers to the new resource, and a Location header (see section 14.30).
+   *
+   * Responses to this method are not cacheable, unless the response includes appropriate Cache-Control or Expires header
+   * fields. However, the 303 (See Other) response can be used to direct the user agent to retrieve a cacheable resource.
+   *
+   * POST requests MUST obey the message transmission requirements set out in section 8.2.
+   *
+   * See section 15.1.3 for security considerations.
+   */
+  POST: "POST",
+  /**
+   * The PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers
+   * to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing
+   * on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being
+   * defined as a new resource by the requesting user agent, the origin server can create the resource with that URI. If
+   * a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. If an
+   * existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate
+   * successful completion of the request. If the resource could not be created or modified with the Request-URI, an
+   * appropriate error response SHOULD be given that reflects the nature of the problem. The recipient of the entity MUST
+   * \NOT ignore any Content-* (e.g. Content-Range) headers that it does not understand or implement and MUST return a
+   * 501 (Not Implemented) response in such cases.
+   *
+   * If the request passes through a cache and the Request-URI identifies one or more currently cached entities, those
+   * entries SHOULD be treated as stale. Responses to this method are not cacheable.
+   *
+   * The fundamental difference between the POST and PUT requests is reflected in the different meaning of the
+   * Request-URI. The URI in a POST request identifies the resource that will handle the enclosed entity. That resource
+   * might be a data-accepting process, a gateway to some other protocol, or a separate entity that accepts annotations.
+   * In contrast, the URI in a PUT request identifies the entity enclosed with the request -- the user agent knows what
+   * URI is intended and the server MUST NOT attempt to apply the request to some other resource. If the server desires
+   * that the request be applied to a different URI, it MUST send a 301 (Moved Permanently) response, the user agent MAY
+   * then make its own decision regarding whether or not to redirect the request.
+   *
+   * A single resource MAY be identified by many different URIs. For example, an article might have a URI for identifying
+   * "the current version" which is separate from the URI identifying each particular version. In this case, a PUT
+   * request on a general URI might result in several other URIs being defined by the origin server.
+   *
+   * HTTP/1.1 does not define how a PUT method affects the state of an origin server.
+   *
+   * PUT requests MUST obey the message transmission requirements set out in section 8.2.
+   *
+   * Unless otherwise specified for a particular entity-header, the entity-headers in the PUT request SHOULD be applied
+   * to the resource created or modified by the PUT.
+   */
+  PUT: "PUT",
+  /**
+   * The DELETE method requests that the origin server delete the resource identified by the Request-URI. This method MAY
+   * be overridden by human intervention (or other means) on the origin server. The client cannot be guaranteed that the
+   * operation has been carried out, even if the status code returned from the origin server indicates that the action
+   * has been completed successfully. However, the server SHOULD NOT indicate success unless, at the time the response
+   * is given, it intends to delete the resource or move it to an inaccessible location.
+   *
+   * A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 202 (Accepted) if
+   * the action has not yet been enacted, or 204 (No Content) if the action has been enacted but the response does not
+   * include an entity.
+   *
+   * If the request passes through a cache and the Request-URI identifies one or more currently cached entities, those
+   * entries SHOULD be treated as stale. Responses to this method are not cacheable.
+   */
+  DELETE: "DELETE",
+  /**
+   * The TRACE method is used to invoke a remote, application-layer loop- back of the request message. The final
+   * recipient of the request SHOULD reflect the message received back to the client as the entity-body of a 200 (OK)
+   * response. The final recipient is either the origin server or the first proxy or gateway to receive a Max-Forwards
+   * value of zero (0) in the request (see section 14.31). A TRACE request MUST NOT include an entity.
+   *
+   * TRACE allows the client to see what is being received at the other end of the request chain and use that data for
+   * testing or diagnostic information. The value of the Via header field (section 14.45) is of particular interest,
+   * since it acts as a trace of the request chain. Use of the Max-Forwards header field allows the client to limit the
+   * length of the request chain, which is useful for testing a chain of proxies forwarding messages in an infinite loop.
+   *
+   * If the request is valid, the response SHOULD contain the entire request message in the entity-body, with a
+   * Content-Type of "message/http". Responses to this method MUST NOT be cached.
+   */
+  TRACE: "TRACE",
+  /**
+   * This specification reserves the method name CONNECT for use with a proxy that can dynamically switch to being a
+   * tunnel (e.g. SSL tunneling [44]).
    */
-  FRONT_END_HTTPS: "front-end-https",
+  CONNECT: "CONNECT",
   /**
-   * 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).
+   * 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.
    *
-   * @example
-   * <code>X-HTTP-Method-Override: DELETE</code>
-   */
-  X_HTTP_METHOD_OVERRIDE: "x-http-method-override",
-  /**
-   * Allows easier parsing of the MakeModel/Firmware that is usually found in the User-Agent String of AT&T Devices.
+   * 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.
    *
-   * @example
-   * <code>X-Att-Deviceid: GT-P7320/P7320XXLPG</code>
-   */
-  X_ATT_DEVICE_ID: "x-att-deviceid",
-  /**
-   * Links to an XML file on the Internet with a full description and details about the device currently connecting. In the example to the right is an XML file for an AT&T Samsung Galaxy S2.
-   * x-wap-profile: http://wap.samsungmobile.com/uaprof/SGH-I777.xml
+   * 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.
    */
-  X_WAP_PROFILE: "x-wap-profile"
+  PATCH: "PATCH"
 };
-var http_request_headers_default = HttpRequestHeader;
 
-// src/http-response-headers.js
+// src/http-response-headers.ts
 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.
@@ -1814,325 +1614,1463 @@ var HttpResponseHeader = {
    */
   X_POWERED_BY: "x-powered-by"
 };
-var http_response_headers_default = HttpResponseHeader;
 
-// src/parameter-map.js
-var ParameterMap = class _ParameterMap extends Map {
+// src/response-status.ts
+var ResponseStatus = class {
+  _code;
+  _text;
   /**
-   * @param {Iterable<[string, *]>|Object} parameters The initial parameters to set.
-   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+   *
+   * @param code The status code from the {@link Response}
+   * @param text The status text from the {@link Response}
    */
-  constructor(parameters = {}) {
-    super();
-    for (const [key, value] of _ParameterMap.#entries(parameters)) {
-      this.append(key, value);
-    }
+  constructor(code, text2) {
+    this._code = code;
+    this._text = text2;
   }
   /**
-   * 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}.
+   * Returns the status code from the {@link Response}
    *
-   * @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.
+   * @returns The status 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;
+  get code() {
+    return this._code;
+  }
+  /**
+   * Returns the status text from the {@link Response}.
+   *
+   * @returns The status text.
+   */
+  get text() {
+    return this._text;
+  }
+  /**
+   * A String value that is used in the creation of the default string
+   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
+   *
+   * @returns The default string description of this object.
+   */
+  get [Symbol.toStringTag]() {
+    return "ResponseStatus";
   }
   /**
-   * 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}.
+   * tostring method for the class.
    *
-   * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
-   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString|Object.prototype.toString}
+   * @returns The status code and status text.
+   */
+  toString() {
+    return `${this._code} ${this._text}`;
+  }
+};
+
+// src/constants.ts
+var charset = { charset: "utf-8" };
+var endsWithSlashRegEx = /\/$/;
+var XSRF_COOKIE_NAME = "XSRF-TOKEN";
+var XSRF_HEADER_NAME = "X-XSRF-TOKEN";
+var mediaTypes = {
+  PNG: new MediaType(HttpMediaType.PNG),
+  TEXT: new MediaType(HttpMediaType.TEXT, charset),
+  JSON: new MediaType(HttpMediaType.JSON, charset),
+  HTML: new MediaType(HttpMediaType.HTML, charset),
+  JAVA_SCRIPT: new MediaType(HttpMediaType.JAVA_SCRIPT, charset),
+  CSS: new MediaType(HttpMediaType.CSS, charset),
+  XML: new MediaType(HttpMediaType.XML, charset),
+  BIN: new MediaType(HttpMediaType.BIN)
+};
+var defaultMediaType = mediaTypes.JSON.toString();
+var RequestCachingPolicy = {
+  DEFAULT: "default",
+  FORCE_CACHE: "force-cache",
+  NO_CACHE: "no-cache",
+  NO_STORE: "no-store",
+  ONLY_IF_CACHED: "only-if-cached",
+  RELOAD: "reload"
+};
+var RequestEvent = {
+  CONFIGURED: "configured",
+  SUCCESS: "success",
+  ERROR: "error",
+  ABORTED: "aborted",
+  TIMEOUT: "timeout",
+  RETRY: "retry",
+  COMPLETE: "complete",
+  ALL_COMPLETE: "all-complete"
+};
+var SignalEvents = {
+  ABORT: "abort",
+  TIMEOUT: "timeout"
+};
+var SignalErrors = {
+  ABORT: "AbortError",
+  TIMEOUT: "TimeoutError"
+};
+var eventListenerOptions = { once: true, passive: true };
+var abortEvent = () => new CustomEvent(SignalEvents.ABORT, { detail: { cause: SignalErrors.ABORT } });
+var timeoutEvent = () => new CustomEvent(SignalEvents.TIMEOUT, { detail: { cause: SignalErrors.TIMEOUT } });
+var requestBodyMethods = [HttpRequestMethod.POST, HttpRequestMethod.PUT, HttpRequestMethod.PATCH, HttpRequestMethod.DELETE];
+var internalServerError = new ResponseStatus(500, "Internal Server Error");
+var aborted = new ResponseStatus(499, "Aborted");
+var timedOut = new ResponseStatus(504, "Request Timeout");
+var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+var retryMethods = [HttpRequestMethod.GET, HttpRequestMethod.PUT, HttpRequestMethod.HEAD, HttpRequestMethod.DELETE, HttpRequestMethod.OPTIONS];
+var retryDelay = 300;
+var retryBackoffFactor = 2;
+
+// src/signal-controller.ts
+var SignalController = class {
+  abortSignal;
+  abortController = new AbortController();
+  events = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new SignalController instance.
+   * @param options - The options for the SignalController.
+   * @param options.signal - The signal to listen for abort events. Defaults to the internal abort signal.
+   * @param options.timeout - The timeout value in milliseconds. Defaults to Infinity.
+   * @throws {RangeError} If the timeout value is negative.
+   */
+  constructor({ signal, timeout = Infinity } = {}) {
+    if (timeout < 0) {
+      throw new RangeError("The timeout cannot be negative");
+    }
+    const signals = [this.abortController.signal];
+    if (signal != null) {
+      signals.push(signal);
+    }
+    if (timeout !== Infinity) {
+      signals.push(AbortSignal.timeout(timeout));
+    }
+    (this.abortSignal = AbortSignal.any(signals)).addEventListener(SignalEvents.ABORT, this, eventListenerOptions);
+  }
+  /**
+   * Handles the 'abort' event. If the event is caused by a timeout, the 'timeout' event is dispatched.
+   * Guards against a timeout firing after a manual abort to prevent spurious timeout events.
+   * @param event The event to abort with
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#specifying_this_using_bind
    */
-  setAll(parameters) {
-    for (const [key, value] of _ParameterMap.#entries(parameters)) {
-      this.set(key, value);
+  handleEvent({ target: { reason } }) {
+    if (this.abortController.signal.aborted) {
+      return;
     }
-    return this;
+    if (reason instanceof DOMException && reason.name === SignalErrors.TIMEOUT) {
+      this.abortSignal.dispatchEvent(timeoutEvent());
+    }
+  }
+  /**
+   * Gets the signal. This signal will be able to abort the request, but will not be notified if the request is aborted by the timeout.
+   * @returns The signal
+   */
+  get signal() {
+    return this.abortSignal;
+  }
+  /**
+   * Adds an event listener for the 'abort' event.
+   *
+   * @param eventListener The listener to add
+   * @returns The SignalController
+   */
+  onAbort(eventListener) {
+    return this.addEventListener(SignalEvents.ABORT, eventListener);
+  }
+  /**
+   * Adds an event listener for the 'timeout' event.
+   *
+   * @param eventListener The listener to add
+   * @returns The SignalController
+   */
+  onTimeout(eventListener) {
+    return this.addEventListener(SignalEvents.TIMEOUT, eventListener);
+  }
+  /**
+   * Aborts the signal.
+   *
+   * @param event The event to abort with
+   */
+  abort(event = abortEvent()) {
+    this.abortController.abort(event.detail?.cause);
   }
   /**
-   * 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.
+   * Removes all event listeners from the signal.
    *
-   * @override
-   * @param {string} key The key to get.
-   * @returns {*} The value associated to the key, or undefined if there is none.
+   * @returns The SignalController
    */
-  get(key) {
-    return super.get(key)?.[0];
+  destroy() {
+    this.abortSignal.removeEventListener(SignalEvents.ABORT, this, eventListenerOptions);
+    for (const [eventListener, type] of this.events) {
+      this.abortSignal.removeEventListener(type, eventListener, eventListenerOptions);
+    }
+    this.events.clear();
+    return this;
   }
   /**
-   * Returns an array of all values associated to the key, or undefined if there are none.
+   * Adds an event listener for the specified event type.
    *
-   * @param {string} key The key to get.
-   * @returns {Array<*>} An array of all values associated to the key, or undefined if there are none.
+   * @param type The event type to listen for
+   * @param eventListener The listener to add
+   * @returns The SignalController
    */
-  getAll(key) {
-    return super.get(key);
+  addEventListener(type, eventListener) {
+    this.abortSignal.addEventListener(type, eventListener, eventListenerOptions);
+    this.events.set(eventListener, type);
+    return this;
   }
   /**
-   * Appends a new value to an existing key inside a ParameterMap, or adds the new key if it does not exist.
+   * 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}.
    *
-   * @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.
+   * @returns The default string description of this object.
    */
-  append(key, value) {
-    const array = super.get(key);
-    if (array?.length > 0) {
-      array.push(value);
+  get [Symbol.toStringTag]() {
+    return "SignalController";
+  }
+};
+
+// node_modules/.pnpm/dompurify@3.3.3/node_modules/dompurify/dist/purify.es.mjs
+var {
+  entries,
+  setPrototypeOf,
+  isFrozen,
+  getPrototypeOf,
+  getOwnPropertyDescriptor
+} = Object;
+var {
+  freeze,
+  seal,
+  create
+} = Object;
+var {
+  apply,
+  construct
+} = typeof Reflect !== "undefined" && Reflect;
+if (!freeze) {
+  freeze = function freeze2(x) {
+    return x;
+  };
+}
+if (!seal) {
+  seal = function seal2(x) {
+    return x;
+  };
+}
+if (!apply) {
+  apply = function apply2(func, thisArg) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    return func.apply(thisArg, args);
+  };
+}
+if (!construct) {
+  construct = function construct2(Func) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    return new Func(...args);
+  };
+}
+var arrayForEach = unapply(Array.prototype.forEach);
+var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+var arrayPop = unapply(Array.prototype.pop);
+var arrayPush = unapply(Array.prototype.push);
+var arraySplice = unapply(Array.prototype.splice);
+var stringToLowerCase = unapply(String.prototype.toLowerCase);
+var stringToString = unapply(String.prototype.toString);
+var stringMatch = unapply(String.prototype.match);
+var stringReplace = unapply(String.prototype.replace);
+var stringIndexOf = unapply(String.prototype.indexOf);
+var stringTrim = unapply(String.prototype.trim);
+var objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+var regExpTest = unapply(RegExp.prototype.test);
+var typeErrorCreate = unconstruct(TypeError);
+function unapply(func) {
+  return function(thisArg) {
+    if (thisArg instanceof RegExp) {
+      thisArg.lastIndex = 0;
+    }
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+    return apply(func, thisArg, args);
+  };
+}
+function unconstruct(Func) {
+  return function() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return construct(Func, args);
+  };
+}
+function addToSet(set, array) {
+  let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
+  if (setPrototypeOf) {
+    setPrototypeOf(set, null);
+  }
+  let l = array.length;
+  while (l--) {
+    let element = array[l];
+    if (typeof element === "string") {
+      const lcElement = transformCaseFunc(element);
+      if (lcElement !== element) {
+        if (!isFrozen(array)) {
+          array[l] = lcElement;
+        }
+        element = lcElement;
+      }
+    }
+    set[element] = true;
+  }
+  return set;
+}
+function cleanArray(array) {
+  for (let index = 0; index < array.length; index++) {
+    const isPropertyExist = objectHasOwnProperty(array, index);
+    if (!isPropertyExist) {
+      array[index] = null;
+    }
+  }
+  return array;
+}
+function clone(object) {
+  const newObject = create(null);
+  for (const [property, value] of entries(object)) {
+    const isPropertyExist = objectHasOwnProperty(object, property);
+    if (isPropertyExist) {
+      if (Array.isArray(value)) {
+        newObject[property] = cleanArray(value);
+      } else if (value && typeof value === "object" && value.constructor === Object) {
+        newObject[property] = clone(value);
+      } else {
+        newObject[property] = value;
+      }
+    }
+  }
+  return newObject;
+}
+function lookupGetter(object, prop) {
+  while (object !== null) {
+    const desc = getOwnPropertyDescriptor(object, prop);
+    if (desc) {
+      if (desc.get) {
+        return unapply(desc.get);
+      }
+      if (typeof desc.value === "function") {
+        return unapply(desc.value);
+      }
+    }
+    object = getPrototypeOf(object);
+  }
+  function fallbackValue() {
+    return null;
+  }
+  return fallbackValue;
+}
+var html$1 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "search", "section", "select", "shadow", "slot", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
+var svg$1 = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "enterkeyhint", "exportparts", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "inputmode", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "part", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
+var svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
+var svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
+var mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]);
+var mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
+var text = freeze(["#text"]);
+var html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]);
+var svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "mask-type", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
+var mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
+var xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
+var MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+var ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+var TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm);
+var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+var IS_ALLOWED_URI = seal(
+  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+  // eslint-disable-line no-useless-escape
+);
+var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+var ATTR_WHITESPACE = seal(
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+  // eslint-disable-line no-control-regex
+);
+var DOCTYPE_NAME = seal(/^html$/i);
+var CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+var EXPRESSIONS = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  ARIA_ATTR,
+  ATTR_WHITESPACE,
+  CUSTOM_ELEMENT,
+  DATA_ATTR,
+  DOCTYPE_NAME,
+  ERB_EXPR,
+  IS_ALLOWED_URI,
+  IS_SCRIPT_OR_DATA,
+  MUSTACHE_EXPR,
+  TMPLIT_EXPR
+});
+var NODE_TYPE = {
+  element: 1,
+  attribute: 2,
+  text: 3,
+  cdataSection: 4,
+  entityReference: 5,
+  // Deprecated
+  entityNode: 6,
+  // Deprecated
+  progressingInstruction: 7,
+  comment: 8,
+  document: 9,
+  documentType: 10,
+  documentFragment: 11,
+  notation: 12
+  // Deprecated
+};
+var getGlobal = function getGlobal2() {
+  return typeof window === "undefined" ? null : window;
+};
+var _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, purifyHostElement) {
+  if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") {
+    return null;
+  }
+  let suffix = null;
+  const ATTR_NAME = "data-tt-policy-suffix";
+  if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+    suffix = purifyHostElement.getAttribute(ATTR_NAME);
+  }
+  const policyName = "dompurify" + (suffix ? "#" + suffix : "");
+  try {
+    return trustedTypes.createPolicy(policyName, {
+      createHTML(html2) {
+        return html2;
+      },
+      createScriptURL(scriptUrl) {
+        return scriptUrl;
+      }
+    });
+  } catch (_) {
+    console.warn("TrustedTypes policy " + policyName + " could not be created.");
+    return null;
+  }
+};
+var _createHooksMap = function _createHooksMap2() {
+  return {
+    afterSanitizeAttributes: [],
+    afterSanitizeElements: [],
+    afterSanitizeShadowDOM: [],
+    beforeSanitizeAttributes: [],
+    beforeSanitizeElements: [],
+    beforeSanitizeShadowDOM: [],
+    uponSanitizeAttribute: [],
+    uponSanitizeElement: [],
+    uponSanitizeShadowNode: []
+  };
+};
+function createDOMPurify() {
+  let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+  const DOMPurify = (root) => createDOMPurify(root);
+  DOMPurify.version = "3.3.3";
+  DOMPurify.removed = [];
+  if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document || !window2.Element) {
+    DOMPurify.isSupported = false;
+    return DOMPurify;
+  }
+  let {
+    document: document2
+  } = window2;
+  const originalDocument = document2;
+  const currentScript = originalDocument.currentScript;
+  const {
+    DocumentFragment: DocumentFragment2,
+    HTMLTemplateElement,
+    Node,
+    Element,
+    NodeFilter,
+    NamedNodeMap = window2.NamedNodeMap || window2.MozNamedAttrMap,
+    HTMLFormElement,
+    DOMParser: DOMParser2,
+    trustedTypes
+  } = window2;
+  const ElementPrototype = Element.prototype;
+  const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
+  const remove = lookupGetter(ElementPrototype, "remove");
+  const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+  const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+  const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+  if (typeof HTMLTemplateElement === "function") {
+    const template = document2.createElement("template");
+    if (template.content && template.content.ownerDocument) {
+      document2 = template.content.ownerDocument;
+    }
+  }
+  let trustedTypesPolicy;
+  let emptyHTML = "";
+  const {
+    implementation,
+    createNodeIterator,
+    createDocumentFragment,
+    getElementsByTagName
+  } = document2;
+  const {
+    importNode
+  } = originalDocument;
+  let hooks = _createHooksMap();
+  DOMPurify.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+  const {
+    MUSTACHE_EXPR: MUSTACHE_EXPR2,
+    ERB_EXPR: ERB_EXPR2,
+    TMPLIT_EXPR: TMPLIT_EXPR2,
+    DATA_ATTR: DATA_ATTR2,
+    ARIA_ATTR: ARIA_ATTR2,
+    IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA2,
+    ATTR_WHITESPACE: ATTR_WHITESPACE2,
+    CUSTOM_ELEMENT: CUSTOM_ELEMENT2
+  } = EXPRESSIONS;
+  let {
+    IS_ALLOWED_URI: IS_ALLOWED_URI$1
+  } = EXPRESSIONS;
+  let ALLOWED_TAGS = null;
+  const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
+  let ALLOWED_ATTR = null;
+  const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
+  let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
+    tagNameCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeNameCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    allowCustomizedBuiltInElements: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: false
+    }
+  }));
+  let FORBID_TAGS = null;
+  let FORBID_ATTR = null;
+  const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+    tagCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    }
+  }));
+  let ALLOW_ARIA_ATTR = true;
+  let ALLOW_DATA_ATTR = true;
+  let ALLOW_UNKNOWN_PROTOCOLS = false;
+  let ALLOW_SELF_CLOSE_IN_ATTR = true;
+  let SAFE_FOR_TEMPLATES = false;
+  let SAFE_FOR_XML = true;
+  let WHOLE_DOCUMENT = false;
+  let SET_CONFIG = false;
+  let FORCE_BODY = false;
+  let RETURN_DOM = false;
+  let RETURN_DOM_FRAGMENT = false;
+  let RETURN_TRUSTED_TYPE = false;
+  let SANITIZE_DOM = true;
+  let SANITIZE_NAMED_PROPS = false;
+  const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+  let KEEP_CONTENT = true;
+  let IN_PLACE = false;
+  let USE_PROFILES = {};
+  let FORBID_CONTENTS = null;
+  const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+  let DATA_URI_TAGS = null;
+  const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
+  let URI_SAFE_ATTRIBUTES = null;
+  const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
+  const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+  const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+  const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+  let NAMESPACE = HTML_NAMESPACE;
+  let IS_EMPTY_INPUT = false;
+  let ALLOWED_NAMESPACES = null;
+  const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+  let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+  let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+  const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
+  let PARSER_MEDIA_TYPE = null;
+  const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+  const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+  let transformCaseFunc = null;
+  let CONFIG = null;
+  const formElement = document2.createElement("form");
+  const isRegexOrFunction = function isRegexOrFunction2(testValue) {
+    return testValue instanceof RegExp || testValue instanceof Function;
+  };
+  const _parseConfig = function _parseConfig2() {
+    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    if (CONFIG && CONFIG === cfg) {
+      return;
+    }
+    if (!cfg || typeof cfg !== "object") {
+      cfg = {};
+    }
+    cfg = clone(cfg);
+    PARSER_MEDIA_TYPE = // eslint-disable-next-line unicorn/prefer-includes
+    SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+    transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
+    ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+    ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+    ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+    URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+    DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+    FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+    FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
+    FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
+    USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES : false;
+    ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+    ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+    ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+    ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+    SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+    SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
+    WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+    RETURN_DOM = cfg.RETURN_DOM || false;
+    RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+    RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+    FORCE_BODY = cfg.FORCE_BODY || false;
+    SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+    SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+    KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+    IN_PLACE = cfg.IN_PLACE || false;
+    IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
+    NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+    MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+    HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
+    CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
+    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+      CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+    }
+    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+      CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+    }
+    if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
+      CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+    }
+    if (SAFE_FOR_TEMPLATES) {
+      ALLOW_DATA_ATTR = false;
+    }
+    if (RETURN_DOM_FRAGMENT) {
+      RETURN_DOM = true;
+    }
+    if (USE_PROFILES) {
+      ALLOWED_TAGS = addToSet({}, text);
+      ALLOWED_ATTR = create(null);
+      if (USE_PROFILES.html === true) {
+        addToSet(ALLOWED_TAGS, html$1);
+        addToSet(ALLOWED_ATTR, html);
+      }
+      if (USE_PROFILES.svg === true) {
+        addToSet(ALLOWED_TAGS, svg$1);
+        addToSet(ALLOWED_ATTR, svg);
+        addToSet(ALLOWED_ATTR, xml);
+      }
+      if (USE_PROFILES.svgFilters === true) {
+        addToSet(ALLOWED_TAGS, svgFilters);
+        addToSet(ALLOWED_ATTR, svg);
+        addToSet(ALLOWED_ATTR, xml);
+      }
+      if (USE_PROFILES.mathMl === true) {
+        addToSet(ALLOWED_TAGS, mathMl$1);
+        addToSet(ALLOWED_ATTR, mathMl);
+        addToSet(ALLOWED_ATTR, xml);
+      }
+    }
+    if (!objectHasOwnProperty(cfg, "ADD_TAGS")) {
+      EXTRA_ELEMENT_HANDLING.tagCheck = null;
+    }
+    if (!objectHasOwnProperty(cfg, "ADD_ATTR")) {
+      EXTRA_ELEMENT_HANDLING.attributeCheck = null;
+    }
+    if (cfg.ADD_TAGS) {
+      if (typeof cfg.ADD_TAGS === "function") {
+        EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+      } else {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone(ALLOWED_TAGS);
+        }
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+      }
+    }
+    if (cfg.ADD_ATTR) {
+      if (typeof cfg.ADD_ATTR === "function") {
+        EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+      } else {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone(ALLOWED_ATTR);
+        }
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+      }
+    }
+    if (cfg.ADD_URI_SAFE_ATTR) {
+      addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+    }
+    if (cfg.FORBID_CONTENTS) {
+      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+        FORBID_CONTENTS = clone(FORBID_CONTENTS);
+      }
+      addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+    }
+    if (cfg.ADD_FORBID_CONTENTS) {
+      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+        FORBID_CONTENTS = clone(FORBID_CONTENTS);
+      }
+      addToSet(FORBID_CONTENTS, cfg.ADD_FORBID_CONTENTS, transformCaseFunc);
+    }
+    if (KEEP_CONTENT) {
+      ALLOWED_TAGS["#text"] = true;
+    }
+    if (WHOLE_DOCUMENT) {
+      addToSet(ALLOWED_TAGS, ["html", "head", "body"]);
+    }
+    if (ALLOWED_TAGS.table) {
+      addToSet(ALLOWED_TAGS, ["tbody"]);
+      delete FORBID_TAGS.tbody;
+    }
+    if (cfg.TRUSTED_TYPES_POLICY) {
+      if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+      }
+      if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+      }
+      trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+      emptyHTML = trustedTypesPolicy.createHTML("");
+    } else {
+      if (trustedTypesPolicy === void 0) {
+        trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+      }
+      if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
+        emptyHTML = trustedTypesPolicy.createHTML("");
+      }
+    }
+    if (freeze) {
+      freeze(cfg);
+    }
+    CONFIG = cfg;
+  };
+  const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
+  const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+  const _checkValidNamespace = function _checkValidNamespace2(element) {
+    let parent = getParentNode(element);
+    if (!parent || !parent.tagName) {
+      parent = {
+        namespaceURI: NAMESPACE,
+        tagName: "template"
+      };
+    }
+    const tagName = stringToLowerCase(element.tagName);
+    const parentTagName = stringToLowerCase(parent.tagName);
+    if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+      return false;
+    }
+    if (element.namespaceURI === SVG_NAMESPACE) {
+      if (parent.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "svg";
+      }
+      if (parent.namespaceURI === MATHML_NAMESPACE) {
+        return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+      }
+      return Boolean(ALL_SVG_TAGS[tagName]);
+    }
+    if (element.namespaceURI === MATHML_NAMESPACE) {
+      if (parent.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "math";
+      }
+      if (parent.namespaceURI === SVG_NAMESPACE) {
+        return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+      }
+      return Boolean(ALL_MATHML_TAGS[tagName]);
+    }
+    if (element.namespaceURI === HTML_NAMESPACE) {
+      if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+    }
+    if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) {
+      return true;
+    }
+    return false;
+  };
+  const _forceRemove = function _forceRemove2(node) {
+    arrayPush(DOMPurify.removed, {
+      element: node
+    });
+    try {
+      getParentNode(node).removeChild(node);
+    } catch (_) {
+      remove(node);
+    }
+  };
+  const _removeAttribute = function _removeAttribute2(name, element) {
+    try {
+      arrayPush(DOMPurify.removed, {
+        attribute: element.getAttributeNode(name),
+        from: element
+      });
+    } catch (_) {
+      arrayPush(DOMPurify.removed, {
+        attribute: null,
+        from: element
+      });
+    }
+    element.removeAttribute(name);
+    if (name === "is") {
+      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+        try {
+          _forceRemove(element);
+        } catch (_) {
+        }
+      } else {
+        try {
+          element.setAttribute(name, "");
+        } catch (_) {
+        }
+      }
+    }
+  };
+  const _initDocument = function _initDocument2(dirty) {
+    let doc = null;
+    let leadingWhitespace = null;
+    if (FORCE_BODY) {
+      dirty = "<remove></remove>" + dirty;
+    } else {
+      const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+      leadingWhitespace = matches && matches[0];
+    }
+    if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
+      dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
+    }
+    const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+    if (NAMESPACE === HTML_NAMESPACE) {
+      try {
+        doc = new DOMParser2().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+      } catch (_) {
+      }
+    }
+    if (!doc || !doc.documentElement) {
+      doc = implementation.createDocument(NAMESPACE, "template", null);
+      try {
+        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+      } catch (_) {
+      }
+    }
+    const body = doc.body || doc.documentElement;
+    if (dirty && leadingWhitespace) {
+      body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+    }
+    if (NAMESPACE === HTML_NAMESPACE) {
+      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
+    }
+    return WHOLE_DOCUMENT ? doc.documentElement : body;
+  };
+  const _createNodeIterator = function _createNodeIterator2(root) {
+    return createNodeIterator.call(
+      root.ownerDocument || root,
+      root,
+      // eslint-disable-next-line no-bitwise
+      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION,
+      null
+    );
+  };
+  const _isClobbered = function _isClobbered2(element) {
+    return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+  };
+  const _isNode = function _isNode2(value) {
+    return typeof Node === "function" && value instanceof Node;
+  };
+  function _executeHooks(hooks2, currentNode, data) {
+    arrayForEach(hooks2, (hook) => {
+      hook.call(DOMPurify, currentNode, data, CONFIG);
+    });
+  }
+  const _sanitizeElements = function _sanitizeElements2(currentNode) {
+    let content = null;
+    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+    if (_isClobbered(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    const tagName = transformCaseFunc(currentNode.nodeName);
+    _executeHooks(hooks.uponSanitizeElement, currentNode, {
+      tagName,
+      allowedTags: ALLOWED_TAGS
+    });
+    if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName])) {
+      if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+          return false;
+        }
+        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+          return false;
+        }
+      }
+      if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+        const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+        const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+        if (childNodes && parentNode) {
+          const childCount = childNodes.length;
+          for (let i = childCount - 1; i >= 0; --i) {
+            const childClone = cloneNode(childNodes[i], true);
+            childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
+            parentNode.insertBefore(childClone, getNextSibling(currentNode));
+          }
+        }
+      }
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+      content = currentNode.textContent;
+      arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+        content = stringReplace(content, expr, " ");
+      });
+      if (currentNode.textContent !== content) {
+        arrayPush(DOMPurify.removed, {
+          element: currentNode.cloneNode()
+        });
+        currentNode.textContent = content;
+      }
+    }
+    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+    return false;
+  };
+  const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+    if (FORBID_ATTR[lcName]) {
+      return false;
+    }
+    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
+      return false;
+    }
+    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR2, lcName)) ;
+    else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR2, lcName)) ;
+    else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag)) ;
+    else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+      if (
+        // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+        // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+        // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+        _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName, lcTag)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+        // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+        lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))
+      ) ;
+      else {
+        return false;
+      }
+    } else if (URI_SAFE_ATTRIBUTES[lcName]) ;
+    else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+    else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) ;
+    else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA2, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+    else if (value) {
+      return false;
+    } else ;
+    return true;
+  };
+  const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+    return tagName !== "annotation-xml" && stringMatch(tagName, CUSTOM_ELEMENT2);
+  };
+  const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+    const {
+      attributes
+    } = currentNode;
+    if (!attributes || _isClobbered(currentNode)) {
+      return;
+    }
+    const hookEvent = {
+      attrName: "",
+      attrValue: "",
+      keepAttr: true,
+      allowedAttributes: ALLOWED_ATTR,
+      forceKeepAttr: void 0
+    };
+    let l = attributes.length;
+    while (l--) {
+      const attr = attributes[l];
+      const {
+        name,
+        namespaceURI,
+        value: attrValue
+      } = attr;
+      const lcName = transformCaseFunc(name);
+      const initValue = attrValue;
+      let value = name === "value" ? initValue : stringTrim(initValue);
+      hookEvent.attrName = lcName;
+      hookEvent.attrValue = value;
+      hookEvent.keepAttr = true;
+      hookEvent.forceKeepAttr = void 0;
+      _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+      value = hookEvent.attrValue;
+      if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name")) {
+        _removeAttribute(name, currentNode);
+        value = SANITIZE_NAMED_PROPS_PREFIX + value;
+      }
+      if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) {
+        _removeAttribute(name, currentNode);
+        continue;
+      }
+      if (lcName === "attributename" && stringMatch(value, "href")) {
+        _removeAttribute(name, currentNode);
+        continue;
+      }
+      if (hookEvent.forceKeepAttr) {
+        continue;
+      }
+      if (!hookEvent.keepAttr) {
+        _removeAttribute(name, currentNode);
+        continue;
+      }
+      if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+        _removeAttribute(name, currentNode);
+        continue;
+      }
+      if (SAFE_FOR_TEMPLATES) {
+        arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+          value = stringReplace(value, expr, " ");
+        });
+      }
+      const lcTag = transformCaseFunc(currentNode.nodeName);
+      if (!_isValidAttribute(lcTag, lcName, value)) {
+        _removeAttribute(name, currentNode);
+        continue;
+      }
+      if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
+        if (namespaceURI) ;
+        else {
+          switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+            case "TrustedHTML": {
+              value = trustedTypesPolicy.createHTML(value);
+              break;
+            }
+            case "TrustedScriptURL": {
+              value = trustedTypesPolicy.createScriptURL(value);
+              break;
+            }
+          }
+        }
+      }
+      if (value !== initValue) {
+        try {
+          if (namespaceURI) {
+            currentNode.setAttributeNS(namespaceURI, name, value);
+          } else {
+            currentNode.setAttribute(name, value);
+          }
+          if (_isClobbered(currentNode)) {
+            _forceRemove(currentNode);
+          } else {
+            arrayPop(DOMPurify.removed);
+          }
+        } catch (_) {
+          _removeAttribute(name, currentNode);
+        }
+      }
+    }
+    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+  };
+  const _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
+    let shadowNode = null;
+    const shadowIterator = _createNodeIterator(fragment);
+    _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+    while (shadowNode = shadowIterator.nextNode()) {
+      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+      _sanitizeElements(shadowNode);
+      _sanitizeAttributes(shadowNode);
+      if (shadowNode.content instanceof DocumentFragment2) {
+        _sanitizeShadowDOM2(shadowNode.content);
+      }
+    }
+    _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+  };
+  DOMPurify.sanitize = function(dirty) {
+    let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    let body = null;
+    let importedNode = null;
+    let currentNode = null;
+    let returnNode = null;
+    IS_EMPTY_INPUT = !dirty;
+    if (IS_EMPTY_INPUT) {
+      dirty = "<!-->";
+    }
+    if (typeof dirty !== "string" && !_isNode(dirty)) {
+      if (typeof dirty.toString === "function") {
+        dirty = dirty.toString();
+        if (typeof dirty !== "string") {
+          throw typeErrorCreate("dirty is not a string, aborting");
+        }
+      } else {
+        throw typeErrorCreate("toString is not a function");
+      }
+    }
+    if (!DOMPurify.isSupported) {
+      return dirty;
+    }
+    if (!SET_CONFIG) {
+      _parseConfig(cfg);
+    }
+    DOMPurify.removed = [];
+    if (typeof dirty === "string") {
+      IN_PLACE = false;
+    }
+    if (IN_PLACE) {
+      if (dirty.nodeName) {
+        const tagName = transformCaseFunc(dirty.nodeName);
+        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+          throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+        }
+      }
+    } else if (dirty instanceof Node) {
+      body = _initDocument("<!---->");
+      importedNode = body.ownerDocument.importNode(dirty, true);
+      if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === "BODY") {
+        body = importedNode;
+      } else if (importedNode.nodeName === "HTML") {
+        body = importedNode;
+      } else {
+        body.appendChild(importedNode);
+      }
     } else {
-      super.set(key, [value]);
+      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && // eslint-disable-next-line unicorn/prefer-includes
+      dirty.indexOf("<") === -1) {
+        return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+      }
+      body = _initDocument(dirty);
+      if (!body) {
+        return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+      }
     }
-    return this;
-  }
-  /**
-   * Appends all key-value pairs from an iterable or object to the ParameterMap.
-   * If a key already exists, the value will be appended to the underlying {@link Array}.
-   * If a key does not exist, the key and value will be added to the ParameterMap.
-   *
-   * @param {Iterable<[string, *]>|Object} parameters The parameters to append.
-   * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
-   */
-  appendAll(parameters) {
-    for (const [key, value] of _ParameterMap.#entries(parameters)) {
-      this.append(key, value);
+    if (body && FORCE_BODY) {
+      _forceRemove(body.firstChild);
     }
-    return this;
-  }
-  /**
-   * Checks if a specific key has a specific value.
-   *
-   * @param {*} value The value to check.
-   * @returns {boolean} True if the key has the value, false otherwise.
-   */
-  hasValue(value) {
-    for (const array of super.values()) {
-      if (array.includes(value)) {
-        return true;
+    const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+    while (currentNode = nodeIterator.nextNode()) {
+      _sanitizeElements(currentNode);
+      _sanitizeAttributes(currentNode);
+      if (currentNode.content instanceof DocumentFragment2) {
+        _sanitizeShadowDOM(currentNode.content);
       }
     }
-    return false;
-  }
-  /**
-   * Removes a specific value from a specific key.
-   *
-   * @param {*} value The value to remove.
-   * @returns {boolean} True if the value was removed, false otherwise.
-   */
-  deleteValue(value) {
-    for (const array of this.values()) {
-      if (array.includes(value)) {
-        return array.splice(array.indexOf(value), 1).length > 0;
+    if (IN_PLACE) {
+      return dirty;
+    }
+    if (RETURN_DOM) {
+      if (RETURN_DOM_FRAGMENT) {
+        returnNode = createDocumentFragment.call(body.ownerDocument);
+        while (body.firstChild) {
+          returnNode.appendChild(body.firstChild);
+        }
+      } else {
+        returnNode = body;
       }
+      if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
+        returnNode = importNode.call(originalDocument, returnNode, true);
+      }
+      return returnNode;
+    }
+    let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+    if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+      serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
+    }
+    if (SAFE_FOR_TEMPLATES) {
+      arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+        serializedHTML = stringReplace(serializedHTML, expr, " ");
+      });
+    }
+    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+  };
+  DOMPurify.setConfig = function() {
+    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    _parseConfig(cfg);
+    SET_CONFIG = true;
+  };
+  DOMPurify.clearConfig = function() {
+    CONFIG = null;
+    SET_CONFIG = false;
+  };
+  DOMPurify.isValidAttribute = function(tag, attr, value) {
+    if (!CONFIG) {
+      _parseConfig({});
+    }
+    const lcTag = transformCaseFunc(tag);
+    const lcName = transformCaseFunc(attr);
+    return _isValidAttribute(lcTag, lcName, value);
+  };
+  DOMPurify.addHook = function(entryPoint, hookFunction) {
+    if (typeof hookFunction !== "function") {
+      return;
+    }
+    arrayPush(hooks[entryPoint], hookFunction);
+  };
+  DOMPurify.removeHook = function(entryPoint, hookFunction) {
+    if (hookFunction !== void 0) {
+      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+      return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
+    }
+    return arrayPop(hooks[entryPoint]);
+  };
+  DOMPurify.removeHooks = function(entryPoint) {
+    hooks[entryPoint] = [];
+  };
+  DOMPurify.removeAllHooks = function() {
+    hooks = _createHooksMap();
+  };
+  return DOMPurify;
+}
+var purify = createDOMPurify();
+
+// src/response-handlers.ts
+var domReady;
+var ensureDom = async () => {
+  if (typeof document !== "undefined" && typeof DOMParser !== "undefined" && typeof DocumentFragment !== "undefined") {
+    return Promise.resolve();
+  }
+  return domReady ??= import("jsdom").then(({ JSDOM }) => {
+    const { window: window2 } = new JSDOM("<!DOCTYPE html><html><head></head><body></body></html>");
+    globalThis.window = window2;
+    Object.assign(globalThis, { document: window2.document, DOMParser: window2.DOMParser, DocumentFragment: window2.DocumentFragment });
+  });
+};
+var handleText = async (response) => await response.text();
+var handleScript = async (response) => {
+  await ensureDom();
+  const objectURL = URL.createObjectURL(await response.blob());
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    Object.assign(script, { src: objectURL, type: HttpMediaType.JAVA_SCRIPT, async: true });
+    script.onload = () => {
+      URL.revokeObjectURL(objectURL);
+      document.head.removeChild(script);
+      resolve();
+    };
+    script.onerror = () => {
+      URL.revokeObjectURL(objectURL);
+      document.head.removeChild(script);
+      reject(new Error("Script failed to load"));
+    };
+    document.head.appendChild(script);
+  });
+};
+var handleCss = async (response) => {
+  await ensureDom();
+  const objectURL = URL.createObjectURL(await response.blob());
+  return new Promise((resolve, reject) => {
+    const link = document.createElement("link");
+    Object.assign(link, { href: objectURL, type: HttpMediaType.CSS, rel: "stylesheet" });
+    link.onload = () => resolve(URL.revokeObjectURL(objectURL));
+    link.onerror = () => {
+      URL.revokeObjectURL(objectURL);
+      document.head.removeChild(link);
+      reject(new Error("Stylesheet load failed"));
+    };
+    document.head.appendChild(link);
+  });
+};
+var handleJson = async (response) => await response.json();
+var handleBlob = async (response) => await response.blob();
+var handleImage = async (response) => {
+  await ensureDom();
+  const objectURL = URL.createObjectURL(await response.blob());
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      URL.revokeObjectURL(objectURL);
+      resolve(img);
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(objectURL);
+      reject(new Error("Image failed to load"));
+    };
+    img.src = objectURL;
+  });
+};
+var handleBuffer = async (response) => await response.arrayBuffer();
+var handleReadableStream = async (response) => Promise.resolve(response.body);
+var handleXml = async (response) => {
+  await ensureDom();
+  return new DOMParser().parseFromString(purify.sanitize(await response.text()), HttpMediaType.XML);
+};
+var handleHtml = async (response) => {
+  await ensureDom();
+  return new DOMParser().parseFromString(purify.sanitize(await response.text()), HttpMediaType.HTML);
+};
+var handleHtmlFragment = async (response) => {
+  await ensureDom();
+  return document.createRange().createContextualFragment(purify.sanitize(await response.text()));
+};
+
+// src/utils.ts
+var isRequestBodyMethod = (method) => method !== void 0 && requestBodyMethods.includes(method);
+var isRawBody = (body) => body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || body instanceof ReadableStream || body instanceof URLSearchParams || ArrayBuffer.isView(body);
+var getCookieValue = (name) => {
+  if (typeof document === "undefined" || !document.cookie) {
+    return;
+  }
+  const prefix = `${name}=`;
+  const cookies = document.cookie.split(";");
+  for (let i = 0, length = cookies.length; i < length; i++) {
+    const cookie = cookies[i].trim();
+    if (cookie.startsWith(prefix)) {
+      return decodeURIComponent(cookie.slice(prefix.length));
     }
-    return false;
   }
-  /**
-   * Determines whether the ParameterMap contains anything.
-   *
-   * @returns {boolean} True if the ParameterMap size is greater than 0, false otherwise.
-   */
-  isEmpty() {
-    return this.size === 0;
+  return void 0;
+};
+var serialize = (data) => JSON.stringify(data);
+var isString = (value) => value !== null && typeof value === "string";
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+var objectMerge = (...objects) => {
+  const length = objects.length;
+  if (length === 0) {
+    return void 0;
   }
-  /**
-   * Returns an Object that can be serialized to JSON.
-   * If a key has only one value, the value will be a single value.
-   * If a key has multiple values, the value will be an array of values.
-   * If a key has no values, the value will be undefined.
-   *
-   * @override
-   * @returns {Object} The Object to be serialized to JSON.
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON_behavior}
-   */
-  toJSON() {
-    const obj = /* @__PURE__ */ Object.create(null);
-    for (const [key, values] of super.entries()) {
-      obj[key] = values.length === 1 ? values[0] : values;
+  if (length === 1) {
+    const [obj] = objects;
+    if (!isObject(obj)) {
+      return obj;
     }
-    return obj;
+    return deepClone(obj);
   }
-  /**
-   * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
-   *
-   * @override
-   * @yields {[string, *]} An iterator for the key-value pairs in the map.
-   */
-  *entries() {
-    for (const [key, array] of super.entries()) {
-      for (const value of array) {
-        yield [key, value];
+  const target = {};
+  for (const source of objects) {
+    if (!isObject(source)) {
+      return void 0;
+    }
+    for (const [property, sourceValue] of Object.entries(source)) {
+      const targetValue = target[property];
+      if (Array.isArray(sourceValue)) {
+        target[property] = [...sourceValue, ...Array.isArray(targetValue) ? targetValue.filter((item) => !sourceValue.includes(item)) : []];
+      } else if (isObject(sourceValue)) {
+        target[property] = isObject(targetValue) ? objectMerge(targetValue, sourceValue) : deepClone(sourceValue);
+      } else {
+        target[property] = sourceValue;
       }
     }
   }
-  /**
-   * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
-   *
-   * @override
-   * @yields {[string, *]} An iterator for the key-value pairs in the map.
-   */
-  *[Symbol.iterator]() {
-    yield* this.entries();
-  }
-  /**
-   * Returns an iterable of key, value pairs for every entry in the parameters object.
-   *
-   * @private
-   * @static
-   * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
-   * @returns {Iterable<[string, *]>} An iterable of key, value pairs for every entry in the parameters object.
-   */
-  static #entries(parameters) {
-    return parameters[Symbol.iterator] ? parameters : Object.entries(parameters);
-  }
-  /**
-   * A String value that is used in the creation of the default string description of an object.
-   * Called by the built-in method {@link Object.prototype.toString}.
-   *
-   * @override
-   * @returns {string} The default string description of this object.
-   */
-  get [Symbol.toStringTag]() {
-    return "ParameterMap";
-  }
+  return target;
 };
+function deepClone(object) {
+  if (isObject(object)) {
+    const cloned = {};
+    const keys = Object.keys(object);
+    for (let i = 0, length = keys.length, key; i < length; i++) {
+      key = keys[i];
+      cloned[key] = deepClone(object[key]);
+    }
+    return cloned;
+  }
+  return object;
+}
 
-// src/transportr.js
-var _handleText = async (response) => await response.text();
-var _handleScript = async (response) => {
-  const objectURL = URL.createObjectURL(await response.blob());
-  document.head.removeChild(document.head.appendChild(Object.assign(document.createElement("script"), { src: objectURL, type: http_media_type_default.JAVA_SCRIPT, async: true })));
-  URL.revokeObjectURL(objectURL);
-  return Promise.resolve();
-};
-var _handleCss = async (response) => {
-  const objectURL = URL.createObjectURL(await response.blob());
-  document.head.appendChild(Object.assign(document.createElement("link"), { href: objectURL, type: http_media_type_default.CSS, rel: "stylesheet" }));
-  URL.revokeObjectURL(objectURL);
-  return Promise.resolve();
-};
-var _handleJson = async (response) => await response.json();
-var _handleBlob = async (response) => await response.blob();
-var _handleImage = async (response) => URL.createObjectURL(await response.blob());
-var _handleBuffer = async (response) => await response.arrayBuffer();
-var _handleReadableStream = async (response) => response.body;
-var _handleXml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.XML);
-var _handleHtml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.HTML);
-var _handleHtmlFragment = async (response) => document.createRange().createContextualFragment(await response.text());
+// src/transportr.ts
 var Transportr = class _Transportr {
-  /** @type {URL} */
-  #baseUrl;
-  /** @type {RequestOptions} */
-  #options;
-  /** @type {Subscribr} */
-  #subscribr;
-  /** @type {Subscribr} */
-  static #globalSubscribr = new Subscribr();
-  /** @type {Set<AbortSignal>} */
-  static #activeRequests = /* @__PURE__ */ new Set();
-  /** @type {Map<ResponseHandler<ResponseBody>, string>} */
-  static #contentTypeHandlers = /* @__PURE__ */ new Map([
-    [_handleImage, mediaTypes.get(http_media_type_default.PNG).type],
-    [_handleText, mediaTypes.get(http_media_type_default.TEXT).type],
-    [_handleJson, mediaTypes.get(http_media_type_default.JSON).subtype],
-    [_handleHtml, mediaTypes.get(http_media_type_default.HTML).subtype],
-    [_handleScript, mediaTypes.get(http_media_type_default.JAVA_SCRIPT).subtype],
-    [_handleCss, mediaTypes.get(http_media_type_default.CSS).subtype],
-    [_handleXml, mediaTypes.get(http_media_type_default.XML).subtype],
-    [_handleReadableStream, mediaTypes.get(http_media_type_default.BIN).subtype]
-  ]);
+  _baseUrl;
+  _options;
+  subscribr;
+  hooks = { beforeRequest: [], afterResponse: [], beforeError: [] };
+  static globalSubscribr = new Subscribr();
+  static globalHooks = { beforeRequest: [], afterResponse: [], beforeError: [] };
+  static signalControllers = /* @__PURE__ */ new Set();
+  /** Map of in-flight deduplicated requests keyed by URL + method */
+  static inflightRequests = /* @__PURE__ */ new Map();
+  /** Cache for parsed MediaType instances to avoid re-parsing the same content-type strings */
+  static mediaTypeCache = new Map(Object.values(mediaTypes).map((mediaType) => [mediaType.toString(), mediaType]));
+  static contentTypeHandlers = [
+    [mediaTypes.TEXT.type, handleText],
+    [mediaTypes.JSON.subtype, handleJson],
+    [mediaTypes.BIN.subtype, handleReadableStream],
+    [mediaTypes.HTML.subtype, handleHtml],
+    [mediaTypes.XML.subtype, handleXml],
+    [mediaTypes.PNG.type, handleImage],
+    [mediaTypes.JAVA_SCRIPT.subtype, handleScript],
+    [mediaTypes.CSS.subtype, handleCss]
+  ];
   /**
    * Create a new Transportr instance with the provided location or origin and context path.
    *
-   * @param {URL|string|RequestOptions} [url=location.origin] The URL for {@link fetch} requests.
-   * @param {RequestOptions} [options={}] The default {@link RequestOptions} for this instance.
+   * @param url The URL for {@link fetch} requests.
+   * @param options The default {@link RequestOptions} for this instance.
    */
-  constructor(url = globalThis.location.origin, options = {}) {
-    if (object_type_default(url) == Object) {
-      [url, options] = [globalThis.location.origin, url];
+  constructor(url = globalThis.location?.origin ?? "http://localhost", options = {}) {
+    if (isObject(url)) {
+      [url, options] = [globalThis.location?.origin ?? "http://localhost", url];
     }
-    this.#baseUrl = _Transportr.#getBaseUrl(url);
-    this.#options = _Transportr.#createOptions(options, _Transportr.#defaultRequestOptions);
-    this.#subscribr = new Subscribr();
-  }
-  /**
-   * @static
-   * @constant {Object<string, HttpRequestMethod>}
-   */
-  static Method = Object.freeze(http_request_methods_default);
-  /**
-   * @static
-   * @constant {Object<string, HttpMediaType>}
-   */
-  static MediaType = Object.freeze(http_media_type_default);
-  /**
-   * @static
-   * @see {@link HttpRequestHeader}
-   * @constant {Object<string, HttpRequestHeader>}
-   */
-  static RequestHeader = Object.freeze(http_request_headers_default);
-  /**
-   * @static
-   * @constant {Object<string, HttpResponseHeader>}
-   */
-  static ResponseHeader = Object.freeze(http_response_headers_default);
-  /**
-   * @static
-   * @constant {Object<string, RequestCache>}
-   */
-  static CachingPolicy = Object.freeze({
-    DEFAULT: "default",
-    FORCE_CACHE: "force-cache",
-    NO_CACHE: "no-cache",
-    NO_STORE: "no-store",
-    ONLY_IF_CACHED: "only-if-cached",
-    RELOAD: "reload"
-  });
-  /**
-   * @static
-   * @constant {Object<string, RequestCredentials>}
-   */
-  static CredentialsPolicy = Object.freeze({
+    this._baseUrl = _Transportr.getBaseUrl(url);
+    this._options = _Transportr.createOptions(options, _Transportr.defaultRequestOptions);
+    this.subscribr = new Subscribr();
+  }
+  /** HTTP Media Types */
+  static MediaType = HttpMediaType;
+  /** HTTP Request Methods */
+  static RequestMethod = HttpRequestMethod;
+  /** HTTP Request Headers */
+  static RequestHeader = HttpRequestHeader;
+  /** HTTP Response Headers */
+  static ResponseHeader = HttpResponseHeader;
+  /** Request Caching Policy */
+  static CachingPolicy = RequestCachingPolicy;
+  /** Credentials Policy */
+  static CredentialsPolicy = {
     INCLUDE: "include",
     OMIT: "omit",
     SAME_ORIGIN: "same-origin"
-  });
-  /**
-   * @static
-   * @constant {Object<string, RequestMode>}
-   */
-  static RequestMode = Object.freeze({
+  };
+  /** Request Modes */
+  static RequestModes = {
     CORS: "cors",
     NAVIGATE: "navigate",
     NO_CORS: "no-cors",
     SAME_ORIGIN: "same-origin"
-  });
-  /**
-   * @static
-   * @constant {Object<string, RequestRedirect>}
-   */
-  static RedirectPolicy = Object.freeze({
+  };
+  /** Request Priorities */
+  static RequestPriorities = {
+    HIGH: "high",
+    LOW: "low",
+    AUTO: "auto"
+  };
+  /** Redirect Policies */
+  static RedirectPolicies = {
     ERROR: "error",
     FOLLOW: "follow",
     MANUAL: "manual"
-  });
-  /**
-   * @static
-   * @constant {Object<string, ReferrerPolicy>}
-   */
-  static ReferrerPolicy = Object.freeze({
+  };
+  /** Referrer Policies */
+  static ReferrerPolicy = {
     NO_REFERRER: "no-referrer",
     NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
     ORIGIN: "origin",
@@ -2141,555 +3079,867 @@ var Transportr = class _Transportr {
     STRICT_ORIGIN: "strict-origin",
     STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
     UNSAFE_URL: "unsafe-url"
-  });
-  /**
-   * @static
-   * @constant {Object<string, TransportrEvent>}
-   */
-  static Events = RequestEvents;
-  /**
-   * @private
-   * @static
-   * @type {RequestOptions}
-   */
-  static #defaultRequestOptions = Object.freeze({
-    body: null,
-    cache: _Transportr.CachingPolicy.NO_STORE,
+  };
+  /** Request Events	*/
+  static RequestEvents = RequestEvent;
+  /** Default Request Options */
+  static defaultRequestOptions = {
+    body: void 0,
+    cache: RequestCachingPolicy.NO_STORE,
     credentials: _Transportr.CredentialsPolicy.SAME_ORIGIN,
-    headers: { [http_request_headers_default.CONTENT_TYPE]: `${mediaTypes.get(http_media_type_default.JSON)}`, [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.JSON)}` },
-    searchParams: {},
+    headers: new Headers({ [HttpRequestHeader.CONTENT_TYPE]: defaultMediaType, [HttpRequestHeader.ACCEPT]: defaultMediaType }),
+    searchParams: void 0,
     integrity: void 0,
     keepalive: void 0,
-    method: http_request_methods_default.GET,
-    mode: _Transportr.RequestMode.CORS,
-    redirect: _Transportr.RedirectPolicy.FOLLOW,
+    method: HttpRequestMethod.GET,
+    mode: _Transportr.RequestModes.CORS,
+    priority: _Transportr.RequestPriorities.AUTO,
+    redirect: _Transportr.RedirectPolicies.FOLLOW,
     referrer: "about:client",
     referrerPolicy: _Transportr.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
     signal: void 0,
     timeout: 3e4,
-    global: true,
-    window: null
-  });
+    global: true
+  };
   /**
    * Returns a {@link EventRegistration} used for subscribing to global events.
    *
-   * @static
-   * @param {TransportrEvent} event The event to subscribe to.
-   * @param {function(Event, *): void} handler The event handler.
-   * @param {*} context The context to bind the handler to.
-   * @returns {EventRegistration} A new {@link EventRegistration} instance.
+   * @param event The event to subscribe to.
+   * @param handler The event handler.
+   * @param context The context to bind the handler to.
+   * @returns A new {@link EventRegistration} instance.
    */
   static register(event, handler, context) {
-    return _Transportr.#globalSubscribr.subscribe(event, handler, context);
+    return _Transportr.globalSubscribr.subscribe(event, handler, context);
   }
   /**
    * Removes a {@link EventRegistration} from the global event handler.
    *
-   * @static
-   * @param {EventRegistration} eventRegistration The {@link EventRegistration} to remove.
-   * @returns {boolean} True if the {@link EventRegistration} was removed, false otherwise.
+   * @param eventRegistration The {@link EventRegistration} to remove.
+   * @returns True if the {@link EventRegistration} was removed, false otherwise.
    */
   static unregister(eventRegistration) {
-    return _Transportr.#globalSubscribr.unsubscribe(eventRegistration);
+    return _Transportr.globalSubscribr.unsubscribe(eventRegistration);
   }
   /**
    * Aborts all active requests.
    * This is useful for when the user navigates away from the current page.
-   * This will also clear the {@link Transportr#activeRequests} set.
-   *
-   * @static
-   * @returns {void}
+   * This will also clear the {@link Transportr#signalControllers} set.
    */
   static abortAll() {
-    for (const abortSignal of this.#activeRequests) {
-      abortSignal.abort(_abortEvent);
+    for (const signalController of this.signalControllers) {
+      signalController.abort(abortEvent());
+    }
+    this.signalControllers.clear();
+  }
+  /**
+   * Registers a custom content-type response handler.
+   * The handler will be matched against response content-type headers using MediaType matching.
+   * New handlers are prepended so they take priority over built-in handlers.
+   *
+   * @param contentType The content-type string to match (e.g. 'application/pdf', 'text', 'csv').
+   * @param handler The response handler function.
+   */
+  static registerContentTypeHandler(contentType, handler) {
+    _Transportr.contentTypeHandlers.unshift([contentType, handler]);
+  }
+  /**
+   * Removes a previously registered content-type response handler.
+   *
+   * @param contentType The content-type string to remove.
+   * @returns True if the handler was found and removed, false otherwise.
+   */
+  static unregisterContentTypeHandler(contentType) {
+    const index = _Transportr.contentTypeHandlers.findIndex(([type]) => type === contentType);
+    if (index === -1) {
+      return false;
+    }
+    _Transportr.contentTypeHandlers.splice(index, 1);
+    return true;
+  }
+  /**
+   * Registers global lifecycle hooks that run on all requests from all instances.
+   * Global hooks execute before instance and per-request hooks.
+   *
+   * @param hooks The hooks to register globally.
+   */
+  static addHooks(hooks) {
+    if (hooks.beforeRequest) {
+      _Transportr.globalHooks.beforeRequest.push(...hooks.beforeRequest);
     }
-    this.#activeRequests.clear();
+    if (hooks.afterResponse) {
+      _Transportr.globalHooks.afterResponse.push(...hooks.afterResponse);
+    }
+    if (hooks.beforeError) {
+      _Transportr.globalHooks.beforeError.push(...hooks.beforeError);
+    }
+  }
+  /**
+   * Removes all global lifecycle hooks.
+   */
+  static clearHooks() {
+    _Transportr.globalHooks = { beforeRequest: [], afterResponse: [], beforeError: [] };
+  }
+  /**
+   * Tears down all global state: aborts in-flight requests, clears global event subscriptions,
+   * hooks, in-flight deduplication map, and media type cache (retaining built-in entries).
+   */
+  static unregisterAll() {
+    _Transportr.abortAll();
+    _Transportr.globalSubscribr = new Subscribr();
+    _Transportr.clearHooks();
+    _Transportr.inflightRequests.clear();
   }
   /**
    * It returns the base {@link URL} for the API.
    *
-   * @returns {URL} The baseUrl property.
+   * @returns The baseUrl property.
    */
   get baseUrl() {
-    return this.#baseUrl;
+    return this._baseUrl;
   }
   /**
    * Registers an event handler with a {@link Transportr} instance.
    *
-   * @param {TransportrEvent} event The name of the event to listen for.
-   * @param {function(Event, *): void} handler The function to call when the event is triggered.
-   * @param {*} [context] The context to bind to the handler.
-   * @returns {EventRegistration} An object that can be used to remove the event handler.
+   * @param event The name of the event to listen for.
+   * @param handler The function to call when the event is triggered.
+   * @param context The context to bind to the handler.
+   * @returns An object that can be used to remove the event handler.
    */
   register(event, handler, context) {
-    return this.#subscribr.subscribe(event, handler, context);
+    return this.subscribr.subscribe(event, handler, context);
   }
   /**
    * Unregisters an event handler from a {@link Transportr} instance.
    *
-   * @param {EventRegistration} eventRegistration The event registration to remove.
-   * @returns {void}
+   * @param eventRegistration The event registration to remove.
+   * @returns True if the {@link EventRegistration} was removed, false otherwise.
    */
   unregister(eventRegistration) {
-    this.#subscribr.unsubscribe(eventRegistration);
+    return this.subscribr.unsubscribe(eventRegistration);
+  }
+  /**
+   * Registers instance-level lifecycle hooks that run on all requests from this instance.
+   * Instance hooks execute after global hooks but before per-request hooks.
+   *
+   * @param hooks The hooks to register on this instance.
+   * @returns This instance for method chaining.
+   */
+  addHooks(hooks) {
+    if (hooks.beforeRequest) {
+      this.hooks.beforeRequest.push(...hooks.beforeRequest);
+    }
+    if (hooks.afterResponse) {
+      this.hooks.afterResponse.push(...hooks.afterResponse);
+    }
+    if (hooks.beforeError) {
+      this.hooks.beforeError.push(...hooks.beforeError);
+    }
+    return this;
+  }
+  /**
+   * Removes all instance-level lifecycle hooks.
+   * @returns This instance for method chaining.
+   */
+  clearHooks() {
+    this.hooks.beforeRequest.length = 0;
+    this.hooks.afterResponse.length = 0;
+    this.hooks.beforeError.length = 0;
+    return this;
+  }
+  /**
+   * Tears down this instance: clears all instance subscriptions and hooks.
+   * The instance should not be used after calling this method.
+   */
+  destroy() {
+    this.clearHooks();
+    this.subscribr.destroy();
   }
   /**
    * This function returns a promise that resolves to the result of a request to the specified path with
    * the specified options, where the method is GET.
    *
    * @async
-   * @param {string} [path] The path to the resource you want to get.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ResponseBody>} A promise that resolves to the response of the request.
+   * @param path The path to the resource you want to get.
+   * @param options The options for the request.
+   * @returns A promise that resolves to the response of the request.
    */
   async get(path, options) {
-    return this.#get(path, options);
+    return this._get(path, options);
   }
   /**
    * This function makes a POST request to the given path with the given body and options.
    *
    * @async
-   * @param {string} [path] The path to the endpoint you want to call.
-   * @param {RequestBody} body The body of the request.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ResponseBody>} A promise that resolves to the response body.
-   */
-  async post(path, body = {}, options = {}) {
-    if (object_type_default(path) != String) {
-      [path, body, options] = [void 0, path, body];
+   * @template T The expected response type (defaults to ResponseBody)
+   * @param path The path to the endpoint you want to call.
+   * @param options The options for the request.
+   * @returns A promise that resolves to the response body.
+   */
+  async post(path, options) {
+    if (typeof path !== "string") {
+      [path, options] = [void 0, path];
     }
-    return this.#request(path, Object.assign(options, { body }), { method: http_request_methods_default.POST });
+    return this.execute(path, options, { method: HttpRequestMethod.POST });
   }
   /**
    * This function returns a promise that resolves to the result of a request to the specified path with
    * the specified options, where the method is PUT.
    *
    * @async
-   * @param {string} [path] The path to the endpoint you want to call.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ResponseBody>} The return value of the #request method.
+   * @template T The expected response type (defaults to ResponseBody)
+   * @param path The path to the endpoint you want to call.
+   * @param options The options for the request.
+   * @returns The return value of the #request method.
    */
   async put(path, options) {
-    return this.#request(path, options, { method: http_request_methods_default.PUT });
+    return this.execute(path, options, { method: HttpRequestMethod.PUT });
   }
   /**
    * It takes a path and options, and returns a request with the method set to PATCH.
    *
    * @async
-   * @param {string} [path] The path to the endpoint you want to hit.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ResponseBody>} A promise that resolves to the response of the request.
+   * @template T The expected response type (defaults to ResponseBody)
+   * @param path The path to the endpoint you want to hit.
+   * @param options The options for the request.
+   * @returns A promise that resolves to the response of the request.
    */
   async patch(path, options) {
-    return this.#request(path, options, { method: http_request_methods_default.PATCH });
+    return this.execute(path, options, { method: HttpRequestMethod.PATCH });
   }
   /**
    * It takes a path and options, and returns a request with the method set to DELETE.
    *
    * @async
-   * @param {string} [path] The path to the resource you want to access.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ResponseBody>} The result of the request.
+   * @param path The path to the resource you want to access.
+   * @param options The options for the request.
+   * @returns The result of the request.
    */
   async delete(path, options) {
-    return this.#request(path, options, { method: http_request_methods_default.DELETE });
+    return this.execute(path, options, { method: HttpRequestMethod.DELETE });
   }
   /**
    * Returns the response headers of a request to the given path.
    *
    * @async
-   * @param {string} [path] The path to the resource you want to access.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ResponseBody>} A promise that resolves to the response object.
+   * @param path The path to the resource you want to access.
+   * @param options The options for the request.
+   * @returns A promise that resolves to the response object.
    */
   async head(path, options) {
-    return this.#request(path, options, { method: http_request_methods_default.HEAD });
+    return this.execute(path, options, { method: HttpRequestMethod.HEAD });
   }
   /**
    * It returns a promise that resolves to the allowed request methods for the given resource path.
    *
    * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<string[]>} A promise that resolves to an array of allowed request methods for this resource.
+   * @param path The path to the resource.
+   * @param options The options for the request.
+   * @returns A promise that resolves to an array of allowed request methods for this resource.
    */
-  async options(path, options) {
-    const response = await this.#request(path, options, { method: http_request_methods_default.OPTIONS });
-    return response.headers.get("allow").split(",").map((method) => method.trim());
+  async options(path, options = {}) {
+    if (isObject(path)) {
+      [path, options] = [void 0, path];
+    }
+    const requestConfig = this.processRequestOptions(options, { method: HttpRequestMethod.OPTIONS });
+    const { requestOptions } = requestConfig;
+    const requestHooks = requestOptions.hooks;
+    let url = _Transportr.createUrl(this._baseUrl, path, requestOptions.searchParams);
+    const beforeRequestHookSets = [_Transportr.globalHooks.beforeRequest, this.hooks.beforeRequest, requestHooks?.beforeRequest];
+    for (const hooks of beforeRequestHookSets) {
+      if (!hooks) {
+        continue;
+      }
+      for (const hook of hooks) {
+        const result = await hook(requestOptions, url);
+        if (result) {
+          Object.assign(requestOptions, result);
+          if (result.searchParams !== void 0) {
+            url = _Transportr.createUrl(this._baseUrl, path, requestOptions.searchParams);
+          }
+        }
+      }
+    }
+    let response = await this._request(path, requestConfig);
+    const afterResponseHookSets = [_Transportr.globalHooks.afterResponse, this.hooks.afterResponse, requestHooks?.afterResponse];
+    for (const hooks of afterResponseHookSets) {
+      if (!hooks) {
+        continue;
+      }
+      for (const hook of hooks) {
+        const result = await hook(response, requestOptions);
+        if (result) {
+          response = result;
+        }
+      }
+    }
+    const allowedMethods = response.headers.get("allow")?.split(",").map((method) => method.trim());
+    this.publish({ name: RequestEvent.SUCCESS, data: allowedMethods, global: options.global });
+    return allowedMethods;
   }
   /**
-   * It takes a path and options, and makes a request to the server.
-   *
+   * It takes a path and options, and makes a request to the server
    * @async
-   * @param {string} [path] The path to the endpoint you want to hit.
-   * @param {RequestOptions} [userOptions] The options for the request.
-   * @returns {Promise<ResponseBody>} The return value of the function is the return value of the function that is passed to the `then` method of the promise returned by the `fetch` method.
-   */
-  async request(path, userOptions) {
-    return this.#request(path, userOptions, {}, (response) => response);
+   * @param path The path to the endpoint you want to hit.
+   * @param options The options for the request.
+   * @returns The return value of the function is the return value of the function that is passed to the `then` method of the promise returned by the `fetch` method.
+   * @throws {HttpError} If an error occurs during the request.
+   */
+  async request(path, options = {}) {
+    if (isObject(path)) {
+      [path, options] = [void 0, path];
+    }
+    const response = await this._request(path, this.processRequestOptions(options, {}));
+    this.publish({ name: RequestEvent.SUCCESS, data: response, global: options.global });
+    return response;
   }
   /**
-   * It gets a JSON resource from the server.
+   * It gets the JSON representation of the resource at the given path.
    *
    * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options object to pass to the request.
-   * @returns {Promise<JsonObject>} A promise that resolves to the response body as a JSON object.
+   * @template T The expected JSON response type (defaults to JsonObject)
+   * @param path The path to the resource.
+   * @param options The options object to pass to the request.
+   * @returns A promise that resolves to the response body as a typed JSON value.
    */
   async getJson(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.JSON)}` } }, _handleJson);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: `${mediaTypes.JSON}` } }, handleJson);
   }
   /**
    * It gets the XML representation of the resource at the given path.
    *
    * @async
-   * @param {string} [path] The path to the resource you want to get.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<Document>} The result of the function call to #get.
+   * @param path The path to the resource you want to get.
+   * @param options The options for the request.
+   * @returns The result of the function call to #get.
    */
   async getXml(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.XML)}` } }, _handleXml);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: `${mediaTypes.XML}` } }, handleXml);
   }
   /**
    * Get the HTML content of the specified path.
+   * When a selector is provided, returns only the first matching element from the parsed document.
    *
-   * @todo Add way to return portion of the retrieved HTML using a selector. Like jQuery.
    * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<Document>} The return value of the function is the return value of the function passed to the `then`
-   * method of the promise returned by the `#get` method.
+   * @param path The path to the resource.
+   * @param options The options for the request.
+   * @param selector An optional CSS selector to extract a specific element from the parsed HTML.
+   * @returns A promise that resolves to a Document, an Element (if selector matched), or void.
    */
-  async getHtml(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.HTML)}` } }, _handleHtml);
+  async getHtml(path, options, selector) {
+    const doc = await this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: `${mediaTypes.HTML}` } }, handleHtml);
+    return selector && doc ? doc.querySelector(selector) : doc;
   }
   /**
    * It returns a promise that resolves to the HTML fragment at the given path.
+   * When a selector is provided, returns only the first matching element from the parsed fragment.
    *
-   * @todo Add way to return portion of the retrieved HTML using a selector. Like jQuery.
    * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<DocumentFragment>} A promise that resolves to an HTML fragment.
+   * @param path The path to the resource.
+   * @param options The options for the request.
+   * @param selector An optional CSS selector to extract a specific element from the parsed fragment.
+   * @returns A promise that resolves to a DocumentFragment, an Element (if selector matched), or void.
    */
-  async getHtmlFragment(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.HTML)}` } }, _handleHtmlFragment);
+  async getHtmlFragment(path, options, selector) {
+    const fragment = await this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: `${mediaTypes.HTML}` } }, handleHtmlFragment);
+    return selector && fragment ? fragment.querySelector(selector) : fragment;
   }
   /**
-   * It gets a script from the server, and appends the script to the {@link Document} {@link HTMLHeadElement}
-   * CORS is enabled by default.
-   *
-   * @async
-   * @param {string} [path] The path to the script.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<void>} A promise that has been resolved.
+   * It gets a script from the server, and appends the script to the Document HTMLHeadElement
+   * @param path The path to the script.
+   * @param options The options for the request.
+   * @returns A promise that resolves to void.
    */
   async getScript(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.JAVA_SCRIPT)}` } }, _handleScript);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: `${mediaTypes.JAVA_SCRIPT}` } }, handleScript);
   }
   /**
-   * Gets a stylesheet from the server, and adds it as a {@link Blob} {@link URL}.
-   *
-   * @async
-   * @param {string} [path] The path to the stylesheet.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<void>} A promise that has been resolved.
+   * Gets a stylesheet from the server, and adds it as a Blob URL.
+   * @param path The path to the stylesheet.
+   * @param options The options for the request.
+   * @returns A promise that resolves to void.
    */
   async getStylesheet(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: `${mediaTypes.get(http_media_type_default.CSS)}` } }, _handleCss);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: `${mediaTypes.CSS}` } }, handleCss);
   }
   /**
    * It returns a blob from the specified path.
-   *
-   * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<Blob>} A promise that resolves to a blob.
+   * @param path The path to the resource.
+   * @param options The options for the request.
+   * @returns A promise that resolves to a Blob or void.
    */
   async getBlob(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBlob);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: HttpMediaType.BIN } }, handleBlob);
   }
   /**
-   * It returns a promise that resolves to an object URL.
-   *
-   * @async
-   * @param {string|RequestOptions} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<string>} A promise that resolves to an object URL.
+   * It returns a promise that resolves to an `HTMLImageElement`.
+   * The object URL created to load the image is automatically revoked to prevent memory leaks.
+   * Works in both browser and Node.js (via JSDOM) environments.
+   * @param path The path to the image.
+   * @param options The options for the request.
+   * @returns A promise that resolves to an `HTMLImageElement` or `void`.
    */
   async getImage(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }, _handleImage);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: "image/*" } }, handleImage);
   }
   /**
    * It gets a buffer from the specified path
-   *
-   * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ArrayBuffer>} A promise that resolves to a buffer.
+   * @param path The path to the resource.
+   * @param options The options for the request.
+   * @returns A promise that resolves to an ArrayBuffer or void.
    */
   async getBuffer(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBuffer);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: HttpMediaType.BIN } }, handleBuffer);
   }
   /**
    * It returns a readable stream of the response body from the specified path.
-   *
-   * @async
-   * @param {string} [path] The path to the resource.
-   * @param {RequestOptions} [options] The options for the request.
-   * @returns {Promise<ReadableStream<Uint8Array>>} A readable stream.
+   * @param path The path to the resource.
+   * @param options The options for the request.
+   * @returns A promise that resolves to a ReadableStream, null, or void.
    */
   async getStream(path, options) {
-    return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleReadableStream);
+    return this._get(path, options, { headers: { [HttpRequestHeader.ACCEPT]: HttpMediaType.BIN } }, handleReadableStream);
   }
   /**
-   * Makes a GET request to the given path, using the given options, and then calls the
-   * given response handler with the response.
-   *
-   * @private
+   * Handles a GET request.
    * @async
-   * @param {string} [path] The path to the endpoint you want to call.
-   * @param {RequestOptions} [userOptions] The options passed to the public function to use for the request.
-   * @param {RequestOptions} [options={}] The options for the request.
-   * @param {ResponseHandler<ResponseBody>} [responseHandler] A function that will be called with the response object.
-   * @returns {Promise<ResponseBody>} The result of the #request method.
-   */
-  async #get(path, userOptions, options = {}, responseHandler) {
-    return this.#request(path, userOptions, Object.assign(options, { method: http_request_methods_default.GET }), responseHandler);
+   * @param path The path to the resource.
+   * @param userOptions The user options for the request.
+   * @param options The options for the request.
+   * @param responseHandler The response handler for the request.
+   * @returns A promise that resolves to the response body or void.
+   */
+  async _get(path, userOptions, options = {}, responseHandler) {
+    return this.execute(path, userOptions, { ...options, method: HttpRequestMethod.GET, body: void 0 }, responseHandler);
+  }
+  /**
+   * It processes the request options and returns a new object with the processed options.
+   * @param path The path to the resource.
+   * @param processedRequestOptions The user options for the request.
+   * @returns A new object with the processed options.
+   */
+  async _request(path, { signalController, requestOptions, global }) {
+    _Transportr.signalControllers.add(signalController);
+    const retryConfig = _Transportr.normalizeRetryOptions(requestOptions.retry);
+    const method = requestOptions.method ?? "GET";
+    const canRetry = retryConfig.limit > 0 && retryConfig.methods.includes(method);
+    const canDedupe = requestOptions.dedupe === true && (method === "GET" || method === "HEAD");
+    let attempt = 0;
+    const startTime = performance.now();
+    const getTiming = () => {
+      const end = performance.now();
+      return { start: startTime, end, duration: end - startTime };
+    };
+    try {
+      const url = _Transportr.createUrl(this._baseUrl, path, requestOptions.searchParams);
+      const dedupeKey = canDedupe ? `${method}:${url.href}` : "";
+      if (canDedupe) {
+        const inflight = _Transportr.inflightRequests.get(dedupeKey);
+        if (inflight) {
+          return (await inflight).clone();
+        }
+      }
+      const doFetch = async () => {
+        while (true) {
+          try {
+            const response = await fetch(url, requestOptions);
+            if (!response.ok) {
+              if (canRetry && attempt < retryConfig.limit && retryConfig.statusCodes.includes(response.status)) {
+                attempt++;
+                this.publish({ name: RequestEvent.RETRY, data: { attempt, status: response.status, method, path, timing: getTiming() }, global });
+                await _Transportr.retryDelay(retryConfig, attempt);
+                continue;
+              }
+              let entity;
+              try {
+                entity = await response.text();
+              } catch {
+              }
+              throw await this.handleError(path, response, { entity, url, method, timing: getTiming() }, requestOptions);
+            }
+            return response;
+          } catch (cause) {
+            if (cause instanceof HttpError) {
+              throw cause;
+            }
+            if (canRetry && attempt < retryConfig.limit) {
+              attempt++;
+              this.publish({ name: RequestEvent.RETRY, data: { attempt, error: cause.message, method, path, timing: getTiming() }, global });
+              await _Transportr.retryDelay(retryConfig, attempt);
+              continue;
+            }
+            throw await this.handleError(path, void 0, { cause, url, method, timing: getTiming() }, requestOptions);
+          }
+        }
+      };
+      if (canDedupe) {
+        const promise = doFetch();
+        _Transportr.inflightRequests.set(dedupeKey, promise);
+        try {
+          const response = await promise;
+          return response;
+        } finally {
+          _Transportr.inflightRequests.delete(dedupeKey);
+        }
+      }
+      return await doFetch();
+    } finally {
+      _Transportr.signalControllers.delete(signalController.destroy());
+      if (!requestOptions.signal?.aborted) {
+        const timing = getTiming();
+        this.publish({ name: RequestEvent.COMPLETE, data: { timing }, global });
+        if (_Transportr.signalControllers.size === 0) {
+          this.publish({ name: RequestEvent.ALL_COMPLETE, global });
+        }
+      }
+    }
   }
   /**
-   * It takes a path, options, and a response handler, and returns a promise that resolves to the
-   * response entity.
-   *
-   * @private
-   * @async
-   * @param {string} [path] The path to the resource you want to access.
-   * @param {RequestOptions} [userOptions={}] The options passed to the public function to use for the request.
-   * @param {RequestOptions} [options={}] The options to use for the request.
-   * @param {ResponseHandler<ResponseBody>} [responseHandler] A function that will be called with the response body as a parameter. This
-   * is useful if you want to do something with the response body before returning it.
-   * @returns {Promise<ResponseBody>} The response from the API call.
-   */
-  async #request(path, userOptions = {}, options = {}, responseHandler) {
-    if (object_type_default(path) == Object) {
+   * Normalizes a retry option into a full RetryOptions object.
+   * @param retry The retry option from request options.
+   * @returns Normalized retry configuration.
+   */
+  static normalizeRetryOptions(retry) {
+    if (retry === void 0) {
+      return { limit: 0, statusCodes: [], methods: [], delay: retryDelay, backoffFactor: retryBackoffFactor };
+    }
+    if (typeof retry === "number") {
+      return { limit: retry, statusCodes: [...retryStatusCodes], methods: [...retryMethods], delay: retryDelay, backoffFactor: retryBackoffFactor };
+    }
+    return {
+      limit: retry.limit ?? 0,
+      statusCodes: retry.statusCodes ?? [...retryStatusCodes],
+      methods: retry.methods ?? [...retryMethods],
+      delay: retry.delay ?? retryDelay,
+      backoffFactor: retry.backoffFactor ?? retryBackoffFactor
+    };
+  }
+  /**
+   * Waits for the appropriate delay before a retry attempt.
+   * @param config The retry configuration.
+   * @param attempt The current attempt number (1-based).
+   * @returns A promise that resolves after the delay.
+   */
+  static retryDelay(config, attempt) {
+    const ms = typeof config.delay === "function" ? config.delay(attempt) : config.delay * config.backoffFactor ** (attempt - 1);
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * It returns a response handler based on the content type of the response.
+   * @param path The path to the resource.
+   * @param userOptions The user options for the request.
+   * @param options The options for the request.
+   * @param responseHandler The response handler for the request.
+   * @returns A response handler function.
+   */
+  async execute(path, userOptions = {}, options = {}, responseHandler) {
+    if (isObject(path)) {
       [path, userOptions] = [void 0, path];
     }
-    options = this.#processRequestOptions(userOptions, options);
-    let response;
-    const url = _Transportr.#createUrl(this.#baseUrl, path, options.searchParams);
-    try {
-      _Transportr.#activeRequests.add(options.signal);
-      response = await fetch(url, new Proxy(options, abortSignalProxyHandler));
-      if (!responseHandler && response.status != 204) {
-        responseHandler = this.#getResponseHandler(response.headers.get(http_response_headers_default.CONTENT_TYPE));
+    const requestConfig = this.processRequestOptions(userOptions, options);
+    const { requestOptions } = requestConfig;
+    const requestHooks = requestOptions.hooks;
+    let url = _Transportr.createUrl(this._baseUrl, path, requestOptions.searchParams);
+    const beforeRequestHookSets = [_Transportr.globalHooks.beforeRequest, this.hooks.beforeRequest, requestHooks?.beforeRequest];
+    for (const hooks of beforeRequestHookSets) {
+      if (!hooks) {
+        continue;
       }
-      const result = await responseHandler?.(response) ?? response;
-      if (!response.ok) {
-        return Promise.reject(this.#handleError(url, { status: _Transportr.#generateResponseStatusFromError("ResponseError", response), entity: result }));
+      for (const hook of hooks) {
+        const result = await hook(requestOptions, url);
+        if (result) {
+          Object.assign(requestOptions, result);
+          if (result.searchParams !== void 0) {
+            url = _Transportr.createUrl(this._baseUrl, path, requestOptions.searchParams);
+          }
+        }
       }
-      this.#publish({ name: RequestEvents.SUCCESS, data: result, global: options.global });
-      return result;
-    } catch (cause) {
-      return Promise.reject(this.#handleError(url, { cause, status: _Transportr.#generateResponseStatusFromError(cause.name, response) }));
-    } finally {
-      options.signal.clearTimeout();
-      if (!options.signal.aborted) {
-        this.#publish({ name: RequestEvents.COMPLETE, data: response, global: options.global });
-        _Transportr.#activeRequests.delete(options.signal);
-        if (_Transportr.#activeRequests.size == 0) {
-          this.#publish({ name: RequestEvents.ALL_COMPLETE, global: options.global });
+    }
+    let response = await this._request(path, requestConfig);
+    const afterResponseHookSets = [_Transportr.globalHooks.afterResponse, this.hooks.afterResponse, requestHooks?.afterResponse];
+    for (const hooks of afterResponseHookSets) {
+      if (!hooks) {
+        continue;
+      }
+      for (const hook of hooks) {
+        const result = await hook(response, requestOptions);
+        if (result) {
+          response = result;
         }
       }
     }
+    try {
+      if (!responseHandler && response.status !== 204) {
+        responseHandler = this.getResponseHandler(response.headers.get(HttpResponseHeader.CONTENT_TYPE));
+      }
+      const data = await responseHandler?.(response);
+      this.publish({ name: RequestEvent.SUCCESS, data, global: requestConfig.global });
+      return data;
+    } catch (cause) {
+      throw await this.handleError(path, response, { cause }, requestOptions);
+    }
   }
   /**
-   * Creates the options for a {@link Transportr} instance.
-   *
-   * @private
-   * @static
-   * @param {RequestOptions} userOptions The {@link RequestOptions} to convert.
-   * @param {RequestOptions} options The default {@link RequestOptions}.
-   * @returns {RequestOptions} The converted {@link RequestOptions}.
+   * Creates a new set of options for a request.
+   * @param options The user options for the request.
+   * @param userOptions The default options for the request.
+   * @returns A new set of options for the request.
    */
-  static #createOptions({ body, headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
-    return object_merge_default(options, userOptions, {
-      body: [FormData, URLSearchParams, Object].includes(object_type_default(body)) ? new ParameterMap(body) : body,
-      headers: _Transportr.#mergeOptions(new Headers(), userHeaders, headers),
-      searchParams: _Transportr.#mergeOptions(new URLSearchParams(), userSearchParams, searchParams)
-    });
+  static createOptions({ headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
+    headers = _Transportr.mergeHeaders(new Headers(), userHeaders, headers);
+    searchParams = _Transportr.mergeSearchParams(new URLSearchParams(), userSearchParams, searchParams);
+    return { ...objectMerge(options, userOptions) ?? {}, headers, searchParams };
   }
   /**
-   * Merge the user options and request options into the target.
-   *
-   * @private
-   * @static
-   * @param {Headers|URLSearchParams|FormData} target The target to merge the options into.
-   * @param {Headers|URLSearchParams|FormData|Object} userOption The user options to merge into the target.
-   * @param {Headers|URLSearchParams|FormData|Object} requestOption The request options to merge into the target.
-   * @returns {Headers|URLSearchParams} The target.
+   * Merges user and request headers into the target Headers object.
+   * @param target The target Headers object.
+   * @param headerSources Variable number of header sources to merge.
+   * @returns The merged Headers object.
    */
-  static #mergeOptions(target, userOption = {}, requestOption = {}) {
-    for (const option of [userOption, requestOption]) {
-      for (const [name, value] of option.entries?.() ?? Object.entries(option)) {
-        target.set(name, value);
+  static mergeHeaders(target, ...headerSources) {
+    for (const headers of headerSources) {
+      if (headers === void 0) {
+        continue;
+      }
+      if (headers instanceof Headers) {
+        headers.forEach((value, name) => target.set(name, value));
+      } else if (Array.isArray(headers)) {
+        for (const [name, value] of headers) {
+          target.set(name, value);
+        }
+      } else {
+        const record = headers;
+        const keys = Object.keys(record);
+        for (let i = 0; i < keys.length; i++) {
+          const name = keys[i];
+          const value = record[name];
+          if (value !== void 0) {
+            target.set(name, String(value));
+          }
+        }
       }
     }
     return target;
   }
   /**
-   * Merges the user options and request options with the instance options into a new object that is used for the request.
-   *
-   * @private
-   * @param {RequestOptions} userOptions The user options to merge into the request options.
-   * @param {RequestOptions} options The request options to merge into the user options.
-   * @returns {RequestOptions} The merged options.
+   * Merges user and request search parameters into the target URLSearchParams object.
+   * @param target The target URLSearchParams object.
+   * @param sources The search parameters to merge.
+   * @returns The merged URLSearchParams object.
    */
-  #processRequestOptions({ body: userBody, headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
-    const requestOptions = object_merge_default(this.#options, userOptions, options, {
-      headers: _Transportr.#mergeOptions(new Headers(this.#options.headers), userHeaders, headers),
-      searchParams: _Transportr.#mergeOptions(new URLSearchParams(this.#options.searchParams), userSearchParams, searchParams)
-    });
-    if (requestBodyMethods.includes(requestOptions.method)) {
-      if ([ParameterMap, FormData, URLSearchParams, Object].includes(object_type_default(userBody))) {
-        const contentType = requestOptions.headers.get(http_request_headers_default.CONTENT_TYPE);
-        const mediaType = (mediaTypes.get(contentType) ?? MediaType.parse(contentType))?.subtype;
-        if (mediaType == http_media_type_default.MULTIPART_FORM_DATA) {
-          requestOptions.body = _Transportr.#mergeOptions(new FormData(requestOptions.body), userBody);
-        } else if (mediaType == http_media_type_default.FORM) {
-          requestOptions.body = _Transportr.#mergeOptions(new URLSearchParams(requestOptions.body), userBody);
-        } else if (mediaType.includes("json")) {
-          requestOptions.body = JSON.stringify(_Transportr.#mergeOptions(new ParameterMap(requestOptions.body), userBody));
-        } else {
-          requestOptions.body = _Transportr.#mergeOptions(new ParameterMap(requestOptions.body), userBody);
+  static mergeSearchParams(target, ...sources) {
+    for (const searchParams of sources) {
+      if (searchParams === void 0) {
+        continue;
+      }
+      if (searchParams instanceof URLSearchParams) {
+        searchParams.forEach((value, name) => target.set(name, value));
+      } else if (isString(searchParams) || Array.isArray(searchParams)) {
+        for (const [name, value] of new URLSearchParams(searchParams)) {
+          target.set(name, value);
         }
       } else {
+        const keys = Object.keys(searchParams);
+        for (let i = 0; i < keys.length; i++) {
+          const name = keys[i];
+          const value = searchParams[name];
+          if (value !== void 0) {
+            target.set(name, String(value));
+          }
+        }
+      }
+    }
+    return target;
+  }
+  /**
+   * Processes request options by merging user, instance, and method-specific options.
+   * This method optimizes performance by using cached instance options and performing
+   * shallow merges where possible instead of deep object cloning.
+   * @param userOptions The user-provided options for the request.
+   * @param options Additional method-specific options.
+   * @returns Processed request options with signal controller and global flag.
+   */
+  processRequestOptions({ body: userBody, headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
+    const requestOptions = {
+      // Spread instance options (already merged with defaults)
+      ...this._options,
+      // Spread user options (shallow merge, sufficient for flat properties)
+      ...userOptions,
+      // Spread method-specific options (e.g., method: 'POST')
+      ...options,
+      // Deep merge required for headers and searchParams
+      headers: _Transportr.mergeHeaders(new Headers(), this._options.headers, userHeaders, headers),
+      searchParams: _Transportr.mergeSearchParams(new URLSearchParams(), this._options.searchParams, userSearchParams, searchParams)
+    };
+    if (isRequestBodyMethod(requestOptions.method)) {
+      if (isRawBody(userBody)) {
         requestOptions.body = userBody;
+        requestOptions.headers.delete(HttpRequestHeader.CONTENT_TYPE);
+      } else {
+        const isJson = requestOptions.headers.get(HttpRequestHeader.CONTENT_TYPE)?.includes("json") ?? false;
+        requestOptions.body = isJson && isObject(userBody) ? serialize(userBody) : userBody;
       }
     } else {
-      requestOptions.headers.delete(http_request_headers_default.CONTENT_TYPE);
-      if (requestOptions.body) {
-        _Transportr.#mergeOptions(requestOptions.searchParams, requestOptions.body);
+      requestOptions.headers.delete(HttpRequestHeader.CONTENT_TYPE);
+      if (requestOptions.body instanceof URLSearchParams) {
+        _Transportr.mergeSearchParams(requestOptions.searchParams, requestOptions.body);
       }
       requestOptions.body = void 0;
     }
-    requestOptions.signal = new AbortSignal(requestOptions.signal).onAbort((event) => this.#publish({ name: RequestEvents.ABORTED, event, global: requestOptions.global })).onTimeout((event) => this.#publish({ name: RequestEvents.TIMEOUT, event, global: requestOptions.global }));
-    this.#publish({ name: RequestEvents.CONFIGURED, data: requestOptions, global: requestOptions.global });
-    return requestOptions;
+    const { signal, timeout, global = false, xsrf } = requestOptions;
+    if (xsrf) {
+      const xsrfConfig = typeof xsrf === "object" ? xsrf : {};
+      const token = getCookieValue(xsrfConfig.cookieName ?? XSRF_COOKIE_NAME);
+      if (token) {
+        requestOptions.headers.set(xsrfConfig.headerName ?? XSRF_HEADER_NAME, token);
+      }
+    }
+    const signalController = new SignalController({ signal, timeout }).onAbort((event) => this.publish({ name: RequestEvent.ABORTED, event, global })).onTimeout((event) => this.publish({ name: RequestEvent.TIMEOUT, event, global }));
+    requestOptions.signal = signalController.signal;
+    this.publish({ name: RequestEvent.CONFIGURED, data: requestOptions, global });
+    return { signalController, requestOptions, global };
   }
   /**
-   * It takes a url or a string, and returns a {@link URL} instance.
-   * If the url is a string and starts with a slash, then the origin of the current page is used as the base url.
-   *
-   * @private
-   * @static
-   * @param {URL|string} url The URL to convert to a {@link URL} instance.
-   * @returns {URL} A {@link URL} instance.
-   * @throws {TypeError} If the url is not a string or {@link URL} instance.
+   * Gets the base URL from a URL or string.
+   * @param url The URL or string to parse.
+   * @returns The base URL.
    */
-  static #getBaseUrl(url) {
-    switch (object_type_default(url)) {
-      case URL:
-        return url;
-      case String:
-        return new URL(url, url.startsWith("/") ? globalThis.location.origin : void 0);
-      default:
-        throw new TypeError("Invalid URL");
+  static getBaseUrl(url) {
+    if (url instanceof URL) {
+      return url;
+    }
+    if (!isString(url)) {
+      throw new TypeError("Invalid URL");
     }
+    return new URL(url, url.startsWith("/") ? globalThis.location.origin : void 0);
   }
   /**
-   * It takes a URL, a path, and a set of search parameters, and returns a new URL with the path and
-   * search parameters applied.
-   *
-   * @private
-   * @static
-   * @param {URL} url The URL to use as a base.
-   * @param {string} [path] The optional, relative path to the resource. This MUST be a relative path, otherwise, you should create a new {@link Transportr} instance.
-   * @param {URLSearchParams} [searchParams] The optional search parameters to append to the URL.
-   * @returns {URL} A new URL object with the pathname and origin of the url parameter, and the path parameter appended to the end of the pathname.
+   * Parses a content-type string into a MediaType instance with caching.
+   * This method caches parsed MediaType instances to avoid re-parsing the same content-type strings,
+   * which significantly improves performance for repeated requests with the same content types.
+   * @param contentType The content-type string to parse.
+   * @returns The parsed MediaType instance, or undefined if parsing fails.
+   */
+  static getOrParseMediaType(contentType) {
+    if (contentType === null) {
+      return;
+    }
+    let mediaType = _Transportr.mediaTypeCache.get(contentType);
+    if (mediaType !== void 0) {
+      return mediaType;
+    }
+    mediaType = MediaType.parse(contentType) ?? void 0;
+    if (mediaType !== void 0) {
+      if (_Transportr.mediaTypeCache.size >= 100) {
+        const firstKey = _Transportr.mediaTypeCache.keys().next().value;
+        if (firstKey !== void 0) {
+          _Transportr.mediaTypeCache.delete(firstKey);
+        }
+      }
+      _Transportr.mediaTypeCache.set(contentType, mediaType);
+    }
+    return mediaType;
+  }
+  /**
+   * Creates a new URL with the given path and search parameters.
+   * @param url The base URL.
+   * @param path The path to append to the base URL.
+   * @param searchParams The search parameters to append to the URL.
+   * @returns A new URL with the given path and search parameters.
    */
-  static #createUrl(url, path, searchParams) {
+  static createUrl(url, path, searchParams) {
     const requestUrl = path ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(url);
-    searchParams?.forEach((value, name) => requestUrl.searchParams.append(name, value));
+    if (searchParams) {
+      _Transportr.mergeSearchParams(requestUrl.searchParams, searchParams);
+    }
     return requestUrl;
   }
   /**
-   * Generates a ResponseStatus object based on the error name and the response.
-   *
-   * @private
-   * @static
-   * @param {string} errorName The name of the error.
-   * @param {Response} response The response object returned by the fetch API.
-   * @returns {ResponseStatus} The response status object.
+   * It generates a ResponseStatus object from an error name and a Response object.
+   * @param errorName The name of the error.
+   * @param response The Response object.
+   * @returns A ResponseStatus object.
    */
-  static #generateResponseStatusFromError(errorName, response) {
+  static generateResponseStatusFromError(errorName, { status, statusText } = new Response()) {
     switch (errorName) {
-      case "AbortError":
-        return eventResponseStatuses[RequestEvents.ABORTED];
-      case "TimeoutError":
-        return eventResponseStatuses[RequestEvents.TIMEOUT];
+      case SignalErrors.ABORT:
+        return aborted;
+      case SignalErrors.TIMEOUT:
+        return timedOut;
       default:
-        return response ? new ResponseStatus(response.status, response.statusText) : internalServerError;
+        return status >= 400 ? new ResponseStatus(status, statusText) : internalServerError;
     }
   }
   /**
-   * Handles an error by logging it and throwing it.
-   *
-   * @private
-   * @param {URL} url The path to the resource you want to access.
-   * @param {import('./http-error.js').HttpErrorOptions} options The options for the HttpError.
-   * @returns {HttpError} The HttpError.
-   */
-  #handleError(url, options) {
-    const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
-    this.#publish({ name: RequestEvents.ERROR, data: error });
+   * Handles an error that occurs during a request.
+   * @param path The path of the request.
+   * @param response The Response object.
+   * @param options Additional error context including cause, entity, url, method, and timing.
+   * @param requestOptions The original request options that led to the error, used for hooks context.
+   * @returns An HttpError object.
+   */
+  async handleError(path, response, { cause, entity, url, method, timing } = {}, requestOptions) {
+    const message = method && url ? `${method} ${url.href} failed${response ? ` with status ${response.status}` : ""}` : `An error has occurred with your request to: '${path}'`;
+    let error = new HttpError(_Transportr.generateResponseStatusFromError(cause?.name, response), { message, cause, entity, url, method, timing });
+    const beforeErrorHookSets = [_Transportr.globalHooks.beforeError, this.hooks.beforeError, requestOptions?.hooks?.beforeError];
+    for (const hooks of beforeErrorHookSets) {
+      if (!hooks) {
+        continue;
+      }
+      for (const hook of hooks) {
+        const result = await hook(error);
+        if (result instanceof HttpError) {
+          error = result;
+        }
+      }
+    }
+    this.publish({ name: RequestEvent.ERROR, data: error });
     return error;
   }
   /**
-   * Publishes an event to the global and instance subscribers.
-   *
-   * @private
-   * @param {Object} options The options for the event.
-   * @param {string} options.name The name of the event.
-   * @param {Event} [options.event] The event object.
-   * @param {*} [options.data] The data to pass to the subscribers.
-   * @param {boolean} [options.global=true] Whether or not to publish the event to the global subscribers.
-   * @returns {void}
+   * Publishes an event to the global and instance event handlers.
+   * @param eventObject The event object to publish.
    */
-  #publish({ name, event = new CustomEvent(name), data, global = true } = {}) {
+  publish({ name, event = new CustomEvent(name), data, global = true }) {
     if (global) {
-      _Transportr.#globalSubscribr.publish(name, event, data);
+      _Transportr.globalSubscribr.publish(name, event, data);
     }
-    this.#subscribr.publish(name, event, data);
+    this.subscribr.publish(name, event, data);
   }
   /**
-   * Returns a response handler for the given content type.
-   *
-   * @private
-   * @param {string} contentType The content type of the response.
-   * @returns {ResponseHandler<ResponseBody>} The response handler.
+   * It returns a response handler based on the content type of the response.
+   * @param contentType The content type of the response.
+   * @returns A response handler function.
    */
-  #getResponseHandler(contentType) {
-    const mediaType = MediaType.parse(contentType);
-    if (mediaType) {
-      for (const [responseHandler, contentType2] of _Transportr.#contentTypeHandlers) {
-        if (mediaType.matches(contentType2)) {
-          return responseHandler;
-        }
+  getResponseHandler(contentType) {
+    if (!contentType) {
+      return;
+    }
+    const mediaType = _Transportr.getOrParseMediaType(contentType);
+    if (!mediaType) {
+      return;
+    }
+    for (const [contentType2, responseHandler] of _Transportr.contentTypeHandlers) {
+      if (mediaType.matches(contentType2)) {
+        return responseHandler;
       }
     }
     return void 0;
   }
   /**
-   * A String value that is used in the creation of the default string
-   * description of an object. Called by the built-in method {@link Object.prototype.toString}.
-   *
-   * @returns {string} The default string description of this object.
+   * A string representation of the Transportr instance.
+   * @returns The string 'Transportr'.
    */
   get [Symbol.toStringTag]() {
     return "Transportr";
   }
 };
 export {
-  Transportr as default
+  Transportr
 };
+/*! Bundled license information:
+
+dompurify/dist/purify.es.mjs:
+  (*! @license DOMPurify 3.3.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.3/LICENSE *)
+*/
+//# sourceMappingURL=transportr.js.map