@d1g1tal/transportr 1.2.2 → 1.3.0

package/dist/transportr.js

@@ -23,38 +23,6 @@ var Transportr = (() => {
     default: () => Transportr
   });
 
-  // 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/@d1g1tal/chrysalis/src/esm/object-is-empty.js
-  var _objectIsEmpty = (object) => !!object && Object.keys(object).length === 0 && object.constructor === Object;
-  var object_is_empty_default = _objectIsEmpty;
-
-  // 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;
-        }
-      }
-    }
-    return target;
-  };
-  var object_merge_default = _objectMerge;
-
   // node_modules/@d1g1tal/collections/src/set-multi-map.js
   var SetMultiMap = class extends Map {
     /**
@@ -101,602 +69,176 @@ var Transportr = (() => {
   };
   var set_multi_map_default = SetMultiMap;
 
-  // node_modules/@d1g1tal/media-type/src/utils.js
-  var whitespaceCharacters = [" ", "	", "\n", "\r"];
-  var leadingWhitespace = /^[ \t\n\r]+/u;
-  var trailingWhitespace = /[ \t\n\r]+$/u;
-  var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
-  var httpQuotedTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
-  var removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(leadingWhitespace, "").replace(trailingWhitespace, "");
-  var removeTrailingHTTPWhitespace = (string) => string.replace(trailingWhitespace, "");
-  var isHTTPWhitespaceChar = (char) => whitespaceCharacters.includes(char);
-  var solelyContainsHTTPTokenCodePoints = (string) => httpTokenCodePoints.test(string);
-  var solelyContainsHTTPQuotedStringTokenCodePoints = (string) => httpQuotedTokenCodePoints.test(string);
-  var asciiLowercase = (string) => {
-    let result = "";
-    for (const [char, charCode = char.charCodeAt(0)] of string) {
-      result += charCode >= 65 && charCode <= 90 ? String.fromCharCode(charCode + 32) : char;
+  // node_modules/@d1g1tal/subscribr/node_modules/@d1g1tal/collections/src/set-multi-map.js
+  var SetMultiMap2 = class extends Map {
+    /**
+     * Adds a new element with a specified key and value to the SetMultiMap. If an element with the same key already exists, the value will be added to the underlying {@link Set}.
+     *
+     * @param {*} key The key to set.
+     * @param {*} value The value to add to the SetMultiMap
+     * @returns {SetMultiMap} The SetMultiMap with the updated key and value.
+     */
+    set(key, value) {
+      super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
+      return this;
     }
-    return result;
-  };
-  var collectAnHTTPQuotedString = (input, position) => {
-    let value = "";
-    for (let length = input.length, char; ++position < length; ) {
-      char = input[position];
-      if (char == "\\") {
-        value += ++position < length ? input[position] : char;
-      } else if (char == '"') {
-        break;
-      } else {
-        value += char;
-      }
+    [Symbol.toStringTag]() {
+      return "SetMultiMap";
     }
-    return [value, position];
   };
 
-  // node_modules/@d1g1tal/media-type/src/media-type-parameters.js
-  var MediaTypeParameters = class {
-    /** @type {Map<string, string>} */
-    #map;
+  // node_modules/@d1g1tal/subscribr/src/context-event-handler.js
+  var ContextEventHandler = class {
+    #context;
+    #eventHandler;
     /**
-     * Create a new MediaTypeParameters instance.
-     *
-     * @param {Array<Array<string>>} entries An array of [name, value] tuples.
+     * @param {*} context The context to bind to the event handler.
+     * @param {function(*): void} eventHandler The event handler to call when the event is published.
      */
-    constructor(entries) {
-      this.#map = new Map(entries);
+    constructor(context, eventHandler) {
+      this.#context = context;
+      this.#eventHandler = eventHandler;
     }
     /**
-     * Gets the number of media type parameters.
+     * Call the event handler for the provided event.
      *
-     * @returns {number} The number of media type parameters
+     * @param {Event} event The event to handle
+     * @param {*} [data] The value to be passed to the event handler as a parameter.
      */
-    get size() {
-      return this.#map.size;
+    handle(event, data) {
+      this.#eventHandler.call(this.#context, event, data);
+    }
+    get [Symbol.toStringTag]() {
+      return "ContextEventHandler";
     }
+  };
+
+  // node_modules/@d1g1tal/subscribr/src/subscription.js
+  var Subscription = class {
+    #eventName;
+    #contextEventHandler;
     /**
-     * Gets the media type parameter value for the supplied name.
-     *
-     * @param {string} name The name of the media type parameter to retrieve.
-     * @returns {string} The media type parameter value.
+     * @param {string} eventName The event name.
+     * @param {ContextEventHandler} contextEventHandler Then context event handler.
      */
-    get(name) {
-      return this.#map.get(asciiLowercase(String(name)));
+    constructor(eventName, contextEventHandler) {
+      this.#eventName = eventName;
+      this.#contextEventHandler = contextEventHandler;
     }
     /**
-     * Indicates whether the media type parameter with the specified name exists or not.
+     * Gets the event name for the subscription.
      *
-     * @param {string} name The name of the media type parameter to check.
-     * @returns {boolean} true if the media type parameter exists, false otherwise.
+     * @returns {string} The event name.
      */
-    has(name) {
-      return this.#map.has(asciiLowercase(String(name)));
+    get eventName() {
+      return this.#eventName;
     }
     /**
-     * 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.
+     * Gets the context event handler.
      *
-     * @param {string} name The name of the media type parameter to set.
-     * @param {string} value The media type parameter value.
-     * @returns {MediaTypeParameters} This instance.
+     * @returns {ContextEventHandler} The context event handler
      */
-    set(name, value) {
-      name = asciiLowercase(String(name));
-      value = String(value);
-      if (!solelyContainsHTTPTokenCodePoints(name)) {
-        throw new Error(`Invalid media type parameter name "${name}": only HTTP token code points are valid.`);
-      }
-      if (!solelyContainsHTTPQuotedStringTokenCodePoints(value)) {
-        throw new Error(`Invalid media type parameter value "${value}": only HTTP quoted-string token code points are valid.`);
-      }
-      this.#map.set(name, value);
-      return this;
+    get contextEventHandler() {
+      return this.#contextEventHandler;
     }
-    /**
-     * Clears all the media type parameters.
-     */
-    clear() {
-      this.#map.clear();
+    get [Symbol.toStringTag]() {
+      return "Subscription";
+    }
+  };
+
+  // node_modules/@d1g1tal/subscribr/src/subscribr.js
+  var Subscribr = class {
+    /** @type {SetMultiMap<string, ContextEventHandler>} */
+    #subscribers;
+    constructor() {
+      this.#subscribers = new SetMultiMap2();
     }
     /**
-     * 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.
+     * @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.
      */
-    delete(name) {
-      name = asciiLowercase(String(name));
-      return this.#map.delete(name);
+    subscribe(eventName, eventHandler, context = eventHandler) {
+      const contextEventHandler = new ContextEventHandler(context, eventHandler);
+      this.#subscribers.set(eventName, contextEventHandler);
+      return new Subscription(eventName, contextEventHandler);
     }
     /**
-     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
+     * Unsubscribe from the event
      *
-     * @param {function(string, string): void} callback The function called on each iteration.
-     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
+     * @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.
      */
-    forEach(callback, thisArg) {
-      this.#map.forEach(callback, thisArg);
+    unsubscribe({ eventName, contextEventHandler }) {
+      const contextEventHandlers = this.#subscribers.get(eventName);
+      const removed = contextEventHandlers?.delete(contextEventHandler);
+      if (removed && contextEventHandlers.size == 0) {
+        this.#subscribers.delete(eventName);
+      }
+      return removed;
     }
     /**
-     * Returns an iterable of parameter names.
+     * Publish an event
      *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
+     * @param {string} eventName The name of the event.
+     * @param {Event} event The event to be handled.
+     * @param {*} [data] The value to be passed to the event handler as a parameter.
      */
-    keys() {
-      return this.#map.keys();
+    publish(eventName, event = new CustomEvent(eventName), data) {
+      if (data == null && !(event instanceof Event)) {
+        [data, event] = [event, new CustomEvent(eventName)];
+      }
+      this.#subscribers.get(eventName)?.forEach((contextEventHandler) => contextEventHandler.handle(event, data));
     }
     /**
-     * Returns an iterable of parameter values.
+     * Check if the event and handler are subscribed.
      *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
+     * @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.
      */
-    values() {
-      return this.#map.values();
+    isSubscribed({ eventName, contextEventHandler }) {
+      return this.#subscribers.get(eventName)?.has(contextEventHandler);
     }
+    get [Symbol.toStringTag]() {
+      return "Subscribr";
+    }
+  };
+
+  // src/http-error.js
+  var HttpError = class extends Error {
+    /** @type {ResponseBody} */
+    #entity;
+    /** @type {ResponseStatus} */
+    #responseStatus;
     /**
-     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
-     *
-     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
+     * @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.
      */
-    entries() {
-      return this.#map.entries();
+    constructor(message, { cause, status, entity }) {
+      super(message, { cause });
+      this.#entity = entity;
+      this.#responseStatus = status;
     }
     /**
-     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
+     * It returns the value of the private variable #entity.
      *
-     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
+     * @returns {ResponseBody} The entity property of the class.
      */
-    [Symbol.iterator]() {
-      return this.#map[Symbol.iterator]();
+    get entity() {
+      return this.#entity;
     }
     /**
-     * Returns a string representation of the media type parameters.
-     * This method is called by the `String()` function.
-     *
-     * @example
-     * const parameters = new MediaTypeParameters(new Map([['charset', 'utf-8']]));
-     * String(parameters); // 'charset=utf-8'
-     * parameters.toString(); // 'charset=utf-8'
-     * parameters + ''; // 'charset=utf-8'
-     * `${parameters}`; // 'charset=utf-8'
-     * parameters[Symbol.toStringTag]; // 'MediaTypeParameters'
-     * parameters[Symbol.toStringTag](); // 'MediaTypeParameters'
-     * Object.prototype.toString.call(parameters); // '[object MediaTypeParameters]'
-     * parameters + ''; // 'charset=utf-8'
-     * @returns {string} The string representation of the media type parameters.
-     */
-    [Symbol.toStringTag]() {
-      return "MediaTypeParameters";
-    }
-  };
-
-  // node_modules/@d1g1tal/media-type/src/parser.js
-  var parse = (input) => {
-    input = removeLeadingAndTrailingHTTPWhitespace(input);
-    let position = 0;
-    let type = "";
-    while (position < input.length && input[position] != "/") {
-      type += input[position];
-      ++position;
-    }
-    if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
-      return null;
-    }
-    if (position >= input.length) {
-      return null;
-    }
-    ++position;
-    let subtype = "";
-    while (position < input.length && input[position] != ";") {
-      subtype += input[position];
-      ++position;
-    }
-    subtype = removeTrailingHTTPWhitespace(subtype);
-    if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
-      return null;
-    }
-    const mediaType = {
-      type: asciiLowercase(type),
-      subtype: asciiLowercase(subtype),
-      parameters: /* @__PURE__ */ new Map()
-    };
-    while (position < input.length) {
-      ++position;
-      while (isHTTPWhitespaceChar(input[position])) {
-        ++position;
-      }
-      let parameterName = "";
-      while (position < input.length && input[position] != ";" && input[position] != "=") {
-        parameterName += input[position];
-        ++position;
-      }
-      parameterName = asciiLowercase(parameterName);
-      if (position < input.length) {
-        if (input[position] == ";") {
-          continue;
-        }
-        ++position;
-      }
-      let parameterValue = null;
-      if (input[position] == '"') {
-        [parameterValue, position] = collectAnHTTPQuotedString(input, position);
-        while (position < input.length && input[position] != ";") {
-          ++position;
-        }
-      } else {
-        parameterValue = "";
-        while (position < input.length && input[position] != ";") {
-          parameterValue += input[position];
-          ++position;
-        }
-        parameterValue = removeTrailingHTTPWhitespace(parameterValue);
-        if (parameterValue === "") {
-          continue;
-        }
-      }
-      if (parameterName.length > 0 && solelyContainsHTTPTokenCodePoints(parameterName) && solelyContainsHTTPQuotedStringTokenCodePoints(parameterValue) && !mediaType.parameters.has(parameterName)) {
-        mediaType.parameters.set(parameterName, parameterValue);
-      }
-    }
-    return mediaType;
-  };
-  var parser_default = parse;
-
-  // node_modules/@d1g1tal/media-type/src/serializer.js
-  var serialize = (mediaType) => {
-    let serialization = `${mediaType.type}/${mediaType.subtype}`;
-    if (mediaType.parameters.size === 0) {
-      return serialization;
-    }
-    for (let [name, value] of mediaType.parameters) {
-      serialization += `;${name}=`;
-      if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
-        value = `"${value.replace(/(["\\])/ug, "\\$1")}"`;
-      }
-      serialization += value;
-    }
-    return serialization;
-  };
-  var serializer_default = serialize;
-
-  // node_modules/@d1g1tal/media-type/src/media-type.js
-  var MediaType = class _MediaType {
-    /** @type {string} */
-    #type;
-    /** @type {string} */
-    #subtype;
-    /** @type {MediaTypeParameters} */
-    #parameters;
-    /**
-     * Create a new MediaType instance from a string representation.
-     *
-     * @param {string} mediaType The media type to parse.
-     * @param {Object} [parameters] Optional parameters.
-     */
-    constructor(mediaType, parameters = {}) {
-      const { type, subtype, parameters: parsedParameters } = parser_default(mediaType);
-      this.#type = type;
-      this.#subtype = subtype;
-      this.#parameters = new MediaTypeParameters([...parsedParameters, ...Object.entries(parameters).map(([name, value]) => [asciiLowercase(name), asciiLowercase(value)])]);
-    }
-    /**
-     * Static factory method for parsing a media type.
-     *
-     * @param {string} string The media type to parse.
-     * @returns {MediaType} The parsed {@link MediaType} object or null if the string could not be parsed.
-     */
-    static parse(string) {
-      try {
-        return new _MediaType(string);
-      } catch (e) {
-        throw new Error(`Could not parse media type string '${string}'`);
-      }
-    }
-    /**
-     * Gets the media type essence (type/subtype).
-     *
-     * @returns {string} The media type without any parameters
-     */
-    get essence() {
-      return `${this.#type}/${this.#subtype}`;
-    }
-    /**
-     * Gets the type.
-     *
-     * @returns {string} The type.
-     */
-    get type() {
-      return this.#type;
-    }
-    /**
-     * Sets the type.
-     */
-    set type(value) {
-      value = asciiLowercase(String(value));
-      if (value.length === 0) {
-        throw new Error("Invalid type: must be a non-empty string");
-      }
-      if (!solelyContainsHTTPTokenCodePoints(value)) {
-        throw new Error(`Invalid type ${value}: must contain only HTTP token code points`);
-      }
-      this.#type = value;
-    }
-    /**
-     * Gets the subtype.
-     *
-     * @returns {string} The subtype.
-     */
-    get subtype() {
-      return this.#subtype;
-    }
-    /**
-     * Sets the subtype.
-     */
-    set subtype(value) {
-      value = asciiLowercase(String(value));
-      if (value.length === 0) {
-        throw new Error("Invalid subtype: must be a non-empty string");
-      }
-      if (!solelyContainsHTTPTokenCodePoints(value)) {
-        throw new Error(`Invalid subtype ${value}: must contain only HTTP token code points`);
-      }
-      this.#subtype = value;
-    }
-    /**
-     * Gets the parameters.
-     *
-     * @returns {MediaTypeParameters} The media type parameters.
-     */
-    get parameters() {
-      return this.#parameters;
-    }
-    /**
-     * Gets the serialized version of the media type.
-     *
-     * @returns {string} The serialized media type.
-     */
-    toString() {
-      return serializer_default(this);
-    }
-    /**
-     * Determines if this instance is a JavaScript media type.
-     *
-     * @param {Object} [options] Optional options.
-     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
-     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
-     */
-    isJavaScript({ prohibitParameters = false } = {}) {
-      switch (this.#type) {
-        case "text": {
-          switch (this.#subtype) {
-            case "ecmascript":
-            case "javascript":
-            case "javascript1.0":
-            case "javascript1.1":
-            case "javascript1.2":
-            case "javascript1.3":
-            case "javascript1.4":
-            case "javascript1.5":
-            case "jscript":
-            case "livescript":
-            case "x-ecmascript":
-            case "x-javascript":
-              return !prohibitParameters || this.#parameters.size === 0;
-            default:
-              return false;
-          }
-        }
-        case "application": {
-          switch (this.#subtype) {
-            case "ecmascript":
-            case "javascript":
-            case "x-ecmascript":
-            case "x-javascript":
-              return !prohibitParameters || this.#parameters.size === 0;
-            default:
-              return false;
-          }
-        }
-        default:
-          return false;
-      }
-    }
-    /**
-     * Determines if this instance is an XML media type.
-     *
-     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
-     */
-    isXML() {
-      return this.#subtype === "xml" && (this.#type === "text" || this.#type === "application") || this.#subtype.endsWith("+xml");
-    }
-    /**
-     * Determines if this instance is an HTML media type.
-     *
-     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
-     */
-    isHTML() {
-      return this.#subtype === "html" && this.#type === "text";
-    }
-    /**
-     * Gets the name of the class.
-     *
-     * @returns {string} The class name
-     */
-    get [Symbol.toStringTag]() {
-      return "MediaType";
-    }
-  };
-
-  // node_modules/@d1g1tal/subscribr/node_modules/@d1g1tal/collections/src/set-multi-map.js
-  var SetMultiMap2 = class extends Map {
-    /**
-     * Adds a new element with a specified key and value to the SetMultiMap. If an element with the same key already exists, the value will be added to the underlying {@link Set}.
-     *
-     * @param {*} key The key to set.
-     * @param {*} value The value to add to the SetMultiMap
-     * @returns {SetMultiMap} The SetMultiMap with the updated key and value.
-     */
-    set(key, value) {
-      super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
-      return this;
-    }
-    [Symbol.toStringTag]() {
-      return "SetMultiMap";
-    }
-  };
-
-  // 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.
-     */
-    constructor(context, eventHandler) {
-      this.#context = context;
-      this.#eventHandler = eventHandler;
-    }
-    /**
-     * Call the event handler for the provided event.
-     *
-     * @param {Event} event The event to handle
-     * @param {*} [data] The value to be passed to the event handler as a parameter.
-     */
-    handle(event, data) {
-      this.#eventHandler.call(this.#context, event, data);
-    }
-    get [Symbol.toStringTag]() {
-      return "ContextEventHandler";
-    }
-  };
-
-  // 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.
-     */
-    constructor(eventName, contextEventHandler) {
-      this.#eventName = eventName;
-      this.#contextEventHandler = contextEventHandler;
-    }
-    /**
-     * Gets the event name for the subscription.
-     *
-     * @returns {string} The event name.
-     */
-    get eventName() {
-      return this.#eventName;
-    }
-    /**
-     * Gets the context event handler.
-     *
-     * @returns {ContextEventHandler} The context event handler
-     */
-    get contextEventHandler() {
-      return this.#contextEventHandler;
-    }
-    get [Symbol.toStringTag]() {
-      return "Subscription";
-    }
-  };
-
-  // node_modules/@d1g1tal/subscribr/src/subscribr.js
-  var Subscribr = class {
-    /** @type {SetMultiMap<string, ContextEventHandler>} */
-    #subscribers;
-    constructor() {
-      this.#subscribers = new SetMultiMap2();
-    }
-    /**
-     * Subscribe to an event
-     *
-     * @param {string} eventName The event name to subscribe to.
-     * @param {function(Event, *): void} eventHandler The event handler to call when the event is published.
-     * @param {*} [context] The context to bind to the event handler.
-     * @returns {Subscription} An object used to check if the subscription still exists and to unsubscribe from the event.
-     */
-    subscribe(eventName, eventHandler, context = eventHandler) {
-      const contextEventHandler = new ContextEventHandler(context, eventHandler);
-      this.#subscribers.set(eventName, contextEventHandler);
-      return new Subscription(eventName, contextEventHandler);
-    }
-    /**
-     * Unsubscribe from the event
-     *
-     * @param {Subscription} subscription The subscription to unsubscribe.
-     * @param {string} subscription.eventName The event name to subscribe to.
-     * @param {ContextEventHandler} subscription.contextEventHandler The event handler to call when the event is published.
-     * @returns {boolean} true if eventListener has been removed successfully. false if the value is not found or if the value is not an object.
-     */
-    unsubscribe({ eventName, contextEventHandler }) {
-      const contextEventHandlers = this.#subscribers.get(eventName);
-      const removed = contextEventHandlers?.delete(contextEventHandler);
-      if (removed && contextEventHandlers.size == 0) {
-        this.#subscribers.delete(eventName);
-      }
-      return removed;
-    }
-    /**
-     * Publish an event
-     *
-     * @param {string} eventName The name of the event.
-     * @param {Event} event The event to be handled.
-     * @param {*} [data] The value to be passed to the event handler as a parameter.
-     */
-    publish(eventName, event = new CustomEvent(eventName), data) {
-      if (data == null && !(event instanceof Event)) {
-        [data, event] = [event, new CustomEvent(eventName)];
-      }
-      this.#subscribers.get(eventName)?.forEach((contextEventHandler) => contextEventHandler.handle(event, data));
-    }
-    /**
-     * Check if the event and handler are subscribed.
-     *
-     * @param {Subscription} subscription The subscription object.
-     * @param {string} subscription.eventName The name of the event to check.
-     * @param {ContextEventHandler} subscription.contextEventHandler The event handler to check.
-     * @returns {boolean} true if the event name and handler are subscribed, false otherwise.
-     */
-    isSubscribed({ eventName, contextEventHandler }) {
-      return this.#subscribers.get(eventName)?.has(contextEventHandler);
-    }
-    get [Symbol.toStringTag]() {
-      return "Subscribr";
-    }
-  };
-
-  // 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}.
+     * It returns the status code of the {@link Response}.
      *
      * @returns {number} The status code of the {@link Response}.
      */
@@ -783,6 +325,8 @@ var Transportr = (() => {
     JSON: "application/json",
     /** JavaScript Object Notation LD Format */
     JSON_LD: "application/ld+json",
+    /** JavaScript Object Notation (JSON) Merge Patch */
+    JSON_MERGE_PATCH: "application/merge-patch+json",
     /** Musical Instrument Digital Interface (MIDI) */
     MID: "audio/midi",
     /** Musical Instrument Digital Interface (MIDI) */
@@ -1465,452 +1009,1228 @@ var Transportr = (() => {
      * Implemented as a misunderstanding of the HTTP specifications. Common because of mistakes in implementations of early HTTP versions. Has exactly the same functionality as standard Connection field.
      *
      * @example
-     * proxy-connection: keep-alive
+     * proxy-connection: keep-alive
+     */
+    PROXY_CONNECTION: "proxy-connection",
+    /**
+     * Server-side deep packet insertion of a unique ID identifying customers of Verizon Wireless, also known as "perma-cookie" or "supercookie"
+     *
+     * @example
+     * x-uidh: ...
+     */
+    X_UIDH: "x-uidh",
+    /**
+     * Used to prevent cross-site request forgery. Alternative header names are: X-CSRFToken and X-XSRF-TOKEN
+     *
+     * @example
+     * x-csrf-token: i8XNjC4b8KVok4uw5RftR38Wgp2BFwql
+     */
+    X_CSRF_TOKEN: "x-csrf-token",
+    /**
+     * Specifying which web sites can participate in cross-origin resource sharing
+     *
+     * @example
+     * access-control-allow-origin: *
+     * Provisional
+     */
+    ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
+    /**
+     * Specifies which patch document formats this server supports
+     *
+     * @example
+     * accept-patch: text/example,charset=utf-8
+     * Permanent
+     */
+    ACCEPT_PATCH: "accept-patch",
+    /**
+     * What partial content range types this server supports via byte serving
+     *
+     * @example
+     * accept-ranges: bytes
+     * Permanent
+     */
+    ACCEPT_RANGES: "accept-ranges",
+    /**
+     * The age the object has been in a proxy cache in seconds
+     *
+     * @example
+     * age: 12
+     * Permanent
+     */
+    AGE: "age",
+    /**
+     * Valid actions for a specified resource. To be used for a 405 Method not allowed
+     *
+     * @example
+     * allow: GET, HEAD
+     * Permanent
+     */
+    ALLOW: "allow",
+    /**
+     * Tells all caching mechanisms from server to client whether they may cache this object. It is measured in seconds
+     *
+     * @example
+     * cache-control: max-age=3600
+     * Permanent
+     */
+    CACHE_CONTROL: "cache-control",
+    /**
+     * Control options for the current connection and list of hop-by-hop response fields
+     *
+     * @example
+     * connection: close
+     * Permanent
+     */
+    CONNECTION: "connection",
+    /**
+     * An opportunity to raise a "File Download" dialogue box for a known MIME type with binary format or suggest a filename for dynamic content. Quotes are necessary with special characters.
+     *
+     * @example
+     * content-disposition: attachment, filename="fname.ext"
+     * Permanent
+     */
+    CONTENT_DISPOSITION: "content-disposition",
+    /**
+     * The type of encoding used on the data. See HTTP compression.
+     *
+     * @example
+     * content-encoding: gzip
+     * Permanent
+     */
+    CONTENT_ENCODING: "content-encoding",
+    /**
+     * The natural language or languages of the intended audience for the enclosed content
+     *
+     * @example
+     * content-language: da
+     * Permanent
+     */
+    CONTENT_LANGUAGE: "content-language",
+    /**
+     * The length of the response body in octets (8-bit bytes)
+     *
+     * @example
+     * content-length: 348
+     * Permanent
+     */
+    CONTENT_LENGTH: "content-length",
+    /**
+     * An alternate location for the returned data
+     *
+     * @example
+     * content-location: /index.htm
+     * Permanent
+     */
+    CONTENT_LOCATION: "content-location",
+    /**
+     * Where in a full body message this partial message belongs
+     *
+     * @example
+     * content-range: bytes 21010-47021/47022
+     * Permanent
+     */
+    CONTENT_RANGE: "content-range",
+    /**
+     * The MIME type of this content
+     *
+     * @example
+     * content-type: text/html, charset=utf-8
+     * Permanent
+     */
+    CONTENT_TYPE: "content-type",
+    /**
+     * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231)
+     *
+     * @example
+     * date: Tue, 15 Nov 1994 08:12:31 GMT
+     * Permanent
+     */
+    DATE: "date",
+    /**
+     * An identifier for a specific version of a resource, often a message digest
+     *
+     * @example
+     * etag: "737060cd8c284d8af7ad3082f209582d"
+     * Permanent
+     */
+    ETAG: "etag",
+    /**
+     * Gives the date/time after which the response is considered stale (in "HTTP-date" format as defined by RFC 7231)
+     *
+     * @example
+     * expires: Thu, 01 Dec 1994 16:00:00 GMT
+     * Permanent
+     */
+    EXPIRES: "expires",
+    /**
+     * The last modified date for the requested object (in "HTTP-date" format as defined by RFC 7231)
+     *
+     * @example
+     * last-modified: Tue, 15 Nov 1994 12:45:26 GMT
+     * Permanent
+     */
+    LAST_MODIFIED: "last-modified",
+    /**
+     * Used to express a typed relationship with another resource, where the relation type is defined by RFC 5988
+     *
+     * @example
+     * link: </feed>, rel="alternate"
+     * Permanent
+     */
+    LINK: "link",
+    /**
+     * Used in redirection, or when a new resource has been created.
+     *
+     * @example
+     * location: http://www.w3.org/pub/WWW/People.html
+     * Permanent
+     */
+    LOCATION: "location",
+    /**
+     * This field is supposed to set P3P policy, in the form of P3P:CP="your_compact_policy". However, P3P did not take off, most browsers have never fully
+     * implemented it, a lot of websites set this field with fake policy text, that was enough to fool browsers the existence of P3P policy and grant permissions for third party cookies.
+     *
+     * @example
+     * p3p: CP="This is not a P3P policy! See http://www.google.com/support/accounts/bin/answer.py?hl=en&answer=151657 for more info."
+     * Permanent
+     */
+    P3P: "p3p",
+    /**
+     * Implementation-specific fields that may have various effects anywhere along the request-response chain.
+     *
+     * @example
+     * pragma: no-cache
+     * Permanent
+     */
+    PRAGMA: "pragma",
+    /**
+     * Request authentication to access the proxy.
+     *
+     * @example
+     * proxy-authenticate: Basic
+     * Permanent
+     */
+    PROXY_AUTHENTICATION: "proxy-authenticate",
+    /**
+     * HTTP Public Key Pinning, announces hash of website's authentic TLS certificate
+     *
+     * @example
+     * public-key-pins: max-age=2592000, pin-sha256="E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=",
+     * Permanent
+     */
+    PUBLIC_KEY_PINS: "public-key-pins",
+    /**
+     * If an entity is temporarily unavailable, this instructs the client to try again later. Value could be a specified period of time (in seconds) or a HTTP-date.
+     *
+     * @example
+     * retry-after: 120
+     * retry-after: Fri, 07 Nov 2014 23:59:59 GMT
+     * Permanent
+     */
+    RETRY_AFTER: "retry-after",
+    /**
+     * A name for the server
+     *
+     * @example
+     * server: Apache/2.4.1 (Unix)
+     * Permanent
+     */
+    SERVER: "server",
+    /**
+     * An HTTP cookie
+     *
+     * @example
+     * set-cookie: UserID=JohnDoe, Max-Age=3600, Version=1
+     * Permanent
+     */
+    SET_COOKIE: "set-cookie",
+    /**
+     * CGI header field specifying the status of the HTTP response. Normal HTTP responses use a separate "Status-Line" instead, defined by RFC 7230.
+     *
+     * @example
+     * status: 200 OK
      */
-    PROXY_CONNECTION: "proxy-connection",
+    STATUS: "status",
     /**
-     * Server-side deep packet insertion of a unique ID identifying customers of Verizon Wireless, also known as "perma-cookie" or "supercookie"
+     * A HSTS Policy informing the HTTP client how long to cache the HTTPS only policy and whether this applies to subdomains.
      *
      * @example
-     * x-uidh: ...
+     * strict-transport-security: max-age=16070400, includeSubDomains
+     * Permanent
      */
-    X_UIDH: "x-uidh",
+    STRICT_TRANSPORT_SECURITY: "strict-transport-security",
     /**
-     * Used to prevent cross-site request forgery. Alternative header names are: X-CSRFToken and X-XSRF-TOKEN
+     * The Trailer general field value indicates that the given set of header fields is present in the trailer of a message encoded with chunked transfer coding.
      *
      * @example
-     * x-csrf-token: i8XNjC4b8KVok4uw5RftR38Wgp2BFwql
+     * trailer: Max-Forwards
+     * Permanent
      */
-    X_CSRF_TOKEN: "x-csrf-token",
+    TRAILER: "trailer",
     /**
-     * Specifying which web sites can participate in cross-origin resource sharing
+     * The form of encoding used to safely transfer the entity to the user. Currently defined methods are: chunked, compress, deflate, gzip, identity.
      *
      * @example
-     * access-control-allow-origin: *
-     * Provisional
+     * transfer-encoding: chunked
+     * Permanent
      */
-    ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
+    TRANSFER_ENCODING: "transfer-encoding",
     /**
-     * Specifies which patch document formats this server supports
+     * Ask the client to upgrade to another protocol.
      *
      * @example
-     * accept-patch: text/example,charset=utf-8
+     * upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
      * Permanent
      */
-    ACCEPT_PATCH: "accept-patch",
+    UPGRADE: "upgrade",
     /**
-     * What partial content range types this server supports via byte serving
+     * Tells downstream proxies how to match future request headers to decide whether the cached response can be used rather than requesting a fresh one from the origin server.
      *
      * @example
-     * accept-ranges: bytes
+     * vary: *
      * Permanent
      */
-    ACCEPT_RANGES: "accept-ranges",
+    VARY: "vary",
     /**
-     * The age the object has been in a proxy cache in seconds
+     * Informs the client of proxies through which the response was sent.
      *
      * @example
-     * age: 12
+     * via: 1.0 fred, 1.1 example.com (Apache/1.1)
      * Permanent
      */
-    AGE: "age",
+    VIA: "via",
     /**
-     * Valid actions for a specified resource. To be used for a 405 Method not allowed
+     * A general warning about possible problems with the entity body.
      *
      * @example
-     * allow: GET, HEAD
+     * warning: 199 Miscellaneous warning
      * Permanent
      */
-    ALLOW: "allow",
+    WARNING: "warning",
     /**
-     * Tells all caching mechanisms from server to client whether they may cache this object. It is measured in seconds
+     * Indicates the authentication scheme that should be used to access the requested entity.
      *
      * @example
-     * cache-control: max-age=3600
+     * www-authenticate: Basic
      * Permanent
      */
-    CACHE_CONTROL: "cache-control",
+    WWW_AUTHENTICATE: "www-authenticate",
     /**
-     * Control options for the current connection and list of hop-by-hop response fields
+     * Cross-site scripting (XSS) filter
      *
      * @example
-     * connection: close
-     * Permanent
+     * x-xss-protection: 1, mode=block
      */
-    CONNECTION: "connection",
+    X_XSS_PROTECTION: "x-xss-protection",
     /**
-     * An opportunity to raise a "File Download" dialogue box for a known MIME type with binary format or suggest a filename for dynamic content. Quotes are necessary with special characters.
+     * The HTTP Content-Security-Policy response header allows web site administrators to control resources the user agent is allowed
+     * to load for a given page. With a few exceptions, policies mostly involve specifying server origins and script endpoints.
+     * This helps guard against cross-site scripting attacks (Cross-site_scripting).
      *
      * @example
-     * content-disposition: attachment, filename="fname.ext"
-     * Permanent
+     * content-security-policy: default-src
      */
-    CONTENT_DISPOSITION: "content-disposition",
+    CONTENT_SECURITY_POLICY: "content-security-policy",
     /**
-     * The type of encoding used on the data. See HTTP compression.
+     * The only defined value, "nosniff", prevents Internet Explorer from MIME-sniffing a response away from the declared content-type. This also applies to Google Chrome, when downloading extensions.
      *
      * @example
-     * content-encoding: gzip
-     * Permanent
+     * x-content-type-options: nosniff
      */
-    CONTENT_ENCODING: "content-encoding",
+    X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
     /**
-     * The natural language or languages of the intended audience for the enclosed content
+     * specifies the technology (e.g. ASP.NET, PHP, JBoss) supporting the web application (version details are often in X-Runtime, X-Version, or X-AspNet-Version)
      *
      * @example
-     * content-language: da
-     * Permanent
+     * x-powered-by: PHP/5.4.0
      */
-    CONTENT_LANGUAGE: "content-language",
+    X_POWERED_BY: "x-powered-by"
+  };
+  var http_response_headers_default = HttpResponseHeader;
+
+  // src/response-status.js
+  var ResponseStatus = class {
+    /** @type {number} */
+    #code;
+    /** @type {string} */
+    #text;
+    /**
+     *
+     * @param {number} code The status code from the {@link Response}
+     * @param {string} text The status text from the {@link Response}
+     */
+    constructor(code, text) {
+      this.#code = code;
+      this.#text = text;
+    }
+    /**
+     * Returns the status code from the {@link Response}
+     *
+     * @returns {number} The status code.
+     */
+    get code() {
+      return this.#code;
+    }
+    /**
+     * Returns the status text from the {@link Response}.
+     *
+     * @returns {string} The status text.
+     */
+    get text() {
+      return this.#text;
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method {@link Object.prototype.toString}.
+     *
+     * @override
+     * @returns {string} The default string description of this object.
+     */
+    get [Symbol.toStringTag]() {
+      return "ResponseStatus";
+    }
+    /**
+     * tostring method for the class.
+     *
+     * @override
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString|Object.prototype.toString}
+     * @returns {string} The status code and status text.
+     */
+    toString() {
+      return `${this.#code} ${this.#text}`;
+    }
+  };
+
+  // src/parameter-map.js
+  var ParameterMap = class _ParameterMap extends Map {
+    /**
+     * @param {Iterable<[string, *]>|Object} parameters The initial parameters to set.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     */
+    constructor(parameters = {}) {
+      super();
+      for (const [key, value] of _ParameterMap.#entries(parameters)) {
+        this.append(key, value);
+      }
+    }
+    /**
+     * Adds a new element with a specified key and value to the ParameterMap.
+     * If an element with the same key already exists, the value will be replaced in the underlying {@link Set}.
+     *
+     * @override
+     * @param {string} key The key to set.
+     * @param {*} value The value to add to the ParameterMap
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     */
+    set(key, value) {
+      const array = super.get(key);
+      if (array?.length > 0) {
+        array.length = 0;
+        array[0] = value;
+      } else {
+        super.set(key, [value]);
+      }
+      return this;
+    }
+    /**
+     * Adds all key-value pairs from an iterable or object to the ParameterMap.
+     * If a key already exists, the value will be replaced in the underlying {@link Array}.
+     *
+     * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     */
+    setAll(parameters) {
+      for (const [key, value] of _ParameterMap.#entries(parameters)) {
+        this.set(key, value);
+      }
+      return this;
+    }
+    /**
+     * Returns the value associated to the key, or undefined if there is none.
+     * If the key has multiple values, the first value will be returned.
+     * If the key has no values, undefined will be returned.
+     *
+     * @override
+     * @param {string} key The key to get.
+     * @returns {*} The value associated to the key, or undefined if there is none.
+     */
+    get(key) {
+      return super.get(key)?.[0];
+    }
+    /**
+     * Returns an array of all values associated to the key, or undefined if there are none.
+     *
+     * @param {string} key The key to get.
+     * @returns {Array<*>} An array of all values associated to the key, or undefined if there are none.
+     */
+    getAll(key) {
+      return super.get(key);
+    }
+    /**
+     * Appends a new value to an existing key inside a ParameterMap, or adds the new key if it does not exist.
+     *
+     * @param {string} key The key to append.
+     * @param {*} value The value to append.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value to allow chaining.
+     */
+    append(key, value) {
+      const array = super.get(key);
+      if (array?.length > 0) {
+        array.push(value);
+      } else {
+        super.set(key, [value]);
+      }
+      return this;
+    }
+    /**
+     * Appends all key-value pairs from an iterable or object to the ParameterMap.
+     * If a key already exists, the value will be appended to the underlying {@link Array}.
+     * If a key does not exist, the key and value will be added to the ParameterMap.
+     *
+     * @param {Iterable<[string, *]>|Object} parameters The parameters to append.
+     * @returns {ParameterMap<string, *>} The ParameterMap with the updated key and value.
+     */
+    appendAll(parameters) {
+      for (const [key, value] of _ParameterMap.#entries(parameters)) {
+        this.append(key, value);
+      }
+      return this;
+    }
+    /**
+     * Checks if a specific key has a specific value.
+     *
+     * @param {*} value The value to check.
+     * @returns {boolean} True if the key has the value, false otherwise.
+     */
+    hasValue(value) {
+      for (const array of super.values()) {
+        if (array.includes(value)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+     * Removes a specific value from a specific key.
+     *
+     * @param {*} value The value to remove.
+     * @returns {boolean} True if the value was removed, false otherwise.
+     */
+    deleteValue(value) {
+      for (const array of this.values()) {
+        if (array.includes(value)) {
+          return array.splice(array.indexOf(value), 1).length > 0;
+        }
+      }
+      return false;
+    }
+    /**
+     * Determines whether the ParameterMap contains anything.
+     *
+     * @returns {boolean} True if the ParameterMap size is greater than 0, false otherwise.
+     */
+    isEmpty() {
+      return this.size === 0;
+    }
+    /**
+     * Returns an Object that can be serialized to JSON.
+     * If a key has only one value, the value will be a single value.
+     * If a key has multiple values, the value will be an array of values.
+     * If a key has no values, the value will be undefined.
+     *
+     * @override
+     * @returns {Object} The Object to be serialized to JSON.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON_behavior}
+     */
+    toJSON() {
+      const obj = /* @__PURE__ */ Object.create(null);
+      for (const [key, values] of super.entries()) {
+        obj[key] = values.length === 1 ? values[0] : values;
+      }
+      return obj;
+    }
+    /**
+     * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
+     *
+     * @override
+     * @yields {[string, *]} An iterator for the key-value pairs in the map.
+     */
+    *entries() {
+      for (const [key, array] of super.entries()) {
+        for (const value of array) {
+          yield [key, value];
+        }
+      }
+    }
+    /**
+     * Returns an iterator that yields all key-value pairs in the map as arrays in their insertion order.
+     *
+     * @override
+     * @yields {[string, *]} An iterator for the key-value pairs in the map.
+     */
+    *[Symbol.iterator]() {
+      yield* this.entries();
+    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the parameters object.
+     *
+     * @private
+     * @static
+     * @param {Iterable<[string, *]>|Object} parameters The parameters to set.
+     * @returns {Iterable<[string, *]>} An iterable of key, value pairs for every entry in the parameters object.
+     */
+    static #entries(parameters) {
+      return parameters[Symbol.iterator] ? parameters : Object.entries(parameters);
+    }
+    /**
+     * A String value that is used in the creation of the default string description of an object.
+     * Called by the built-in method {@link Object.prototype.toString}.
+     *
+     * @override
+     * @returns {string} The default string description of this object.
+     */
+    get [Symbol.toStringTag]() {
+      return "ParameterMap";
+    }
+  };
+
+  // node_modules/@d1g1tal/media-type/src/utils.js
+  var whitespaceCharacters = [" ", "	", "\n", "\r"];
+  var leadingWhitespace = /^[ \t\n\r]+/u;
+  var trailingWhitespace = /[ \t\n\r]+$/u;
+  var httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
+  var httpQuotedTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
+  var removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(leadingWhitespace, "").replace(trailingWhitespace, "");
+  var removeTrailingHTTPWhitespace = (string) => string.replace(trailingWhitespace, "");
+  var isHTTPWhitespaceChar = (char) => whitespaceCharacters.includes(char);
+  var solelyContainsHTTPTokenCodePoints = (string) => httpTokenCodePoints.test(string);
+  var solelyContainsHTTPQuotedStringTokenCodePoints = (string) => httpQuotedTokenCodePoints.test(string);
+  var asciiLowercase = (string) => {
+    let result = "";
+    for (const [char, charCode = char.charCodeAt(0)] of string) {
+      result += charCode >= 65 && charCode <= 90 ? String.fromCharCode(charCode + 32) : char;
+    }
+    return result;
+  };
+  var collectAnHTTPQuotedString = (input, position) => {
+    let value = "";
+    for (let length = input.length, char; ++position < length; ) {
+      char = input[position];
+      if (char == "\\") {
+        value += ++position < length ? input[position] : char;
+      } else if (char == '"') {
+        break;
+      } else {
+        value += char;
+      }
+    }
+    return [value, position];
+  };
+
+  // node_modules/@d1g1tal/media-type/src/media-type-parameters.js
+  var MediaTypeParameters = class {
+    /** @type {Map<string, string>} */
+    #map;
     /**
-     * The length of the response body in octets (8-bit bytes)
+     * Create a new MediaTypeParameters instance.
      *
-     * @example
-     * content-length: 348
-     * Permanent
+     * @param {Array<Array<string>>} entries An array of [name, value] tuples.
      */
-    CONTENT_LENGTH: "content-length",
+    constructor(entries) {
+      this.#map = new Map(entries);
+    }
     /**
-     * An alternate location for the returned data
+     * Gets the number of media type parameters.
      *
-     * @example
-     * content-location: /index.htm
-     * Permanent
+     * @returns {number} The number of media type parameters
      */
-    CONTENT_LOCATION: "content-location",
+    get size() {
+      return this.#map.size;
+    }
     /**
-     * Where in a full body message this partial message belongs
+     * Gets the media type parameter value for the supplied name.
      *
-     * @example
-     * content-range: bytes 21010-47021/47022
-     * Permanent
+     * @param {string} name The name of the media type parameter to retrieve.
+     * @returns {string} The media type parameter value.
      */
-    CONTENT_RANGE: "content-range",
+    get(name) {
+      return this.#map.get(asciiLowercase(String(name)));
+    }
     /**
-     * The MIME type of this content
+     * Indicates whether the media type parameter with the specified name exists or not.
      *
-     * @example
-     * content-type: text/html, charset=utf-8
-     * Permanent
+     * @param {string} name The name of the media type parameter to check.
+     * @returns {boolean} true if the media type parameter exists, false otherwise.
      */
-    CONTENT_TYPE: "content-type",
+    has(name) {
+      return this.#map.has(asciiLowercase(String(name)));
+    }
     /**
-     * The date and time that the message was sent (in "HTTP-date" format as defined by RFC 7231)
+     * Adds a new media type parameter using the specified name and value to the MediaTypeParameters.
+     * If an parameter with the same name already exists, the parameter will be updated.
      *
-     * @example
-     * date: Tue, 15 Nov 1994 08:12:31 GMT
-     * Permanent
+     * @param {string} name The name of the media type parameter to set.
+     * @param {string} value The media type parameter value.
+     * @returns {MediaTypeParameters} This instance.
      */
-    DATE: "date",
+    set(name, value) {
+      name = asciiLowercase(String(name));
+      value = String(value);
+      if (!solelyContainsHTTPTokenCodePoints(name)) {
+        throw new Error(`Invalid media type parameter name "${name}": only HTTP token code points are valid.`);
+      }
+      if (!solelyContainsHTTPQuotedStringTokenCodePoints(value)) {
+        throw new Error(`Invalid media type parameter value "${value}": only HTTP quoted-string token code points are valid.`);
+      }
+      this.#map.set(name, value);
+      return this;
+    }
     /**
-     * An identifier for a specific version of a resource, often a message digest
-     *
-     * @example
-     * etag: "737060cd8c284d8af7ad3082f209582d"
-     * Permanent
+     * Clears all the media type parameters.
      */
-    ETAG: "etag",
+    clear() {
+      this.#map.clear();
+    }
     /**
-     * Gives the date/time after which the response is considered stale (in "HTTP-date" format as defined by RFC 7231)
+     * Removes the media type parameter using the specified name.
      *
-     * @example
-     * expires: Thu, 01 Dec 1994 16:00:00 GMT
-     * Permanent
+     * @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.
      */
-    EXPIRES: "expires",
+    delete(name) {
+      name = asciiLowercase(String(name));
+      return this.#map.delete(name);
+    }
     /**
-     * The last modified date for the requested object (in "HTTP-date" format as defined by RFC 7231)
+     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
      *
-     * @example
-     * last-modified: Tue, 15 Nov 1994 12:45:26 GMT
-     * Permanent
+     * @param {function(string, string): void} callback The function called on each iteration.
+     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
      */
-    LAST_MODIFIED: "last-modified",
+    forEach(callback, thisArg) {
+      this.#map.forEach(callback, thisArg);
+    }
     /**
-     * Used to express a typed relationship with another resource, where the relation type is defined by RFC 5988
+     * Returns an iterable of parameter names.
      *
-     * @example
-     * link: </feed>, rel="alternate"
-     * Permanent
+     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
      */
-    LINK: "link",
+    keys() {
+      return this.#map.keys();
+    }
     /**
-     * Used in redirection, or when a new resource has been created.
+     * Returns an iterable of parameter values.
      *
-     * @example
-     * location: http://www.w3.org/pub/WWW/People.html
-     * Permanent
+     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
      */
-    LOCATION: "location",
+    values() {
+      return this.#map.values();
+    }
     /**
-     * This field is supposed to set P3P policy, in the form of P3P:CP="your_compact_policy". However, P3P did not take off, most browsers have never fully
-     * implemented it, a lot of websites set this field with fake policy text, that was enough to fool browsers the existence of P3P policy and grant permissions for third party cookies.
+     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
      *
-     * @example
-     * p3p: CP="This is not a P3P policy! See http://www.google.com/support/accounts/bin/answer.py?hl=en&answer=151657 for more info."
-     * Permanent
+     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
      */
-    P3P: "p3p",
+    entries() {
+      return this.#map.entries();
+    }
     /**
-     * Implementation-specific fields that may have various effects anywhere along the request-response chain.
+     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
      *
-     * @example
-     * pragma: no-cache
-     * Permanent
+     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
      */
-    PRAGMA: "pragma",
+    [Symbol.iterator]() {
+      return this.#map[Symbol.iterator]();
+    }
     /**
-     * Request authentication to access the proxy.
+     * Returns a string representation of the media type parameters.
+     * This method is called by the `String()` function.
      *
      * @example
-     * proxy-authenticate: Basic
-     * Permanent
+     * const parameters = new MediaTypeParameters(new Map([['charset', 'utf-8']]));
+     * String(parameters); // 'charset=utf-8'
+     * parameters.toString(); // 'charset=utf-8'
+     * parameters + ''; // 'charset=utf-8'
+     * `${parameters}`; // 'charset=utf-8'
+     * parameters[Symbol.toStringTag]; // 'MediaTypeParameters'
+     * parameters[Symbol.toStringTag](); // 'MediaTypeParameters'
+     * Object.prototype.toString.call(parameters); // '[object MediaTypeParameters]'
+     * parameters + ''; // 'charset=utf-8'
+     * @returns {string} The string representation of the media type parameters.
      */
-    PROXY_AUTHENTICATION: "proxy-authenticate",
+    [Symbol.toStringTag]() {
+      return "MediaTypeParameters";
+    }
+  };
+
+  // node_modules/@d1g1tal/media-type/src/parser.js
+  var parse = (input) => {
+    input = removeLeadingAndTrailingHTTPWhitespace(input);
+    let position = 0;
+    let type = "";
+    while (position < input.length && input[position] != "/") {
+      type += input[position];
+      ++position;
+    }
+    if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
+      return null;
+    }
+    if (position >= input.length) {
+      return null;
+    }
+    ++position;
+    let subtype = "";
+    while (position < input.length && input[position] != ";") {
+      subtype += input[position];
+      ++position;
+    }
+    subtype = removeTrailingHTTPWhitespace(subtype);
+    if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
+      return null;
+    }
+    const mediaType = {
+      type: asciiLowercase(type),
+      subtype: asciiLowercase(subtype),
+      parameters: /* @__PURE__ */ new Map()
+    };
+    while (position < input.length) {
+      ++position;
+      while (isHTTPWhitespaceChar(input[position])) {
+        ++position;
+      }
+      let parameterName = "";
+      while (position < input.length && input[position] != ";" && input[position] != "=") {
+        parameterName += input[position];
+        ++position;
+      }
+      parameterName = asciiLowercase(parameterName);
+      if (position < input.length) {
+        if (input[position] == ";") {
+          continue;
+        }
+        ++position;
+      }
+      let parameterValue = null;
+      if (input[position] == '"') {
+        [parameterValue, position] = collectAnHTTPQuotedString(input, position);
+        while (position < input.length && input[position] != ";") {
+          ++position;
+        }
+      } else {
+        parameterValue = "";
+        while (position < input.length && input[position] != ";") {
+          parameterValue += input[position];
+          ++position;
+        }
+        parameterValue = removeTrailingHTTPWhitespace(parameterValue);
+        if (parameterValue === "") {
+          continue;
+        }
+      }
+      if (parameterName.length > 0 && solelyContainsHTTPTokenCodePoints(parameterName) && solelyContainsHTTPQuotedStringTokenCodePoints(parameterValue) && !mediaType.parameters.has(parameterName)) {
+        mediaType.parameters.set(parameterName, parameterValue);
+      }
+    }
+    return mediaType;
+  };
+  var parser_default = parse;
+
+  // node_modules/@d1g1tal/media-type/src/serializer.js
+  var serialize = (mediaType) => {
+    let serialization = `${mediaType.type}/${mediaType.subtype}`;
+    if (mediaType.parameters.size === 0) {
+      return serialization;
+    }
+    for (let [name, value] of mediaType.parameters) {
+      serialization += `;${name}=`;
+      if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
+        value = `"${value.replace(/(["\\])/ug, "\\$1")}"`;
+      }
+      serialization += value;
+    }
+    return serialization;
+  };
+  var serializer_default = serialize;
+
+  // node_modules/@d1g1tal/media-type/src/media-type.js
+  var MediaType = class _MediaType {
+    /** @type {string} */
+    #type;
+    /** @type {string} */
+    #subtype;
+    /** @type {MediaTypeParameters} */
+    #parameters;
     /**
-     * HTTP Public Key Pinning, announces hash of website's authentic TLS certificate
+     * Create a new MediaType instance from a string representation.
      *
-     * @example
-     * public-key-pins: max-age=2592000, pin-sha256="E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=",
-     * Permanent
+     * @param {string} mediaType The media type to parse.
+     * @param {Object} [parameters] Optional parameters.
      */
-    PUBLIC_KEY_PINS: "public-key-pins",
+    constructor(mediaType, parameters = {}) {
+      const { type, subtype, parameters: parsedParameters } = parser_default(mediaType);
+      this.#type = type;
+      this.#subtype = subtype;
+      this.#parameters = new MediaTypeParameters([...parsedParameters, ...Object.entries(parameters).map(([name, value]) => [asciiLowercase(name), asciiLowercase(value)])]);
+    }
     /**
-     * If an entity is temporarily unavailable, this instructs the client to try again later. Value could be a specified period of time (in seconds) or a HTTP-date.
+     * Static factory method for parsing a media type.
      *
-     * @example
-     * retry-after: 120
-     * retry-after: Fri, 07 Nov 2014 23:59:59 GMT
-     * Permanent
+     * @param {string} string The media type to parse.
+     * @returns {MediaType} The parsed {@link MediaType} object or null if the string could not be parsed.
      */
-    RETRY_AFTER: "retry-after",
+    static parse(string) {
+      try {
+        return new _MediaType(string);
+      } catch (e) {
+        throw new Error(`Could not parse media type string '${string}'`);
+      }
+    }
     /**
-     * A name for the server
+     * Gets the media type essence (type/subtype).
      *
-     * @example
-     * server: Apache/2.4.1 (Unix)
-     * Permanent
+     * @returns {string} The media type without any parameters
      */
-    SERVER: "server",
+    get essence() {
+      return `${this.#type}/${this.#subtype}`;
+    }
     /**
-     * An HTTP cookie
+     * Gets the type.
      *
-     * @example
-     * set-cookie: UserID=JohnDoe, Max-Age=3600, Version=1
-     * Permanent
+     * @returns {string} The type.
      */
-    SET_COOKIE: "set-cookie",
+    get type() {
+      return this.#type;
+    }
     /**
-     * CGI header field specifying the status of the HTTP response. Normal HTTP responses use a separate "Status-Line" instead, defined by RFC 7230.
-     *
-     * @example
-     * status: 200 OK
+     * Sets the type.
      */
-    STATUS: "status",
+    set type(value) {
+      value = asciiLowercase(String(value));
+      if (value.length === 0) {
+        throw new Error("Invalid type: must be a non-empty string");
+      }
+      if (!solelyContainsHTTPTokenCodePoints(value)) {
+        throw new Error(`Invalid type ${value}: must contain only HTTP token code points`);
+      }
+      this.#type = value;
+    }
     /**
-     * A HSTS Policy informing the HTTP client how long to cache the HTTPS only policy and whether this applies to subdomains.
+     * Gets the subtype.
      *
-     * @example
-     * strict-transport-security: max-age=16070400, includeSubDomains
-     * Permanent
+     * @returns {string} The subtype.
      */
-    STRICT_TRANSPORT_SECURITY: "strict-transport-security",
+    get subtype() {
+      return this.#subtype;
+    }
     /**
-     * The Trailer general field value indicates that the given set of header fields is present in the trailer of a message encoded with chunked transfer coding.
-     *
-     * @example
-     * trailer: Max-Forwards
-     * Permanent
+     * Sets the subtype.
      */
-    TRAILER: "trailer",
+    set subtype(value) {
+      value = asciiLowercase(String(value));
+      if (value.length === 0) {
+        throw new Error("Invalid subtype: must be a non-empty string");
+      }
+      if (!solelyContainsHTTPTokenCodePoints(value)) {
+        throw new Error(`Invalid subtype ${value}: must contain only HTTP token code points`);
+      }
+      this.#subtype = value;
+    }
     /**
-     * The form of encoding used to safely transfer the entity to the user. Currently defined methods are: chunked, compress, deflate, gzip, identity.
+     * Gets the parameters.
      *
-     * @example
-     * transfer-encoding: chunked
-     * Permanent
+     * @returns {MediaTypeParameters} The media type parameters.
      */
-    TRANSFER_ENCODING: "transfer-encoding",
+    get parameters() {
+      return this.#parameters;
+    }
     /**
-     * Ask the client to upgrade to another protocol.
+     * Gets the serialized version of the media type.
      *
-     * @example
-     * upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
-     * Permanent
+     * @returns {string} The serialized media type.
      */
-    UPGRADE: "upgrade",
+    toString() {
+      return serializer_default(this);
+    }
     /**
-     * Tells downstream proxies how to match future request headers to decide whether the cached response can be used rather than requesting a fresh one from the origin server.
+     * Determines if this instance is a JavaScript media type.
      *
-     * @example
-     * vary: *
-     * Permanent
+     * @param {Object} [options] Optional options.
+     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
+     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
      */
-    VARY: "vary",
+    isJavaScript({ prohibitParameters = false } = {}) {
+      switch (this.#type) {
+        case "text": {
+          switch (this.#subtype) {
+            case "ecmascript":
+            case "javascript":
+            case "javascript1.0":
+            case "javascript1.1":
+            case "javascript1.2":
+            case "javascript1.3":
+            case "javascript1.4":
+            case "javascript1.5":
+            case "jscript":
+            case "livescript":
+            case "x-ecmascript":
+            case "x-javascript":
+              return !prohibitParameters || this.#parameters.size === 0;
+            default:
+              return false;
+          }
+        }
+        case "application": {
+          switch (this.#subtype) {
+            case "ecmascript":
+            case "javascript":
+            case "x-ecmascript":
+            case "x-javascript":
+              return !prohibitParameters || this.#parameters.size === 0;
+            default:
+              return false;
+          }
+        }
+        default:
+          return false;
+      }
+    }
     /**
-     * Informs the client of proxies through which the response was sent.
+     * Determines if this instance is an XML media type.
      *
-     * @example
-     * via: 1.0 fred, 1.1 example.com (Apache/1.1)
-     * Permanent
+     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
      */
-    VIA: "via",
+    isXML() {
+      return this.#subtype === "xml" && (this.#type === "text" || this.#type === "application") || this.#subtype.endsWith("+xml");
+    }
     /**
-     * A general warning about possible problems with the entity body.
+     * Determines if this instance is an HTML media type.
      *
-     * @example
-     * warning: 199 Miscellaneous warning
-     * Permanent
+     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
      */
-    WARNING: "warning",
+    isHTML() {
+      return this.#subtype === "html" && this.#type === "text";
+    }
     /**
-     * Indicates the authentication scheme that should be used to access the requested entity.
+     * Gets the name of the class.
      *
-     * @example
-     * www-authenticate: Basic
-     * Permanent
+     * @returns {string} The class name
      */
-    WWW_AUTHENTICATE: "www-authenticate",
+    get [Symbol.toStringTag]() {
+      return "MediaType";
+    }
+  };
+
+  // src/constants.js
+  var defaultCharset = "utf-8";
+  var endsWithSlashRegEx = /\/$/;
+  var mediaTypes = /* @__PURE__ */ new Map([
+    [http_media_type_default.PNG, new MediaType(http_media_type_default.PNG)],
+    [http_media_type_default.TEXT, new MediaType(http_media_type_default.TEXT, { defaultCharset })],
+    [http_media_type_default.JSON, new MediaType(http_media_type_default.JSON, { defaultCharset })],
+    [http_media_type_default.HTML, new MediaType(http_media_type_default.HTML, { defaultCharset })],
+    [http_media_type_default.JAVA_SCRIPT, new MediaType(http_media_type_default.JAVA_SCRIPT, { defaultCharset })],
+    [http_media_type_default.CSS, new MediaType(http_media_type_default.CSS, { defaultCharset })],
+    [http_media_type_default.XML, new MediaType(http_media_type_default.XML, { defaultCharset })],
+    [http_media_type_default.BIN, new MediaType(http_media_type_default.BIN)]
+  ]);
+  var RequestEvents = Object.freeze({
+    CONFIGURED: "configured",
+    SUCCESS: "success",
+    ERROR: "error",
+    ABORTED: "aborted",
+    TIMEOUT: "timeout",
+    COMPLETE: "complete",
+    ALL_COMPLETE: "all-complete"
+  });
+  var SignalEvents = Object.freeze({
+    ABORT: "abort",
+    TIMEOUT: "timeout"
+  });
+  var _abortEvent = new CustomEvent(SignalEvents.ABORT, { detail: { cause: new DOMException("The request was aborted", "AbortError") } });
+  var requestBodyMethods = [http_request_methods_default.POST, http_request_methods_default.PUT, http_request_methods_default.PATCH];
+
+  // src/abort-signal.js
+  var NativeAbortSignal = globalThis.AbortSignal;
+  var AbortSignal = class _AbortSignal extends EventTarget {
+    /** @type {AbortController} */
+    #abortController;
+    /** @type {number} */
+    #timeoutId;
     /**
-     * Cross-site scripting (XSS) filter
-     *
-     * @example
-     * x-xss-protection: 1, mode=block
+     * @param {AbortSignal} signal The signal to listen to
      */
-    X_XSS_PROTECTION: "x-xss-protection",
+    constructor(signal) {
+      super();
+      this.#abortController = new AbortController();
+      signal?.addEventListener(SignalEvents.ABORT, (event) => this.#abort(event));
+    }
     /**
-     * The HTTP Content-Security-Policy response header allows web site administrators to control resources the user agent is allowed
-     * to load for a given page. With a few exceptions, policies mostly involve specifying server origins and script endpoints.
-     * This helps guard against cross-site scripting attacks (Cross-site_scripting).
+     * Returns an {@link AbortSignal} instance that is already set as aborted.
      *
-     * @example
-     * content-security-policy: default-src
+     * @static
+     * @returns {AbortSignal} The abort signal
      */
-    CONTENT_SECURITY_POLICY: "content-security-policy",
+    static abort() {
+      return NativeAbortSignal.abort();
+    }
     /**
-     * The only defined value, "nosniff", prevents Internet Explorer from MIME-sniffing a response away from the declared content-type. This also applies to Google Chrome, when downloading extensions.
+     * Returns an AbortSignal instance that will automatically abort after a specified time.
      *
-     * @example
-     * x-content-type-options: nosniff
+     * @static
+     * @param {number} time The time in milliseconds to wait before aborting
+     * @returns {AbortSignal} The abort signal
      */
-    X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
+    static timeout(time) {
+      return NativeAbortSignal.timeout(time);
+    }
     /**
-     * specifies the technology (e.g. ASP.NET, PHP, JBoss) supporting the web application (version details are often in X-Runtime, X-Version, or X-AspNet-Version)
+     * The aborted property is a Boolean that indicates whether the request has been aborted (true) or not (false).
      *
-     * @example
-     * x-powered-by: PHP/5.4.0
-     */
-    X_POWERED_BY: "x-powered-by"
-  };
-  var http_response_headers_default = HttpResponseHeader;
-
-  // src/response-status.js
-  var ResponseStatus = class {
-    /** @type {number} */
-    #code;
-    /** @type {string} */
-    #text;
+     * @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.
      *
-     * @param {number} code The status code from the {@link Response}
-     * @param {string} text The status text from the {@link Response}
+     * @returns {DOMException} The reason the signal was aborted
      */
-    constructor(code, text) {
-      this.#code = code;
-      this.#text = text;
+    get reason() {
+      return this.#abortController.signal.reason;
     }
     /**
-     * Returns the status code from the {@link Response}
+     * throws the signal's abort reason if the signal has been aborted; otherwise it does nothing.
      *
-     * @returns {number} The status code.
+     * @returns {void}
      */
-    get code() {
-      return this.#code;
+    throwIfAborted() {
+      this.#abortController.signal.throwIfAborted();
     }
     /**
-     * Returns the status text from the {@link Response}.
+     * Returns an AbortSignal instance that will be aborted when the provided amount of milliseconds have passed.
+     * A value of -1 (which is the default) means there is no timeout.
+     * Note: You can't set this property to a value less than 0.
      *
-     * @returns {string} The status text.
+     * @param {number} timeout The timeout in milliseconds
+     * @returns {AbortSignal} The abort signal
      */
-    get text() {
-      return this.#text;
+    withTimeout(timeout) {
+      if (timeout < 0) {
+        throw new RangeError("The timeout cannot be negative");
+      }
+      this.#timeoutId ??= setTimeout(() => this.#abort(_AbortSignal.#generateTimeoutEvent(timeout), true), timeout);
+      return this.#abortController.signal;
     }
     /**
-     * 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}.
+     * Clears the timeout.
+     * Note: This does not abort the signal, dispatch the timeout event, or reset the timeout.
      *
-     * @override
-     * @returns {string} The default string description of this object.
+     * @returns {void}
      */
-    get [Symbol.toStringTag]() {
-      return "ResponseStatus";
+    clearTimeout() {
+      clearTimeout(this.#timeoutId);
     }
     /**
-     * tostring method for the class.
+     * Adds an event listener for the specified event type.
      *
      * @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 {string} eventName The name of the event to listen to
+     * @param {EventListener} listener The listener to add
+     * @returns {void}
      */
-    toString() {
-      return `${this.#code} ${this.#text}`;
+    addEventListener(eventName, listener) {
+      this.#abortController.signal.addEventListener(eventName, listener);
     }
-  };
-
-  // src/signal-controller.js
-  var SignalController = class {
-    /** @type {AbortController} */
-    #abortController;
     /**
-     * @param {AbortSignal} [signal] The signal to be used to abort the request.
+     * Dispatches an event to this EventTarget.
+     *
+     * @override
+     * @param {Event} event The event to dispatch
+     * @returns {boolean} Whether the event was dispatched or not
      */
-    constructor(signal) {
-      this.#abortController = new AbortController();
-      signal?.addEventListener("abort", () => this.#abortController.abort());
+    dispatchEvent(event) {
+      return this.#abortController.signal.dispatchEvent(event);
     }
     /**
-     * Returns the {@link AbortSignal} object associated with this object.
+     * Removes an event listener for the specified event type.
      *
-     * @returns {AbortSignal} The {@link AbortSignal} object associated with this object.
+     * @override
+     * @param {string} eventName The name of the event to listen to
+     * @param {EventListener} listener The listener to remove
+     * @returns {void}
      */
-    get signal() {
-      return this.#abortController.signal;
+    removeEventListener(eventName, listener) {
+      this.#abortController.signal.removeEventListener(eventName, listener);
     }
     /**
-     * Aborts a DOM request before it has completed.
-     * This is able to abort fetch requests, data sent using the XMLHttpRequest API, and Web Sockets.
+     * Aborts the signal. This is so naughty. ¯\_(ツ)_/¯
      *
-     * @param {DOMException} [reason] The reason for aborting the request.
+     * @param {Event} event The event to abort with
      * @returns {void}
      */
-    abort(reason) {
-      this.#abortController.abort(reason);
+    abort(event) {
+      this.#abort(event);
     }
     /**
-     * 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}.
+     * Aborts the signal.
      *
-     * @override
-     * @returns {string} The default string description of this object.
+     * @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);
+      }
+    }
+    /**
+     * Generates a timeout event.
+     *
+     * @private
+     * @static
+     * @param {number} timeout The timeout in milliseconds
+     * @returns {CustomEvent} The timeout event
      */
-    get [Symbol.toStringTag]() {
-      return "SignalController";
+    static #generateTimeoutEvent(timeout) {
+      return new CustomEvent(SignalEvents.TIMEOUT, { detail: { timeout, cause: new DOMException(`The request timed-out after ${timeout / 1e3} seconds`, "TimeoutError") } });
+    }
+  };
+
+  // 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/@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;
+        }
+      }
     }
+    return target;
   };
+  var object_merge_default = _objectMerge;
 
   // src/transportr.js
-  var endsWithSlashRegEx = /\/$/;
-  var charset = "utf-8";
-  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, { charset })],
-    [http_media_type_default.JSON, new MediaType(http_media_type_default.JSON, { charset })],
-    [http_media_type_default.HTML, new MediaType(http_media_type_default.HTML, { charset })],
-    [http_media_type_default.JAVA_SCRIPT, new MediaType(http_media_type_default.JAVA_SCRIPT, { charset })],
-    [http_media_type_default.CSS, new MediaType(http_media_type_default.CSS, { charset })],
-    [http_media_type_default.XML, new MediaType(http_media_type_default.XML, { charset })],
-    [http_media_type_default.BIN, new MediaType(http_media_type_default.BIN)]
-  ]);
   var _handleText = async (response) => await response.text();
   var _handleScript = async (response) => {
     const objectURL = URL.createObjectURL(await response.blob());
@@ -1932,7 +2252,6 @@ var Transportr = (() => {
   var _handleXml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.XML);
   var _handleHtml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.HTML);
   var _handleHtmlFragment = async (response) => document.createRange().createContextualFragment(await response.text());
-  var _typeConverter = (data) => Object.fromEntries(Array.from(data.keys()).map((key, index, keys, value = data.getAll(key)) => [key, value.length > 1 ? value : value[0]]));
   var Transportr = class _Transportr {
     /** @type {URL} */
     #baseUrl;
@@ -1942,32 +2261,18 @@ var Transportr = (() => {
     #subscribr;
     /** @type {Subscribr} */
     static #globalSubscribr = new Subscribr();
-    /** @type {Array<SignalController>} */
-    static #activeRequests = [];
-    /**
-     * @private
-     * @static
-     * @type {SetMultiMap<ResponseHandler<ResponseBody>, string>}
-     */
+    /** @type {Set<AbortSignal>} */
+    static #activeRequests = /* @__PURE__ */ new Set();
+    /** @type {SetMultiMap<ResponseHandler<ResponseBody>, string>} */
     static #contentTypeHandlers = new set_multi_map_default([
-      [_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]
-    ]);
-    /**
-     * @private
-     * @static
-     * @type {Set<PropertyTypeConverter>}
-     */
-    static #propertyTypeConverters = /* @__PURE__ */ new Set([
-      [{ property: "body", type: FormData, converter: _typeConverter }],
-      [{ property: "searchParams", type: URLSearchParams, converter: _typeConverter }],
-      [{ property: "headers", type: Headers, converter: Object.fromEntries }]
+      [_handleImage, mediaTypes.get(http_media_type_default.PNG).type],
+      [_handleText, mediaTypes.get(http_media_type_default.TEXT).type],
+      [_handleJson, mediaTypes.get(http_media_type_default.JSON).subtype],
+      [_handleHtml, mediaTypes.get(http_media_type_default.HTML).subtype],
+      [_handleScript, mediaTypes.get(http_media_type_default.JAVA_SCRIPT).subtype],
+      [_handleCss, mediaTypes.get(http_media_type_default.CSS).subtype],
+      [_handleXml, mediaTypes.get(http_media_type_default.XML).subtype],
+      [_handleReadableStream, mediaTypes.get(http_media_type_default.BIN).subtype]
     ]);
     /**
      * Create a new Transportr instance with the provided location or origin and context path.
@@ -1975,65 +2280,14 @@ var Transportr = (() => {
      * @param {URL|string|RequestOptions} [url=location.origin] The URL for {@link fetch} requests.
      * @param {RequestOptions} [options={}] The default {@link RequestOptions} for this instance.
      */
-    constructor(url = location.origin, options = {}) {
-      const type = object_type_default(url);
-      if (type == Object) {
-        options = url;
-        url = location.origin;
-      } else if (type != URL) {
-        url = url.startsWith("/") ? new URL(url, location.origin) : new URL(url);
+    constructor(url = globalThis.location.origin, options = {}) {
+      if (object_type_default(url) == Object) {
+        [url, options] = [globalThis.location.origin, url];
       }
-      this.#baseUrl = url;
-      this.#options = object_merge_default(_Transportr.#defaultRequestOptions, _Transportr.#convertRequestOptions(options));
+      this.#baseUrl = _Transportr.#getBaseUrl(url);
+      this.#options = _Transportr.#createOptions(options, _Transportr.#defaultRequestOptions);
       this.#subscribr = new Subscribr();
     }
-    /**
-     * Returns a {@link SignalController} used for aborting requests.
-     *
-     * @static
-     * @param {AbortSignal} [signal] The optional {@link AbortSignal} to used for chaining.
-     * @returns {SignalController} A new {@link SignalController} instance.
-     */
-    static signalController(signal) {
-      return new SignalController(signal);
-    }
-    /**
-     * Returns a {@link EventRegistration} used for subscribing to global events.
-     *
-     * @static
-     * @param {TransportrEvent} event The event to subscribe to.
-     * @param {function(Event, *): void} handler The event handler.
-     * @param {*} context The context to bind the handler to.
-     * @returns {EventRegistration} A new {@link EventRegistration} instance.
-     */
-    static register(event, handler, context) {
-      return _Transportr.#globalSubscribr.subscribe(event, handler, context);
-    }
-    /**
-     * Removes a {@link EventRegistration} from the global event handler.
-     *
-     * @static
-     * @param {EventRegistration} eventRegistration The {@link EventRegistration} to remove.
-     * @returns {boolean} True if the {@link EventRegistration} was removed, false otherwise.
-     */
-    static unregister(eventRegistration) {
-      return _Transportr.#globalSubscribr.unsubscribe(eventRegistration);
-    }
-    /**
-     * Aborts all active requests.
-     * This is useful for when the user navigates away from the current page.
-     * This will also clear the {@link Transportr#activeRequests} array.
-     * This is called automatically when the {@link Transportr#abort} method is called.
-     *
-     * @static
-     * @returns {void}
-     */
-    static abortAll() {
-      for (const signalController of this.#activeRequests) {
-        signalController.abort();
-      }
-      this.#activeRequests = [];
-    }
     /**
      * @static
      * @constant {Object<string, HttpRequestMethod>}
@@ -2113,15 +2367,7 @@ var Transportr = (() => {
      * @static
      * @constant {Object<string, TransportrEvent>}
      */
-    static Events = Object.freeze({
-      CONFIGURED: "configured",
-      SUCCESS: "success",
-      ERROR: "error",
-      ABORTED: "aborted",
-      TIMEOUT: "timeout",
-      COMPLETE: "complete",
-      ALL_COMPLETE: "all-complete"
-    });
+    static RequestEvents = RequestEvents;
     /**
      * @private
      * @static
@@ -2131,7 +2377,7 @@ var Transportr = (() => {
       body: null,
       cache: _Transportr.CachingPolicy.NO_STORE,
       credentials: _Transportr.CredentialsPolicy.SAME_ORIGIN,
-      headers: { [http_request_headers_default.CONTENT_TYPE]: _mediaTypes.get(http_media_type_default.JSON).toString(), [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.JSON).toString() },
+      headers: { [http_request_headers_default.CONTENT_TYPE]: mediaTypes.get(http_media_type_default.JSON).toString(), [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.JSON).toString() },
       searchParams: {},
       integrity: void 0,
       keepalive: void 0,
@@ -2151,9 +2397,54 @@ var Transportr = (() => {
      * @type {Map<TransportrEvent, ResponseStatus>}
      */
     static #eventResponseStatuses = /* @__PURE__ */ new Map([
-      [_Transportr.Events.ABORTED, new ResponseStatus(499, "Aborted")],
-      [_Transportr.Events.TIMEOUT, new ResponseStatus(504, "Gateway Timeout")]
+      [RequestEvents.ABORTED, new ResponseStatus(499, "Aborted")],
+      [RequestEvents.TIMEOUT, new ResponseStatus(504, "Gateway Timeout")]
     ]);
+    /**
+     * Returns a {@link AbortSignal} used for aborting requests.
+     *
+     * @static
+     * @returns {AbortSignal} A new {@link AbortSignal} instance.
+     */
+    static abortSignal() {
+      return new AbortSignal();
+    }
+    /**
+     * Returns a {@link EventRegistration} used for subscribing to global events.
+     *
+     * @static
+     * @param {TransportrEvent} event The event to subscribe to.
+     * @param {function(Event, *): void} handler The event handler.
+     * @param {*} context The context to bind the handler to.
+     * @returns {EventRegistration} A new {@link EventRegistration} instance.
+     */
+    static register(event, handler, context) {
+      return _Transportr.#globalSubscribr.subscribe(event, handler, context);
+    }
+    /**
+     * Removes a {@link EventRegistration} from the global event handler.
+     *
+     * @static
+     * @param {EventRegistration} eventRegistration The {@link EventRegistration} to remove.
+     * @returns {boolean} True if the {@link EventRegistration} was removed, false otherwise.
+     */
+    static unregister(eventRegistration) {
+      return _Transportr.#globalSubscribr.unsubscribe(eventRegistration);
+    }
+    /**
+     * Aborts all active requests.
+     * This is useful for when the user navigates away from the current page.
+     * This will also clear the {@link Transportr#activeRequests} set.
+     *
+     * @static
+     * @returns {void}
+     */
+    static abortAll() {
+      for (const abortSignal of this.#activeRequests) {
+        abortSignal.abort(_abortEvent);
+      }
+      this.#activeRequests.clear();
+    }
     /**
      * It returns the base {@link URL} for the API.
      *
@@ -2252,26 +2543,27 @@ var Transportr = (() => {
       return this.#request(path, options, { method: http_request_methods_default.HEAD });
     }
     /**
-     * It takes a path and options, and returns a request with the method set to OPTIONS.
+     * 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<ResponseBody>} The return value of the #request method.
+     * @returns {Promise<string[]>} A promise that resolves to an array of allowed request methods for this resource.
      */
     async options(path, options) {
-      return this.#request(path, options, { method: http_request_methods_default.OPTIONS });
+      const response = await this.#request(path, options, { method: http_request_methods_default.OPTIONS });
+      return response.headers.get("allow").split(",").map((method) => method.trim());
     }
     /**
      * It takes a path and options, and makes a request to the server.
      *
      * @async
      * @param {string} [path] The path to the endpoint you want to hit.
-     * @param {RequestOptions} [options] The options for the request.
+     * @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, options) {
-      return this.#request(path, options);
+    async request(path, userOptions) {
+      return this.#request(path, userOptions, {}, (response) => response);
     }
     /**
      * It gets a JSON resource from the server.
@@ -2282,7 +2574,7 @@ var Transportr = (() => {
      * @returns {Promise<JsonObject>} A promise that resolves to the response body as a JSON object.
      */
     async getJson(path, options) {
-      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.JSON).toString() } }, _handleJson);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.JSON).toString() } }, _handleJson);
     }
     /**
      * It gets the XML representation of the resource at the given path.
@@ -2293,7 +2585,7 @@ var Transportr = (() => {
      * @returns {Promise<Document>} The result of the function call to #get.
      */
     async getXml(path, options) {
-      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.XML).toString() } }, _handleXml);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.XML).toString() } }, _handleXml);
     }
     /**
      * Get the HTML content of the specified path.
@@ -2306,7 +2598,7 @@ var Transportr = (() => {
      * method of the promise returned by the `#get` method.
      */
     async getHtml(path, options) {
-      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.HTML).toString() } }, _handleHtml);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.HTML).toString() } }, _handleHtml);
     }
     /**
      * It returns a promise that resolves to the HTML fragment at the given path.
@@ -2318,7 +2610,7 @@ var Transportr = (() => {
      * @returns {Promise<DocumentFragment>} A promise that resolves to an HTML fragment.
      */
     async getHtmlFragment(path, options) {
-      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.HTML).toString() } }, _handleHtmlFragment);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.HTML).toString() } }, _handleHtmlFragment);
     }
     /**
      * It gets a script from the server, and appends the script to the {@link Document} {@link HTMLHeadElement}
@@ -2330,7 +2622,7 @@ var Transportr = (() => {
      * @returns {Promise<void>} A promise that has been resolved.
      */
     async getScript(path, options) {
-      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.JAVA_SCRIPT).toString() } }, _handleScript);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.JAVA_SCRIPT).toString() } }, _handleScript);
     }
     /**
      * Gets a stylesheet from the server, and adds it as a {@link Blob} {@link URL}.
@@ -2341,7 +2633,7 @@ var Transportr = (() => {
      * @returns {Promise<void>} A promise that has been resolved.
      */
     async getStylesheet(path, options) {
-      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.CSS).toString() } }, _handleCss);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: mediaTypes.get(http_media_type_default.CSS).toString() } }, _handleCss);
     }
     /**
      * It returns a blob from the specified path.
@@ -2400,8 +2692,7 @@ var Transportr = (() => {
      * @returns {Promise<ResponseBody>} The result of the #request method.
      */
     async #get(path, userOptions, options, responseHandler) {
