@d1g1tal/transportr 1.2.0 → 1.2.2

package/dist/transportr.js

@@ -3,7 +3,6 @@ var Transportr = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,32 +16,6 @@ var Transportr = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
-  var __accessCheck = (obj, member, msg) => {
-    if (!member.has(obj))
-      throw TypeError("Cannot " + msg);
-  };
-  var __privateGet = (obj, member, getter) => {
-    __accessCheck(obj, member, "read from private field");
-    return getter ? getter.call(obj) : member.get(obj);
-  };
-  var __privateAdd = (obj, member, value) => {
-    if (member.has(obj))
-      throw TypeError("Cannot add the same private member more than once");
-    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-  };
-  var __privateSet = (obj, member, value, setter) => {
-    __accessCheck(obj, member, "write to private field");
-    setter ? setter.call(obj, value) : member.set(obj, value);
-    return value;
-  };
-  var __privateMethod = (obj, member, method) => {
-    __accessCheck(obj, member, "access private method");
-    return method;
-  };
 
   // src/transportr.js
   var transportr_exports = {};
@@ -85,20 +58,48 @@ var Transportr = (() => {
   // node_modules/@d1g1tal/collections/src/set-multi-map.js
   var SetMultiMap = class extends Map {
     /**
-     * Adds a new element with a specified key and value to the SetMultiMap. If an element with the same key already exists, the value will be added to the underlying {@link Set}.
+     * Adds a new element with a specified key and value to the SetMultiMap.
+     * If an element with the same key already exists, the value will be added to the underlying {@link Set}.
+     * If the value already exists in the {@link Set}, it will not be added again.
      *
      * @param {K} key The key to set.
      * @param {V} value The value to add to the SetMultiMap
-     * @returns {SetMultiMap} The SetMultiMap with the updated key and value.
+     * @returns {SetMultiMap<K, V>} The SetMultiMap with the updated key and value.
      */
     set(key, value) {
       super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
       return this;
     }
-    [Symbol.toStringTag]() {
+    /**
+     * Checks if a specific key has a specific value.
+     *
+     * @param {K} key The key to check.
+     * @param {V} value The value to check.
+     * @returns {boolean} True if the key has the value, false otherwise.
+     */
+    hasValue(key, value) {
+      const values = super.get(key);
+      return values ? values.has(value) : false;
+    }
+    /**
+     * Removes a specific value from a specific key.
+     *
+     * @param {K} key The key to remove the value from.
+     * @param {V} value The value to remove.
+     * @returns {boolean} True if the value was removed, false otherwise.
+     */
+    deleteValue(key, value) {
+      const values = super.get(key);
+      if (values) {
+        return values.delete(value);
+      }
+      return false;
+    }
+    get [Symbol.toStringTag]() {
       return "SetMultiMap";
     }
   };
+  var set_multi_map_default = SetMultiMap;
 
   // node_modules/@d1g1tal/media-type/src/utils.js
   var whitespaceCharacters = [" ", "	", "\n", "\r"];
@@ -359,7 +360,7 @@ var Transportr = (() => {
   var serializer_default = serialize;
 
   // node_modules/@d1g1tal/media-type/src/media-type.js
-  var MediaType = class {
+  var MediaType = class _MediaType {
     /** @type {string} */
     #type;
     /** @type {string} */
@@ -386,7 +387,7 @@ var Transportr = (() => {
      */
     static parse(string) {
       try {
-        return new MediaType(string);
+        return new _MediaType(string);
       } catch (e) {
         throw new Error(`Could not parse media type string '${string}'`);
       }
@@ -526,6 +527,24 @@ var Transportr = (() => {
     }
   };
 
+  // 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;
@@ -590,7 +609,7 @@ var Transportr = (() => {
     /** @type {SetMultiMap<string, ContextEventHandler>} */
     #subscribers;
     constructor() {
-      this.#subscribers = new SetMultiMap();
+      this.#subscribers = new SetMultiMap2();
     }
     /**
      * Subscribe to an event
@@ -1914,8 +1933,42 @@ var Transportr = (() => {
   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 _baseUrl, _options, _subscribr, _globalSubscribr, _activeRequests, _contentTypeHandlers, _propertyTypeConverters, _defaultRequestOptions, _eventResponseStatuses, _get, get_fn, _request, request_fn, _handleError, handleError_fn, _publish, publish_fn, _generateResponseStatusFromError, generateResponseStatusFromError_fn, _processResponse, processResponse_fn, _createUrl, createUrl_fn, _needsSerialization, needsSerialization_fn, _convertRequestOptions, convertRequestOptions_fn;
-  var _Transportr = class {
+  var Transportr = class _Transportr {
+    /** @type {URL} */
+    #baseUrl;
+    /** @type {RequestOptions} */
+    #options;
+    /** @type {Subscribr} */
+    #subscribr;
+    /** @type {Subscribr} */
+    static #globalSubscribr = new Subscribr();
+    /** @type {Array<SignalController>} */
+    static #activeRequests = [];
+    /**
+     * @private
+     * @static
+     * @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 }]
+    ]);
     /**
      * Create a new Transportr instance with the provided location or origin and context path.
      *
@@ -1923,73 +1976,6 @@ var Transportr = (() => {
      * @param {RequestOptions} [options={}] The default {@link RequestOptions} for this instance.
      */
     constructor(url = location.origin, options = {}) {
-      /**
-       * Makes a GET request to the given path, using the given options, and then calls the
-       * given response handler with the response.
-       *
-       * @private
-       * @async
-       * @param {string} path - The path to the endpoint you want to call.
-       * @param {RequestOptions} [userOptions] - The options passed to the public function to use for the request.
-       * @param {RequestOptions} [options] - The options for the request.
-       * @param {ResponseHandler<ResponseBody>} [responseHandler] - A function that will be called with the response object.
-       * @returns {Promise<ResponseBody>} The result of the #request method.
-       */
-      __privateAdd(this, _get);
-      /**
-       * It takes a path, options, and a response handler, and returns a promise that resolves to the
-       * response entity.
-       *
-       * @private
-       * @async
-       * @param {string} path - The path to the resource you want to access.
-       * @param {RequestOptions} [userOptions={}] - The options passed to the public function to use for the request.
-       * @param {RequestOptions} [options={}] - The options to use for the request.
-       * @param {ResponseHandler<ResponseBody>} [responseHandler] - A function that will be called with the response body as a parameter. This
-       * is useful if you want to do something with the response body before returning it.
-       * @returns {Promise<ResponseBody>} The response from the API call.
-       */
-      __privateAdd(this, _request);
-      /**
-       * 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.
-       */
-      __privateAdd(this, _handleError);
-      /**
-       * Publishes an event to the global and instance subscribers.
-       *
-       * @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}
-       */
-      __privateAdd(this, _publish);
-      /**
-       * It takes a response and a handler, and if the handler is not defined, it tries to find a handler
-       * based on the response's content type
-       *
-       * @private
-       * @static
-       * @async
-       * @param {Response} response - The response object returned by the fetch API.
-       * @param {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.
-       */
-      __privateAdd(this, _processResponse);
-      /** @type {URL} */
-      __privateAdd(this, _baseUrl, void 0);
-      /** @type {RequestOptions} */
-      __privateAdd(this, _options, void 0);
-      /** @type {Subscribr} */
-      __privateAdd(this, _subscribr, void 0);
-      var _a;
       const type = object_type_default(url);
       if (type == Object) {
         options = url;
@@ -1997,9 +1983,9 @@ var Transportr = (() => {
       } else if (type != URL) {
         url = url.startsWith("/") ? new URL(url, location.origin) : new URL(url);
       }
-      __privateSet(this, _baseUrl, url);
-      __privateSet(this, _options, object_merge_default(__privateGet(_Transportr, _defaultRequestOptions), __privateMethod(_a = _Transportr, _convertRequestOptions, convertRequestOptions_fn).call(_a, options)));
-      __privateSet(this, _subscribr, new Subscribr());
+      this.#baseUrl = url;
+      this.#options = object_merge_default(_Transportr.#defaultRequestOptions, _Transportr.#convertRequestOptions(options));
+      this.#subscribr = new Subscribr();
     }
     /**
      * Returns a {@link SignalController} used for aborting requests.
@@ -2021,7 +2007,7 @@ var Transportr = (() => {
      * @returns {EventRegistration} A new {@link EventRegistration} instance.
      */
     static register(event, handler, context) {
-      return __privateGet(_Transportr, _globalSubscribr).subscribe(event, handler, context);
+      return _Transportr.#globalSubscribr.subscribe(event, handler, context);
     }
     /**
      * Removes a {@link EventRegistration} from the global event handler.
@@ -2031,7 +2017,7 @@ var Transportr = (() => {
      * @returns {boolean} True if the {@link EventRegistration} was removed, false otherwise.
      */
     static unregister(eventRegistration) {
-      return __privateGet(_Transportr, _globalSubscribr).unsubscribe(eventRegistration);
+      return _Transportr.#globalSubscribr.unsubscribe(eventRegistration);
     }
     /**
      * Aborts all active requests.
@@ -2043,18 +2029,138 @@ var Transportr = (() => {
      * @returns {void}
      */
     static abortAll() {
-      for (const signalController of __privateGet(this, _activeRequests)) {
+      for (const signalController of this.#activeRequests) {
         signalController.abort();
       }
-      __privateSet(this, _activeRequests, []);
+      this.#activeRequests = [];
     }
+    /**
+     * @static
+     * @constant {Object<string, HttpRequestMethod>}
+     */
+    static Method = Object.freeze(http_request_methods_default);
+    /**
+     * @static
+     * @constant {Object<string, HttpMediaType>}
+     */
+    static MediaType = Object.freeze(http_media_type_default);
+    /**
+     * @static
+     * @see {@link HttpRequestHeader}
+     * @constant {Object<string, HttpRequestHeader>}
+     */
+    static RequestHeader = Object.freeze(http_request_headers_default);
+    /**
+     * @static
+     * @constant {Object<string, HttpResponseHeader>}
+     */
+    static ResponseHeader = Object.freeze(http_response_headers_default);
+    /**
+     * @static
+     * @constant {Object<string, RequestCache>}
+     */
+    static CachingPolicy = Object.freeze({
+      DEFAULT: "default",
+      FORCE_CACHE: "force-cache",
+      NO_CACHE: "no-cache",
+      NO_STORE: "no-store",
+      ONLY_IF_CACHED: "only-if-cached",
+      RELOAD: "reload"
+    });
+    /**
+     * @static
+     * @constant {Object<string, RequestCredentials>}
+     */
+    static CredentialsPolicy = Object.freeze({
+      INCLUDE: "include",
+      OMIT: "omit",
+      SAME_ORIGIN: "same-origin"
+    });
+    /**
+     * @static
+     * @constant {Object<string, RequestMode>}
+     */
+    static RequestMode = Object.freeze({
+      CORS: "cors",
+      NAVIGATE: "navigate",
+      NO_CORS: "no-cors",
+      SAME_ORIGIN: "same-origin"
+    });
+    /**
+     * @static
+     * @constant {Object<string, RequestRedirect>}
+     */
+    static RedirectPolicy = Object.freeze({
+      ERROR: "error",
+      FOLLOW: "follow",
+      MANUAL: "manual"
+    });
+    /**
+     * @static
+     * @constant {Object<string, ReferrerPolicy>}
+     */
+    static ReferrerPolicy = Object.freeze({
+      NO_REFERRER: "no-referrer",
+      NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
+      ORIGIN: "origin",
+      ORIGIN_WHEN_CROSS_ORIGIN: "origin-when-cross-origin",
+      SAME_ORIGIN: "same-origin",
+      STRICT_ORIGIN: "strict-origin",
+      STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
+      UNSAFE_URL: "unsafe-url"
+    });
+    /**
+     * @static
+     * @constant {Object<string, TransportrEvent>}
+     */
+    static Events = Object.freeze({
+      CONFIGURED: "configured",
+      SUCCESS: "success",
+      ERROR: "error",
+      ABORTED: "aborted",
+      TIMEOUT: "timeout",
+      COMPLETE: "complete",
+      ALL_COMPLETE: "all-complete"
+    });
+    /**
+     * @private
+     * @static
+     * @type {RequestOptions}
+     */
+    static #defaultRequestOptions = Object.freeze({
+      body: null,
+      cache: _Transportr.CachingPolicy.NO_STORE,
+      credentials: _Transportr.CredentialsPolicy.SAME_ORIGIN,
+      headers: { [http_request_headers_default.CONTENT_TYPE]: _mediaTypes.get(http_media_type_default.JSON).toString(), [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.JSON).toString() },
+      searchParams: {},
+      integrity: void 0,
+      keepalive: void 0,
+      method: http_request_methods_default.GET,
+      mode: _Transportr.RequestMode.CORS,
+      redirect: _Transportr.RedirectPolicy.FOLLOW,
+      referrer: "about:client",
+      referrerPolicy: _Transportr.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
+      signal: void 0,
+      timeout: 3e4,
+      global: true,
+      window: null
+    });
+    /**
+     * @private
+     * @static
+     * @type {Map<TransportrEvent, ResponseStatus>}
+     */
+    static #eventResponseStatuses = /* @__PURE__ */ new Map([
+      [_Transportr.Events.ABORTED, new ResponseStatus(499, "Aborted")],
+      [_Transportr.Events.TIMEOUT, new ResponseStatus(504, "Gateway Timeout")]
+    ]);
     /**
      * It returns the base {@link URL} for the API.
      *
      * @returns {URL} The baseUrl property.
      */
     get baseUrl() {
-      return __privateGet(this, _baseUrl);
+      return this.#baseUrl;
     }
     /**
      * Registers an event handler with a {@link Transportr} instance.
@@ -2065,7 +2171,7 @@ var Transportr = (() => {
      * @returns {EventRegistration} An object that can be used to remove the event handler.
      */
     register(event, handler, context) {
-      return __privateGet(this, _subscribr).subscribe(event, handler, context);
+      return this.#subscribr.subscribe(event, handler, context);
     }
     /**
      * Unregisters an event handler from a {@link Transportr} instance.
@@ -2074,545 +2180,435 @@ var Transportr = (() => {
      * @returns {void}
      */
     unregister(eventRegistration) {
-      __privateGet(this, _subscribr).unsubscribe(eventRegistration);
+      this.#subscribr.unsubscribe(eventRegistration);
     }
     /**
      * This function returns a promise that resolves to the result of a request to the specified path with
      * the specified options, where the method is GET.
      *
      * @async
-     * @param {string} path - The path to the resource you want to get.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource you want to get.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} A promise that resolves to the response of the request.
      */
     async get(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, options);
+      return this.#get(path, options);
     }
     /**
      * This function makes a POST request to the given path with the given body and options.
      *
      * @async
-     * @param {string} path - The path to the endpoint you want to call.
-     * @param {RequestBody} body - The body of the request.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the endpoint you want to call.
+     * @param {RequestBody} body The body of the request.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} A promise that resolves to the response body.
      */
     async post(path, body, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, { ...options, body }, { method: http_request_methods_default.POST });
+      return this.#request(path, { ...options, body }, { method: http_request_methods_default.POST });
     }
     /**
      * This function returns a promise that resolves to the result of a request to the specified path with
      * the specified options, where the method is PUT.
      *
      * @async
-     * @param {string} path - The path to the endpoint you want to call.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the endpoint you want to call.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} The return value of the #request method.
      */
     async put(path, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.PUT });
+      return this.#request(path, options, { method: http_request_methods_default.PUT });
     }
     /**
      * It takes a path and options, and returns a request with the method set to PATCH.
      *
      * @async
-     * @param {string} path - The path to the endpoint you want to hit.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the endpoint you want to hit.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} A promise that resolves to the response of the request.
      */
     async patch(path, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.PATCH });
+      return this.#request(path, options, { method: http_request_methods_default.PATCH });
     }
     /**
      * It takes a path and options, and returns a request with the method set to DELETE.
      *
      * @async
-     * @param {string} path - The path to the resource you want to access.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource you want to access.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} The result of the request.
      */
     async delete(path, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.DELETE });
+      return this.#request(path, options, { method: http_request_methods_default.DELETE });
     }
     /**
      * Returns the response headers of a request to the given path.
      *
      * @async
-     * @param {string} path - The path to the resource you want to access.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource you want to access.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} A promise that resolves to the response object.
      */
     async head(path, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.HEAD });
+      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.
      *
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} The return value of the #request method.
      */
     async options(path, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options, { method: http_request_methods_default.OPTIONS });
+      return this.#request(path, options, { method: http_request_methods_default.OPTIONS });
     }
     /**
      * It takes a path and options, and makes a request to the server.
      *
      * @async
-     * @param {string} path - The path to the endpoint you want to hit.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the endpoint you want to hit.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ResponseBody>} The return value of the function is the return value of the function that is passed to the `then` method of the promise returned by the `fetch` method.
      */
     async request(path, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options);
