@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -1,146 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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 };