@nfdi4plants/arctrl 3.0.0-alpha.4 → 3.0.0-beta.10

package/dist/ts/node_modules/@fable-org/fable-library-js/Async.js

@@ -0,0 +1,146 @@
+import { protectedCont, protectedBind, CancellationToken, OperationCanceledError, protectedReturn, Trampoline } from './AsyncBuilder.js';
+import { Choice_makeChoice2Of2, Choice_makeChoice1Of2 } from './Choice.js';
+import { TimeoutException } from './SystemException.js';
+
+function emptyContinuation(_x) {
+    // NOP
+}
+// see AsyncBuilder.Delay
+function delay(generator) {
+    return protectedCont((ctx) => generator()(ctx));
+}
+// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
+function makeAsync(body) {
+    return body;
+}
+// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
+function invoke(computation, ctx) {
+    return computation(ctx);
+}
+// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
+function callThenInvoke(ctx, result1, part2) {
+    return part2(result1)(ctx);
+}
+// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
+function bind(ctx, part1, part2) {
+    return protectedBind(part1, part2)(ctx);
+}
+function createCancellationToken(arg) {
+    const token = new CancellationToken(typeof arg === "boolean" ? arg : false);
+    if (typeof arg === "number") {
+        setTimeout(() => { token.cancel(); }, arg);
+    }
+    return token;
+}
+function cancel(token) {
+    token.cancel();
+}
+function cancelAfter(token, ms) {
+    setTimeout(() => { token.cancel(); }, ms);
+}
+function isCancellationRequested(token) {
+    return token != null && token.isCancelled;
+}
+function throwIfCancellationRequested(token) {
+    if (token != null && token.isCancelled) {
+        throw new Error("Operation is cancelled");
+    }
+}
+function throwAfter(millisecondsDueTime) {
+    return protectedCont((ctx) => {
+        let tokenId;
+        const timeoutId = setTimeout(() => {
+            ctx.cancelToken.removeListener(tokenId);
+            ctx.onError(new TimeoutException());
+        }, millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => {
+            clearTimeout(timeoutId);
+            ctx.onCancel(new OperationCanceledError());
+        });
+    });
+}
+function startChild(computation, ms) {
+    if (ms) {
+        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));
+        return startChild(computationWithTimeout);
+    }
+    const promise = startAsPromise(computation);
+    // JS Promises are hot, computation has already started
+    // but we delay returning the result
+    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));
+}
+function awaitPromise(p) {
+    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError
+        ? conts[2] : conts[1])(err)));
+}
+function cancellationToken() {
+    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));
+}
+const defaultCancellationToken = new CancellationToken();
+function catchAsync(work) {
+    return protectedCont((ctx) => {
+        work({
+            onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),
+            onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),
+            onCancel: ctx.onCancel,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    });
+}
+function fromContinuations(f) {
+    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+}
+function ignore(computation) {
+    return protectedBind(computation, (_x) => protectedReturn(void 0));
+}
+function parallel(computations) {
+    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
+}
+function parallel2(a, b) {
+    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
+}
+function sequential(computations) {
+    function _sequential(computations) {
+        let pr = Promise.resolve([]);
+        for (const c of computations) {
+            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));
+        }
+        return pr;
+    }
+    return delay(() => awaitPromise(_sequential(computations)));
+}
+function sleep(millisecondsDueTime) {
+    return protectedCont((ctx) => {
+        let tokenId;
+        const timeoutId = setTimeout(() => {
+            ctx.cancelToken.removeListener(tokenId);
+            ctx.onSuccess(void 0);
+        }, millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => {
+            clearTimeout(timeoutId);
+            ctx.onCancel(new OperationCanceledError());
+        });
+    });
+}
+function start(computation, cancellationToken) {
+    return startWithContinuations(computation, emptyContinuation, function (err) { throw err; }, emptyContinuation, cancellationToken);
+}
+function startImmediate(computation, cancellationToken) {
+    return start(computation, cancellationToken);
+}
+function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
+    const trampoline = new Trampoline();
+    computation({
+        onSuccess: continuation ? continuation : emptyContinuation,
+        onError: exceptionContinuation,
+        onCancel: cancellationContinuation,
+        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
+        trampoline,
+    });
+}
+function startAsPromise(computation, cancellationToken) {
+    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
+}
+
+export { awaitPromise, bind, callThenInvoke, cancel, cancelAfter, cancellationToken, catchAsync, createCancellationToken, defaultCancellationToken, fromContinuations, ignore, invoke, isCancellationRequested, makeAsync, parallel, sequential, sleep, start, startAsPromise, startChild, startImmediate, startWithContinuations, throwIfCancellationRequested };