+      return this.#request(path, options);
     }
     /**
      * It gets a JSON resource from the server.
      *
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options object to pass to the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options object to pass to the request.
      * @returns {Promise<JsonObject>} A promise that resolves to the response body as a JSON object.
      */
     async getJson(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, 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.
      *
      * @async
-     * @param {string} path - The path to the resource you want to get.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource you want to get.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<Document>} The result of the function call to #get.
      */
     async getXml(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, 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.
      *
      * @todo Add way to return portion of the retrieved HTML using a selector. Like jQuery.
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<Document>} The return value of the function is the return value of the function passed to the `then`
      * method of the promise returned by the `#get` method.
      */
     async getHtml(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, 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.
      *
-     * @todo - Add way to return portion of the retrieved HTML using a selector. Like jQuery.
+     * @todo Add way to return portion of the retrieved HTML using a selector. Like jQuery.
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<DocumentFragment>} A promise that resolves to an HTML fragment.
      */
     async getHtmlFragment(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, 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}
      * CORS is enabled by default.
      *
      * @async
-     * @param {string} path - The path to the script.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the script.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<void>} A promise that has been resolved.
      */
     async getScript(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, 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}.
      *
      * @async
-     * @param {string} path - The path to the stylesheet.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the stylesheet.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<void>} A promise that has been resolved.
      */
     async getStylesheet(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, 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.
      *
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<Blob>} A promise that resolves to a blob.
      */
     async getBlob(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBlob);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBlob);
     }
     /**
      * It returns a promise that resolves to an object URL.
      *
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string|RequestOptions} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<string>} A promise that resolves to an object URL.
      */
     async getImage(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }, _handleImage);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }, _handleImage);
     }
     /**
      * It gets a buffer from the specified path
      *
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ArrayBuffer>} A promise that resolves to a buffer.
      */
     async getBuffer(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBuffer);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleBuffer);
     }
     /**
      * It returns a readable stream of the response body from the specified path.
      *
      * @async
-     * @param {string} path - The path to the resource.
-     * @param {RequestOptions} [options] - The options for the request.
+     * @param {string} [path] The path to the resource.
+     * @param {RequestOptions} [options] The options for the request.
      * @returns {Promise<ReadableStream<Uint8Array>>} A readable stream.
      */
     async getStream(path, options) {
-      return __privateMethod(this, _get, get_fn).call(this, path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleReadableStream);
+      return this.#get(path, options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }, _handleReadableStream);
     }
     /**
-     * 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}.
+     * Makes a GET request to the given path, using the given options, and then calls the
+     * given response handler with the response.
      *
-     * @returns {string} The default string description of this object.
+     * @private
+     * @async
+     * @param {string} [path] The path to the endpoint you want to call.
+     * @param {RequestOptions} [userOptions] The options passed to the public function to use for the request.
+     * @param {RequestOptions} [options] The options for the request.
+     * @param {ResponseHandler<ResponseBody>} [responseHandler] A function that will be called with the response object.
+     * @returns {Promise<ResponseBody>} The result of the #request method.
      */
