@utiliread/http 1.19.5 → 1.20.0

package/dist/index.js

@@ -1,86 +1,60 @@
-var $8zHUo$luxon = require("luxon");
+'use strict';
 
+var luxon = require('luxon');
 
-function $parcel$exportWildcard(dest, source) {
-  Object.keys(source).forEach(function(key) {
-    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
-      return;
+class EventAggregator {
+    constructor() {
+        this.callbacks = [];
     }
-
-    Object.defineProperty(dest, key, {
-      enumerable: true,
-      get: function get() {
-        return source[key];
-      }
-    });
-  });
-
-  return dest;
-}
-
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
-}
-
-$parcel$export(module.exports, "Http", () => $071fc1f89bbb01d6$export$2a5b27776dbece47);
-$parcel$export(module.exports, "QueryString", () => $2d2fb1ca67e3fdc1$export$eada748df1dd417f);
-$parcel$export(module.exports, "HttpResponse", () => $ddf5c8852ff85dec$export$1d94dfe0d9d1f1e7);
-$parcel$export(module.exports, "HttpResponseOfT", () => $ddf5c8852ff85dec$export$bcbae67b865a76d2);
-$parcel$export(module.exports, "HttpBuilder", () => $b95ba42a6fda4623$export$fc624c0231d0f8a);
-$parcel$export(module.exports, "HttpBuilderOfT", () => $b95ba42a6fda4623$export$7dfcf6a5b7becec8);
-$parcel$export(module.exports, "HttpError", () => $22d313d0e1bb48b4$export$65bd6083489bd8bb);
-$parcel$export(module.exports, "TimeoutError", () => $2449c0a03f7caf8c$export$66d311bf29d5c89c);
-$parcel$export(module.exports, "events", () => $a541277566782c5f$export$4bf9923669ad6c63);
-$parcel$export(module.exports, "statusCodes", () => $a6d3c6600287d438$export$5b6a6a9b6e9a7920);
-class $0a30027052ee48d0$export$f93b90549b868d0 {
     get any() {
         return this.callbacks.length > 0;
     }
     subscribe(callback) {
         this.callbacks.push(callback);
         return {
-            dispose: ()=>{
+            dispose: () => {
                 const index = this.callbacks.indexOf(callback);
-                if (index >= 0) this.callbacks.splice(index, 1);
-            }
+                if (index >= 0) {
+                    this.callbacks.splice(index, 1);
+                }
+            },
         };
     }
     async publish(...params) {
         const callbacks = this.callbacks.slice();
-        for (const callback of callbacks)await Promise.resolve(callback.apply(this, params));
-    }
-    constructor(){
-        this.callbacks = [];
+        for (const callback of callbacks) {
+            await Promise.resolve(callback.apply(this, params));
+        }
     }
 }
 
