@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/fable_modules/fable-library-js.4.24.0/Async.d.ts

@@ -1,27 +0,0 @@
-import { Continuation, Continuations } from "./AsyncBuilder.js";
-import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.js";
-import { FSharpChoice$2_$union } from "./Choice.js";
-export declare function makeAsync<T>(body: Async<T>): Async<T>;
-export declare function invoke<T>(computation: Async<T>, ctx: IAsyncContext<T>): void;
-export declare function callThenInvoke<T, U>(ctx: IAsyncContext<T>, result1: U, part2: (x: U) => Async<T>): void;
-export declare function bind<T, U>(ctx: IAsyncContext<T>, part1: Async<U>, part2: (x: U) => Async<T>): void;
-export declare function createCancellationToken(arg?: boolean | number): CancellationToken;
-export declare function cancel(token: CancellationToken): void;
-export declare function cancelAfter(token: CancellationToken, ms: number): void;
-export declare function isCancellationRequested(token: CancellationToken): boolean;
-export declare function throwIfCancellationRequested(token: CancellationToken): void;
-export declare function startChild<T>(computation: Async<T>, ms?: number): Async<Async<T>>;
-export declare function awaitPromise<T>(p: Promise<T>): (ctx: IAsyncContext<T>) => void;
-export declare function cancellationToken(): (ctx: IAsyncContext<CancellationToken>) => void;
-export declare const defaultCancellationToken: CancellationToken;
-export declare function catchAsync<T>(work: Async<T>): (ctx: IAsyncContext<FSharpChoice$2_$union<T, Error>>) => void;
-export declare function fromContinuations<T>(f: (conts: Continuations<T>) => void): (ctx: IAsyncContext<T>) => void;
-export declare function ignore<T>(computation: Async<T>): (ctx: IAsyncContext<undefined>) => void;
-export declare function parallel<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<Awaited<T>[]>) => void;
-export declare function sequential<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<T[]>) => void;
-export declare function sleep(millisecondsDueTime: number): (ctx: IAsyncContext<void>) => void;
-export declare function runSynchronously(): never;
-export declare function start<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
-export declare function startImmediate<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
-export declare function startWithContinuations<T>(computation: Async<T>, continuation?: Continuation<T> | CancellationToken, exceptionContinuation?: Continuation<any>, cancellationContinuation?: Continuation<any>, cancelToken?: CancellationToken): void;
-export declare function startAsPromise<T>(computation: Async<T>, cancellationToken?: CancellationToken): Promise<T>;

package/fable_modules/fable-library-js.4.24.0/Async.js

@@ -1,152 +0,0 @@
-import { OperationCanceledError, Trampoline } from "./AsyncBuilder.js";
-import { CancellationToken } from "./AsyncBuilder.js";
-import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
-import { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } 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>
-export function makeAsync(body) {
-    return body;
-}
-// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
-export function invoke(computation, ctx) {
-    return computation(ctx);
-}
-// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
-export function callThenInvoke(ctx, result1, part2) {
-    return part2(result1)(ctx);
-}
-// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
-export function bind(ctx, part1, part2) {
-    return protectedBind(part1, part2)(ctx);
-}
-export function createCancellationToken(arg) {
-    const token = new CancellationToken(typeof arg === "boolean" ? arg : false);
-    if (typeof arg === "number") {
-        setTimeout(() => { token.cancel(); }, arg);
-    }
-    return token;
-}
-export function cancel(token) {
-    token.cancel();
-}
-export function cancelAfter(token, ms) {
-    setTimeout(() => { token.cancel(); }, ms);
-}
-export function isCancellationRequested(token) {
-    return token != null && token.isCancelled;
-}
-export 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());
-        });
-    });
-}
-export 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));
-}
-export function awaitPromise(p) {
-    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError
-        ? conts[2] : conts[1])(err)));
-}
-export function cancellationToken() {
-    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));
-}
-export const defaultCancellationToken = new CancellationToken();
-export 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,
-        });
-    });
-}
-export function fromContinuations(f) {
-    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
-}
-export function ignore(computation) {
-    return protectedBind(computation, (_x) => protectedReturn(void 0));
-}
-export 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)])));
-}
-export 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)));
-}
-export 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());
-        });
-    });
-}
-export function runSynchronously() {
-    throw new Error("Asynchronous code cannot be run synchronously in JS");
-}
-export function start(computation, cancellationToken) {
-    return startWithContinuations(computation, cancellationToken);
-}
-export function startImmediate(computation, cancellationToken) {
-    return start(computation, cancellationToken);
-}
-export function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
-    if (typeof continuation !== "function") {
-        cancelToken = continuation;
-        continuation = undefined;
-    }
-    const trampoline = new Trampoline();
-    computation({
-        onSuccess: continuation ? continuation : emptyContinuation,
-        onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,
-        onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,
-        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
-        trampoline,
-    });
-}
-export function startAsPromise(computation, cancellationToken) {
-    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
-}

package/fable_modules/fable-library-js.4.24.0/AsyncBuilder.d.ts