-    get [Symbol.toStringTag]() {
-      return "Transportr";
+    async #get(path, userOptions, options, responseHandler) {
+      delete userOptions?.method;
+      return this.#request(path, userOptions, options, responseHandler);
     }
-  };
-  var Transportr = _Transportr;
-  _baseUrl = new WeakMap();
-  _options = new WeakMap();
-  _subscribr = new WeakMap();
-  _globalSubscribr = new WeakMap();
-  _activeRequests = new WeakMap();
-  _contentTypeHandlers = new WeakMap();
-  _propertyTypeConverters = new WeakMap();
-  _defaultRequestOptions = new WeakMap();
-  _eventResponseStatuses = new WeakMap();
-  _get = new WeakSet();
-  get_fn = async function(path, userOptions, options, responseHandler) {
-    return __privateMethod(this, _request, request_fn).call(this, path, userOptions, options, responseHandler);
-  };
-  _request = new WeakSet();
-  request_fn = async function(path, userOptions = {}, options = {}, responseHandler) {
-    var _a, _b, _c, _d, _e;
-    const requestOptions = object_merge_default(__privateGet(this, _options), __privateMethod(_a = _Transportr, _convertRequestOptions, convertRequestOptions_fn).call(_a, userOptions), options);
-    const url = __privateMethod(_b = _Transportr, _createUrl, createUrl_fn).call(_b, __privateGet(this, _baseUrl), path, requestOptions.searchParams);
-    const signalController = new SignalController(requestOptions.signal);
-    __privateGet(_Transportr, _activeRequests).push(signalController);
-    requestOptions.signal = signalController.signal;
-    if (__privateMethod(_c = _Transportr, _needsSerialization, needsSerialization_fn).call(_c, 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 }));
+    /**
+     * It takes a path, options, and a response handler, and returns a promise that resolves to the
+     * response entity.
+     *
+     * @private
+     * @async
+     * @param {string} [path] The path to the resource you want to access.
+     * @param {RequestOptions} [userOptions={}] The options passed to the public function to use for the request.
+     * @param {RequestOptions} [options={}] The options to use for the request.
+     * @param {ResponseHandler<ResponseBody>} [responseHandler] A function that will be called with the response body as a parameter. This
+     * is useful if you want to do something with the response body before returning it.
+     * @returns {Promise<ResponseBody>} The response from the API call.
+     */
+    async #request(path, userOptions = {}, options = {}, responseHandler) {
+      if (object_type_default(path) == Object) {
+        userOptions = path;
+        path = void 0;
       }