-      delete userOptions?.method;
-      return this.#request(path, userOptions, options, responseHandler);
+      return this.#request(path, userOptions, { ...options, method: http_request_methods_default.GET }, responseHandler);
     }
     /**
      * It takes a path, options, and a response handler, and returns a promise that resolves to the
@@ -2418,135 +2709,151 @@ var Transportr = (() => {
      */
     async #request(path, userOptions = {}, options = {}, responseHandler) {
       if (object_type_default(path) == Object) {
-        userOptions = path;
-        path = void 0;
+        [path, userOptions] = [void 0, path];
       }
-      const requestOptions = object_merge_default(this.#options, _Transportr.#convertRequestOptions(userOptions), options);
-      const url = _Transportr.#createUrl(this.#baseUrl, path, requestOptions.searchParams);
-      const signalController = new SignalController(requestOptions.signal);
-      _Transportr.#activeRequests.push(signalController);
-      requestOptions.signal = signalController.signal;
-      if (_Transportr.#needsSerialization(requestOptions.method, requestOptions.headers[http_request_headers_default.CONTENT_TYPE])) {
-        try {
-          requestOptions.body = JSON.stringify(requestOptions.body);
-        } catch (error) {
-          return Promise.reject(new HttpError(url, { cause: error }));
-        }
-      } else if (requestOptions.method == http_request_methods_default.GET && requestOptions.headers[http_request_headers_default.CONTENT_TYPE] != "") {
-        delete requestOptions.headers[http_request_headers_default.CONTENT_TYPE];
-        delete requestOptions.body;
+      try {
+        options = this.#processRequestOptions(userOptions, options);
+      } catch (cause) {
+        return Promise.reject(new HttpError("Unable to process request options", { cause }));
       }
-      requestOptions.signal.addEventListener("abort", (event) => this.#publish(_Transportr.Events.ABORTED, requestOptions.global, event));
-      requestOptions.signal.addEventListener("timeout", (event) => this.#publish(_Transportr.Events.TIMEOUT, requestOptions.global, event));
-      this.#publish(_Transportr.Events.CONFIGURED, requestOptions.global, requestOptions);
-      let result, timeoutId, response;
+      this.#publish({ name: RequestEvents.CONFIGURED, data: options, global: options.global });
+      const url = _Transportr.#createUrl(this.#baseUrl, path);
+      if (object_type_default(options.signal) != AbortSignal) {
+        options.signal = new AbortSignal(options.signal);
+      }
+      options.signal.addEventListener(SignalEvents.ABORT, (event) => this.#publish({ name: RequestEvents.ABORTED, event, global: options.global }));
+      options.signal.addEventListener(SignalEvents.TIMEOUT, (event) => this.#publish({ name: RequestEvents.TIMEOUT, event, global: options.global }));
+      _Transportr.#activeRequests.add(options.signal);
+      let response, result;
       try {
-        timeoutId = setTimeout(() => {
-          const cause = new DOMException(`The call to '${url}' timed-out after ${requestOptions.timeout / 1e3} seconds`, "TimeoutError");
-          signalController.abort(cause);
-          requestOptions.signal.dispatchEvent(new CustomEvent(_Transportr.Events.TIMEOUT, { detail: { url, options: requestOptions, cause } }));
-        }, requestOptions.timeout);
-        response = await fetch(url, requestOptions);
+        response = await fetch(url, new Proxy(options, { get: _Transportr.#requestOptionsProxyHandler(options.timeout) }));
+        if (!responseHandler && response.status != 204 && response.headers.has(http_response_headers_default.CONTENT_TYPE)) {
+          responseHandler = this.#getResponseHandler(response.headers.get(http_response_headers_default.CONTENT_TYPE));
+        }
+        result = await responseHandler?.(response) ?? response;
         if (!response.ok) {
-          return Promise.reject(this.#handleError(url, { status: _Transportr.#generateResponseStatusFromError("ResponseError", response), entity: await this.#processResponse(response, url) }));
+          return Promise.reject(this.#handleError(url, { status: _Transportr.#generateResponseStatusFromError("ResponseError", response), entity: result }));
         }
-        result = await this.#processResponse(response, url, responseHandler);
-        this.#publish(_Transportr.Events.SUCCESS, requestOptions.global, result);
+        this.#publish({ name: RequestEvents.SUCCESS, data: result, global: options.global });
       } catch (error) {
         return Promise.reject(this.#handleError(url, { cause: error, status: _Transportr.#generateResponseStatusFromError(error.name, response) }));
       } finally {
-        clearTimeout(timeoutId);
-        if (!requestOptions.signal.aborted) {
-          this.#publish(_Transportr.Events.COMPLETE, requestOptions.global, response);
-          const index = _Transportr.#activeRequests.indexOf(signalController);
-          if (index > -1) {
-            _Transportr.#activeRequests.splice(index, 1);
-          }
-          if (_Transportr.#activeRequests.length === 0) {
-            this.#publish(_Transportr.Events.ALL_COMPLETE, requestOptions.global, response);
+        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 });
           }
         }
       }
       return result;
     }
     /**
-     * Handles an error by logging it and throwing it.
+     * Creates the options for a {@link Transportr} instance.
      *
      * @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.
+     * @static
+     * @param {RequestOptions} userOptions The {@link RequestOptions} to convert.
+     * @param {RequestOptions} options The default {@link RequestOptions}.
+     * @returns {RequestOptions} The converted {@link RequestOptions}.
      */
-    #handleError(url, options) {
-      const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
-      this.#publish(_Transportr.Events.ERROR, true, error);
-      return error;
+    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)
+      });
     }
     /**
-     * Publishes an event to the global and instance subscribers.
+     * Merge the user options and request options into the target.
      *
      * @private
-     * @param {string} eventName The name of the event.
-     * @param {boolean} global Whether or not to publish the event to the global subscribers.
-     * @param {Event} [event] The event object.
-     * @param {*} [data] The data to pass to the subscribers.
-     * @returns {void}
-     */
-    #publish(eventName, global, event, data) {
-      if (global) {
-        _Transportr.#globalSubscribr.publish(eventName, event, data);
+     * @static
+     * @param {Headers|URLSearchParams|FormData} target The target to merge the options into.
+     * @param {Headers|URLSearchParams|FormData|Object} userOption The user options to merge into the target.
+     * @param {Headers|URLSearchParams|FormData|Object} requestOption The request options to merge into the target.
+     * @returns {Headers|URLSearchParams} The target.
+     */
+    static #mergeOptions(target, userOption = {}, requestOption = {}) {
+      for (const option of [userOption, requestOption]) {
+        for (const [name, value] of option.entries?.() ?? Object.entries(option)) {
+          target.set(name, value);
+        }
       }
-      this.#subscribr.publish(eventName, event, data);
+      return target;
     }
     /**
-     * Generates a ResponseStatus object based on the error name and the response.
+     * Merges the user options and request options with the instance options into a new object that is used for the request.
      *
      * @private
-     * @static
-     * @param {string} errorName The name of the error.
-     * @param {Response} response The response object returned by the fetch API.
-     * @returns {ResponseStatus} The response status object.
-     */
-    static #generateResponseStatusFromError(errorName, response) {
-      switch (errorName) {
-        case "AbortError":
-          return _Transportr.#eventResponseStatuses.get(_Transportr.Events.ABORTED);
-        case "TimeoutError":
-          return _Transportr.#eventResponseStatuses.get(_Transportr.Events.TIMEOUT);
-        default:
-          return response ? new ResponseStatus(response.status, response.statusText) : new ResponseStatus(500, "Internal Server Error");
+     * @param {RequestOptions} userOptions The user options to merge into the request options.
+     * @param {RequestOptions} options The request options to merge into the user options.
+     * @returns {RequestOptions} The merged options.
+     */
+    #processRequestOptions({ body: userBody, headers: userHeaders, searchParams: userSearchParams, ...userOptions }, { headers, searchParams, ...options }) {
+      const requestOptions = object_merge_default(this.#options, userOptions, options, {
+        headers: _Transportr.#mergeOptions(new Headers(this.#options.headers), userHeaders, headers),
+        searchParams: _Transportr.#mergeOptions(new URLSearchParams(this.#options.searchParams), userSearchParams, searchParams)
+      });
+      if (requestBodyMethods.includes(requestOptions.method)) {
+        if ([ParameterMap, FormData, URLSearchParams, Object].includes(object_type_default(userBody))) {
+          const contentType = requestOptions.headers.get(http_request_headers_default.CONTENT_TYPE);
+          const mediaType = (mediaTypes.get(contentType) ?? MediaType.parse(contentType))?.subtype;
+          if (mediaType == http_media_type_default.MULTIPART_FORM_DATA) {
+            requestOptions.body = _Transportr.#mergeOptions(new FormData(requestOptions.body), userBody);
+          } else if (mediaType == http_media_type_default.FORM) {
+            requestOptions.body = _Transportr.#mergeOptions(new URLSearchParams(requestOptions.body), userBody);
+          } else if (mediaType.includes("json")) {
+            requestOptions.body = JSON.stringify(_Transportr.#mergeOptions(new ParameterMap(requestOptions.body), userBody));
+          } else {
+            requestOptions.body = _Transportr.#mergeOptions(new ParameterMap(requestOptions.body), userBody);
+          }
+        } else {
+          requestOptions.body = userBody;
+        }
+      } else {
+        requestOptions.headers.delete(http_request_headers_default.CONTENT_TYPE);
+        if (!requestOptions.body?.isEmpty()) {
+          _Transportr.#mergeOptions(requestOptions.searchParams, requestOptions.body);
+        }
+        requestOptions.body = void 0;
       }
+      return requestOptions;
     }
     /**
-     * It takes a response and a handler, and if the handler is not defined, it tries to find a handler
-     * based on the response's content type
+     * Returns a Proxy of the options object that traps for 'signal' access.
+     * If the signal has not been aborted, then it will return a new signal with a timeout.
      *
      * @private
      * @static
-     * @async
-     * @param {Response} response The response object returned by the fetch API.
-     * @param {URL} url The path to the resource you want to access. Used for error handling.
-     * @param {ResponseHandler<ResponseBody>} [handler] The handler to use for processing the response.
-     * @returns {Promise<ResponseBody>} The response is being returned.
+     * @param {number} timeout The timeout in milliseconds before the signal is aborted.
+     * @returns {Proxy<RequestOptions>} A proxy for the options object.
      */
-    async #processResponse(response, url, handler) {
-      try {
-        let mediaType;
-        if (!handler) {
-          mediaType = MediaType.parse(response.headers.get(http_response_headers_default.CONTENT_TYPE));
-          if (mediaType) {
-            for (const [responseHandler, contentTypes] of _Transportr.#contentTypeHandlers) {
-              if (contentTypes.has(mediaType.type) || contentTypes.has(mediaType.subtype)) {
-                handler = responseHandler;
-                break;
-              }
-            }
-          }
-        }
-        return (handler ?? _handleText)(response);
-      } catch (error) {
-        console.error("Unable to process response.", error, response);
-        return Promise.reject(this.#handleError(url, { cause: error }));
+    static #requestOptionsProxyHandler(timeout) {
+      return (target, property) => {
+        const value = Reflect.get(target, property);
+        return property == "signal" && !value.aborted ? value.withTimeout(timeout) : value;
+      };
+    }
+    /**
+     * It takes a url or a string, and returns a {@link URL} instance.
+     * If the url is a string and starts with a slash, then the origin of the current page is used as the base url.
+     *
+     * @private
+     * @static
+     * @param {URL|string} url The URL to convert to a {@link URL} instance.
+     * @returns {URL} A {@link URL} instance.
+     * @throws {TypeError} If the url is not a string or {@link URL} instance.
+     */
+    static #getBaseUrl(url) {
+      switch (object_type_default(url)) {
+        case URL:
+          return url;
+        case String:
+          return new URL(url, url.startsWith("/") ? globalThis.location.origin : void 0);
+        default:
+          throw new TypeError("Invalid URL");
       }
     }
     /**
@@ -2556,48 +2863,81 @@ var Transportr = (() => {
      * @private
      * @static
      * @param {URL} url The URL to use as a base.
-     * @param {string} [path] The path to the resource. This can be a relative path or a full URL.
-     * @param {Object<string, string>} [searchParams={}] An object containing the query parameters to be added to the URL.
+     * @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.
      * @returns {URL} A new URL object with the pathname and origin of the url parameter, and the path parameter
      * appended to the end of the pathname.
      */
-    static #createUrl(url, path, searchParams = {}) {
-      let _url;
-      if (path) {
-        _url = path.startsWith("/") ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(path);
-      } else {
-        _url = new URL(url);
-      }
-      Object.entries(searchParams).forEach(([key, value]) => _url.searchParams.append(key, value));
-      return _url;
+    static #createUrl(url, path) {
+      return path ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(url);
     }
     /**
-     * If the request method is POST, PUT, or PATCH, and the content type is JSON, then the request body
-     * needs to be serialized.
+     * Generates a ResponseStatus object based on the error name and the response.
      *
      * @private
      * @static
-     * @param {RequestMethod} method The HTTP request method.
-     * @param {HttpMediaType} contentType The headers of the request.
-     * @returns {boolean} `true` if the request body needs to be serialized, `false` otherwise.
+     * @param {string} errorName The name of the error.
+     * @param {Response} response The response object returned by the fetch API.
+     * @returns {ResponseStatus} The response status object.
+     */
+    static #generateResponseStatusFromError(errorName, response) {
+      switch (errorName) {
+        case "AbortError":
+          return _Transportr.#eventResponseStatuses.get(RequestEvents.ABORTED);
+        case "TimeoutError":
+          return _Transportr.#eventResponseStatuses.get(RequestEvents.TIMEOUT);
+        default:
+          return response ? new ResponseStatus(response.status, response.statusText) : new ResponseStatus(500, "Internal Server Error");
+      }
+    }
+    /**
+     * 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.
      */
-    static #needsSerialization(method, contentType) {
-      return (_mediaTypes.get(contentType) ?? new MediaType(contentType)).essence == http_media_type_default.JSON && [http_request_methods_default.POST, http_request_methods_default.PUT, http_request_methods_default.PATCH].includes(method);
+    #handleError(url, options) {
+      const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
+      this.#publish({ name: RequestEvents.ERROR, data: error });
+      return error;
     }
     /**
+     * Publishes an event to the global and instance subscribers.
      *
-     * @param {RequestOptions} options The options passed to the public function to use for the request.
-     * @returns {RequestOptions} The options to use for the request.
+     * @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}
      */
-    static #convertRequestOptions(options) {
-      if (!object_is_empty_default(options)) {
-        for (const [{ property, type, converter }, option = options[property]] of _Transportr.#propertyTypeConverters) {
-          if (option instanceof type) {
-            options[property] = converter(option);
+    #publish({ name, event = new CustomEvent(name), data, global = true } = {}) {
+      if (global) {
+        _Transportr.#globalSubscribr.publish(name, event, data);
+      }
+      this.#subscribr.publish(name, event, data);
+    }
+    /**
+     * Returns a response handler for the given content type.
+     *
+     * @private
+     * @param {string} contentType The content type of the response.
+     * @returns {ResponseHandler<ResponseBody>} The response handler.
+     */
+    #getResponseHandler(contentType) {
+      let handler;
+      const mediaType = MediaType.parse(contentType);
+      if (mediaType) {
+        for (const [responseHandler, contentTypes] of _Transportr.#contentTypeHandlers) {
+          if (contentTypes.has(mediaType.type) || contentTypes.has(mediaType.subtype)) {
+            handler = responseHandler;
+            break;
           }
         }
       }
-      return options;
+      return handler;
     }
     /**
      * A String value that is used in the creation of the default string