package/dist/ts/node_modules/@fable-org/fable-library-js/AsyncBuilder.js

@@ -0,0 +1,186 @@
+import { ensureErrorOrException } from './Types.js';
+
+class CancellationToken {
+    constructor(cancelled = false) {
+        this._id = 0;
+        this._cancelled = cancelled;
+        this._listeners = new Map();
+    }
+    get isCancelled() {
+        return this._cancelled;
+    }
+    cancel() {
+        if (!this._cancelled) {
+            this._cancelled = true;
+            for (const [, listener] of this._listeners) {
+                listener();
+            }
+        }
+    }
+    addListener(f) {
+        const id = this._id;
+        this._listeners.set(this._id++, f);
+        return id;
+    }
+    removeListener(id) {
+        return this._listeners.delete(id);
+    }
+    register(f, state) {
+        const $ = this;
+        const id = this.addListener(state == null ? f : () => f(state));
+        return { Dispose() { $.removeListener(id); } };
+    }
+    Dispose() {
+        // Implement IDisposable for compatibility but do nothing
+        // According to docs, calling Dispose does not trigger cancellation
+        // https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource.dispose?view=net-6.0
+    }
+}
+class OperationCanceledError extends Error {
+    constructor() {
+        super("The operation was canceled");
+        Object.setPrototypeOf(this, OperationCanceledError.prototype);
+    }
+}
+class Trampoline {
+    static get maxTrampolineCallCount() {
+        return 2000;
+    }
+    constructor() {
+        this.callCount = 0;
+    }
+    incrementAndCheck() {
+        return this.callCount++ > Trampoline.maxTrampolineCallCount;
+    }
+    hijack(f) {
+        this.callCount = 0;
+        setTimeout(f, 0);
+    }
+}
+function protectedCont(f) {
+    return (ctx) => {
+        if (ctx.cancelToken.isCancelled) {
+            ctx.onCancel(new OperationCanceledError());
+        }
+        else if (ctx.trampoline.incrementAndCheck()) {
+            ctx.trampoline.hijack(() => {
+                try {
+                    f(ctx);
+                }
+                catch (err) {
+                    ctx.onError(ensureErrorOrException(err));
+                }
+            });
+        }
+        else {
+            try {
+                f(ctx);
+            }
+            catch (err) {
+                ctx.onError(ensureErrorOrException(err));
+            }
+        }
+    };
+}
+function protectedBind(computation, binder) {
+    return protectedCont((ctx) => {
+        computation({
+            onSuccess: (x) => {
+                try {
+                    binder(x)(ctx);
+                }
+                catch (err) {
+                    ctx.onError(ensureErrorOrException(err));
+                }
+            },
+            onError: ctx.onError,
+            onCancel: ctx.onCancel,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    });
+}
+function protectedReturn(value) {
+    return protectedCont((ctx) => ctx.onSuccess(value));
+}
+class AsyncBuilder {
+    Bind(computation, binder) {
+        return protectedBind(computation, binder);
+    }
+    Combine(computation1, computation2) {
+        return this.Bind(computation1, () => computation2);
+    }
+    Delay(generator) {
+        return protectedCont((ctx) => generator()(ctx));
+    }
+    For(sequence, body) {
+        const iter = sequence[Symbol.iterator]();
+        let cur = iter.next();
+        return this.While(() => !cur.done, this.Delay(() => {
+            const res = body(cur.value);
+            cur = iter.next();
+            return res;
+        }));
+    }
+    Return(value) {
+        return protectedReturn(value);
+    }
+    ReturnFrom(computation) {
+        return computation;
+    }
+    TryFinally(computation, compensation) {
+        return protectedCont((ctx) => {
+            computation({
+                onSuccess: (x) => {
+                    compensation();
+                    ctx.onSuccess(x);
+                },
+                onError: (x) => {
+                    compensation();
+                    ctx.onError(x);
+                },
+                onCancel: (x) => {
+                    compensation();
+                    ctx.onCancel(x);
+                },
+                cancelToken: ctx.cancelToken,
+                trampoline: ctx.trampoline,
+            });
+        });
+    }
+    TryWith(computation, catchHandler) {
+        return protectedCont((ctx) => {
+            computation({
+                onSuccess: ctx.onSuccess,
+                onCancel: ctx.onCancel,
+                cancelToken: ctx.cancelToken,
+                trampoline: ctx.trampoline,
+                onError: (ex) => {
+                    try {
+                        catchHandler(ex)(ctx);
+                    }
+                    catch (err) {
+                        ctx.onError(ensureErrorOrException(err));
+                    }
+                },
+            });
+        });
+    }
+    Using(resource, binder) {
+        return this.TryFinally(binder(resource), () => resource.Dispose());
+    }
+    While(guard, computation) {
+        if (guard()) {
+            return this.Bind(computation, () => this.While(guard, computation));
+        }
+        else {
+            return this.Return(void 0);
+        }
+    }
+    Zero() {
+        return protectedCont((ctx) => ctx.onSuccess(void 0));
+    }
+}
+const singleton = new AsyncBuilder();
+
+export { AsyncBuilder, CancellationToken, OperationCanceledError, Trampoline, protectedBind, protectedCont, protectedReturn, singleton };

package/dist/ts/node_modules/@fable-org/fable-library-js/BigInt.js

@@ -0,0 +1,286 @@
+import { truncate, fromParts } from './Decimal.js';
+import { bigintHash } from './Util.js';
+
+const isBigEndian = false;
+BigInt.prototype.toJSON = function () {
+    return `${this.toString()}`;
+};
+const zero = 0n;
+const one = 1n;
+const two = 2n;
+const minusOne = -1n;
+function isBigInt(x) {
+    return typeof x === "bigint";
+}
+function hash(x) {
+    return bigintHash(x);
+}
+function equals(x, y) {
+    return x === y;
+}
+function compare(x, y) {
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+function abs(x) { return x < zero ? -x : x; }
+function sign(x) { return x < zero ? -1 : x > zero ? 1 : 0; }
+function max(x, y) { return x > y ? x : y; }
+function min(x, y) { return x < y ? x : y; }
+function maxMagnitude(x, y) { return abs(x) > abs(y) ? x : y; }
+function minMagnitude(x, y) { return abs(x) < abs(y) ? x : y; }
+function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}
+function add(x, y) { return x + y; }
+function subtract(x, y) { return x - y; }
+function multiply(x, y) { return x * y; }
+function divide(x, y) { return x / y; }
+function remainder(x, y) { return x % y; }
+function negate(x) { return -x; }
+function op_UnaryNegation(x) { return -x; }
+function op_LogicalNot(x) { return ~x; }
+function op_UnaryPlus(x) { return x; }
+function op_Addition(x, y) { return x + y; }
+function op_Subtraction(x, y) { return x - y; }
+function op_Multiply(x, y) { return x * y; }
+function op_Division(x, y) { return x / y; }
+function op_Modulus(x, y) { return x % y; }
+function op_RightShift(x, n) { return x >> BigInt(n); }
+function op_LeftShift(x, n) { return x << BigInt(n); }
+function op_BitwiseAnd(x, y) { return x & y; }
+function op_BitwiseOr(x, y) { return x | y; }
+function op_ExclusiveOr(x, y) { return x ^ y; }
+function op_LessThan(x, y) { return x < y; }
+function op_LessThanOrEqual(x, y) { return x <= y; }
+function op_GreaterThan(x, y) { return x > y; }
+function op_GreaterThanOrEqual(x, y) { return x >= y; }
+function op_Equality(x, y) { return x === y; }
+function op_Inequality(x, y) { return x !== y; }
+function get_Zero() { return zero; }
+function get_One() { return one; }
+function get_MinusOne() { return minusOne; }
+function get_IsZero(x) { return x === zero; }
+function get_IsOne(x) { return x === one; }
+function get_IsEven(x) { return isEvenInteger(x); }
+function get_IsPowerOfTwo(x) { return isPow2(x); }
+function get_Sign(x) { return sign(x); }
+function isNegative(x) { return x < zero; }
+function isPositive(x) { return x > zero; }
+function isEvenInteger(x) { return (x % two) === zero; }
+function isOddInteger(x) { return (x % two) !== zero; }
+function isPow2(x) { return (x & (x - one)) === zero; }
+function fromZero() { return zero; }
+function fromOne() { return one; }
+function fromInt8(n) { return BigInt(n); }
+function fromUInt8(n) { return BigInt(n); }
+function fromInt16(n) { return BigInt(n); }
+function fromUInt16(n) { return BigInt(n); }
+function fromInt32(n) { return BigInt(n); }
+function fromUInt32(n) { return BigInt(n); }
+function fromInt64(n) { return n; }
+function fromUInt64(n) { return n; }
+function fromInt128(n) { return n; }
+function fromUInt128(n) { return n; }
+function fromNativeInt(n) { return n; }
+function fromUNativeInt(n) { return n; }
+function fromFloat16(n) { return BigInt(Math.trunc(n)); }
+function fromFloat32(n) { return BigInt(Math.trunc(n)); }
+function fromFloat64(n) { return BigInt(Math.trunc(n)); }
+function fromDecimal(d) { return BigInt(truncate(d).toString()); }
+function fromBigInt(x) { return x; }
+function fromBoolean(b) { return BigInt(b); }
+function fromChar(c) { return BigInt(c.charCodeAt(0)); }
+function fromString(s) { return BigInt(s); }
+function fromByteArray(bytes) {
+    return fromSignedBytes(bytes, isBigEndian);
+}
+function toByteArray(value) {
+    return toSignedBytes(value, isBigEndian);
+}
+function toInt8(x) { return Number(BigInt.asIntN(8, x)); }
+function toUInt8(x) { return Number(BigInt.asUintN(8, x)); }
+function toInt16(x) { return Number(BigInt.asIntN(16, x)); }
+function toUInt16(x) { return Number(BigInt.asUintN(16, x)); }
+function toInt32(x) { return Number(BigInt.asIntN(32, x)); }
+function toUInt32(x) { return Number(BigInt.asUintN(32, x)); }
+function toInt64(x) { return BigInt.asIntN(64, x); }
+function toUInt64(x) { return BigInt.asUintN(64, x); }
+function toInt128(x) { return BigInt.asIntN(128, x); }
+function toUInt128(x) { return BigInt.asUintN(128, x); }
+function toNativeInt(x) { return BigInt.asIntN(64, x); }
+function toUNativeInt(x) { return BigInt.asUintN(64, x); }
+function toFloat16(x) { return Number(x); }
+function toFloat32(x) { return Number(x); }
+function toFloat64(x) { return Number(x); }
+function toDecimal(x) {
+    const isNegative = x < zero;
+    const bits = abs(x);
+    const low = Number(BigInt.asUintN(32, bits));
+    const mid = Number(BigInt.asUintN(32, bits >> 32n));
+    const high = Number(BigInt.asUintN(32, bits >> 64n));
+    const scale = 0;
+    return fromParts(low, mid, high, isNegative, scale);
+}
+function toBigInt(x) { return x; }
+function toBoolean(x) { return x !== zero; }
+function toChar(x) {
+    return String.fromCharCode(toUInt16(x));
+}
+function toString(x) { return x.toString(); }
+function tryParse(s, res) {
+    try {
+        res.contents = BigInt(s);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+function parse(s) {
+    return BigInt(s);
+}
+function pow(x, n) {
+    return x ** BigInt(n);
+}
+function modPow(x, e, m) {
+    return (x ** e) % m;
+}
+function divRem(x, y, out) {
+    const div = x / y;
+    const rem = x % y;
+    if (out === void 0) {
+        return [div, rem];
+    }
+    else {
+        out.contents = rem;
+        return div;
+    }
+}
+function greatestCommonDivisor(x, y) {
+    while (y > zero) {
+        const q = x / y;
+        const r = x - q * y;
+        x = y;
+        y = r;
+    }
+    return x;
+}
+function getBitLength(x) {
+    return fromFloat64(x === zero ? 1 : log2(abs(x)) + 1);
+}
+function log2(x) {
+    const n = Number(x);
+    if (Number.isFinite(n))
+        return Math.log2(n); // fast path
+    if (x < zero)
+        return Number.NaN;
+    let shift = one;
+    while (x >= (one << shift)) {
+        shift = shift << one;
+    }
+    let log = zero;
+    while (shift > one) {
+        shift = shift >> one;
+        if (x >= (one << shift)) {
+            log = log + shift;
+            x = x >> shift;
+        }
+    }
+    return Number(log);
+}
+function log10(x) {
+    return log2(x) * Math.log10(2);
+}
+function ln(x) {
+    return log2(x) * Math.log(2);
+}
+function log(x, base) {
+    return log2(x) / Math.log2(base);
+}
+function ilog2(x) {
+    return BigInt(log2(x));
+}
+// export function copySign
+// export function createChecked
+// export function createSaturating
+// export function createTruncating
+// export function getByteCount
+// export function leadingZeroCount
+// export function popCount
+// export function rotateLeft
+// export function rotateRight
+// export function trailingZeroCount
+// export function tryFormat
+// export function tryWriteBytes
+// -------------------------------------------------
+// Binary serialization
+// -------------------------------------------------
+const hexCodes = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102]);
+function fromHexCode(code) {
+    if (48 <= code && code <= 57)
+        return code - 48;
+    if (97 <= code && code <= 102)
+        return code - 97 + 10;
+    if (65 <= code && code <= 70)
+        return code - 65 + 10;
+    throw Error(`Invalid hex code: ${code}`);
+}
+function toSignedBytes(x, isBigEndian) {
+    const isNeg = x < 0n;
+    if (isNeg) {
+        const len = log2(-x);
+        const bits = len + (8 - len % 8);
+        const pow2 = (1n << BigInt(bits));
+        x = x + pow2; // two's complement
+    }
+    const hex = x.toString(16);
+    const len = hex.length;
+    const odd = len % 2;
+    const first = hex.charCodeAt(0);
+    const isLow = 48 <= first && first <= 55; // 0..7
+    const start = (isNeg && isLow) || (!isNeg && !isLow) ? 1 : 0;
+    const bytes = new Uint8Array(start + (len + odd) / 2);
+    const inc = isBigEndian ? 1 : -1;
+    let pos = isBigEndian ? 0 : bytes.length - 1;
+    if (start > 0) {
+        bytes[pos] = isNeg ? 255 : 0;
+        pos += inc;
+    }
+    if (odd > 0) {
+        bytes[pos] = fromHexCode(first);
+        pos += inc;
+    }
+    for (let i = odd; i < len; i += 2, pos += inc) {
+        const a = fromHexCode(hex.charCodeAt(i));
+        const b = fromHexCode(hex.charCodeAt(i + 1));
+        bytes[pos] = (a << 4) | b;
+    }
+    return bytes;
+}
+function fromSignedBytes(bytes, isBigEndian) {
+    if (bytes == null) {
+        throw new Error("bytes is null");
+    }
+    const len = bytes.length;
+    const first = isBigEndian ? 0 : len - 1;
+    const isNeg = bytes[first] > 127;
+    const codes = new Uint16Array(len * 2 + 2);
+    codes[0] = 48; // 0
+    codes[1] = 120; // x
+    const inc = isBigEndian ? 1 : -1;
+    let pos = isBigEndian ? 0 : len - 1;
+    for (let i = 0; i < bytes.length; i++, pos += inc) {
+        const byte = bytes[pos];
+        codes[2 * i + 2] = hexCodes[byte >> 4];
+        codes[2 * i + 3] = hexCodes[byte & 15];
+    }
+    const str = String.fromCharCode.apply(null, codes);
+    let x = BigInt(str);
+    if (isNeg) {
+        const bits = len * 8;
+        const pow2 = (1n << BigInt(bits));
+        x = x - pow2; // two's complement
+    }
+    return x;
+}
+
+export { abs, add, clamp, compare, divRem, divide, equals, fromBigInt, fromBoolean, fromByteArray, fromChar, fromDecimal, fromFloat16, fromFloat32, fromFloat64, fromInt128, fromInt16, fromInt32, fromInt64, fromInt8, fromNativeInt, fromOne, fromString, fromUInt128, fromUInt16, fromUInt32, fromUInt64, fromUInt8, fromUNativeInt, fromZero, getBitLength, get_IsEven, get_IsOne, get_IsPowerOfTwo, get_IsZero, get_MinusOne, get_One, get_Sign, get_Zero, greatestCommonDivisor, hash, ilog2, isBigInt, isEvenInteger, isNegative, isOddInteger, isPositive, isPow2, ln, log, log10, log2, max, maxMagnitude, min, minMagnitude, modPow, multiply, negate, op_Addition, op_BitwiseAnd, op_BitwiseOr, op_Division, op_Equality, op_ExclusiveOr, op_GreaterThan, op_GreaterThanOrEqual, op_Inequality, op_LeftShift, op_LessThan, op_LessThanOrEqual, op_LogicalNot, op_Modulus, op_Multiply, op_RightShift, op_Subtraction, op_UnaryNegation, op_UnaryPlus, parse, pow, remainder, sign, subtract, toBigInt, toBoolean, toByteArray, toChar, toDecimal, toFloat16, toFloat32, toFloat64, toInt128, toInt16, toInt32, toInt64, toInt8, toNativeInt, toString, toUInt128, toUInt16, toUInt32, toUInt64, toUInt8, toUNativeInt, tryParse };

package/dist/ts/node_modules/@fable-org/fable-library-js/Boolean.js

@@ -0,0 +1,24 @@
+import { FSharpRef } from './Types.js';
+
+function tryParse(str, defValue) {
+    if (str != null && str.match(/^\s*true\s*$/i)) {
+        defValue.contents = true;
+        return true;
+    }
+    else if (str != null && str.match(/^\s*false\s*$/i)) {
+        defValue.contents = false;
+        return true;
+    }
+    return false;
+}
+function parse(str) {
+    const defValue = new FSharpRef(false);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`String '${str}' was not recognized as a valid Boolean.`);
+    }
+}
+
+export { parse, tryParse };