-    } 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;
-    }
-    requestOptions.signal.addEventListener("abort", (event) => __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.ABORTED, requestOptions.global, event));
-    requestOptions.signal.addEventListener("timeout", (event) => __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.TIMEOUT, requestOptions.global, event));
-    __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.CONFIGURED, requestOptions.global, requestOptions);
-    let result, timeoutId, response;
-    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);
-      if (!response.ok) {
-        return Promise.reject(__privateMethod(this, _handleError, handleError_fn).call(this, url, { status: __privateMethod(_d = _Transportr, _generateResponseStatusFromError, generateResponseStatusFromError_fn).call(_d, "ResponseError", response), entity: await __privateMethod(this, _processResponse, processResponse_fn).call(this, response, url) }));
+      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;
       }
-      result = await __privateMethod(this, _processResponse, processResponse_fn).call(this, response, url, responseHandler);
-      __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.SUCCESS, requestOptions.global, result);
-    } catch (error) {
-      return Promise.reject(__privateMethod(this, _handleError, handleError_fn).call(this, url, { cause: error, status: __privateMethod(_e = _Transportr, _generateResponseStatusFromError, generateResponseStatusFromError_fn).call(_e, error.name, response) }));
-    } finally {
-      clearTimeout(timeoutId);
-      if (!requestOptions.signal.aborted) {
-        __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.COMPLETE, requestOptions.global, response);
-        const index = __privateGet(_Transportr, _activeRequests).indexOf(signalController);
-        if (index > -1) {
-          __privateGet(_Transportr, _activeRequests).splice(index, 1);
+      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;
+      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);
+        if (!response.ok) {
+          return Promise.reject(this.#handleError(url, { status: _Transportr.#generateResponseStatusFromError("ResponseError", response), entity: await this.#processResponse(response, url) }));
         }
-        if (__privateGet(_Transportr, _activeRequests).length === 0) {
-          __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.ALL_COMPLETE, requestOptions.global, response);
+        result = await this.#processResponse(response, url, responseHandler);
+        this.#publish(_Transportr.Events.SUCCESS, requestOptions.global, result);
+      } 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);
+          }
         }
       }
