@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -1,73 +0,0 @@
-const symbol = Symbol("numeric");
-function isNumeric(x) {
-    return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
-}
-function compare(x, y) {
-    if (typeof x === "number") {
-        return x < y ? -1 : (x > y ? 1 : 0);
-    }
-    else if (typeof x === "bigint") {
-        return x < y ? -1 : (x > y ? 1 : 0);
-    }
-    else {
-        return x.CompareTo(y);
-    }
-}
-function multiply(x, y) {
-    if (typeof x === "number") {
-        return x * y;
-    }
-    else if (typeof x === "bigint") {
-        return x * BigInt(y);
-    }
-    else {
-        return x[symbol]().multiply(y);
-    }
-}
-function toFixed(x, dp) {
-    if (typeof x === "number") {
-        return x.toFixed(dp);
-    }
-    else if (typeof x === "bigint") {
-        return x;
-    }
-    else {
-        return x[symbol]().toFixed(dp);
-    }
-}
-function toPrecision(x, sd) {
-    if (typeof x === "number") {
-        return x.toPrecision(sd);
-    }
-    else if (typeof x === "bigint") {
-        return x;
-    }
-    else {
-        return x[symbol]().toPrecision(sd);
-    }
-}
-function toExponential(x, dp) {
-    if (typeof x === "number") {
-        return x.toExponential(dp);
-    }
-    else if (typeof x === "bigint") {
-        return x;
-    }
-    else {
-        return x[symbol]().toExponential(dp);
-    }
-}
-function toHex(x) {
-    if (typeof x === "number") {
-        return (Number(x) >>> 0).toString(16);
-    }
-    else if (typeof x === "bigint") {
-        // TODO: properly handle other bit sizes
-        return BigInt.asUintN(64, x).toString(16);
-    }
-    else {
-        return x[symbol]().toHex();
-    }
-}
-
-export { compare, isNumeric, multiply, symbol, toExponential, toFixed, toHex, toPrecision };

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

@@ -1,99 +0,0 @@
-import { structuralHash, equals, compare } from './Util.js';
-
-// Using a class here for better compatibility with TS files importing Some
-class Some {
-    constructor(value) {
-        this.value = value;
-    }
-    toJSON() {
-        return this.value;
-    }
-    // Don't add "Some" for consistency with erased options
-    toString() {
-        return String(this.value);
-    }
-    GetHashCode() {
-        return structuralHash(this.value);
-    }
-    Equals(other) {
-        if (other == null) {
-            return false;
-        }
-        else {
-            return equals(this.value, other instanceof Some ? other.value : other);
-        }
-    }
-    CompareTo(other) {
-        if (other == null) {
-            return 1;
-        }
-        else {
-            return compare(this.value, other instanceof Some ? other.value : other);
-        }
-    }
-}
-function value(x) {
-    if (x == null) {
-        throw new Error("Option has no value");
-    }
-    else {
-        return x instanceof Some ? x.value : x;
-    }
-}
-function unwrap(opt) {
-    return opt instanceof Some ? opt.value : opt;
-}
-function some(x) {
-    return x == null || x instanceof Some ? new Some(x) : x;
-}
-function ofNullable(x) {
-    // This will fail with unit probably, an alternative would be:
-    // return x === null ? undefined : (x === undefined ? new Some(x) : x);
-    return x == null ? undefined : x;
-}
-function toNullable(x) {
-    return x == null ? null : value(x);
-}
-function flatten(x) {
-    return x == null ? undefined : value(x);
-}
-function toArray(opt) {
-    return (opt == null) ? [] : [value(opt)];
-}
-function defaultArg(opt, defaultValue) {
-    return (opt != null) ? value(opt) : defaultValue;
-}
-function defaultArgWith(opt, defThunk) {
-    return (opt != null) ? value(opt) : defThunk();
-}
-function orElse(opt, ifNone) {
-    return opt == null ? ifNone : opt;
-}
-function orElseWith(opt, ifNoneThunk) {
-    return opt == null ? ifNoneThunk() : opt;
-}
-function filter(predicate, opt) {
-    return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;
-}
-function map(mapping, opt) {
-    return (opt != null) ? some(mapping(value(opt))) : undefined;
-}
-function map2(mapping, opt1, opt2) {
-    return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;
-}
-function map3(mapping, opt1, opt2, opt3) {
-    return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;
-}
-function bind(binder, opt) {
-    return opt != null ? binder(value(opt)) : undefined;
-}
-function tryOp(op, arg) {
-    try {
-        return some(op(arg));
-    }
-    catch {
-        return undefined;
-    }
-}
-
-export { Some, bind, defaultArg, defaultArgWith, filter, flatten, map, map2, map3, ofNullable, orElse, orElseWith, some, toArray, toNullable, tryOp, unwrap, value };

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