-
-class $22d313d0e1bb48b4$export$65bd6083489bd8bb extends Error {
+class HttpError extends Error {
     get hasDetails() {
         const contentType = this.response?.rawResponse?.headers.get("Content-Type");
         return contentType?.includes("application/problem+json");
     }
-    constructor(statusCode, response){
+    constructor(statusCode, response = undefined) {
         super(`The response was not successful: ${statusCode}`);
         this.statusCode = statusCode;
         this.response = response;
         this.name = "HttpError";
         // Set the prototype explicitly to allow for "... instanceof HttpError",
         // see https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(this, $22d313d0e1bb48b4$export$65bd6083489bd8bb.prototype);
+        Object.setPrototypeOf(this, HttpError.prototype);
     }
     details() {
         const rawResponse = this.response?.rawResponse;
         if (rawResponse && this.hasDetails) {
-            this.detailsPromise ??= rawResponse.json().then((details)=>details);
-            return this.detailsPromise.then((details)=>details);
+            this.detailsPromise ?? (this.detailsPromise = rawResponse
+                .json()
+                .then((details) => details));
+            return this.detailsPromise.then((details) => details);
         }
         return Promise.reject(new Error("There are no problem details in the response"));
     }
 }
 
-
-class $ddf5c8852ff85dec$export$1d94dfe0d9d1f1e7 {
+class HttpResponse {
     get url() {
         return this.rawResponse.url;
     }
@@ -105,16 +79,18 @@ class $ddf5c8852ff85dec$export$1d94dfe0d9d1f1e7 {
     get isServerError() {
         return this.statusCode >= 500 && this.statusCode < 600;
     }
-    constructor(rawResponse){
+    constructor(rawResponse) {
         this.rawResponse = rawResponse;
     }
     ensureSuccessfulStatusCode() {
-        if (!this.isSuccessful) throw new (0, $22d313d0e1bb48b4$export$65bd6083489bd8bb)(this.statusCode, this);
+        if (!this.isSuccessful) {
+            throw new HttpError(this.statusCode, this);
+        }
         return this;
     }
 }
-class $ddf5c8852ff85dec$export$bcbae67b865a76d2 extends $ddf5c8852ff85dec$export$1d94dfe0d9d1f1e7 {
-    constructor(rawResponse, handler){
+class HttpResponseOfT extends HttpResponse {
+    constructor(rawResponse, handler) {
         super(rawResponse);
         this.handler = handler;
     }
@@ -123,27 +99,25 @@ class $ddf5c8852ff85dec$export$bcbae67b865a76d2 extends $ddf5c8852ff85dec$export
     }
 }
 
-
-class $2449c0a03f7caf8c$export$66d311bf29d5c89c extends Error {
-    constructor(){
+class TimeoutError extends Error {
+    constructor() {
         super("Timeout: The request was not successful");
         this.name = "TimeoutError";
         // Set the prototype explicitly to allow for "... instanceof TimeoutError",
         // see https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(this, $2449c0a03f7caf8c$export$66d311bf29d5c89c.prototype);
+        Object.setPrototypeOf(this, TimeoutError.prototype);
     }
 }
 
-
-
-class $b95ba42a6fda4623$export$fc624c0231d0f8a {
-    constructor(message, options, /** @internal */ http){
+class HttpBuilder {
+    constructor(message, options, 
+    /** @internal */ http) {
         this.message = message;
         this.options = options;
         this.http = http;
         this._ensureSuccessStatusCode = true;
-        this._onSend = new (0, $0a30027052ee48d0$export$f93b90549b868d0)();
-        this._onSent = new (0, $0a30027052ee48d0$export$f93b90549b868d0)();
+        this._onSend = new EventAggregator();
+        this._onSent = new EventAggregator();
     }
     onSend(callback) {
         this._onSend.subscribe(callback);
@@ -154,10 +128,12 @@ class $b95ba42a6fda4623$export$fc624c0231d0f8a {
         return this;
     }
     useHandler(handler) {
-        return new $b95ba42a6fda4623$export$7dfcf6a5b7becec8(this, handler);
+        return new HttpBuilderOfT(this, handler);
     }
     async send(abortSignal) {
-        if (this.message.contentType) this.message.headers.set("Content-Type", this.message.contentType);
+        if (this.message.contentType) {
+            this.message.headers.set("Content-Type", this.message.contentType);
+        }
         // Resolve the final url and assign it to the message
         // This makes the final url apper in onSend, onSent, and on Received handlers
         this.message.url = this.getUrl();
@@ -167,40 +143,57 @@ class $b95ba42a6fda4623$export$fc624c0231d0f8a {
             method: this.message.method,
             body: this.message.content,
             headers: this.message.headers,
-            mode: this.message.mode
+            mode: this.message.mode,
         };
         if (abortSignal || this.options.timeout) {
             var outerController = new AbortController();
-            if (abortSignal) abortSignal.addEventListener("abort", ()=>{
-                outerController.abort();
-            });
+            if (abortSignal) {
+                abortSignal.addEventListener("abort", () => {
+                    outerController.abort();
+                });
+            }
             init.signal = outerController.signal;
         }
         const fetchResponsePromise = this.options.fetch(this.message.url, init);
         let fetchResponse;
-        if (this.options.timeout) fetchResponse = await Promise.race([
-            fetchResponsePromise,
-            new Promise((_, reject)=>setTimeout(()=>{
+        if (this.options.timeout) {
+            fetchResponse = await Promise.race([
+                fetchResponsePromise,
+                new Promise((_, reject) => setTimeout(() => {
                     outerController.abort();
-                    reject(new (0, $2449c0a03f7caf8c$export$66d311bf29d5c89c)());
-                }, this.options.timeout))
-        ]);
-        else fetchResponse = await fetchResponsePromise;
-        const httpResponse = new (0, $ddf5c8852ff85dec$export$1d94dfe0d9d1f1e7)(fetchResponse);
-        if (this._ensureSuccessStatusCode) httpResponse.ensureSuccessfulStatusCode();
+                    reject(new TimeoutError());
+                }, this.options.timeout)),
+            ]);
+        }
+        else {
+            fetchResponse = await fetchResponsePromise;
+        }
+        const httpResponse = new HttpResponse(fetchResponse);
+        if (this._ensureSuccessStatusCode) {
+            httpResponse.ensureSuccessfulStatusCode();
+        }
         await this._onSent.publish(httpResponse, this.message);
         await this.http._onSent.publish(httpResponse, this.message);
         return httpResponse;
     }
     getUrl() {
         let baseUrl = this.options.baseUrl;
-        if (!baseUrl) return this.message.url;
-        if (baseUrl.endsWith("/")) baseUrl = baseUrl.substr(0, baseUrl.length - 1);
-        if (this.message.url.startsWith("/")) return baseUrl + this.message.url;
-        else return baseUrl + "/" + this.message.url;
+        if (!baseUrl) {
+            return this.message.url;
+        }
+        if (baseUrl.endsWith("/")) {
+            baseUrl = baseUrl.substr(0, baseUrl.length - 1);
+        }
+        if (this.message.url.startsWith("/")) {
+            return baseUrl + this.message.url;
+        }
+        else {
+            return baseUrl + "/" + this.message.url;
+        }
     }
     ensureSuccessStatusCode(ensureSuccessStatusCode) {
-        this._ensureSuccessStatusCode = ensureSuccessStatusCode === false ? false : true;
+        this._ensureSuccessStatusCode =
+            ensureSuccessStatusCode === false ? false : true;
         return this;
     }
     useCors(mode) {
@@ -229,22 +222,22 @@ class $b95ba42a6fda4623$export$fc624c0231d0f8a {
     }
     // Expect Extensions
     expectString() {
-        return this.useHandler((response)=>{
+        return this.useHandler((response) => {
             return response.rawResponse.text();
         });
     }
     expectBinary() {
-        return this.useHandler((response)=>{
+        return this.useHandler((response) => {
             return response.rawResponse.arrayBuffer();
         });
     }
 }
-class $b95ba42a6fda4623$export$7dfcf6a5b7becec8 extends $b95ba42a6fda4623$export$fc624c0231d0f8a {
-    constructor(inner, handler){
+class HttpBuilderOfT extends HttpBuilder {
+    constructor(inner, handler) {
         super(inner.message, inner.options, inner.http);
         this.inner = inner;
         this.handler = handler;
-        this._onReceived = new (0, $0a30027052ee48d0$export$f93b90549b868d0)();
+        this._onReceived = new EventAggregator();
     }
     onSend(callback) {
         this.inner.onSend(callback);
@@ -267,9 +260,13 @@ class $b95ba42a6fda4623$export$7dfcf6a5b7becec8 extends $b95ba42a6fda4623$export
         return this;
     }
     allowEmptyResponse() {
-        if (this._onReceived.any) throw new Error("onReceived() must be called after allowEmptyResponse() because the callback type changes");
-        return new $b95ba42a6fda4623$export$7dfcf6a5b7becec8(this.inner, (response)=>{
-            if (response.statusCode === 204) return Promise.resolve(null);
+        if (this._onReceived.any) {
+            throw new Error("onReceived() must be called after allowEmptyResponse() because the callback type changes");
+        }
+        return new HttpBuilderOfT(this.inner, (response) => {
+            if (response.statusCode === 204) {
+                return Promise.resolve(null);
+            }
             return this.handler(response);
         });
     }
@@ -278,11 +275,13 @@ class $b95ba42a6fda4623$export$7dfcf6a5b7becec8 extends $b95ba42a6fda4623$export
         return this;
     }
     send(abortSignal) {
-        const responsePromise = this.inner.send(abortSignal).then((x)=>new (0, $ddf5c8852ff85dec$export$bcbae67b865a76d2)(x.rawResponse, this.handler));
-        return $b95ba42a6fda4623$var$asSendPromise(responsePromise, ()=>responsePromise.then((response)=>this.handleReceive(response)));
+        const responsePromise = this.inner
+            .send(abortSignal)
+            .then((x) => new HttpResponseOfT(x.rawResponse, this.handler));
+        return asSendPromise(responsePromise, () => responsePromise.then((response) => this.handleReceive(response)));
     }
     transfer(abortSignal) {
-        return this.send(abortSignal).then((response)=>this.handleReceive(response));
+        return this.send(abortSignal).then((response) => this.handleReceive(response));
     }
     async handleReceive(response) {
         const request = this.message;
@@ -292,23 +291,27 @@ class $b95ba42a6fda4623$export$7dfcf6a5b7becec8 extends $b95ba42a6fda4623$export
         return value;
     }
 }
-function $b95ba42a6fda4623$var$asSendPromise(responsePromise, thenReceive) {
+function asSendPromise(responsePromise, thenReceive) {
     const sendPromise = responsePromise;
     sendPromise.thenReceive = thenReceive;
     return sendPromise;
 }
 
-
-
-class $2d2fb1ca67e3fdc1$export$eada748df1dd417f {
+class QueryString {
     static serialize(params) {
-        if (!params) return "";
+        if (!params) {
+            return "";
+        }
         const serialized = this._serializeQueryString(params);
-        if (!serialized.length) return "";
+        if (!serialized.length) {
+            return "";
+        }
         return "?" + serialized;
     }
     static append(url, params) {
-        if (!params) return url;
+        if (!params) {
+            return url;
+        }
         const any = url.indexOf("?") >= 0;
         const separator = any ? "&" : "?";
         return url + separator + this._serializeQueryString(params);
@@ -317,39 +320,56 @@ class $2d2fb1ca67e3fdc1$export$eada748df1dd417f {
         const regex = new RegExp(`[?&]${name}(=([^&#]*)|&|#|$)`);
         const match = regex.exec(window.location.href);
         if (match) {
-            if (match[1].length > 0) return decodeURIComponent(match[2]);
-            else return null;
+            if (match[1].length > 0) {
+                return decodeURIComponent(match[2]);
+            }
+            else {
+                return null;
+            }
         }
     }
     static _serializeQueryString(source, prefix) {
         const parts = [];
-        for(const propertyName in source)if (source.hasOwnProperty(propertyName)) {
-            const key = prefix != null ? prefix + (Array.isArray(source) ? "[" + encodeURIComponent(propertyName) + "]" : "." + encodeURIComponent(propertyName)) : encodeURIComponent(propertyName);
-            const value = source[propertyName];
-            if (value instanceof (0, $8zHUo$luxon.DateTime)) {
-                if (value.isValid) parts.push(key + "=" + encodeURIComponent(value.toISO()));
-            } else if (value === null) parts.push(key);
-            else if (value !== undefined) {
-                if (typeof value === "object") parts.push(this._serializeQueryString(value, key));
-                else parts.push(key + "=" + encodeURIComponent(value));
+        for (const propertyName in source) {
+            if (source.hasOwnProperty(propertyName)) {
+                const key = prefix != null
+                    ? prefix +
+                        (Array.isArray(source)
+                            ? "[" + encodeURIComponent(propertyName) + "]"
+                            : "." + encodeURIComponent(propertyName))
+                    : encodeURIComponent(propertyName);
+                const value = source[propertyName];
+                if (value instanceof luxon.DateTime) {
+                    if (value.isValid) {
+                        parts.push(key + "=" + encodeURIComponent(value.toISO()));
+                    }
+                }
+                else if (value === null) {
+                    parts.push(key);
+                }
+                else if (value !== undefined) {
+                    if (typeof value === "object") {
+                        parts.push(this._serializeQueryString(value, key));
+                    }
+                    else {
+                        parts.push(key + "=" + encodeURIComponent(value));
+                    }
+                }
             }
         }
         return parts.join("&");
     }
 }
 
-
-class $071fc1f89bbb01d6$export$2a5b27776dbece47 {
-    static{
-        this.defaults = {
-            fetch: self.fetch ? self.fetch.bind(self) : undefined
-        };
-    }
-    constructor(options){
-        /** @internal */ this._onSend = new (0, $0a30027052ee48d0$export$f93b90549b868d0)();
-        /** @internal */ this._onSent = new (0, $0a30027052ee48d0$export$f93b90549b868d0)();
-        /** @internal */ this._onReceived = new (0, $0a30027052ee48d0$export$f93b90549b868d0)();
-        this.options = Object.assign({}, $071fc1f89bbb01d6$export$2a5b27776dbece47.defaults, options); // Later sources' properties overwrite earlier ones.
+class Http {
+    constructor(options) {
+        /** @internal */
+        this._onSend = new EventAggregator();
+        /** @internal */
+        this._onSent = new EventAggregator();
+        /** @internal */
+        this._onReceived = new EventAggregator();
+        this.options = Object.assign({}, Http.defaults, options); // Later sources' properties overwrite earlier ones.
     }
     static request(method, url, params) {
         return this.getInstance().request(method, url, params);
@@ -374,25 +394,27 @@ class $071fc1f89bbb01d6$export$2a5b27776dbece47 {
     }
     static getInstance() {
         if (!this.instance) {
-            this.instance = new $071fc1f89bbb01d6$export$2a5b27776dbece47();
+            this.instance = new Http();
             // The singleton instance should always use the static options
-            this.instance.options = $071fc1f89bbb01d6$export$2a5b27776dbece47.defaults;
+            this.instance.options = Http.defaults;
         }
         return this.instance;
     }
     request(method, url, params) {
         const message = {
-            method: method,
-            url: url + (0, $2d2fb1ca67e3fdc1$export$eada748df1dd417f).serialize(params),
+            method,
+            url: url + QueryString.serialize(params),
             headers: new Headers(),
-            properties: {}
+            properties: {},
         };
         const fetch = this.options.fetch;
-        if (!fetch) throw Error("fetch() is not properly configured");
-        const builder = new (0, $b95ba42a6fda4623$export$fc624c0231d0f8a)(message, {
-            fetch: fetch,
+        if (!fetch) {
+            throw Error("fetch() is not properly configured");
+        }
+        const builder = new HttpBuilder(message, {
+            fetch,
             timeout: this.options.timeout,
-            baseUrl: this.options.baseUrl
+            baseUrl: this.options.baseUrl,
         }, this);
         return builder;
     }
@@ -424,141 +446,493 @@ class $071fc1f89bbb01d6$export$2a5b27776dbece47 {
         return this._onReceived.subscribe(callback);
     }
 }
+Http.defaults = {
+    fetch: self.fetch ? self.fetch.bind(self) : undefined,
+};
 
-
-
-
-
-
-
-
-function $a541277566782c5f$export$4bf9923669ad6c63(action, configure) {
-    return function(...params) {
+function events(action, configure) {
+    return function (...params) {
         const builder = action(...params);
         const events = configure(...params);
-        if (events.sent) builder.onSent(events.sent);
-        if (builder instanceof (0, $b95ba42a6fda4623$export$7dfcf6a5b7becec8) && events.received) builder.onReceived(events.received);
+        if (events.sent) {
+            builder.onSent(events.sent);
+        }
+        if (builder instanceof HttpBuilderOfT && events.received) {
+            builder.onReceived(events.received);
+        }
         return builder;
     };
 }
 
-
-var $dfecd32049fa58e9$exports = {};
-
-$parcel$export($dfecd32049fa58e9$exports, "isHttpError", () => $dfecd32049fa58e9$export$97b788730ba59845);
-$parcel$export($dfecd32049fa58e9$exports, "isAbortError", () => $dfecd32049fa58e9$export$d2c30ea522b3259e);
-$parcel$export($dfecd32049fa58e9$exports, "isTimeoutError", () => $dfecd32049fa58e9$export$f47339bf28a93789);
-function $dfecd32049fa58e9$export$97b788730ba59845(error) {
+function isHttpError(error) {
     return error.name === "HttpError";
 }
-function $dfecd32049fa58e9$export$d2c30ea522b3259e(error) {
+function isAbortError(error) {
     return error.name === "AbortError";
 }
-function $dfecd32049fa58e9$export$f47339bf28a93789(error) {
+function isTimeoutError(error) {
     return error.name === "TimeoutError";
 }
 
-
-const $a6d3c6600287d438$export$5b6a6a9b6e9a7920 = Object.freeze({
-    status100Continue: 100,
-    status101SwitchingProtocols: 101,
-    status102Processing: 102,
-    status200OK: 200,
-    status201Created: 201,
-    status202Accepted: 202,
-    status203NonAuthoritative: 203,
-    status204NoContent: 204,
-    status205ResetContent: 205,
-    status206PartialContent: 206,
-    status207MultiStatus: 207,
-    status208AlreadyReported: 208,
-    status226IMUsed: 226,
-    status300MultipleChoices: 300,
-    status301MovedPermanently: 301,
-    status302Found: 302,
-    status303SeeOther: 303,
-    status304NotModified: 304,
-    status305UseProxy: 305,
-    status306SwitchProxy: 306,
-    status307TemporaryRedirect: 307,
-    status308PermanentRedirect: 308,
-    status400BadRequest: 400,
-    status401Unauthorized: 401,
-    status402PaymentRequired: 402,
-    status403Forbidden: 403,
-    status404NotFound: 404,
-    status405MethodNotAllowed: 405,
-    status406NotAcceptable: 406,
-    status407ProxyAuthenticationRequired: 407,
-    status408RequestTimeout: 408,
-    status409Conflict: 409,
-    status410Gone: 410,
-    status411LengthRequired: 411,
-    status412PreconditionFailed: 412,
-    status413RequestEntityTooLarge: 413,
-    status413PayloadTooLarge: 413,
-    status414RequestUriTooLong: 414,
-    status414UriTooLong: 414,
-    status415UnsupportedMediaType: 415,
-    status416RequestedRangeNotSatisfiable: 416,
-    status416RangeNotSatisfiable: 416,
-    status417ExpectationFailed: 417,
-    status418ImATeapot: 418,
-    status419AuthenticationTimeout: 419,
-    status421MisdirectedRequest: 421,
-    status422UnprocessableEntity: 422,
-    status423Locked: 423,
-    status424FailedDependency: 424,
-    status426UpgradeRequired: 426,
-    status428PreconditionRequired: 428,
-    status429TooManyRequests: 429,
-    status431RequestHeaderFieldsTooLarge: 431,
-    status451UnavailableForLegalReasons: 451,
-    status500InternalServerError: 500,
-    status501NotImplemented: 501,
-    status502BadGateway: 502,
-    status503ServiceUnavailable: 503,
-    status504GatewayTimeout: 504,
-    status505HttpVersionNotsupported: 505,
-    status506VariantAlsoNegotiates: 506,
-    status507InsufficientStorage: 507,
-    status508LoopDetected: 508,
-    status510NotExtended: 510,
-    status511NetworkAuthenticationRequired: 511
+/** Gets the `Accept` HTTP header name. */
+const accept = "Accept";
+/** Gets the `Accept-Charset` HTTP header name. */
+const acceptCharset = "Accept-Charset";
+/** Gets the `Accept-Encoding` HTTP header name. */
+const acceptEncoding = "Accept-Encoding";
+/** Gets the `Accept-Language` HTTP header name. */
+const acceptLanguage = "Accept-Language";
+/** Gets the `Accept-Ranges` HTTP header name. */
+const acceptRanges = "Accept-Ranges";
+/** Gets the `Access-Control-Allow-Credentials` HTTP header name. */
+const accessControlAllowCredentials = "Access-Control-Allow-Credentials";
+/** Gets the `Access-Control-Allow-Headers` HTTP header name. */
+const accessControlAllowHeaders = "Access-Control-Allow-Headers";
+/** Gets the `Access-Control-Allow-Methods` HTTP header name. */
+const accessControlAllowMethods = "Access-Control-Allow-Methods";
+/** Gets the `Access-Control-Allow-Origin` HTTP header name. */
+const accessControlAllowOrigin = "Access-Control-Allow-Origin";
+/** Gets the `Access-Control-Expose-Headers` HTTP header name. */
+const accessControlExposeHeaders = "Access-Control-Expose-Headers";
+/** Gets the `Access-Control-Max-Age` HTTP header name. */
+const accessControlMaxAge = "Access-Control-Max-Age";
+/** Gets the `Access-Control-Request-Headers` HTTP header name. */
+const accessControlRequestHeaders = "Access-Control-Request-Headers";
+/** Gets the `Access-Control-Request-Method` HTTP header name. */
+const accessControlRequestMethod = "Access-Control-Request-Method";
+/** Gets the `Age` HTTP header name. */
+const age = "Age";
+/** Gets the `Allow` HTTP header name. */
+const allow = "Allow";
+/** Gets the `Alt-Svc` HTTP header name. */
+const altSvc = "Alt-Svc";
+/** Gets the `Authorization` HTTP header name. */
+const authorization = "Authorization";
+/** Gets the `baggage` HTTP header name. */
+const baggage = "baggage";
+/** Gets the `Cache-Control` HTTP header name. */
+const cacheControl = "Cache-Control";
+/** Gets the `Connection` HTTP header name. */
+const connection = "Connection";
+/** Gets the `Content-Disposition` HTTP header name. */
+const contentDisposition = "Content-Disposition";
+/** Gets the `Content-Encoding` HTTP header name. */
+const contentEncoding = "Content-Encoding";
+/** Gets the `Content-Language` HTTP header name. */
+const contentLanguage = "Content-Language";
+/** Gets the `Content-Length` HTTP header name. */
+const contentLength = "Content-Length";
+/** Gets the `Content-Location` HTTP header name. */
+const contentLocation = "Content-Location";
+/** Gets the `Content-MD5` HTTP header name. */
+const contentMD5 = "Content-MD5";
+/** Gets the `Content-Range` HTTP header name. */
+const contentRange = "Content-Range";
+/** Gets the `Content-Security-Policy` HTTP header name. */
+const contentSecurityPolicy = "Content-Security-Policy";
+/** Gets the `Content-Security-Policy-Report-Only` HTTP header name. */
+const contentSecurityPolicyReportOnly = "Content-Security-Policy-Report-Only";
+/** Gets the `Content-Type` HTTP header name. */
+const contentType = "Content-Type";
+/** Gets the `Correlation-Context` HTTP header name. */
+const correlationContext = "Correlation-Context";
+/** Gets the `Cookie` HTTP header name. */
+const cookie = "Cookie";
+/** Gets the `Date` HTTP header name. */
+const date = "Date";
+/** Gets the `DNT` HTTP header name. */
+const dnt = "DNT";
+/** Gets the `ETag` HTTP header name. */
+const eTag = "ETag";
+/** Gets the `Expires` HTTP header name. */
+const expires = "Expires";
+/** Gets the `Expect` HTTP header name. */
+const expect = "Expect";
+/** Gets the `From` HTTP header name. */
+const from = "From";
+/** Gets the `Grpc-Accept-Encoding` HTTP header name. */
+const grpcAcceptEncoding = "Grpc-Accept-Encoding";
+/** Gets the `Grpc-Encoding` HTTP header name. */
+const grpcEncoding = "Grpc-Encoding";
+/** Gets the `Grpc-Message` HTTP header name. */
+const grpcMessage = "Grpc-Message";
+/** Gets the `Grpc-Status` HTTP header name. */
+const grpcStatus = "Grpc-Status";
+/** Gets the `Grpc-Timeout` HTTP header name. */
+const grpcTimeout = "Grpc-Timeout";
+/** Gets the `Host` HTTP header name. */
+const host = "Host";
+/** Gets the `Keep-Alive` HTTP header name. */
+const keepAlive = "Keep-Alive";
+/** Gets the `If-Match` HTTP header name. */
+const ifMatch = "If-Match";
+/** Gets the `If-Modified-Since` HTTP header name. */
+const ifModifiedSince = "If-Modified-Since";
+/** Gets the `If-None-Match` HTTP header name. */
+const ifNoneMatch = "If-None-Match";
+/** Gets the `If-Range` HTTP header name. */
+const ifRange = "If-Range";
+/** Gets the `If-Unmodified-Since` HTTP header name. */
+const ifUnmodifiedSince = "If-Unmodified-Since";
+/** Gets the `Last-Modified` HTTP header name. */
+const lastModified = "Last-Modified";
+/** Gets the `Link` HTTP header name. */
+const link = "Link";
+/** Gets the `Location` HTTP header name. */
+const location = "Location";
+/** Gets the `Max-Forwards` HTTP header name. */
+const maxForwards = "Max-Forwards";
+/** Gets the `Origin` HTTP header name. */
+const origin = "Origin";
+/** Gets the `Pragma` HTTP header name. */
+const pragma = "Pragma";
+/** Gets the `Proxy-Authenticate` HTTP header name. */
+const proxyAuthenticate = "Proxy-Authenticate";
+/** Gets the `Proxy-Authorization` HTTP header name. */
+const proxyAuthorization = "Proxy-Authorization";
+/** Gets the `Proxy-Connection` HTTP header name. */
+const proxyConnection = "Proxy-Connection";
+/** Gets the `Range` HTTP header name. */
+const range = "Range";
+/** Gets the `Referer` HTTP header name. */
+const referer = "Referer";
+/** Gets the `Retry-After` HTTP header name. */
+const retryAfter = "Retry-After";
+/** Gets the `Request-Id` HTTP header name. */
+const requestId = "Request-Id";
+/** Gets the `Sec-WebSocket-Accept` HTTP header name. */
+const secWebSocketAccept = "Sec-WebSocket-Accept";
+/** Gets the `Sec-WebSocket-Key` HTTP header name. */
+const secWebSocketKey = "Sec-WebSocket-Key";
+/** Gets the `Sec-WebSocket-Protocol` HTTP header name. */
+const secWebSocketProtocol = "Sec-WebSocket-Protocol";
+/** Gets the `Sec-WebSocket-Version` HTTP header name. */
+const secWebSocketVersion = "Sec-WebSocket-Version";
+/** Gets the `Sec-WebSocket-Extensions` HTTP header name. */
+const secWebSocketExtensions = "Sec-WebSocket-Extensions";
+/** Gets the `Server` HTTP header name. */
+const server = "Server";
+/** Gets the `Set-Cookie` HTTP header name. */
+const setCookie = "Set-Cookie";
+/** Gets the `Strict-Transport-Security` HTTP header name. */
+const strictTransportSecurity = "Strict-Transport-Security";
+/** Gets the `TE` HTTP header name. */
+const te = "TE";
+/** Gets the `Trailer` HTTP header name. */
+const trailer = "Trailer";
+/** Gets the `Transfer-Encoding` HTTP header name. */
+const transferEncoding = "Transfer-Encoding";
+/** Gets the `Translate` HTTP header name. */
+const translate = "Translate";
+/** Gets the `traceparent` HTTP header name. */
+const traceParent = "traceparent";
+/** Gets the `tracestate` HTTP header name. */
+const traceState = "tracestate";
+/** Gets the `Upgrade` HTTP header name. */
+const upgrade = "Upgrade";
+/** Gets the `Upgrade-Insecure-Requests` HTTP header name. */
+const upgradeInsecureRequests = "Upgrade-Insecure-Requests";
+/** Gets the `User-Agent` HTTP header name. */
+const userAgent = "User-Agent";
+/** Gets the `Vary` HTTP header name. */
+const vary = "Vary";
+/** Gets the `Via` HTTP header name. */
+const via = "Via";
+/** Gets the `Warning` HTTP header name. */
+const warning = "Warning";
+/** Gets the `Sec-WebSocket-Protocol` HTTP header name. */
+const webSocketSubProtocols = "Sec-WebSocket-Protocol";
+/** Gets the `WWW-Authenticate` HTTP header name. */
+const wWWAuthenticate = "WWW-Authenticate";
+/** Gets the `X-Content-Type-Options` HTTP header name. */
+const xContentTypeOptions = "X-Content-Type-Options";
+/** Gets the `X-Frame-Options` HTTP header name. */
+const xFrameOptions = "X-Frame-Options";
+/** Gets the `X-Powered-By` HTTP header name. */
+const xPoweredBy = "X-Powered-By";
+/** Gets the `X-Requested-With` HTTP header name. */
+const xRequestedWith = "X-Requested-With";
+/** Gets the `X-UA-Compatible` HTTP header name. */
+const xUACompatible = "X-UA-Compatible";
+/** Gets the `X-XSS-Protection` HTTP header name. */
+const xXSSProtection = "X-XSS-Protection";
+
+var headerNames = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    accept: accept,
+    acceptCharset: acceptCharset,
+    acceptEncoding: acceptEncoding,
+    acceptLanguage: acceptLanguage,
+    acceptRanges: acceptRanges,
+    accessControlAllowCredentials: accessControlAllowCredentials,
+    accessControlAllowHeaders: accessControlAllowHeaders,
+    accessControlAllowMethods: accessControlAllowMethods,
+    accessControlAllowOrigin: accessControlAllowOrigin,
+    accessControlExposeHeaders: accessControlExposeHeaders,
+    accessControlMaxAge: accessControlMaxAge,
+    accessControlRequestHeaders: accessControlRequestHeaders,
+    accessControlRequestMethod: accessControlRequestMethod,
+    age: age,
+    allow: allow,
+    altSvc: altSvc,
+    authorization: authorization,
+    baggage: baggage,
+    cacheControl: cacheControl,
+    connection: connection,
+    contentDisposition: contentDisposition,
+    contentEncoding: contentEncoding,
+    contentLanguage: contentLanguage,
+    contentLength: contentLength,
+    contentLocation: contentLocation,
+    contentMD5: contentMD5,
+    contentRange: contentRange,
+    contentSecurityPolicy: contentSecurityPolicy,
+    contentSecurityPolicyReportOnly: contentSecurityPolicyReportOnly,
+    contentType: contentType,
+    cookie: cookie,
+    correlationContext: correlationContext,
+    date: date,
+    dnt: dnt,
+    eTag: eTag,
+    expect: expect,
+    expires: expires,
+    from: from,
+    grpcAcceptEncoding: grpcAcceptEncoding,
+    grpcEncoding: grpcEncoding,
+    grpcMessage: grpcMessage,
+    grpcStatus: grpcStatus,
+    grpcTimeout: grpcTimeout,
+    host: host,
+    ifMatch: ifMatch,
+    ifModifiedSince: ifModifiedSince,
+    ifNoneMatch: ifNoneMatch,
+    ifRange: ifRange,
+    ifUnmodifiedSince: ifUnmodifiedSince,
+    keepAlive: keepAlive,
+    lastModified: lastModified,
+    link: link,
+    location: location,
+    maxForwards: maxForwards,
+    origin: origin,
+    pragma: pragma,
+    proxyAuthenticate: proxyAuthenticate,
+    proxyAuthorization: proxyAuthorization,
+    proxyConnection: proxyConnection,
+    range: range,
+    referer: referer,
+    requestId: requestId,
+    retryAfter: retryAfter,
+    secWebSocketAccept: secWebSocketAccept,
+    secWebSocketExtensions: secWebSocketExtensions,
+    secWebSocketKey: secWebSocketKey,
+    secWebSocketProtocol: secWebSocketProtocol,
+    secWebSocketVersion: secWebSocketVersion,
+    server: server,
+    setCookie: setCookie,
+    strictTransportSecurity: strictTransportSecurity,
+    te: te,
+    traceParent: traceParent,
+    traceState: traceState,
+    trailer: trailer,
+    transferEncoding: transferEncoding,
+    translate: translate,
+    upgrade: upgrade,
+    upgradeInsecureRequests: upgradeInsecureRequests,
+    userAgent: userAgent,
+    vary: vary,
+    via: via,
+    wWWAuthenticate: wWWAuthenticate,
+    warning: warning,
+    webSocketSubProtocols: webSocketSubProtocols,
+    xContentTypeOptions: xContentTypeOptions,
+    xFrameOptions: xFrameOptions,
+    xPoweredBy: xPoweredBy,
+    xRequestedWith: xRequestedWith,
+    xUACompatible: xUACompatible,
+    xXSSProtection: xXSSProtection
 });
 
+const status100Continue = 100;
+const status101SwitchingProtocols = 101;
+const status102Processing = 102;
+const status200OK = 200;
+const status201Created = 201;
+const status202Accepted = 202;
+const status203NonAuthoritative = 203;
+const status204NoContent = 204;
+const status205ResetContent = 205;
+const status206PartialContent = 206;
+const status207MultiStatus = 207;
+const status208AlreadyReported = 208;
+const status226IMUsed = 226;
+const status300MultipleChoices = 300;
+const status301MovedPermanently = 301;
+const status302Found = 302;
+const status303SeeOther = 303;
+const status304NotModified = 304;
+const status305UseProxy = 305;
+const status306SwitchProxy = 306;
+const status307TemporaryRedirect = 307;
+const status308PermanentRedirect = 308;
+const status400BadRequest = 400;
+const status401Unauthorized = 401;
+const status402PaymentRequired = 402;
+const status403Forbidden = 403;
+const status404NotFound = 404;
+const status405MethodNotAllowed = 405;
+const status406NotAcceptable = 406;
+const status407ProxyAuthenticationRequired = 407;
+const status408RequestTimeout = 408;
+const status409Conflict = 409;
+const status410Gone = 410;
+const status411LengthRequired = 411;
+const status412PreconditionFailed = 412;
+const status413RequestEntityTooLarge = 413;
+const status413PayloadTooLarge = 413;
+const status414RequestUriTooLong = 414;
+const status414UriTooLong = 414;
+const status415UnsupportedMediaType = 415;
+const status416RequestedRangeNotSatisfiable = 416;
+const status416RangeNotSatisfiable = 416;
+const status417ExpectationFailed = 417;
+const status418ImATeapot = 418;
+const status419AuthenticationTimeout = 419;
+const status421MisdirectedRequest = 421;
+const status422UnprocessableEntity = 422;
+const status423Locked = 423;
+const status424FailedDependency = 424;
+const status426UpgradeRequired = 426;
+const status428PreconditionRequired = 428;
+const status429TooManyRequests = 429;
+const status431RequestHeaderFieldsTooLarge = 431;
+const status451UnavailableForLegalReasons = 451;
+const status500InternalServerError = 500;
+const status501NotImplemented = 501;
+const status502BadGateway = 502;
+const status503ServiceUnavailable = 503;
+const status504GatewayTimeout = 504;
+const status505HttpVersionNotsupported = 505;
+const status506VariantAlsoNegotiates = 506;
+const status507InsufficientStorage = 507;
+const status508LoopDetected = 508;
+const status510NotExtended = 510;
+const status511NetworkAuthenticationRequired = 511;
+
+var statusCodes = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    status100Continue: status100Continue,
+    status101SwitchingProtocols: status101SwitchingProtocols,
+    status102Processing: status102Processing,
+    status200OK: status200OK,
+    status201Created: status201Created,
+    status202Accepted: status202Accepted,
+    status203NonAuthoritative: status203NonAuthoritative,
+    status204NoContent: status204NoContent,
+    status205ResetContent: status205ResetContent,
+    status206PartialContent: status206PartialContent,
+    status207MultiStatus: status207MultiStatus,
+    status208AlreadyReported: status208AlreadyReported,
+    status226IMUsed: status226IMUsed,
+    status300MultipleChoices: status300MultipleChoices,
+    status301MovedPermanently: status301MovedPermanently,
+    status302Found: status302Found,
+    status303SeeOther: status303SeeOther,
+    status304NotModified: status304NotModified,
+    status305UseProxy: status305UseProxy,
+    status306SwitchProxy: status306SwitchProxy,
+    status307TemporaryRedirect: status307TemporaryRedirect,
+    status308PermanentRedirect: status308PermanentRedirect,
+    status400BadRequest: status400BadRequest,
+    status401Unauthorized: status401Unauthorized,
+    status402PaymentRequired: status402PaymentRequired,
+    status403Forbidden: status403Forbidden,
+    status404NotFound: status404NotFound,
+    status405MethodNotAllowed: status405MethodNotAllowed,
+    status406NotAcceptable: status406NotAcceptable,
+    status407ProxyAuthenticationRequired: status407ProxyAuthenticationRequired,
+    status408RequestTimeout: status408RequestTimeout,
+    status409Conflict: status409Conflict,
+    status410Gone: status410Gone,
+    status411LengthRequired: status411LengthRequired,
+    status412PreconditionFailed: status412PreconditionFailed,
+    status413PayloadTooLarge: status413PayloadTooLarge,
+    status413RequestEntityTooLarge: status413RequestEntityTooLarge,
+    status414RequestUriTooLong: status414RequestUriTooLong,
+    status414UriTooLong: status414UriTooLong,
+    status415UnsupportedMediaType: status415UnsupportedMediaType,
+    status416RangeNotSatisfiable: status416RangeNotSatisfiable,
+    status416RequestedRangeNotSatisfiable: status416RequestedRangeNotSatisfiable,
+    status417ExpectationFailed: status417ExpectationFailed,
+    status418ImATeapot: status418ImATeapot,
+    status419AuthenticationTimeout: status419AuthenticationTimeout,
+    status421MisdirectedRequest: status421MisdirectedRequest,
+    status422UnprocessableEntity: status422UnprocessableEntity,
+    status423Locked: status423Locked,
+    status424FailedDependency: status424FailedDependency,
+    status426UpgradeRequired: status426UpgradeRequired,
+    status428PreconditionRequired: status428PreconditionRequired,
+    status429TooManyRequests: status429TooManyRequests,
+    status431RequestHeaderFieldsTooLarge: status431RequestHeaderFieldsTooLarge,
+    status451UnavailableForLegalReasons: status451UnavailableForLegalReasons,
+    status500InternalServerError: status500InternalServerError,
+    status501NotImplemented: status501NotImplemented,
+    status502BadGateway: status502BadGateway,
+    status503ServiceUnavailable: status503ServiceUnavailable,
+    status504GatewayTimeout: status504GatewayTimeout,
+    status505HttpVersionNotsupported: status505HttpVersionNotsupported,
+    status506VariantAlsoNegotiates: status506VariantAlsoNegotiates,
+    status507InsufficientStorage: status507InsufficientStorage,
+    status508LoopDetected: status508LoopDetected,
+    status510NotExtended: status510NotExtended,
+    status511NetworkAuthenticationRequired: status511NetworkAuthenticationRequired
+});
 
-var $219bed0dc5a2c88f$exports = {};
-
-$parcel$export($219bed0dc5a2c88f$exports, "getNullableMapper", () => $219bed0dc5a2c88f$export$27b49540aaa79f4f);
-$parcel$export($219bed0dc5a2c88f$exports, "getMapper", () => $219bed0dc5a2c88f$export$bf53df0dfe06e237);
-function $219bed0dc5a2c88f$export$27b49540aaa79f4f(deserialize, typeOrMap) {
-    if (!typeOrMap) return (x)=>x;
-    if ($219bed0dc5a2c88f$var$isZeroArgumentFunction(typeOrMap)) // It cannot be a factory function if it takes no arguments,
-    // so it must be a (zero argument) type (constructor)
-    return (x)=>{
-        const bound = deserialize(x, typeOrMap);
-        // The server cannot produce the undefined result
-        if (bound === undefined) throw Error("The model factory created a undefined result");
-        return bound;
-    };
+function getNullableMapper(deserialize, typeOrMap) {
+    if (!typeOrMap) {
+        return (x) => x;
+    }
+    if (isZeroArgumentFunction(typeOrMap)) {
+        // It cannot be a factory function if it takes no arguments,
+        // so it must be a (zero argument) type (constructor)
+        return (x) => {
+            const bound = deserialize(x, typeOrMap);
+            // The server cannot produce the undefined result
+            if (bound === undefined) {
+                throw Error("The model factory created a undefined result");
+            }
+            return bound;
+        };
+    }
     return typeOrMap;
 }
-function $219bed0dc5a2c88f$export$bf53df0dfe06e237(deserialize, typeOrMap) {
-    const nullableFactory = $219bed0dc5a2c88f$export$27b49540aaa79f4f(deserialize, typeOrMap);
-    return (x)=>{
+function getMapper(deserialize, typeOrMap) {
+    const nullableFactory = getNullableMapper(deserialize, typeOrMap);
+    return (x) => {
         const result = nullableFactory(x);
-        if (result === null) throw Error("The model factory created a null result");
+        if (result === null) {
+            throw Error("The model factory created a null result");
+        }
         return result;
     };
 }
-function $219bed0dc5a2c88f$var$isZeroArgumentFunction(typeCtor) {
+function isZeroArgumentFunction(typeCtor) {
     return typeCtor.length === 0;
 }
 
-
-$parcel$exportWildcard(module.exports, $dfecd32049fa58e9$exports);
-$parcel$exportWildcard(module.exports, $219bed0dc5a2c88f$exports);
-
-
+exports.Http = Http;
+exports.HttpBuilder = HttpBuilder;
+exports.HttpBuilderOfT = HttpBuilderOfT;
+exports.HttpError = HttpError;
+exports.HttpResponse = HttpResponse;
+exports.HttpResponseOfT = HttpResponseOfT;
+exports.QueryString = QueryString;
+exports.TimeoutError = TimeoutError;
+exports.events = events;
+exports.getMapper = getMapper;
+exports.getNullableMapper = getNullableMapper;
+exports.headerNames = headerNames;
+exports.isAbortError = isAbortError;
+exports.isHttpError = isHttpError;
+exports.isTimeoutError = isTimeoutError;
+exports.statusCodes = statusCodes;
 //# sourceMappingURL=index.js.map