+      return result;
     }
-    return result;
-  };
-  _handleError = new WeakSet();
-  handleError_fn = function(url, options) {
-    const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
-    __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.ERROR, true, error);
-    return error;
-  };
-  _publish = new WeakSet();
-  publish_fn = function(eventName, global, event, data) {
-    if (global) {
-      __privateGet(_Transportr, _globalSubscribr).publish(eventName, event, data);
+    /**
+     * Handles an error by logging it and throwing it.
+     *
+     * @private
+     * @param {URL} url The path to the resource you want to access.
+     * @param {import('./http-error.js').HttpErrorOptions} options The options for the HttpError.
+     * @returns {HttpError} The HttpError.
+     */
+    #handleError(url, options) {
+      const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
+      this.#publish(_Transportr.Events.ERROR, true, error);
+      return error;
     }
-    __privateGet(this, _subscribr).publish(eventName, event, data);
-  };
-  _generateResponseStatusFromError = new WeakSet();
-  generateResponseStatusFromError_fn = function(errorName, response) {
-    switch (errorName) {
-      case "AbortError":
-        return __privateGet(_Transportr, _eventResponseStatuses).get(_Transportr.Events.ABORTED);
-      case "TimeoutError":
-        return __privateGet(_Transportr, _eventResponseStatuses).get(_Transportr.Events.TIMEOUT);
-      default:
-        return response ? new ResponseStatus(response.status, response.statusText) : new ResponseStatus(500, "Internal Server Error");
+    /**
+     * Publishes an event to the global and instance subscribers.
+     *
+     * @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);
+      }
+      this.#subscribr.publish(eventName, event, data);
     }
-  };
-  _processResponse = new WeakSet();
-  processResponse_fn = async function(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 __privateGet(_Transportr, _contentTypeHandlers)) {
-            if (contentTypes.has(mediaType.type) || contentTypes.has(mediaType.subtype)) {
-              handler = responseHandler;
-              break;
+    /**
+     * Generates a ResponseStatus object based on the error name and the response.
+     *
+     * @private
+     * @static
+     * @param {string} errorName The name of the error.
+     * @param {Response} response The response object returned by the fetch API.
+     * @returns {ResponseStatus} The response status object.
+     */
+    static #generateResponseStatusFromError(errorName, response) {
+      switch (errorName) {
+        case "AbortError":
+          return _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");
+      }
+    }
+    /**
+     * It takes a response and a handler, and if the handler is not defined, it tries to find a handler
+     * based on the response's content type
+     *
+     * @private
+     * @static
+     * @async
+     * @param {Response} response The response object returned by the fetch API.
+     * @param {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.
+     */
+    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 }));
       }
