@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/cjs/ts/fable_modules/Fable.Promise.3.2.0/Promise.fs.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseBuilder = void 0;
+exports.tap = tap;
+exports.result = result;
+exports.mapResult = mapResult;
+exports.bindResult = bindResult;
+exports.mapResultError = mapResultError;
+exports.PromiseBuilder_$reflection = PromiseBuilder_$reflection;
+exports.PromiseBuilder_$ctor = PromiseBuilder_$ctor;
+exports.PromiseBuilder__For_1565554B = PromiseBuilder__For_1565554B;
+exports.PromiseBuilder__While_2044D34 = PromiseBuilder__While_2044D34;
+exports.PromiseBuilder__TryFinally_7D49A2FD = PromiseBuilder__TryFinally_7D49A2FD;
+exports.PromiseBuilder__Delay_62FBFDE1 = PromiseBuilder__Delay_62FBFDE1;
+exports.PromiseBuilder__Run_212F1D4B = PromiseBuilder__Run_212F1D4B;
+exports.PromiseBuilder__Using_74F7E79D = PromiseBuilder__Using_74F7E79D;
+const Result_js_1 = require("@fable-org/fable-library-js/Result.js");
+const Reflection_js_1 = require("@fable-org/fable-library-js/Reflection.js");
+const Util_js_1 = require("@fable-org/fable-library-js/Util.js");
+/**
+ * This is an identity function, it calls the given function and return the promise value untouched.
+ * <example>
+ * <code lang="fsharp">
+ * fetchUser ()
+ * |> Promise.tap (fun user ->
+ * // Do something
+ * console.log "The user has been received"
+ * )
+ * |> Promise.map (fun user ->
+ * // user value is available here untouched
+ * )
+ * </code>
+ * </example>
+ */
+function tap(fn, a) {
+    return a.then((x) => {
+        fn(x);
+        return x;
+    });
+}
+/**
+ * Map the <c>Promise</c> result into a <c>Result</c> type.
+ * <example>
+ * <code lang="fsharp">
+ * Success example
+ * Promise.lift 42
+ * |> Promise.result
+ * |> Promise.map (fun value ->
+ * // value = Ok 42
+ * )
+ *
+ * // Fail example
+ * Promise.reject "Invalid value"
+ * |> Promise.result
+ * |> Promise.map (fun value ->
+ * // value = Error "Invalid value"
+ * )
+ * </code>
+ * </example>
+ */
+function result(a) {
+    return a.then(Result_js_1.FSharpResult$2_Ok).catch(Result_js_1.FSharpResult$2_Error);
+}
+/**
+ * Evaluates to `myPromise |> Promise.map (Result.map fn)`
+ * <example>
+ * <code lang="fsharp">
+ * Promise.lift 42
+ * |> Promise.result
+ * |> Promise.mapResult (fun value ->
+ * value + 10
+ * )
+ * |> Promise.map (fun value ->
+ * // value = Ok 52
+ * )
+ * </code>
+ * </example>
+ */
+function mapResult(fn, a) {
+    return a.then((result_1) => (0, Result_js_1.Result_Map)(fn, result_1));
+}
+/**
+ * Transform the success part of a result promise into another promise.
+ * <example>
+ * <code lang="fsharp">
+ * let multiplyBy2 (value : int) =
+ * Promise.create (fun resolve reject ->
+ * resolve (value * 2)
+ * )
+ *
+ * Promise.lift 42
+ * |> Promise.result
+ * |> Promise.bindResult (fun value ->
+ * multiplyBy2 value
+ * )
+ * |> Promise.map (fun value ->
+ * // value = Ok 84
+ * )
+ * </code>
+ * </example>
+ */
+function bindResult(fn, a) {
+    return a.then((a_1) => {
+        if (a_1.tag === /* Error */ 1) {
+            const e = a_1.fields[0];
+            return Promise.resolve((0, Result_js_1.FSharpResult$2_Error)(e));
+        }
+        else {
+            const pr = fn(a_1.fields[0]);
+            return pr.then(Result_js_1.FSharpResult$2_Ok);
+        }
+    });
+}
+/**
+ * Evaluates to <c>myPromise |> Promise.map (Result.map fn)</c>
+ * <example>
+ * <code lang="fsharp">
+ * Promise.reject -1
+ * |> Promise.result
+ * |> Promise.mapResultError (fun value ->
+ * $"%s{value} is not a valid value"
+ * )
+ * |> Promise.map (fun value ->
+ * // value = Error "-1 is not a valid value"
+ * )
+ * </code>
+ * </example>
+ */
+function mapResultError(fn, a) {
+    return a.then((result_1) => (0, Result_js_1.Result_MapError)(fn, result_1));
+}
+class PromiseBuilder {
+    constructor() {
+    }
+}
+exports.PromiseBuilder = PromiseBuilder;
+function PromiseBuilder_$reflection() {
+    return (0, Reflection_js_1.class_type)("Promise.PromiseBuilder", undefined, PromiseBuilder);
+}
+function PromiseBuilder_$ctor() {
+    return new PromiseBuilder();
+}
+function PromiseBuilder__For_1565554B(_, seq, body) {
+    let pr;
+    let p = Promise.resolve(undefined);
+    const enumerator = (0, Util_js_1.getEnumerator)(seq);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const a = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            p = ((pr = p, pr.then(() => body(a))));
+        }
+    }
+    finally {
+        (0, Util_js_1.disposeSafe)(enumerator);
+    }
+    return p;
+}
+function PromiseBuilder__While_2044D34(this$, guard, p) {
+    if (guard()) {
+        return p.then(() => PromiseBuilder__While_2044D34(this$, guard, p));
+    }
+    else {
+        return Promise.resolve(undefined);
+    }
+}
+function PromiseBuilder__TryFinally_7D49A2FD(_, p, compensation) {
+    return p.then((x) => {
+        compensation();
+        return x;
+    }).catch((er) => {
+        compensation();
+        throw er;
+    });
+}
+function PromiseBuilder__Delay_62FBFDE1(_, generator) {
+    return {
+        then: (onSuccess, onError) => {
+            try {
+                return generator().then(onSuccess, onError);
+            }
+            catch (er) {
+                if (onError == null) {
+                    return Promise.reject(er);
+                }
+                else {
+                    try {
+                        const a = onError(er);
+                        return Promise.resolve(a);
+                    }
+                    catch (er_1) {
+                        return Promise.reject(er_1);
+                    }
+                }
+            }
+        },
+        catch: (onError_1) => {
+            try {
+                return generator().catch(onError_1);
+            }
+            catch (er_2) {
+                try {
+                    const a_1 = onError_1(er_2);
+                    return Promise.resolve(a_1);
+                }
+                catch (er_3) {
+                    return Promise.reject(er_3);
+                }
+            }
+        },
+    };
+}
+function PromiseBuilder__Run_212F1D4B(_, p) {
+    return p.then((x) => x);
+}
+function PromiseBuilder__Using_74F7E79D(this$, resource, binder) {
+    return PromiseBuilder__TryFinally_7D49A2FD(this$, binder(resource), () => {
+        let copyOfStruct = resource;
+        (0, Util_js_1.disposeSafe)(copyOfStruct);
+    });
+}