@@ -1,59 +0,0 @@
-import { IDisposable } from "./Util.js";
-export interface AsyncReplyChannel<Reply> {
-    reply(value: Reply): void;
-}
-export type Continuation<T> = (x: T) => void;
-export type Continuations<T> = [
-    Continuation<T>,
-    Continuation<Error>,
-    Continuation<OperationCanceledError>
-];
-export declare class CancellationToken implements IDisposable {
-    private _id;
-    private _cancelled;
-    private _listeners;
-    constructor(cancelled?: boolean);
-    get isCancelled(): boolean;
-    cancel(): void;
-    addListener(f: () => void): number;
-    removeListener(id: number): boolean;
-    register(f: (state?: any) => void, state?: any): {
-        Dispose(): void;
-    };
-    Dispose(): void;
-}
-export declare class OperationCanceledError extends Error {
-    constructor();
-}
-export declare class Trampoline {
-    static get maxTrampolineCallCount(): number;
-    private callCount;
-    constructor();
-    incrementAndCheck(): boolean;
-    hijack(f: () => void): void;
-}
-export interface IAsyncContext<T> {
-    onSuccess: Continuation<T>;
-    onError: Continuation<Error>;
-    onCancel: Continuation<OperationCanceledError>;
-    cancelToken: CancellationToken;
-    trampoline: Trampoline;
-}
-export type Async<T> = (x: IAsyncContext<T>) => void;
-export declare function protectedCont<T>(f: Async<T>): (ctx: IAsyncContext<T>) => void;
-export declare function protectedBind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
-export declare function protectedReturn<T>(value: T): (ctx: IAsyncContext<T>) => void;
-export declare class AsyncBuilder {
-    Bind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
-    Combine<T>(computation1: Async<void>, computation2: Async<T>): (ctx: IAsyncContext<T>) => void;
-    Delay<T>(generator: () => Async<T>): (ctx: IAsyncContext<T>) => void;
-    For<T>(sequence: Iterable<T>, body: (x: T) => Async<void>): Async<void>;
-    Return<T>(value: T): (ctx: IAsyncContext<T>) => void;
-    ReturnFrom<T>(computation: Async<T>): Async<T>;
-    TryFinally<T>(computation: Async<T>, compensation: () => void): (ctx: IAsyncContext<T>) => void;
-    TryWith<T>(computation: Async<T>, catchHandler: (e: any) => Async<T>): (ctx: IAsyncContext<T>) => void;
-    Using<T extends IDisposable, U>(resource: T, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
-    While(guard: () => boolean, computation: Async<void>): Async<void>;
-    Zero(): (ctx: IAsyncContext<void>) => void;
-}
-export declare const singleton: AsyncBuilder;

package/fable_modules/fable-library-js.4.24.0/AsyncBuilder.js

@@ -1,183 +0,0 @@
-import { ensureErrorOrException } from './Types.js';
-export 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
-    }
-}
-export class OperationCanceledError extends Error {
-    constructor() {
-        super("The operation was canceled");
-        Object.setPrototypeOf(this, OperationCanceledError.prototype);
-    }
-}
-export 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);
-    }
-}
-export 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));
-            }
-        }
-    };
-}
-export 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,
-        });
-    });
-}
-export function protectedReturn(value) {
-    return protectedCont((ctx) => ctx.onSuccess(value));
-}
-export 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));
-    }
-}
-export const singleton = new AsyncBuilder();

package/fable_modules/fable-library-js.4.24.0/BigInt.d.ts