-      return (handler ?? _handleText)(response);
-    } catch (error) {
-      console.error("Unable to process response.", error, response);
-      return Promise.reject(__privateMethod(this, _handleError, handleError_fn).call(this, url, { cause: error }));
     }
-  };
-  _createUrl = new WeakSet();
-  createUrl_fn = function(url, path, searchParams = {}) {
-    if (path) {
-      url = path.startsWith("/") ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(path);
+    /**
+     * It takes a URL, a path, and a set of search parameters, and returns a new URL with the path and
+     * search parameters applied.
+     *
+     * @private
+     * @static
+     * @param {URL} url The URL to use as a base.
+     * @param {string} [path] The path to the resource. This can be a relative path or a full URL.
+     * @param {Object<string, string>} [searchParams={}] An object containing the query parameters to be added to the URL.
+     * @returns {URL} A new URL object with the pathname and origin of the url parameter, and the path parameter
+     * appended to the end of the pathname.
+     */
+    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;
     }
-    Object.entries(searchParams).forEach(([key, value]) => url.searchParams.append(key, value));
-    return url;
-  };
-  _needsSerialization = new WeakSet();
-  needsSerialization_fn = function(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);
-  };
-  _convertRequestOptions = new WeakSet();
-  convertRequestOptions_fn = function(options) {
-    if (!object_is_empty_default(options)) {
-      for (const [{ property, type, converter }, option = options[property]] of __privateGet(_Transportr, _propertyTypeConverters)) {
-        if (option instanceof type) {
-          options[property] = converter(option);
+    /**
+     * If the request method is POST, PUT, or PATCH, and the content type is JSON, then the request body
+     * needs to be serialized.
+     *
+     * @private
+     * @static
+     * @param {RequestMethod} method The HTTP request method.
+     * @param {HttpMediaType} contentType The headers of the request.
+     * @returns {boolean} `true` if the request body needs to be serialized, `false` otherwise.
+     */
+    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);
+    }
+    /**
+     *
+     * @param {RequestOptions} options The options passed to the public function to use for the request.
+     * @returns {RequestOptions} The options to use for the request.
+     */
+    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);
+          }
         }
       }