@@ -1,48 +0,0 @@
-import { compare } from './Util.js';
-import { delay, unfold } from './Seq.js';
-import { fromZero, op_Addition, toInt64, toUInt64 } from './BigInt.js';
-import { fromParts, op_Addition as op_Addition$1 } from './Decimal.js';
-
-function makeRangeStepFunction(step, stop, zero, add) {
-    const stepComparedWithZero = compare(step, zero) | 0;
-    if (stepComparedWithZero === 0) {
-        throw new Error("The step of a range cannot be zero");
-    }
-    const stepGreaterThanZero = stepComparedWithZero > 0;
-    return (x) => {
-        const comparedWithLast = compare(x, stop) | 0;
-        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? [x, add(x, step)] : undefined;
-    };
-}
-function integralRangeStep(start, step, stop, zero, add) {
-    const stepFn = makeRangeStepFunction(step, stop, zero, add);
-    return delay(() => unfold(stepFn, start));
-}
-function rangeBigInt(start, step, stop) {
-    return integralRangeStep(start, step, stop, fromZero(), op_Addition);
-}
-function rangeDecimal(start, step, stop) {
-    return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition$1);
-}
-function rangeDouble(start, step, stop) {
-    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));
-}
-function rangeInt64(start, step, stop) {
-    return integralRangeStep(start, step, stop, 0n, (x, y) => toInt64(op_Addition(x, y)));
-}
-function rangeUInt64(start, step, stop) {
-    return integralRangeStep(start, step, stop, 0n, (x, y) => toUInt64(op_Addition(x, y)));
-}
-function rangeChar(start, stop) {
-    const intStop = ~~stop.charCodeAt(0) | 0;
-    return delay(() => unfold((c) => {
-        if (c <= intStop) {
-            return [String.fromCharCode(c), c + 1];
-        }
-        else {
-            return undefined;
-        }
-    }, ~~start.charCodeAt(0)));
-}
-
-export { integralRangeStep, makeRangeStepFunction, rangeBigInt, rangeChar, rangeDecimal, rangeDouble, rangeInt64, rangeUInt64 };

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