@@ -1,115 +0,0 @@
-import { FSharpRef } from "./Types.js";
-import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
-import { decimal } from "./Decimal.js";
-export type int64 = bigint;
-export type uint64 = bigint;
-export type int128 = bigint;
-export type uint128 = bigint;
-export type nativeint = bigint;
-export type unativeint = bigint;
-export declare function isBigInt(x: any): boolean;
-export declare function hash(x: bigint): int32;
-export declare function equals(x: bigint, y: bigint): boolean;
-export declare function compare(x: bigint, y: bigint): int32;
-export declare function abs(x: bigint): bigint;
-export declare function sign(x: bigint): int32;
-export declare function max(x: bigint, y: bigint): bigint;
-export declare function min(x: bigint, y: bigint): bigint;
-export declare function maxMagnitude(x: bigint, y: bigint): bigint;
-export declare function minMagnitude(x: bigint, y: bigint): bigint;
-export declare function clamp(x: bigint, min: bigint, max: bigint): bigint;
-export declare function add(x: bigint, y: bigint): bigint;
-export declare function subtract(x: bigint, y: bigint): bigint;
-export declare function multiply(x: bigint, y: bigint): bigint;
-export declare function divide(x: bigint, y: bigint): bigint;
-export declare function remainder(x: bigint, y: bigint): bigint;
-export declare function negate(x: bigint): bigint;
-export declare function op_UnaryNegation(x: bigint): bigint;
-export declare function op_LogicalNot(x: bigint): bigint;
-export declare function op_UnaryPlus(x: bigint): bigint;
-export declare function op_Addition(x: bigint, y: bigint): bigint;
-export declare function op_Subtraction(x: bigint, y: bigint): bigint;
-export declare function op_Multiply(x: bigint, y: bigint): bigint;
-export declare function op_Division(x: bigint, y: bigint): bigint;
-export declare function op_Modulus(x: bigint, y: bigint): bigint;
-export declare function op_RightShift(x: bigint, n: int32): bigint;
-export declare function op_LeftShift(x: bigint, n: int32): bigint;
-export declare function op_BitwiseAnd(x: bigint, y: bigint): bigint;
-export declare function op_BitwiseOr(x: bigint, y: bigint): bigint;
-export declare function op_ExclusiveOr(x: bigint, y: bigint): bigint;
-export declare function op_LessThan(x: bigint, y: bigint): boolean;
-export declare function op_LessThanOrEqual(x: bigint, y: bigint): boolean;
-export declare function op_GreaterThan(x: bigint, y: bigint): boolean;
-export declare function op_GreaterThanOrEqual(x: bigint, y: bigint): boolean;
-export declare function op_Equality(x: bigint, y: bigint): boolean;
-export declare function op_Inequality(x: bigint, y: bigint): boolean;
-export declare function get_Zero(): bigint;
-export declare function get_One(): bigint;
-export declare function get_MinusOne(): bigint;
-export declare function get_IsZero(x: bigint): boolean;
-export declare function get_IsOne(x: bigint): boolean;
-export declare function get_IsEven(x: bigint): boolean;
-export declare function get_IsPowerOfTwo(x: bigint): boolean;
-export declare function get_Sign(x: bigint): int32;
-export declare function isNegative(x: bigint): boolean;
-export declare function isPositive(x: bigint): boolean;
-export declare function isEvenInteger(x: bigint): boolean;
-export declare function isOddInteger(x: bigint): boolean;
-export declare function isPow2(x: bigint): boolean;
-export declare function fromZero(): bigint;
-export declare function fromOne(): bigint;
-export declare function fromInt8(n: int8): bigint;
-export declare function fromUInt8(n: uint8): bigint;
-export declare function fromInt16(n: int16): bigint;
-export declare function fromUInt16(n: uint16): bigint;
-export declare function fromInt32(n: int32): bigint;
-export declare function fromUInt32(n: uint32): bigint;
-export declare function fromInt64(n: int64): bigint;
-export declare function fromUInt64(n: uint64): bigint;
-export declare function fromInt128(n: int128): bigint;
-export declare function fromUInt128(n: uint128): bigint;
-export declare function fromNativeInt(n: nativeint): bigint;
-export declare function fromUNativeInt(n: unativeint): bigint;
-export declare function fromFloat16(n: float16): bigint;
-export declare function fromFloat32(n: float32): bigint;
-export declare function fromFloat64(n: float64): bigint;
-export declare function fromDecimal(d: decimal): bigint;
-export declare function fromBigInt(x: bigint): bigint;
-export declare function fromBoolean(b: boolean): bigint;
-export declare function fromChar(c: string): bigint;
-export declare function fromString(s: string): bigint;
-export declare function fromByteArray(bytes: ArrayLike<uint8>): bigint;
-export declare function toByteArray(value: bigint): number[];
-export declare function toInt8(x: bigint): int8;
-export declare function toUInt8(x: bigint): uint8;
-export declare function toInt16(x: bigint): int16;
-export declare function toUInt16(x: bigint): uint16;
-export declare function toInt32(x: bigint): int32;
-export declare function toUInt32(x: bigint): uint32;
-export declare function toInt64(x: bigint): int64;
-export declare function toUInt64(x: bigint): uint64;
-export declare function toInt128(x: bigint): int128;
-export declare function toUInt128(x: bigint): uint128;
-export declare function toNativeInt(x: bigint): nativeint;
-export declare function toUNativeInt(x: bigint): unativeint;
-export declare function toFloat16(x: bigint): float32;
-export declare function toFloat32(x: bigint): float32;
-export declare function toFloat64(x: bigint): float64;
-export declare function toDecimal(x: bigint): decimal;
-export declare function toBigInt(x: bigint): bigint;
-export declare function toBoolean(x: bigint): boolean;
-export declare function toChar(x: bigint): string;
-export declare function toString(x: bigint): string;
-export declare function tryParse(s: string, res: FSharpRef<bigint>): boolean;
-export declare function parse(s: string): bigint;
-export declare function pow(x: bigint, n: int32): bigint;
-export declare function modPow(x: bigint, e: bigint, m: bigint): bigint;
-export declare function divRem(x: bigint, y: bigint): [bigint, bigint];
-export declare function divRem(x: bigint, y: bigint, out: FSharpRef<bigint>): bigint;
-export declare function greatestCommonDivisor(x: bigint, y: bigint): bigint;
-export declare function getBitLength(x: bigint): int64;
-export declare function log2(x: bigint): float64;
-export declare function log10(x: bigint): float64;
-export declare function ln(x: bigint): float64;
-export declare function log(x: bigint, base: float64): float64;
-export declare function ilog2(x: bigint): bigint;