+      return options;
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method {@link Object.prototype.toString}.
+     *
+     * @returns {string} The default string description of this object.
+     */
+    get [Symbol.toStringTag]() {
+      return "Transportr";
     }
-    return options;
   };
-  /**
-   * Generates a ResponseStatus object based on the error name and the response.
-   *
-   * @private
-   * @static
-   * @param {string} errorName The name of the error.
-   * @param {Response} response The response object returned by the fetch API.
-   * @returns {ResponseStatus} The response status object.
-   */
-  __privateAdd(Transportr, _generateResponseStatusFromError);
-  /**
-   * It takes a URL, a path, and a set of search parameters, and returns a new URL with the path and
-   * search parameters applied.
-   *
-   * @private
-   * @static
-   * @param {URL} url - The URL to use as a base.
-   * @param {string} path - The path to the resource. This can be a relative path or a full URL.
-   * @param {Object<string, string>} [searchParams={}] - An object containing the query parameters to be added to the URL.
-   * @returns {URL} A new URL object with the pathname and origin of the url parameter, and the path parameter
-   * appended to the end of the pathname.
-   */
-  __privateAdd(Transportr, _createUrl);
-  /**
-   * If the request method is POST, PUT, or PATCH, and the content type is JSON, then the request body
-   * needs to be serialized.
-   *
-   * @private
-   * @static
-   * @param {RequestMethod} method - The HTTP request method.
-   * @param {HttpMediaType} contentType - The headers of the request.
-   * @returns {boolean} `true` if the request body needs to be serialized, `false` otherwise.
-   */
-  __privateAdd(Transportr, _needsSerialization);
-  /**
-   *
-   * @param {RequestOptions} options - The options passed to the public function to use for the request.
-   * @returns {RequestOptions} The options to use for the request.
-   */
-  __privateAdd(Transportr, _convertRequestOptions);
-  /** @type {Subscribr} */
-  __privateAdd(Transportr, _globalSubscribr, new Subscribr());
-  /** @type {Array<SignalController>} */
-  __privateAdd(Transportr, _activeRequests, []);
-  /**
-   * @private
-   * @static
-   * @type {SetMultiMap<ResponseHandler<ResponseBody>, string>}
-   */
-  __privateAdd(Transportr, _contentTypeHandlers, new SetMultiMap([
-    [_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>}
-   */
-  __privateAdd(Transportr, _propertyTypeConverters, /* @__PURE__ */ new Set([
-    [{ property: "body", type: FormData, converter: _typeConverter }],
-    [{ property: "searchParams", type: URLSearchParams, converter: _typeConverter }],
-    [{ property: "headers", type: Headers, converter: Object.fromEntries }]
-  ]));
-  /**
-   * @static
-   * @constant {Object<string, HttpRequestMethod>}
-   */
-  __publicField(Transportr, "Method", Object.freeze(http_request_methods_default));
-  /**
-   * @static
-   * @constant {Object<string, HttpMediaType>}
-   */
-  __publicField(Transportr, "MediaType", Object.freeze(http_media_type_default));
-  /**
-   * @static
-   * @see {@link HttpRequestHeader}
-   * @constant {Object<string, HttpRequestHeader>}
-   */
-  __publicField(Transportr, "RequestHeader", Object.freeze(http_request_headers_default));
-  /**
-   * @static
-   * @constant {Object<string, HttpResponseHeader>}
-   */
-  __publicField(Transportr, "ResponseHeader", Object.freeze(http_response_headers_default));
-  /**
-   * @static
-   * @constant {Object<string, RequestCache>}
-   */
-  __publicField(Transportr, "CachingPolicy", Object.freeze({
-    DEFAULT: "default",
-    FORCE_CACHE: "force-cache",
-    NO_CACHE: "no-cache",
-    NO_STORE: "no-store",
-    ONLY_IF_CACHED: "only-if-cached",
-    RELOAD: "reload"
-  }));
-  /**
-   * @static
-   * @constant {Object<string, RequestCredentials>}
-   */
-  __publicField(Transportr, "CredentialsPolicy", Object.freeze({
-    INCLUDE: "include",
-    OMIT: "omit",
-    SAME_ORIGIN: "same-origin"
-  }));
-  /**
-   * @static
-   * @constant {Object<string, RequestMode>}
-   */
-  __publicField(Transportr, "RequestMode", Object.freeze({
-    CORS: "cors",
-    NAVIGATE: "navigate",
-    NO_CORS: "no-cors",
-    SAME_ORIGIN: "same-origin"
-  }));
-  /**
-   * @static
-   * @constant {Object<string, RequestRedirect>}
-   */
-  __publicField(Transportr, "RedirectPolicy", Object.freeze({
-    ERROR: "error",
-    FOLLOW: "follow",
-    MANUAL: "manual"
-  }));
-  /**
-   * @static
-   * @constant {Object<string, ReferrerPolicy>}
-   */
-  __publicField(Transportr, "ReferrerPolicy", Object.freeze({
-    NO_REFERRER: "no-referrer",
-    NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
-    ORIGIN: "origin",
-    ORIGIN_WHEN_CROSS_ORIGIN: "origin-when-cross-origin",
-    SAME_ORIGIN: "same-origin",
-    STRICT_ORIGIN: "strict-origin",
-    STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
-    UNSAFE_URL: "unsafe-url"
-  }));
-  /**
-   * @static
-   * @constant {Object<string, TransportrEvent>}
-   */
-  __publicField(Transportr, "Events", Object.freeze({
-    CONFIGURED: "configured",
-    SUCCESS: "success",
-    ERROR: "error",
-    ABORTED: "aborted",
-    TIMEOUT: "timeout",
-    COMPLETE: "complete",
-    ALL_COMPLETE: "all-complete"
-  }));
-  /**
-   * @private
-   * @static
-   * @type {RequestOptions}
-   */
-  __privateAdd(Transportr, _defaultRequestOptions, Object.freeze({
-    body: null,
-    cache: _Transportr.CachingPolicy.NO_STORE,
-    credentials: _Transportr.CredentialsPolicy.SAME_ORIGIN,
-    headers: { [http_request_headers_default.CONTENT_TYPE]: _mediaTypes.get(http_media_type_default.JSON).toString(), [http_request_headers_default.ACCEPT]: _mediaTypes.get(http_media_type_default.JSON).toString() },
-    searchParams: {},
-    integrity: void 0,
-    keepalive: void 0,
-    method: http_request_methods_default.GET,
-    mode: _Transportr.RequestMode.CORS,
-    redirect: _Transportr.RedirectPolicy.FOLLOW,
-    referrer: "about:client",
-    referrerPolicy: _Transportr.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
-    signal: void 0,
-    timeout: 1e4,
-    global: true,
-    window: null
-  }));
-  /**
-   * @private
-   * @static
-   * @type {Map<TransportrEvent, ResponseStatus>}
-   */
-  __privateAdd(Transportr, _eventResponseStatuses, /* @__PURE__ */ new Map([
-    [_Transportr.Events.ABORTED, new ResponseStatus(499, "Aborted")],
-    [_Transportr.Events.TIMEOUT, new ResponseStatus(504, "Gateway Timeout")]
-  ]));
   return __toCommonJS(transportr_exports);
 })();
 window.Transportr = Transportr.default;