package/dist/ts/cjs/ts/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promise = void 0;
+exports.SettledValue_toResult = SettledValue_toResult;
+const Promise_fs_js_1 = require("./Promise.fs.js");
+const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
+const Result_js_1 = require("@fable-org/fable-library-js/Result.js");
+exports.promise = (0, Promise_fs_js_1.PromiseBuilder_$ctor)();
+/**
+ * Helper functionm to convert a settled result into an F# result
+ */
+function SettledValue_toResult(p) {
+    const matchValue = p.status;
+    if (matchValue === "rejected") {
+        return (0, Result_js_1.FSharpResult$2_Error)((0, Option_js_1.value)(p.reason));
+    }
+    else {
+        return (0, Result_js_1.FSharpResult$2_Ok)((0, Option_js_1.value)(p.value));
+    }
+}

package/dist/ts/cjs/ts/fable_modules/Fable.SimpleHttp.3.5.0/Http.fs.js

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blob_download = Blob_download;
+exports.FileReader_readBlobAsText = FileReader_readBlobAsText;
+exports.FileReader_readFileAsText = FileReader_readFileAsText;
+exports.FormData_append = FormData_append;
+exports.FormData_appendFile = FormData_appendFile;
+exports.FormData_appendNamedFile = FormData_appendNamedFile;
+exports.FormData_appendBlob = FormData_appendBlob;
+exports.FormData_appendNamedBlob = FormData_appendNamedBlob;
+exports.Headers_contentType = Headers_contentType;
+exports.Headers_accept = Headers_accept;
+exports.Headers_acceptCharset = Headers_acceptCharset;
+exports.Headers_acceptEncoding = Headers_acceptEncoding;
+exports.Headers_acceptLanguage = Headers_acceptLanguage;
+exports.Headers_acceptDateTime = Headers_acceptDateTime;
+exports.Headers_authorization = Headers_authorization;
+exports.Headers_cacheControl = Headers_cacheControl;
+exports.Headers_connection = Headers_connection;
+exports.Headers_cookie = Headers_cookie;
+exports.Headers_contentMD5 = Headers_contentMD5;
+exports.Headers_date = Headers_date;
+exports.Headers_expect = Headers_expect;
+exports.Headers_ifMatch = Headers_ifMatch;
+exports.Headers_ifModifiedSince = Headers_ifModifiedSince;
+exports.Headers_ifNoneMatch = Headers_ifNoneMatch;
+exports.Headers_ifRange = Headers_ifRange;
+exports.Headers_IfUnmodifiedSince = Headers_IfUnmodifiedSince;
+exports.Headers_maxForwards = Headers_maxForwards;
+exports.Headers_origin = Headers_origin;
+exports.Headers_pragma = Headers_pragma;
+exports.Headers_proxyAuthorization = Headers_proxyAuthorization;
+exports.Headers_range = Headers_range;
+exports.Headers_referer = Headers_referer;
+exports.Headers_userAgent = Headers_userAgent;
+exports.Headers_create = Headers_create;
+exports.Http_request = Http_request;
+exports.Http_method = Http_method;
+exports.Http_header = Http_header;
+exports.Http_headers = Http_headers;
+exports.Http_withCredentials = Http_withCredentials;
+exports.Http_withTimeout = Http_withTimeout;
+exports.Http_overrideMimeType = Http_overrideMimeType;
+exports.Http_overrideResponseType = Http_overrideResponseType;
+exports.Http_content = Http_content;
+exports.Http_send = Http_send;
+exports.Http_get = Http_get;
+exports.Http_put = Http_put;
+exports.Http_delete = Http_delete;
+exports.Http_patch = Http_patch;
+exports.Http_post = Http_post;
+const Async_js_1 = require("@fable-org/fable-library-js/Async.js");
+const AsyncBuilder_js_1 = require("@fable-org/fable-library-js/AsyncBuilder.js");
+const Types_fs_js_1 = require("./Types.fs.js");
+const List_js_1 = require("@fable-org/fable-library-js/List.js");
+const Map_js_1 = require("@fable-org/fable-library-js/Map.js");
+const Util_js_1 = require("@fable-org/fable-library-js/Util.js");
+const String_js_1 = require("@fable-org/fable-library-js/String.js");
+const Array_js_1 = require("@fable-org/fable-library-js/Array.js");
+const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
+/**
+ * Download a Blob
+ */
+function Blob_download(blob, fileName) {
+    const element = document.createElement("a");
+    element.target = "_blank";
+    element.href = (window.URL.createObjectURL(blob));
+    element.setAttribute("download", fileName);
+    document.body.appendChild(element);
+    element.click();
+    document.body.removeChild(element);
+}
+/**
+ * Asynchronously reads the blob data content as string
+ */
+function FileReader_readBlobAsText(blob) {
+    return (0, Async_js_1.fromContinuations)((tupledArg) => {
+        const reader = new FileReader();
+        reader.onload = ((_arg_2) => {
+            if (reader.readyState === 2) {
+                tupledArg[0](reader.result);
+            }
+        });
+        reader.readAsText(blob);
+    });
+}
+/**
+ * Asynchronously reads the blob data content as string
+ */
+function FileReader_readFileAsText(file) {
+    return (0, Async_js_1.fromContinuations)((tupledArg) => {
+        const reader = new FileReader();
+        reader.onload = ((_arg_2) => {
+            if (reader.readyState === 2) {
+                tupledArg[0](reader.result);
+            }
+        });
+        reader.readAsText(file);
+    });
+}
+/**
+ * Appends a key-value pair to the form data
+ */
+function FormData_append(key, value, form) {
+    form.append(key, value);
+    return form;
+}
+/**
+ * Appends a file to the form data
+ */
+function FormData_appendFile(key, file, form) {
+    form.append(key, file);
+    return form;
+}
+/**
+ * Appends a named file to the form data
+ */
+function FormData_appendNamedFile(key, fileName, file, form) {
+    form.append(key, file, fileName);
+    return form;
+}
+/**
+ * Appends a blog to the form data
+ */
+function FormData_appendBlob(key, blob, form) {
+    form.append(key, blob);
+    return form;
+}
+/**
+ * Appends a blog to the form data
+ */
+function FormData_appendNamedBlob(key, fileName, blob, form) {
+    form.append(key, blob, fileName);
+    return form;
+}
+function Headers_contentType(value) {
+    return new Types_fs_js_1.Header("Content-Type", value);
+}
+function Headers_accept(value) {
+    return new Types_fs_js_1.Header("Accept", value);
+}
+function Headers_acceptCharset(value) {
+    return new Types_fs_js_1.Header("Accept-Charset", value);
+}
+function Headers_acceptEncoding(value) {
+    return new Types_fs_js_1.Header("Accept-Encoding", value);
+}
+function Headers_acceptLanguage(value) {
+    return new Types_fs_js_1.Header("Accept-Language", value);
+}
+function Headers_acceptDateTime(value) {
+    return new Types_fs_js_1.Header("Accept-Datetime", value);
+}
+function Headers_authorization(value) {
+    return new Types_fs_js_1.Header("Authorization", value);
+}
+function Headers_cacheControl(value) {
+    return new Types_fs_js_1.Header("Cache-Control", value);
+}
+function Headers_connection(value) {
+    return new Types_fs_js_1.Header("Connection", value);
+}
+function Headers_cookie(value) {
+    return new Types_fs_js_1.Header("Cookie", value);
+}
+function Headers_contentMD5(value) {
+    return new Types_fs_js_1.Header("Content-MD5", value);
+}
+function Headers_date(value) {
+    return new Types_fs_js_1.Header("Date", value);
+}
+function Headers_expect(value) {
+    return new Types_fs_js_1.Header("Expect", value);
+}
+function Headers_ifMatch(value) {
+    return new Types_fs_js_1.Header("If-Match", value);
+}
+function Headers_ifModifiedSince(value) {
+    return new Types_fs_js_1.Header("If-Modified-Since", value);
+}
+function Headers_ifNoneMatch(value) {
+    return new Types_fs_js_1.Header("If-None-Match", value);
+}
+function Headers_ifRange(value) {
+    return new Types_fs_js_1.Header("If-Range", value);
+}
+function Headers_IfUnmodifiedSince(value) {
+    return new Types_fs_js_1.Header("If-Unmodified-Since", value);
+}
+function Headers_maxForwards(value) {
+    return new Types_fs_js_1.Header("Max-Forwards", value);
+}
+function Headers_origin(value) {
+    return new Types_fs_js_1.Header("Origin", value);
+}
+function Headers_pragma(value) {
+    return new Types_fs_js_1.Header("Pragma", value);
+}
+function Headers_proxyAuthorization(value) {
+    return new Types_fs_js_1.Header("Proxy-Authorization", value);
+}
+function Headers_range(value) {
+    return new Types_fs_js_1.Header("Range", value);
+}
+function Headers_referer(value) {
+    return new Types_fs_js_1.Header("Referer", value);
+}
+function Headers_userAgent(value) {
+    return new Types_fs_js_1.Header("User-Agent", value);
+}
+function Headers_create(key, value) {
+    return new Types_fs_js_1.Header(key, value);
+}
+const Http_defaultRequest = new Types_fs_js_1.HttpRequest("", (0, Types_fs_js_1.HttpMethod_GET)(), (0, List_js_1.empty)(), false, undefined, undefined, undefined, (0, Types_fs_js_1.BodyContent_Empty)());
+const Http_emptyResponse = new Types_fs_js_1.HttpResponse(0, "", "", "", (0, Map_js_1.empty)({
+    Compare: Util_js_1.comparePrimitives,
+}), (0, Types_fs_js_1.ResponseContent_Text)(""));
+function Http_splitAt(delimiter, input) {
+    if ((0, String_js_1.isNullOrEmpty)(input)) {
+        return [input];
+    }
+    else {
+        return (0, String_js_1.split)(input, [delimiter], undefined, 0);
+    }
+}
+function Http_serializeMethod(_arg) {
+    switch (_arg.tag) {
+        case /* POST */ 1:
+            return "POST";
+        case /* PATCH */ 3:
+            return "PATCH";
+        case /* PUT */ 2:
+            return "PUT";
+        case /* DELETE */ 4:
+            return "DELETE";
+        case /* OPTIONS */ 6:
+            return "OPTIONS";
+        case /* HEAD */ 5:
+            return "HEAD";
+        default:
+            return "GET";
+    }
+}
+/**
+ * Starts the configuration of the request with the specified url
+ */
+function Http_request(url) {
+    return new Types_fs_js_1.HttpRequest(url, Http_defaultRequest.method, Http_defaultRequest.headers, Http_defaultRequest.withCredentials, Http_defaultRequest.overridenMimeType, Http_defaultRequest.overridenResponseType, Http_defaultRequest.timeout, Http_defaultRequest.content);
+}
+/**
+ * Sets the Http method of the request
+ */
+function Http_method(httpVerb, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, httpVerb, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Appends a header to the request configuration
+ */
+function Http_header(singleHeader, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, (0, List_js_1.append)(req.headers, (0, List_js_1.singleton)(singleHeader)), req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Appends a list of headers to the request configuration
+ */
+function Http_headers(values, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, (0, List_js_1.append)(req.headers, values), req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Enables cross-site credentials such as cookies
+ */
+function Http_withCredentials(enabled, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, req.headers, enabled, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Enables Http request timeout
+ */
+function Http_withTimeout(timeoutInMilliseconds, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, timeoutInMilliseconds, req.content);
+}
+/**
+ * Specifies a MIME type other than the one provided by the server to be used instead when interpreting the data being transferred in a request. This may be used, for example, to force a stream to be treated and parsed as "text/xml", even if the server does not report it as such.
+ */
+function Http_overrideMimeType(value, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, req.headers, req.withCredentials, value, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Change the expected response type from the server
+ */
+function Http_overrideResponseType(value, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, req.headers, req.withCredentials, req.overridenMimeType, value, req.timeout, req.content);
+}
+/**
+ * Sets the body content of the request
+ */
+function Http_content(bodyContent, req) {
+    return new Types_fs_js_1.HttpRequest(req.url, req.method, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, bodyContent);
+}
+/**
+ * Sends the request to the server, this function does not throw
+ */
+function Http_send(req) {
+    return (0, Async_js_1.fromContinuations)((tupledArg) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open(Http_serializeMethod(req.method), req.url);
+        xhr.onreadystatechange = (() => {
+            let responseText, matchValue, statusCode, responseType, content, matchValue_1, responseHeaders;
+            if (xhr.readyState === 4) {
+                tupledArg[0]((responseText = ((matchValue = xhr.responseType, (matchValue === "") ? xhr.responseText : ((matchValue === "text") ? xhr.responseText : ""))), (statusCode = (xhr.status | 0), (responseType = xhr.responseType, (content = ((matchValue_1 = xhr.responseType, (matchValue_1 === "") ? (0, Types_fs_js_1.ResponseContent_Text)(xhr.responseText) : ((matchValue_1 === "text") ? (0, Types_fs_js_1.ResponseContent_Text)(xhr.responseText) : ((matchValue_1 === "arraybuffer") ? (0, Types_fs_js_1.ResponseContent_ArrayBuffer)(xhr.response) : ((matchValue_1 === "blob") ? (0, Types_fs_js_1.ResponseContent_Blob)(xhr.response) : (0, Types_fs_js_1.ResponseContent_Unknown)(xhr.response)))))), (responseHeaders = (0, Map_js_1.ofArray)((0, Array_js_1.choose)((headerLine) => {
+                    const matchValue_2 = (0, List_js_1.ofArray)(Http_splitAt(":", headerLine));
+                    if (!(0, List_js_1.isEmpty)(matchValue_2)) {
+                        return [(0, List_js_1.head)(matchValue_2).toLocaleLowerCase(), (0, String_js_1.join)(":", (0, List_js_1.tail)(matchValue_2)).trim()];
+                    }
+                    else {
+                        return undefined;
+                    }
+                }, Http_splitAt("\r\n", xhr.getAllResponseHeaders())), {
+                    Compare: Util_js_1.comparePrimitives,
+                }), new Types_fs_js_1.HttpResponse(statusCode, responseText, responseType, xhr.responseURL, responseHeaders, content)))))));
+            }
+        });
+        const enumerator = (0, Util_js_1.getEnumerator)(req.headers);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                const value = forLoopVar.fields[1];
+                const key_1 = forLoopVar.fields[0];
+                xhr.setRequestHeader(key_1, value);
+            }
+        }
+        finally {
+            (0, Util_js_1.disposeSafe)(enumerator);
+        }
+        xhr.withCredentials = req.withCredentials;
+        const matchValue_3 = req.overridenMimeType;
+        if (matchValue_3 == null) {
+        }
+        else {
+            const mimeType = (0, Option_js_1.value)(matchValue_3);
+            xhr.overrideMimeType(mimeType);
+        }
+        const matchValue_4 = req.overridenResponseType;
+        if (matchValue_4 == null) {
+        }
+        else {
+            switch ((0, Option_js_1.value)(matchValue_4).tag) {
+                case /* Blob */ 1: {
+                    xhr.responseType = "blob";
+                    break;
+                }
+                case /* ArrayBuffer */ 2: {
+                    xhr.responseType = "arraybuffer";
+                    break;
+                }
+                default:
+                    xhr.responseType = "text";
+            }
+        }
+        const matchValue_5 = req.timeout;
+        if (matchValue_5 == null) {
+        }
+        else {
+            const timeout = (0, Option_js_1.value)(matchValue_5) | 0;
+            xhr.timeout = (timeout | 0);
+        }
+        const matchValue_6 = req.content;
+        switch (matchValue_6.tag) {
+            case /* Text */ 1: {
+                const value_1 = matchValue_6.fields[0];
+                xhr.send((0, Option_js_1.some)(value_1));
+                break;
+            }
+            case /* Form */ 3: {
+                const formData = matchValue_6.fields[0];
+                xhr.send((0, Option_js_1.some)(formData));
+                break;
+            }
+            case /* Binary */ 2: {
+                const blob = matchValue_6.fields[0];
+                xhr.send((0, Option_js_1.some)(blob));
+                break;
+            }
+            default:
+                xhr.send();
+        }
+    });
+}
+/**
+ * Safely sends a GET request and returns a tuple(status code * response text). This function does not throw.
+ */
+function Http_get(url) {
+    return AsyncBuilder_js_1.singleton.Delay(() => AsyncBuilder_js_1.singleton.Bind(Http_send(Http_method((0, Types_fs_js_1.HttpMethod_GET)(), Http_request(url))), (_arg) => {
+        const response = _arg;
+        return AsyncBuilder_js_1.singleton.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a PUT request and returns a tuple(status code * response text). This function does not throw.
+ */
+function Http_put(url, data) {
+    return AsyncBuilder_js_1.singleton.Delay(() => AsyncBuilder_js_1.singleton.Bind(Http_send(Http_content((0, Types_fs_js_1.BodyContent_Text)(data), Http_method((0, Types_fs_js_1.HttpMethod_PUT)(), Http_request(url)))), (_arg) => {
+        const response = _arg;
+        return AsyncBuilder_js_1.singleton.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a DELETE request and returns a tuple(status code * response text). This function does not throw.
+ */
+function Http_delete(url) {
+    return AsyncBuilder_js_1.singleton.Delay(() => AsyncBuilder_js_1.singleton.Bind(Http_send(Http_method((0, Types_fs_js_1.HttpMethod_DELETE)(), Http_request(url))), (_arg) => {
+        const response = _arg;
+        return AsyncBuilder_js_1.singleton.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a PATCH request and returns a tuple(status code * response text). This function does not throw.
+ */
+function Http_patch(url, data) {
+    return AsyncBuilder_js_1.singleton.Delay(() => AsyncBuilder_js_1.singleton.Bind(Http_send(Http_content((0, Types_fs_js_1.BodyContent_Text)(data), Http_method((0, Types_fs_js_1.HttpMethod_PATCH)(), Http_request(url)))), (_arg) => {
+        const response = _arg;
+        return AsyncBuilder_js_1.singleton.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a POST request and returns a tuple(status code * response text). This function does not throw.
+ */
+function Http_post(url, data) {
+    return AsyncBuilder_js_1.singleton.Delay(() => AsyncBuilder_js_1.singleton.Bind(Http_send(Http_content((0, Types_fs_js_1.BodyContent_Text)(data), Http_method((0, Types_fs_js_1.HttpMethod_POST)(), Http_request(url)))), (_arg) => {
+        const response = _arg;
+        return AsyncBuilder_js_1.singleton.Return([response.statusCode, response.responseText]);
+    }));
+}