@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

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

@@ -0,0 +1,680 @@
+import { join } from './String.js';
+import { value, some } from './Option.js';
+import { toIterator, getEnumerator, equals, structuralHash, compare, defaultOf, isArrayLike, disposeSafe } from './Util.js';
+import { Record } from './Types.js';
+import { SR_inputWasEmpty, SR_keyNotFoundAlt, SR_indexOutOfBounds } from './Global.js';
+import { fill, setItem, item as item$1, foldBack as foldBack$1, map as map$1, transpose as transpose$1 } from './Array.js';
+
+class FSharpList extends Record {
+    constructor(head, tail) {
+        super();
+        this.head = head;
+        this.tail = tail;
+    }
+    toString() {
+        const xs = this;
+        return ("[" + join("; ", xs)) + "]";
+    }
+    Equals(other) {
+        const xs = this;
+        if (xs === other) {
+            return true;
+        }
+        else {
+            const loop = (xs_1_mut, ys_1_mut) => {
+                loop: while (true) {
+                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+                    const matchValue = xs_1.tail;
+                    const matchValue_1 = ys_1.tail;
+                    if (matchValue != null) {
+                        if (matchValue_1 != null) {
+                            const xt = value(matchValue);
+                            const yt = value(matchValue_1);
+                            if (equals(xs_1.head, ys_1.head)) {
+                                xs_1_mut = xt;
+                                ys_1_mut = yt;
+                                continue loop;
+                            }
+                            else {
+                                return false;
+                            }
+                        }
+                        else {
+                            return false;
+                        }
+                    }
+                    else if (matchValue_1 != null) {
+                        return false;
+                    }
+                    else {
+                        return true;
+                    }
+                }
+            };
+            return loop(xs, other);
+        }
+    }
+    GetHashCode() {
+        const xs = this;
+        const loop = (i_mut, h_mut, xs_1_mut) => {
+            loop: while (true) {
+                const i = i_mut, h = h_mut, xs_1 = xs_1_mut;
+                const matchValue = xs_1.tail;
+                if (matchValue != null) {
+                    const t = value(matchValue);
+                    if (i > 18) {
+                        return h | 0;
+                    }
+                    else {
+                        i_mut = (i + 1);
+                        h_mut = (((h << 1) + structuralHash(xs_1.head)) + (631 * i));
+                        xs_1_mut = t;
+                        continue loop;
+                    }
+                }
+                else {
+                    return h | 0;
+                }
+            }
+        };
+        return loop(0, 0, xs) | 0;
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    CompareTo(other) {
+        const xs = this;
+        const loop = (xs_1_mut, ys_1_mut) => {
+            loop: while (true) {
+                const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+                const matchValue = xs_1.tail;
+                const matchValue_1 = ys_1.tail;
+                if (matchValue != null) {
+                    if (matchValue_1 != null) {
+                        const xt = value(matchValue);
+                        const yt = value(matchValue_1);
+                        const c = compare(xs_1.head, ys_1.head) | 0;
+                        if (c === 0) {
+                            xs_1_mut = xt;
+                            ys_1_mut = yt;
+                            continue loop;
+                        }
+                        else {
+                            return c | 0;
+                        }
+                    }
+                    else {
+                        return 1;
+                    }
+                }
+                else if (matchValue_1 != null) {
+                    return -1;
+                }
+                else {
+                    return 0;
+                }
+            }
+        };
+        return loop(xs, other) | 0;
+    }
+    GetEnumerator() {
+        const xs = this;
+        return ListEnumerator$1_$ctor_3002E699(xs);
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const xs = this;
+        return getEnumerator(xs);
+    }
+}
+class ListEnumerator$1 {
+    constructor(xs) {
+        this.xs = xs;
+        this.it = this.xs;
+        this.current = defaultOf();
+    }
+    "System.Collections.Generic.IEnumerator`1.get_Current"() {
+        const _ = this;
+        return _.current;
+    }
+    "System.Collections.IEnumerator.get_Current"() {
+        const _ = this;
+        return _.current;
+    }
+    "System.Collections.IEnumerator.MoveNext"() {
+        const _ = this;
+        const matchValue = _.it.tail;
+        if (matchValue != null) {
+            const t = value(matchValue);
+            _.current = _.it.head;
+            _.it = t;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    "System.Collections.IEnumerator.Reset"() {
+        const _ = this;
+        _.it = _.xs;
+        _.current = defaultOf();
+    }
+    Dispose() {
+    }
+}
+function ListEnumerator$1_$ctor_3002E699(xs) {
+    return new ListEnumerator$1(xs);
+}
+function FSharpList_get_Empty() {
+    return new FSharpList(defaultOf(), undefined);
+}
+function FSharpList_Cons_305B8EAC(x, xs) {
+    return new FSharpList(x, xs);
+}
+function FSharpList__get_IsEmpty(xs) {
+    return xs.tail == null;
+}
+function FSharpList__get_Length(xs) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            const matchValue = xs_1.tail;
+            if (matchValue != null) {
+                i_mut = (i + 1);
+                xs_1_mut = value(matchValue);
+                continue loop;
+            }
+            else {
+                return i | 0;
+            }
+        }
+    };
+    return loop(0, xs) | 0;
+}
+function FSharpList__get_Head(xs) {
+    const matchValue = xs.tail;
+    if (matchValue != null) {
+        return xs.head;
+    }
+    else {
+        throw new Error((SR_inputWasEmpty + "\\nParameter name: ") + "list");
+    }
+}
+function FSharpList__get_Tail(xs) {
+    const matchValue = xs.tail;
+    if (matchValue != null) {
+        return value(matchValue);
+    }
+    else {
+        throw new Error((SR_inputWasEmpty + "\\nParameter name: ") + "list");
+    }
+}
+function FSharpList__get_Item_Z524259A4(xs, index) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            const matchValue = xs_1.tail;
+            if (matchValue != null) {
+                if (i === index) {
+                    return xs_1.head;
+                }
+                else {
+                    i_mut = (i + 1);
+                    xs_1_mut = value(matchValue);
+                    continue loop;
+                }
+            }
+            else {
+                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+        }
+    };
+    return loop(0, xs);
+}
+function indexNotFound() {
+    throw new Error(SR_keyNotFoundAlt);
+}
+function empty() {
+    return FSharpList_get_Empty();
+}
+function cons(x, xs) {
+    return FSharpList_Cons_305B8EAC(x, xs);
+}
+function singleton(x) {
+    return FSharpList_Cons_305B8EAC(x, FSharpList_get_Empty());
+}
+function isEmpty(xs) {
+    return FSharpList__get_IsEmpty(xs);
+}
+function length(xs) {
+    return FSharpList__get_Length(xs);
+}
+function head(xs) {
+    return FSharpList__get_Head(xs);
+}
+function tryHead(xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        return undefined;
+    }
+    else {
+        return some(FSharpList__get_Head(xs));
+    }
+}
+function tail(xs) {
+    return FSharpList__get_Tail(xs);
+}
+function tryLast(xs_mut) {
+    tryLast: while (true) {
+        const xs = xs_mut;
+        if (FSharpList__get_IsEmpty(xs)) {
+            return undefined;
+        }
+        else {
+            const t = FSharpList__get_Tail(xs);
+            if (FSharpList__get_IsEmpty(t)) {
+                return some(FSharpList__get_Head(xs));
+            }
+            else {
+                xs_mut = t;
+                continue tryLast;
+            }
+        }
+    }
+}
+function toArray(xs) {
+    const len = FSharpList__get_Length(xs) | 0;
+    const res = fill(new Array(len), 0, len, null);
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            if (!FSharpList__get_IsEmpty(xs_1)) {
+                setItem(res, i, FSharpList__get_Head(xs_1));
+                i_mut = (i + 1);
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    loop(0, xs);
+    return res;
+}
+function fold(folder, state, xs) {
+    let acc = state;
+    let xs_1 = xs;
+    while (!FSharpList__get_IsEmpty(xs_1)) {
+        acc = folder(acc, head(xs_1));
+        xs_1 = FSharpList__get_Tail(xs_1);
+    }
+    return acc;
+}
+function reverse(xs) {
+    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), FSharpList_get_Empty(), xs);
+}
+function foldBack(folder, xs, state) {
+    return foldBack$1(folder, toArray(xs), state);
+}
+function foldIndexed(folder, state, xs) {
+    const loop = (i_mut, acc_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return acc;
+            }
+            else {
+                i_mut = (i + 1);
+                acc_mut = folder(i, acc, FSharpList__get_Head(xs_1));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+        }
+    };
+    return loop(0, state, xs);
+}
+function fold2(folder, state, xs, ys) {
+    let acc = state;
+    let xs_1 = xs;
+    let ys_1 = ys;
+    while (!FSharpList__get_IsEmpty(xs_1) && !FSharpList__get_IsEmpty(ys_1)) {
+        acc = folder(acc, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1));
+        xs_1 = FSharpList__get_Tail(xs_1);
+        ys_1 = FSharpList__get_Tail(ys_1);
+    }
+    return acc;
+}
+function iterate(action, xs) {
+    fold((unitVar, x) => {
+        action(x);
+    }, undefined, xs);
+}
+function iterateIndexed(action, xs) {
+    fold((i, x) => {
+        action(i, x);
+        return (i + 1) | 0;
+    }, 0, xs);
+}
+function ofArrayWithTail(xs, tail_1) {
+    let res = tail_1;
+    for (let i = xs.length - 1; i >= 0; i--) {
+        res = FSharpList_Cons_305B8EAC(item$1(i, xs), res);
+    }
+    return res;
+}
+function ofArray(xs) {
+    return ofArrayWithTail(xs, FSharpList_get_Empty());
+}
+function ofSeq(xs) {
+    let xs_3, t;
+    if (isArrayLike(xs)) {
+        return ofArray(xs);
+    }
+    else if (xs instanceof FSharpList) {
+        return xs;
+    }
+    else {
+        const root = FSharpList_get_Empty();
+        let node = root;
+        const enumerator = getEnumerator(xs);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                node = ((xs_3 = node, (t = (new FSharpList(x, undefined)), (xs_3.tail = t, t))));
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        const xs_5 = node;
+        const t_2 = FSharpList_get_Empty();
+        xs_5.tail = t_2;
+        return FSharpList__get_Tail(root);
+    }
+}
+function concat(lists) {
+    const root = FSharpList_get_Empty();
+    let node = root;
+    const action = (xs) => {
+        node = fold((acc, x) => {
+            const t = new FSharpList(x, undefined);
+            acc.tail = t;
+            return t;
+        }, node, xs);
+    };
+    if (isArrayLike(lists)) {
+        const xs_3 = lists;
+        xs_3.forEach(action);
+    }
+    else if (lists instanceof FSharpList) {
+        iterate(action, lists);
+    }
+    else {
+        const enumerator = getEnumerator(lists);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                action(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    const xs_6 = node;
+    const t_2 = FSharpList_get_Empty();
+    xs_6.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function append(xs, ys) {
+    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));
+}
+function collect(mapping, xs) {
+    let xs_1, t;
+    const root = FSharpList_get_Empty();
+    let node = root;
+    let ys = xs;
+    while (!FSharpList__get_IsEmpty(ys)) {
+        let zs = mapping(FSharpList__get_Head(ys));
+        while (!FSharpList__get_IsEmpty(zs)) {
+            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head(zs), undefined)), (xs_1.tail = t, t))));
+            zs = FSharpList__get_Tail(zs);
+        }
+        ys = FSharpList__get_Tail(ys);
+    }
+    const xs_3 = node;
+    const t_2 = FSharpList_get_Empty();
+    xs_3.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function mapIndexed(mapping, xs) {
+    const root = FSharpList_get_Empty();
+    const node = foldIndexed((i, acc, x) => {
+        const t = new FSharpList(mapping(i, x), undefined);
+        acc.tail = t;
+        return t;
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function map(mapping, xs) {
+    const root = FSharpList_get_Empty();
+    const node = fold((acc, x) => {
+        const t = new FSharpList(mapping(x), undefined);
+        acc.tail = t;
+        return t;
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function map2(mapping, xs, ys) {
+    const root = FSharpList_get_Empty();
+    const node = fold2((acc, x, y) => {
+        const t = new FSharpList(mapping(x, y), undefined);
+        acc.tail = t;
+        return t;
+    }, root, xs, ys);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function tryPick(f, xs) {
+    const loop = (xs_1_mut) => {
+        loop: while (true) {
+            const xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return undefined;
+            }
+            else {
+                const matchValue = f(FSharpList__get_Head(xs_1));
+                if (matchValue == null) {
+                    xs_1_mut = FSharpList__get_Tail(xs_1);
+                    continue loop;
+                }
+                else {
+                    return matchValue;
+                }
+            }
+        }
+    };
+    return loop(xs);
+}
+function pick(f, xs) {
+    const matchValue = tryPick(f, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return value(matchValue);
+    }
+}
+function tryFind(f, xs) {
+    return tryPick((x) => (f(x) ? some(x) : undefined), xs);
+}
+function find(f, xs) {
+    const matchValue = tryFind(f, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return value(matchValue);
+    }
+}
+function tryFindIndex(f, xs) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return undefined;
+            }
+            else if (f(FSharpList__get_Head(xs_1))) {
+                return i;
+            }
+            else {
+                i_mut = (i + 1);
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+        }
+    };
+    return loop(0, xs);
+}
+function tryItem(n, xs) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return undefined;
+            }
+            else if (i === n) {
+                return some(FSharpList__get_Head(xs_1));
+            }
+            else {
+                i_mut = (i + 1);
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+        }
+    };
+    return loop(0, xs);
+}
+function item(n, xs) {
+    return FSharpList__get_Item_Z524259A4(xs, n);
+}
+function filter(f, xs) {
+    const root = FSharpList_get_Empty();
+    const node = fold((acc, x) => {
+        if (f(x)) {
+            const t = new FSharpList(x, undefined);
+            acc.tail = t;
+            return t;
+        }
+        else {
+            return acc;
+        }
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function choose(f, xs) {
+    const root = FSharpList_get_Empty();
+    const node = fold((acc, x) => {
+        const matchValue = f(x);
+        if (matchValue == null) {
+            return acc;
+        }
+        else {
+            const t = new FSharpList(value(matchValue), undefined);
+            acc.tail = t;
+            return t;
+        }
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function initialize(n, f) {
+    let xs, t;
+    const root = FSharpList_get_Empty();
+    let node = root;
+    for (let i = 0; i <= (n - 1); i++) {
+        node = ((xs = node, (t = (new FSharpList(f(i), undefined)), (xs.tail = t, t))));
+    }
+    const xs_2 = node;
+    const t_2 = FSharpList_get_Empty();
+    xs_2.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function reduce(f, xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        throw new Error(SR_inputWasEmpty);
+    }
+    else {
+        return fold(f, head(xs), tail(xs));
+    }
+}
+function exists(f, xs) {
+    return tryFindIndex(f, xs) != null;
+}
+function unzip(xs) {
+    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty()]);
+}
+function zip(xs, ys) {
+    return map2((x, y) => [x, y], xs, ys);
+}
+function sortWith(comparer, xs) {
+    const arr = toArray(xs);
+    arr.sort(comparer);
+    return ofArray(arr);
+}
+function sortBy(projection, xs, comparer) {
+    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);
+}
+function skipWhile(predicate_mut, xs_mut) {
+    skipWhile: while (true) {
+        const predicate = predicate_mut, xs = xs_mut;
+        if (FSharpList__get_IsEmpty(xs)) {
+            return xs;
+        }
+        else if (!predicate(FSharpList__get_Head(xs))) {
+            return xs;
+        }
+        else {
+            predicate_mut = predicate;
+            xs_mut = FSharpList__get_Tail(xs);
+            continue skipWhile;
+        }
+    }
+}
+function takeWhile(predicate, xs) {
+    const loop = (acc_mut, xs_1_mut) => {
+        let t;
+        loop: while (true) {
+            const acc = acc_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return acc;
+            }
+            else if (!predicate(FSharpList__get_Head(xs_1))) {
+                return acc;
+            }
+            else {
+                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), undefined)), (acc.tail = t, t)));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+        }
+    };
+    const root = FSharpList_get_Empty();
+    const node = loop(root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function transpose(lists) {
+    return ofArray(map$1(ofArray, transpose$1(map$1(toArray, Array.from(lists)))));
+}
+
+export { FSharpList, FSharpList_Cons_305B8EAC, FSharpList__get_Head, FSharpList__get_IsEmpty, FSharpList__get_Item_Z524259A4, FSharpList__get_Length, FSharpList__get_Tail, FSharpList_get_Empty, ListEnumerator$1, ListEnumerator$1_$ctor_3002E699, append, choose, collect, concat, cons, empty, exists, filter, find, fold, fold2, foldBack, foldIndexed, head, indexNotFound, initialize, isEmpty, item, iterate, iterateIndexed, length, map, map2, mapIndexed, ofArray, ofArrayWithTail, ofSeq, pick, reduce, reverse, singleton, skipWhile, sortBy, sortWith, tail, takeWhile, toArray, transpose, tryFind, tryFindIndex, tryHead, tryItem, tryLast, tryPick, unzip, zip };

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

@@ -0,0 +1,40 @@
+import { isValid, getPrefix } from './Int32.js';
+import { fromString } from './BigInt.js';
+
+function getMaxValue(unsigned, radix, isNegative) {
+    switch (radix) {
+        case 2: return unsigned ?
+            "1111111111111111111111111111111111111111111111111111111111111111" :
+            (isNegative ? "1000000000000000000000000000000000000000000000000000000000000000"
+                : "111111111111111111111111111111111111111111111111111111111111111");
+        case 8: return unsigned ?
+            "1777777777777777777777" :
+            (isNegative ? "1000000000000000000000" : "777777777777777777777");
+        case 10: return unsigned ?
+            "18446744073709551615" :
+            (isNegative ? "9223372036854775808" : "9223372036854775807");
+        case 16: return unsigned ?
+            "FFFFFFFFFFFFFFFF" :
+            (isNegative ? "8000000000000000" : "7FFFFFFFFFFFFFFF");
+        default: throw new Error("Invalid radix.");
+    }
+}
+function parse(str, style, unsigned, _bitsize, radix) {
+    const res = isValid(str, style, radix);
+    if (res != null) {
+        const lessOrEqual = (x, y) => {
+            const len = Math.max(x.length, y.length);
+            return x.padStart(len, "0") <= y.padStart(len, "0");
+        };
+        const isNegative = res.sign === "-";
+        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);
+        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {
+            str = getPrefix(res.radix) + res.digits;
+            str = isNegative ? res.sign + str : str;
+            return fromString(str);
+        }
+    }
+    throw new Error(`The input string ${str} was not in a correct format.`);
+}
+
+export { parse };