@@ -1,465 +0,0 @@
-import { Union, Record } from './Types.js';
-import { stringHash, combineHashCodes, equalArraysWith } from './Util.js';
-import './Decimal.js';
-import { Big } from './lib/big.js';
-
-class CaseInfo {
-    constructor(declaringType, tag, name, fields) {
-        this.declaringType = declaringType;
-        this.tag = tag;
-        this.name = name;
-        this.fields = fields;
-    }
-}
-class MethodInfo {
-    constructor(name, parameters, returnType) {
-        this.name = name;
-        this.parameters = parameters;
-        this.returnType = returnType;
-    }
-}
-class TypeInfo {
-    constructor(fullname, generics, construct, parent, fields, cases, enumCases) {
-        this.fullname = fullname;
-        this.generics = generics;
-        this.construct = construct;
-        this.parent = parent;
-        this.fields = fields;
-        this.cases = cases;
-        this.enumCases = enumCases;
-    }
-    toString() {
-        return fullName(this);
-    }
-    GetHashCode() {
-        return getHashCode(this);
-    }
-    Equals(other) {
-        return equals(this, other);
-    }
-}
-class GenericParameter extends TypeInfo {
-    constructor(name) {
-        super(name);
-    }
-}
-function getGenerics(t) {
-    return t.generics != null ? t.generics : [];
-}
-function getHashCode(t) {
-    const fullnameHash = stringHash(t.fullname);
-    const genHashes = getGenerics(t).map(getHashCode);
-    return combineHashCodes([fullnameHash, ...genHashes]);
-}
-function equals(t1, t2) {
-    if (t1.fullname === "") { // Anonymous records
-        return t2.fullname === ""
-            && equalArraysWith(getRecordElements(t1), getRecordElements(t2), ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2));
-    }
-    else {
-        return t1.fullname === t2.fullname
-            && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);
-    }
-}
-function class_type(fullname, generics, construct, parent) {
-    return new TypeInfo(fullname, generics, construct, parent);
-}
-function record_type(fullname, generics, construct, fields) {
-    return new TypeInfo(fullname, generics, construct, undefined, fields);
-}
-function anonRecord_type(...fields) {
-    return new TypeInfo("", undefined, undefined, undefined, () => fields);
-}
-function union_type(fullname, generics, construct, cases) {
-    const t = new TypeInfo(fullname, generics, construct, undefined, undefined, () => {
-        const caseNames = construct.prototype.cases();
-        return cases().map((fields, i) => new CaseInfo(t, i, caseNames[i], fields));
-    });
-    return t;
-}
-function tuple_type(...generics) {
-    return new TypeInfo("System.Tuple`" + generics.length, generics);
-}
-function delegate_type(...generics) {
-    return new TypeInfo("System.Func`" + generics.length, generics);
-}
-function lambda_type(argType, returnType) {
-    return new TypeInfo("Microsoft.FSharp.Core.FSharpFunc`2", [argType, returnType]);
-}
-function option_type(generic) {
-    return new TypeInfo("Microsoft.FSharp.Core.FSharpOption`1", [generic]);
-}
-function list_type(generic) {
-    return new TypeInfo("Microsoft.FSharp.Collections.FSharpList`1", [generic]);
-}
-function array_type(generic) {
-    return new TypeInfo("[]", [generic]);
-}
-function enum_type(fullname, underlyingType, enumCases) {
-    return new TypeInfo(fullname, [underlyingType], undefined, undefined, undefined, undefined, enumCases);
-}
-function measure_type(fullname) {
-    return new TypeInfo(fullname);
-}
-function generic_type(name) {
-    return new GenericParameter(name);
-}
-const obj_type = new TypeInfo("System.Object");
-const unit_type = new TypeInfo("Microsoft.FSharp.Core.Unit");
-const char_type = new TypeInfo("System.Char");
-const string_type = new TypeInfo("System.String");
-const bool_type = new TypeInfo("System.Boolean");
-const int8_type = new TypeInfo("System.SByte");
-const uint8_type = new TypeInfo("System.Byte");
-const int16_type = new TypeInfo("System.Int16");
-const uint16_type = new TypeInfo("System.UInt16");
-const int32_type = new TypeInfo("System.Int32");
-const uint32_type = new TypeInfo("System.UInt32");
-const int64_type = new TypeInfo("System.Int64");
-const uint64_type = new TypeInfo("System.UInt64");
-const int128_type = new TypeInfo("System.Int128");
-const uint128_type = new TypeInfo("System.UInt128");
-const nativeint_type = new TypeInfo("System.IntPtr");
-const unativeint_type = new TypeInfo("System.UIntPtr");
-const float16_type = new TypeInfo("System.Half");
-const float32_type = new TypeInfo("System.Single");
-const float64_type = new TypeInfo("System.Double");
-const decimal_type = new TypeInfo("System.Decimal");
-const bigint_type = new TypeInfo("System.Numerics.BigInteger");
-function name(info) {
-    if (Array.isArray(info)) {
-        return info[0];
-    }
-    else if (info instanceof TypeInfo) {
-        const elemType = getElementType(info);
-        if (elemType != null) {
-            return name(elemType) + "[]";
-        }
-        else {
-            const i = info.fullname.lastIndexOf(".");
-            return i === -1 ? info.fullname : info.fullname.substr(i + 1);
-        }
-    }
-    else {
-        return info.name;
-    }
-}
-function fullName(t) {
-    const elemType = getElementType(t);
-    if (elemType != null) {
-        return fullName(elemType) + "[]";
-    }
-    else if (t.generics == null || t.generics.length === 0) {
-        return t.fullname;
-    }
-    else {
-        return t.fullname + "[" + t.generics.map((x) => fullName(x)).join(",") + "]";
-    }
-}
-function namespace(t) {
-    const elemType = getElementType(t);
-    if (elemType != null) {
-        return namespace(elemType);
-    }
-    else {
-        const i = t.fullname.lastIndexOf(".");
-        return i === -1 ? "" : t.fullname.substr(0, i);
-    }
-}
-function isArray(t) {
-    return getElementType(t) != null;
-}
-function getElementType(t) {
-    return t.fullname === "[]" && t.generics?.length === 1 ? t.generics[0] : undefined;
-}
-function isGenericType(t) {
-    return t.generics != null && t.generics.length > 0;
-}
-function isGenericParameter(t) {
-    return t instanceof GenericParameter;
-}
-function isEnum(t) {
-    return t.enumCases != null && t.enumCases.length > 0;
-}
-function isSubclassOf(t1, t2) {
-    return (t2.fullname === obj_type.fullname) || (t1.parent != null && (t1.parent.Equals(t2) || isSubclassOf(t1.parent, t2)));
-}
-function isErasedToNumber(t) {
-    return isEnum(t) || [
-        int8_type.fullname,
-        uint8_type.fullname,
-        int16_type.fullname,
-        uint16_type.fullname,
-        int32_type.fullname,
-        uint32_type.fullname,
-        float16_type.fullname,
-        float32_type.fullname,
-        float64_type.fullname,
-    ].includes(t.fullname);
-}
-function isErasedToBigInt(t) {
-    return isEnum(t) || [
-        int64_type.fullname,
-        uint64_type.fullname,
-        int128_type.fullname,
-        uint128_type.fullname,
-        nativeint_type.fullname,
-        unativeint_type.fullname,
-        bigint_type.fullname,
-    ].includes(t.fullname);
-}
-function isInstanceOfType(t, o) {
-    if (t.fullname === obj_type.fullname)
-        return true;
-    switch (typeof o) {
-        case "boolean":
-            return t.fullname === bool_type.fullname;
-        case "string":
-            return t.fullname === string_type.fullname;
-        case "function":
-            return isFunction(t);
-        case "number":
-            return isErasedToNumber(t);
-        case "bigint":
-            return isErasedToBigInt(t);
-        default:
-            return t.construct != null && o instanceof t.construct;
-    }
-}
-/**
- * This doesn't replace types for fields (records) or cases (unions)
- * but it should be enough for type comparison purposes
- */
-function getGenericTypeDefinition(t) {
-    return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));
-}
-function getEnumUnderlyingType(t) {
-    return t.generics?.[0];
-}
-function getEnumValues(t) {
-    if (isEnum(t) && t.enumCases != null) {
-        return t.enumCases.map((kv) => kv[1]);
-    }
-    else {
-        throw new Error(`${t.fullname} is not an enum type`);
-    }
-}
-function getEnumNames(t) {
-    if (isEnum(t) && t.enumCases != null) {
-        return t.enumCases.map((kv) => kv[0]);
-    }
-    else {
-        throw new Error(`${t.fullname} is not an enum type`);
-    }
-}
-function getEnumCase(t, v) {
-    if (t.enumCases != null) {
-        if (typeof v === "string") {
-            for (const kv of t.enumCases) {
-                if (kv[0] === v) {
-                    return kv;
-                }
-            }
-            throw new Error(`'${v}' was not found in ${t.fullname}`);
-        }
-        else {
-            for (const kv of t.enumCases) {
-                if (kv[1] === v) {
-                    return kv;
-                }
-            }
-            // .NET returns the number even if it doesn't match any of the cases
-            return ["", v];
-        }
-    }
-    else {
-        throw new Error(`${t.fullname} is not an enum type`);
-    }
-}
-function parseEnum(t, str) {
-    // TODO: better int parsing here, parseInt ceils floats: "4.8" -> 4
-    const value = parseInt(str, 10);
-    return getEnumCase(t, isNaN(value) ? str : value)[1];
-}
-function tryParseEnum(t, str, defValue) {
-    try {
-        defValue.contents = parseEnum(t, str);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function getEnumName(t, v) {
-    return getEnumCase(t, v)[0];
-}
-function isEnumDefined(t, v) {
-    try {
-        const kv = getEnumCase(t, v);
-        return kv[0] != null && kv[0] !== "";
-    }
-    catch {
-        // supress error
-    }
-    return false;
-}
-// FSharpType
-function getUnionCases(t) {
-    if (t.cases != null) {
-        return t.cases();
-    }
-    else {
-        throw new Error(`${t.fullname} is not an F# union type`);
-    }
-}
-function getRecordElements(t) {
-    if (t.fields != null) {
-        return t.fields();
-    }
-    else {
-        throw new Error(`${t.fullname} is not an F# record type`);
-    }
-}
-function getTupleElements(t) {
-    if (isTuple(t) && t.generics != null) {
-        return t.generics;
-    }
-    else {
-        throw new Error(`${t.fullname} is not a tuple type`);
-    }
-}
-function getFunctionElements(t) {
-    if (isFunction(t) && t.generics != null) {
-        const gen = t.generics;
-        return [gen[0], gen[1]];
-    }
-    else {
-        throw new Error(`${t.fullname} is not an F# function type`);
-    }
-}
-function isUnion(t) {
-    return t instanceof TypeInfo ? t.cases != null : t instanceof Union;
-}
-function isRecord(t) {
-    return t instanceof TypeInfo ? t.fields != null : t instanceof Record;
-}
-function isTuple(t) {
-    return t.fullname.startsWith("System.Tuple");
-}
-// In .NET this is false for delegates
-function isFunction(t) {
-    return t.fullname === "Microsoft.FSharp.Core.FSharpFunc`2";
-}
-// FSharpValue
-function getUnionFields(v, t) {
-    const cases = getUnionCases(t);
-    const case_ = cases[v.tag];
-    if (case_ == null) {
-        throw new Error(`Cannot find case ${v.name} in union type`);
-    }
-    return [case_, v.fields];
-}
-function getUnionCaseFields(uci) {
-    return uci.fields == null ? [] : uci.fields;
-}
-// This is used as replacement of `FSharpValue.GetRecordFields`
-// For `FSharpTypes.GetRecordFields` see `getRecordElements`
-// Object.keys returns keys in the order they were added to the object
-function getRecordFields(v) {
-    return Object.keys(v).map((k) => v[k]);
-}
-function getRecordField(v, field) {
-    return v[field[0]];
-}
-function getTupleFields(v) {
-    return v;
-}
-function getTupleField(v, i) {
-    return v[i];
-}
-function makeUnion(uci, values) {
-    const expectedLength = (uci.fields || []).length;
-    if (values.length !== expectedLength) {
-        throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);
-    }
-    const construct = uci.declaringType.construct;
-    if (construct == null) {
-        return {};
-    }
-    const isSingleCase = uci.declaringType.cases ? uci.declaringType.cases().length == 1 : false;
-    if (isSingleCase) {
-        return new construct(...values);
-    }
-    else {
-        return new construct(uci.tag, values);
-    }
-}
-function makeRecord(t, values) {
-    const fields = getRecordElements(t);
-    if (fields.length !== values.length) {
-        throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);
-    }
-    return t.construct != null
-        ? new t.construct(...values)
-        : fields.reduce((obj, [key, _t], i) => {
-            obj[key] = values[i];
-            return obj;
-        }, {});
-}
-function makeTuple(values, _t) {
-    return values;
-}
-function makeGenericType(t, generics) {
-    return new TypeInfo(t.fullname, generics, t.construct, t.parent, t.fields, t.cases);
-}
-function createInstance(t, consArgs) {
-    // TODO: Check if consArgs length is same as t.construct?
-    // (Arg types can still be different)
-    if (typeof t.construct === "function") {
-        return new t.construct(...(consArgs ?? []));
-    }
-    else if (isErasedToNumber(t)) {
-        return 0;
-    }
-    else if (isErasedToBigInt(t)) {
-        return 0n;
-    }
-    else {
-        switch (t.fullname) {
-            case obj_type.fullname:
-                return {};
-            case bool_type.fullname:
-                return false;
-            case decimal_type.fullname:
-                return new Big(0);
-            case char_type.fullname:
-                // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null
-                return null;
-            default:
-                throw new Error(`Cannot access constructor of ${t.fullname}`);
-        }
-    }
-}
-function getValue(propertyInfo, v) {
-    return v[propertyInfo[0]];
-}
-// Fable.Core.Reflection
-function assertUnion(x) {
-    if (!(x instanceof Union)) {
-        throw new Error(`Value is not an F# union type`);
-    }
-}
-function getCaseTag(x) {
-    assertUnion(x);
-    return x.tag;
-}
-function getCaseName(x) {
-    assertUnion(x);
-    return x.cases()[x.tag];
-}
-function getCaseFields(x) {
-    assertUnion(x);
-    return x.fields;
-}
-
-export { CaseInfo, GenericParameter, MethodInfo, TypeInfo, anonRecord_type, array_type, bigint_type, bool_type, char_type, class_type, createInstance, decimal_type, delegate_type, enum_type, equals, float16_type, float32_type, float64_type, fullName, generic_type, getCaseFields, getCaseName, getCaseTag, getElementType, getEnumName, getEnumNames, getEnumUnderlyingType, getEnumValues, getFunctionElements, getGenericTypeDefinition, getGenerics, getHashCode, getRecordElements, getRecordField, getRecordFields, getTupleElements, getTupleField, getTupleFields, getUnionCaseFields, getUnionCases, getUnionFields, getValue, int128_type, int16_type, int32_type, int64_type, int8_type, isArray, isEnum, isEnumDefined, isFunction, isGenericParameter, isGenericType, isInstanceOfType, isRecord, isSubclassOf, isTuple, isUnion, lambda_type, list_type, makeGenericType, makeRecord, makeTuple, makeUnion, measure_type, name, namespace, nativeint_type, obj_type, option_type, parseEnum, record_type, string_type, tryParseEnum, tuple_type, uint128_type, uint16_type, uint32_type, uint64_type, uint8_type, unativeint_type, union_type, unit_type };