@d1g1tal/transportr 0.0.2

package/dist/transportr.js

@@ -0,0 +1,887 @@
+var Transportr = (() => {
+  var __defProp = Object.defineProperty;
+  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 });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    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 = {};
+  __export(transportr_exports, {
+    default: () => Transportr
+  });
+
+  // node_modules/@d1g1tal/collections/src/list.js
+  var List = class {
+    #array;
+    constructor(iterable = []) {
+      this.#array = Array.of(...iterable);
+    }
+    static from(iterable, mapper, context) {
+      return new List(Array.from(iterable, mapper, context));
+    }
+    static withSize(size) {
+      return new List(new Array(size));
+    }
+    add(element) {
+      this.#array.push(element);
+      return this;
+    }
+    addAll(iterable) {
+      this.#array.push(...iterable);
+      return this;
+    }
+    clear() {
+      this.#array.length = 0;
+    }
+    concat(elements) {
+      return this(this.#array.concat(...elements));
+    }
+    every(predicate) {
+      return this.#array.every((element, index) => predicate(element, index, this));
+    }
+    some(predicate) {
+      return this.#array.some((element, index) => predicate(element, index, this));
+    }
+    filter(predicate) {
+      return new List(this.#array.filter((element, index) => predicate(element, index, this)));
+    }
+    find(predicate, context) {
+      return this.#array.find((element, index) => predicate(element, index, this), context);
+    }
+    findIndex(predicate, context) {
+      return this.#array.findIndex((element, index) => predicate(element, index, this), context);
+    }
+    map(mapper) {
+      return new List(this.#array.map((element, index) => mapper(element, index, this)));
+    }
+    reduce(reducer, initialValue) {
+      return this.#array.reduce(reducer, initialValue);
+    }
+    sort(comparator) {
+      this.#array.sort(comparator);
+      return this;
+    }
+    forEach(consumer) {
+      this.#array.forEach((element, index) => consumer(element, index, this));
+    }
+    get(element, fromIndex = 0) {
+      return this.#array.at(this.#array.indexOf(element, fromIndex));
+    }
+    has(element) {
+      return this.#array.includes(element);
+    }
+    insert(index, element) {
+      this.#array.splice(index, 0, element);
+    }
+    delete(element) {
+      return this.#array.splice(this.#array.indexOf(element), 1).length == 1;
+    }
+    deleteAt(index) {
+      return this.#array.splice(index, 1).length == 1;
+    }
+    keys() {
+      return this.#array.keys();
+    }
+    values() {
+      return this[Symbol.iterator]();
+    }
+    entries() {
+      return this.#array.entries();
+    }
+    isEmpty() {
+      return this.#array.length === 0;
+    }
+    toArray() {
+      return [...this.#array];
+    }
+    toString() {
+      return this.#array.toString();
+    }
+    valueOf() {
+      return this.#array.valueOf();
+    }
+    get size() {
+      return this.#array.length;
+    }
+    [Symbol.iterator]() {
+      return this.#array[Symbol.iterator]();
+    }
+    get [Symbol.toStringTag]() {
+      return "List";
+    }
+  };
+
+  // node_modules/@d1g1tal/collections/src/multi-map.js
+  var MultiMap = class extends Map {
+    set(key, value) {
+      super.set(key, (this.get(key) ?? new List()).add(value));
+      return this;
+    }
+    [Symbol.toStringTag]() {
+      return "MultiMap";
+    }
+  };
+
+  // node_modules/@d1g1tal/collections/src/set-multi-map.js
+  var SetMultiMap = class extends Map {
+    set(key, value) {
+      super.set(key, (super.get(key) ?? /* @__PURE__ */ new Set()).add(value));
+      return this;
+    }
+    [Symbol.toStringTag]() {
+      return "SetMultiMap";
+    }
+  };
+
+  // node_modules/@d1g1tal/collections/src/node.js
+  var Node = class {
+    #value;
+    #next;
+    constructor(value) {
+      this.#value = value;
+      this.#next = null;
+    }
+    get value() {
+      return this.#value;
+    }
+    get next() {
+      return this.#next;
+    }
+    get [Symbol.toStringTag]() {
+      return "Node";
+    }
+  };
+
+  // node_modules/@d1g1tal/collections/src/weak-set-multi-map.js
+  var WeakSetMultiMap = class extends Map {
+    set(key, value) {
+      super.set(key, (super.get(key) ?? /* @__PURE__ */ new WeakSet()).add(value));
+      return this;
+    }
+    [Symbol.toStringTag]() {
+      return "WeakSetMultiMap";
+    }
+  };
+
+  // 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-type.js
+  var _isType = (object, type) => object_type_default(object) === type;
+  var object_is_type_default = _isType;
+
+  // node_modules/@d1g1tal/chrysalis/src/esm/object-merge.js
+  var _objectMerge = (...objects) => {
+    return objects.reduce((prev, obj) => {
+      Object.keys(obj).forEach((key) => {
+        const pVal = prev[key];
+        const oVal = obj[key];
+        if (Array.isArray(pVal) && Array.isArray(oVal)) {
+          prev[key] = [.../* @__PURE__ */ new Set([...oVal, ...pVal])];
+        } else if (object_is_type_default(pVal, Object) && object_is_type_default(oVal, Object)) {
+          prev[key] = _objectMerge(pVal, oVal);
+        } else {
+          prev[key] = oVal;
+        }
+      });
+      return prev;
+    }, {});
+  };
+  var object_merge_default = _objectMerge;
+
+  // node_modules/@d1g1tal/media-type/src/utils.js
+  var removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(/^[ \t\n\r]+/u, "").replace(/[ \t\n\r]+$/u, "");
+  var removeTrailingHTTPWhitespace = (string) => string.replace(/[ \t\n\r]+$/u, "");
+  var isHTTPWhitespaceChar = (char) => char === " " || char === "	" || char === "\n" || char === "\r";
+  var solelyContainsHTTPTokenCodePoints = (string) => /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u.test(string);
+  var solelyContainsHTTPQuotedStringTokenCodePoints = (string) => /^[\t\u0020-\u007E\u0080-\u00FF]*$/u.test(string);
+  var asciiLowercase = (string) => string.replace(/[A-Z]/ug, (l) => l.toLowerCase());
+  var collectAnHTTPQuotedString = (input, position) => {
+    let value = "";
+    position++;
+    while (true) {
+      while (position < input.length && input[position] !== '"' && input[position] !== "\\") {
+        value += input[position];
+        ++position;
+      }
+      if (position >= input.length) {
+        break;
+      }
+      const quoteOrBackslash = input[position];
+      ++position;
+      if (quoteOrBackslash === "\\") {
+        if (position >= input.length) {
+          value += "\\";
+          break;
+        }
+        value += input[position];
+        ++position;
+      } else {
+        break;
+      }
+    }
+    return [value, position];
+  };
+
+  // node_modules/@d1g1tal/media-type/src/media-type-parameters.js
+  var MediaTypeParameters = class {
+    constructor(map) {
+      this._map = map;
+    }
+    get size() {
+      return this._map.size;
+    }
+    get(name) {
+      return this._map.get(asciiLowercase(String(name)));
+    }
+    has(name) {
+      return this._map.has(asciiLowercase(String(name)));
+    }
+    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;
+    }
+    clear() {
+      this._map.clear();
+    }
+    delete(name) {
+      name = asciiLowercase(String(name));
+      return this._map.delete(name);
+    }
+    forEach(callback, thisArg) {
+      this._map.forEach(callback, thisArg);
+    }
+    keys() {
+      return this._map.keys();
+    }
+    values() {
+      return this._map.values();
+    }
+    entries() {
+      return this._map.entries();
+    }
+    [Symbol.iterator]() {
+      return this._map[Symbol.iterator]();
+    }
+  };
+
+  // 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 += ";";
+      serialization += name;
+      serialization += "=";
+      if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
+        value = value.replace(/(["\\])/ug, "\\$1");
+        value = `"${value}"`;
+      }
+      serialization += value;
+    }
+    return serialization;
+  };
+  var serializer_default = serialize;
+
+  // node_modules/@d1g1tal/media-type/src/media-type.js
+  var MediaType = class {
+    constructor(string) {
+      string = String(string);
+      const result = parser_default(string);
+      if (result === null) {
+        throw new Error(`Could not parse media type string '${string}'`);
+      }
+      this._type = result.type;
+      this._subtype = result.subtype;
+      this._parameters = new MediaTypeParameters(result.parameters);
+    }
+    static parse(string) {
+      try {
+        return new this(string);
+      } catch (e) {
+        return null;
+      }
+    }
+    get essence() {
+      return `${this.type}/${this.subtype}`;
+    }
+    get type() {
+      return this._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;
+    }
+    get subtype() {
+      return this._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;
+    }
+    get parameters() {
+      return this._parameters;
+    }
+    toString() {
+      return serializer_default(this);
+    }
+    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;
+      }
+    }
+    isXML() {
+      return this._subtype === "xml" && (this._type === "text" || this._type === "application") || this._subtype.endsWith("+xml");
+    }
+    isHTML() {
+      return this._subtype === "html" && this._type === "text";
+    }
+    get [Symbol.toStringTag]() {
+      return "MediaType";
+    }
+  };
+
+  // src/http-media-type.js
+  var HttpMediaType = {
+    AAC: "audio/aac",
+    ABW: "application/x-abiword",
+    ARC: "application/x-freearc",
+    AVIF: "image/avif",
+    AVI: "video/x-msvideo",
+    AZW: "application/vnd.amazon.ebook",
+    BIN: "application/octet-stream",
+    BMP: "image/bmp",
+    BZIP: "application/x-bzip",
+    BZIP2: "application/x-bzip2",
+    CDA: "application/x-cdf",
+    CSH: "application/x-csh",
+    CSS: "text/css",
+    CSV: "text/csv",
+    DOC: "application/msword",
+    DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    EOT: "application/vnd.ms-fontobject",
+    EPUB: "application/epub+zip",
+    GZIP: "application/gzip",
+    GIF: "image/gif",
+    HTML: "text/html",
+    ICO: "image/vnd.microsoft.icon",
+    ICS: "text/calendar",
+    JAR: "application/java-archive",
+    JPEG: "image/jpeg",
+    JAVA_SCRIPT: "text/javascript",
+    JSON: "application/json",
+    JSON_LD: "application/ld+json",
+    MID: "audio/midi",
+    X_MID: "audio/x-midi",
+    MP3: "audio/mpeg",
+    MP4A: "audio/mp4",
+    MP4: "video/mp4",
+    MPEG: "video/mpeg",
+    MPKG: "application/vnd.apple.installer+xml",
+    ODP: "application/vnd.oasis.opendocument.presentation",
+    ODS: "application/vnd.oasis.opendocument.spreadsheet",
+    ODT: "application/vnd.oasis.opendocument.text",
+    OGA: "audio/ogg",
+    OGV: "video/ogg",
+    OGX: "application/ogg",
+    OPUS: "audio/opus",
+    OTF: "font/otf",
+    PNG: "image/png",
+    PDF: "application/pdf",
+    PHP: "application/x-httpd-php",
+    PPT: "application/vnd.ms-powerpoint",
+    PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    RAR: "application/vnd.rar",
+    RTF: "application/rtf",
+    SH: "application/x-sh",
+    SVG: "image/svg+xml",
+    TAR: "application/x-tar",
+    TIFF: "image/tiff",
+    TRANSPORT_STREAM: "video/mp2t",
+    TTF: "font/ttf",
+    TEXT: "text/plain",
+    VSD: "application/vnd.visio",
+    WAV: "audio/wav",
+    WEBA: "audio/webm",
+    WEBM: "video/webm",
+    WEBP: "image/webp",
+    WOFF: "font/woff",
+    WOFF2: "font/woff2",
+    XHTML: "application/xhtml+xml",
+    XLS: "application/vnd.ms-excel",
+    XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    XML: "application/xml",
+    XUL: "application/vnd.mozilla.xul+xml",
+    ZIP: "application/zip",
+    "3GP": "video/3gpp",
+    "3G2": "video/3gpp2",
+    "7Z": "application/x-7z-compressed"
+  };
+  var http_media_type_default = HttpMediaType;
+
+  // src/http-request-headers.js
+  var HttpRequestHeader = {
+    ACCEPT: "accept",
+    ACCEPT_CHARSET: "accept-charset",
+    ACCEPT_ENCODING: "accept-encoding",
+    ACCEPT_LANGUAGE: "accept-language",
+    AUTHORIZATION: "authorization",
+    CACHE_CONTROL: "cache-control",
+    CONNECTION: "connection",
+    COOKIE: "cookie",
+    CONTENT_LENGTH: "content-length",
+    CONTENT_MD5: "content-md5",
+    CONTENT_TYPE: "content-type",
+    DATE: "date",
+    EXPECT: "expect",
+    FROM: "from",
+    HOST: "host",
+    IF_MATCH: "if-match",
+    IF_MODIFIED_SINCE: "if-modified-since",
+    IF_NONE_MATCH: "if-none-match",
+    IF_RANGE: "if-range",
+    IF_UNMODIFIED_SINCE: "if-unmodified-since",
+    MAX_FORWARDS: "max-forwards",
+    ORIGIN: "origin",
+    PRAGMA: "pragma",
+    PROXY_AUTHORIZATION: "proxy-authorization",
+    RANGE: "range",
+    REFERER: "referer",
+    TE: "te",
+    USER_AGENT: "user-agent",
+    UPGRADE: "upgrade",
+    VIA: "via",
+    WARNING: "warning",
+    X_REQUESTED_WITH: "x-requested-with",
+    DNT: "dnt",
+    X_FORWARDED_FOR: "x-forwarded-for",
+    X_FORWARDED_HOST: "x-forwarded-host",
+    X_FORWARDED_PROTO: "x-forwarded-proto",
+    FRONT_END_HTTPS: "front-end-https",
+    X_HTTP_METHOD_OVERRIDE: "x-http-method-override",
+    X_ATT_DEVICE_ID: "x-att-deviceid",
+    X_WAP_PROFILE: "x-wap-profile"
+  };
+  var http_request_headers_default = HttpRequestHeader;
+
+  // src/http-request-methods.js
+  var HttpRequestMethod = {
+    OPTIONS: "OPTIONS",
+    GET: "GET",
+    HEAD: "HEAD",
+    POST: "POST",
+    PUT: "PUT",
+    DELETE: "DELETE",
+    TRACE: "TRACE",
+    CONNECT: "CONNECT",
+    PATCH: "PATCH"
+  };
+  var http_request_methods_default = HttpRequestMethod;
+
+  // src/http-response-headers.js
+  var HttpResponseHeader = {
+    PROXY_CONNECTION: "proxy-connection",
+    X_UIDH: "x-uidh",
+    X_CSRF_TOKEN: "x-csrf-token",
+    ACCESS_CONTROL_ALLOW_ORIGIN: "access-control-allow-origin",
+    ACCEPT_PATCH: "accept-patch",
+    ACCEPT_RANGES: "accept-ranges",
+    AGE: "age",
+    ALLOW: "allow",
+    CACHE_CONTROL: "cache-control",
+    CONNECTION: "connection",
+    CONTENT_DISPOSITION: "content-disposition",
+    CONTENT_ENCODING: "content-encoding",
+    CONTENT_LANGUAGE: "content-language",
+    CONTENT_LENGTH: "content-length",
+    CONTENT_LOCATION: "content-location",
+    CONTENT_RANGE: "content-range",
+    CONTENT_TYPE: "content-type",
+    DATE: "date",
+    ETAG: "etag",
+    EXPIRES: "expires",
+    LAST_MODIFIED: "last-modified",
+    LINK: "link",
+    LOCATION: "location",
+    P3P: "p3p",
+    PRAGMA: "pragma",
+    PROXY_AUTHENTICATION: "proxy-authenticate",
+    PUBLIC_KEY_PINS: "public-key-pins",
+    RETRY_AFTER: "retry-after",
+    SERVER: "server",
+    SET_COOKIE: "set-cookie",
+    STATUS: "status",
+    STRICT_TRANSPORT_SECURITY: "strict-transport-security",
+    TRAILER: "trailer",
+    TRANSFER_ENCODING: "transfer-encoding",
+    UPGRADE: "upgrade",
+    VARY: "vary",
+    VIA: "via",
+    WARNING: "warning",
+    WWW_AUTHENTICATE: "www-authenticate",
+    X_XSS_PROTECTION: "x-xss-protection",
+    CONTENT_SECURITY_POLICY: "content-security-policy",
+    X_CONTENT_TYPE_OPTIONS: "x-content-type-options",
+    X_POWERED_BY: "x-powered-by"
+  };
+  var http_response_headers_default = HttpResponseHeader;
+
+  // src/transportr.js
+  var HttpError = class extends Error {
+  };
+  var endsWithSlashRegEx = /\/$/;
+  var _handleText = async (response) => await response.text();
+  var _handleJson = async (response) => await response.json();
+  var _handleBlob = async (response) => await response.blob();
+  var _handleBuffer = async (response) => await response.arrayBuffer();
+  var _handleReadableStream = async (response) => response.body;
+  var _handleXml = async (response) => new DOMParser().parseFromString(await response.text(), Transportr.MediaType.XML.essence);
+  var _baseUrl, _MediaType, _contentTypeHandlers, _defaultRequestOptions, _get, get_fn, _request, request_fn, _createUrl, createUrl_fn, _processResponse, processResponse_fn;
+  var _Transportr = class {
+    constructor(url = location.origin) {
+      __privateAdd(this, _get);
+      __privateAdd(this, _request);
+      __privateAdd(this, _baseUrl, void 0);
+      __privateAdd(this, _defaultRequestOptions, {
+        body: null,
+        cache: _Transportr.CachingPolicy.NO_STORE,
+        credentials: "same-origin",
+        headers: {},
+        integrity: void 0,
+        keepalive: void 0,
+        method: void 0,
+        mode: "cors",
+        redirect: "follow",
+        referrer: "about:client",
+        referrerPolicy: "strict-origin-when-cross-origin",
+        signal: null,
+        window: null
+      });
+      __privateSet(this, _baseUrl, url instanceof URL ? url : url.startsWith("/") ? new URL(url, location.origin) : new URL(url));
+    }
+    get baseUrl() {
+      return __privateGet(this, _baseUrl);
+    }
+    async get(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.GET }));
+    }
+    async post(path, body, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { body, method: http_request_methods_default.POST }));
+    }
+    async put(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.PUT }));
+    }
+    async patch(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.PATCH }));
+    }
+    async delete(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.DELETE }));
+    }
+    async head(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.HEAD }));
+    }
+    async options(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: http_request_methods_default.OPTIONS }));
+    }
+    async request(path, options = {}) {
+      return __privateMethod(this, _request, request_fn).call(this, path, options);
+    }
+    async getJson(path, options = {}) {
+      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: _Transportr.MediaType.JSON } }), _handleJson);
+    }
+    async getXml(path, options = {}) {
+      return new DOMParser().parseFromString(await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: _Transportr.MediaType.XML } }), _handleBlob), http_media_type_default.XML);
+    }
+    async getHtml(path, options = {}) {
+      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.HTML } }), _handleText);
+    }
+    async getScript(path, options = {}) {
+      return __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.JAVA_SCRIPT } }), _handleText);
+    }
+    async getBlob(path, options = {}) {
+      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }), _handleBlob);
+    }
+    async getImage(path, options = {}) {
+      return URL.createObjectURL(await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: "image/*" } }), _handleBlob));
+    }
+    async getBuffer(path, options = {}) {
+      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }), _handleBuffer);
+    }
+    async getStream(path, options = {}) {
+      return await __privateMethod(this, _get, get_fn).call(this, path, object_merge_default(options, { headers: { [http_request_headers_default.ACCEPT]: http_media_type_default.BIN } }), _handleReadableStream);
+    }
+  };
+  var Transportr = _Transportr;
+  _baseUrl = new WeakMap();
+  _MediaType = new WeakMap();
+  _contentTypeHandlers = new WeakMap();
+  _defaultRequestOptions = new WeakMap();
+  _get = new WeakSet();
+  get_fn = async function(path, options, responseHandler) {
+    return __privateMethod(this, _request, request_fn).call(this, path, object_merge_default(options, { method: _Transportr.Method.GET }), responseHandler);
+  };
+  _request = new WeakSet();
+  request_fn = async function(path, options, responseHandler) {
+    var _a, _b;
+    console.debug(`Calling '${path}'`);
+    const requestOptions = object_merge_default(__privateGet(this, _defaultRequestOptions), options);
+    const headers = new Headers(requestOptions.headers);
+    if (headers.get(_Transportr.RequestHeader.CONTENT_TYPE) == _Transportr.MediaType.JSON) {
+      requestOptions.body = JSON.stringify(requestOptions.body);
+    }
+    let response;
+    try {
+      response = await fetch(__privateMethod(_a = _Transportr, _createUrl, createUrl_fn).call(_a, __privateGet(this, _baseUrl), path, requestOptions.searchParams), requestOptions);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+    if (!response.ok) {
+      throw new HttpError(`An error has occurred with your request: ${response.status} - ${await response.text()}`);
+    }
+    try {
+      return await (responseHandler ? responseHandler(response) : __privateMethod(_b = _Transportr, _processResponse, processResponse_fn).call(_b, response));
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  };
+  _createUrl = new WeakSet();
+  createUrl_fn = function(url, path, searchParams = {}) {
+    url = new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin);
+    for (const [name, value] of Object.entries(searchParams)) {
+      if (url.searchParams.has(name)) {
+        url.searchParams.set(name, value);
+      } else {
+        url.searchParams.append(name, value);
+      }
+    }
+    return url;
+  };
+  _processResponse = new WeakSet();
+  processResponse_fn = async function(response) {
+    const mediaType = new MediaType(response.headers.get(http_response_headers_default.CONTENT_TYPE));
+    for (const [responseHandler, contentTypes] of __privateGet(_Transportr, _contentTypeHandlers).entries()) {
+      if (contentTypes.has(mediaType.subtype)) {
+        return await responseHandler(response);
+      }
+    }
+    console.warn("Unable to process response. Unknown content-type or no response handler defined.");
+    return response;
+  };
+  __privateAdd(Transportr, _createUrl);
+  __privateAdd(Transportr, _processResponse);
+  __privateAdd(Transportr, _MediaType, {
+    JSON: new MediaType(http_media_type_default.JSON),
+    XML: new MediaType(http_media_type_default.XML),
+    HTML: new MediaType(http_media_type_default.HTML),
+    SCRIPT: new MediaType(http_media_type_default.JAVA_SCRIPT),
+    TEXT: new MediaType(http_media_type_default.TEXT),
+    CSS: new MediaType(http_media_type_default.CSS),
+    WEBP: new MediaType(http_media_type_default.WEBP),
+    PNG: new MediaType(http_media_type_default.PNG),
+    GIF: new MediaType(http_media_type_default.GIF),
+    JPG: new MediaType(http_media_type_default.JPEG),
+    OTF: new MediaType(http_media_type_default.OTF),
+    WOFF: new MediaType(http_media_type_default.WOFF),
+    WOFF2: new MediaType(http_media_type_default.WOFF2),
+    TTF: new MediaType(http_media_type_default.TTF),
+    PDF: new MediaType(http_media_type_default.PDF)
+  });
+  __privateAdd(Transportr, _contentTypeHandlers, new SetMultiMap([
+    [_handleJson, __privateGet(_Transportr, _MediaType).JSON.subtype],
+    [_handleText, __privateGet(_Transportr, _MediaType).HTML.subtype],
+    [_handleText, __privateGet(_Transportr, _MediaType).SCRIPT.subtype],
+    [_handleText, __privateGet(_Transportr, _MediaType).CSS.subtype],
+    [_handleText, __privateGet(_Transportr, _MediaType).TEXT.subtype],
+    [_handleXml, __privateGet(_Transportr, _MediaType).XML.subtype],
+    [_handleBlob, __privateGet(_Transportr, _MediaType).GIF.subtype],
+    [_handleBlob, __privateGet(_Transportr, _MediaType).JPG.subtype],
+    [_handleBlob, __privateGet(_Transportr, _MediaType).PNG.subtype]
+  ]));
+  __publicField(Transportr, "Method", Object.freeze(http_request_methods_default));
+  __publicField(Transportr, "MediaType", http_media_type_default);
+  __publicField(Transportr, "RequestHeader", http_request_headers_default);
+  __publicField(Transportr, "ResponseHeader", Object.freeze(http_response_headers_default));
+  __publicField(Transportr, "CachingPolicy", {
+    DEFAULT: "default",
+    FORCE_CACHE: "force-cache",
+    NO_CACHE: "no-cache",
+    NO_STORE: "no-store",
+    ONLY_IF_CACHED: "only-if-cached",
+    RELOAD: "reload"
+  });
+  __publicField(Transportr, "CredentialsPolicy", {
+    INCLUDE: "include",
+    OMIT: "omit",
+    SAME_ORIGIN: "same-origin"
+  });
+  return __toCommonJS(transportr_exports);
+})();
+window.Transportr = Transportr.default;