@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

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

@@ -1,461 +0,0 @@
-import { Record, Union } from "./Types.js";
-import { combineHashCodes, equalArraysWith, stringHash } from "./Util.js";
-import Decimal from "./Decimal.js";
-export class CaseInfo {
-    constructor(declaringType, tag, name, fields) {
-        this.declaringType = declaringType;
-        this.tag = tag;
-        this.name = name;
-        this.fields = fields;
-    }
-}
-export class MethodInfo {
-    constructor(name, parameters, returnType) {
-        this.name = name;
-        this.parameters = parameters;
-        this.returnType = returnType;
-    }
-}
-export 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);
-    }
-}
-export class GenericParameter extends TypeInfo {
-    constructor(name) {
-        super(name);
-    }
-}
-export function getGenerics(t) {
-    return t.generics != null ? t.generics : [];
-}
-export function getHashCode(t) {
-    const fullnameHash = stringHash(t.fullname);
-    const genHashes = getGenerics(t).map(getHashCode);
-    return combineHashCodes([fullnameHash, ...genHashes]);
-}
-export 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);
-    }
-}
-export function class_type(fullname, generics, construct, parent) {
-    return new TypeInfo(fullname, generics, construct, parent);
-}
-export function record_type(fullname, generics, construct, fields) {
-    return new TypeInfo(fullname, generics, construct, undefined, fields);
-}
-export function anonRecord_type(...fields) {
-    return new TypeInfo("", undefined, undefined, undefined, () => fields);
-}
-export 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;
-}
-export function tuple_type(...generics) {
-    return new TypeInfo("System.Tuple`" + generics.length, generics);
-}
-export function delegate_type(...generics) {
-    return new TypeInfo("System.Func`" + generics.length, generics);
-}
-export function lambda_type(argType, returnType) {
-    return new TypeInfo("Microsoft.FSharp.Core.FSharpFunc`2", [argType, returnType]);
-}
-export function option_type(generic) {
-    return new TypeInfo("Microsoft.FSharp.Core.FSharpOption`1", [generic]);
-}
-export function list_type(generic) {
-    return new TypeInfo("Microsoft.FSharp.Collections.FSharpList`1", [generic]);
-}
-export function array_type(generic) {
-    return new TypeInfo("[]", [generic]);
-}
-export function enum_type(fullname, underlyingType, enumCases) {
-    return new TypeInfo(fullname, [underlyingType], undefined, undefined, undefined, undefined, enumCases);
-}
-export function measure_type(fullname) {
-    return new TypeInfo(fullname);
-}
-export function generic_type(name) {
-    return new GenericParameter(name);
-}
-export const obj_type = new TypeInfo("System.Object");
-export const unit_type = new TypeInfo("Microsoft.FSharp.Core.Unit");
-export const char_type = new TypeInfo("System.Char");
-export const string_type = new TypeInfo("System.String");
-export const bool_type = new TypeInfo("System.Boolean");
-export const int8_type = new TypeInfo("System.SByte");
-export const uint8_type = new TypeInfo("System.Byte");
-export const int16_type = new TypeInfo("System.Int16");
-export const uint16_type = new TypeInfo("System.UInt16");
-export const int32_type = new TypeInfo("System.Int32");
-export const uint32_type = new TypeInfo("System.UInt32");
-export const int64_type = new TypeInfo("System.Int64");
-export const uint64_type = new TypeInfo("System.UInt64");
-export const int128_type = new TypeInfo("System.Int128");
-export const uint128_type = new TypeInfo("System.UInt128");
-export const nativeint_type = new TypeInfo("System.IntPtr");
-export const unativeint_type = new TypeInfo("System.UIntPtr");
-export const float16_type = new TypeInfo("System.Half");
-export const float32_type = new TypeInfo("System.Single");
-export const float64_type = new TypeInfo("System.Double");
-export const decimal_type = new TypeInfo("System.Decimal");
-export const bigint_type = new TypeInfo("System.Numerics.BigInteger");
-export 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;
-    }
-}
-export 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(",") + "]";
-    }
-}
-export 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);
-    }
-}
-export function isArray(t) {
-    return getElementType(t) != null;
-}
-export function getElementType(t) {
-    return t.fullname === "[]" && t.generics?.length === 1 ? t.generics[0] : undefined;
-}
-export function isGenericType(t) {
-    return t.generics != null && t.generics.length > 0;
-}
-export function isGenericParameter(t) {
-    return t instanceof GenericParameter;
-}
-export function isEnum(t) {
-    return t.enumCases != null && t.enumCases.length > 0;
-}
-export 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);
-}
-export 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
- */
-export function getGenericTypeDefinition(t) {
-    return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));
-}
-export function getEnumUnderlyingType(t) {
-    return t.generics?.[0];
-}
-export 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`);
-    }
-}
-export 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`);
-    }
-}
-export 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];
-}
-export function tryParseEnum(t, str, defValue) {
-    try {
-        defValue.contents = parseEnum(t, str);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function getEnumName(t, v) {
-    return getEnumCase(t, v)[0];
-}
-export function isEnumDefined(t, v) {
-    try {
-        const kv = getEnumCase(t, v);
-        return kv[0] != null && kv[0] !== "";
-    }
-    catch {
-        // supress error
-    }
-    return false;
-}
-// FSharpType
-export function getUnionCases(t) {
-    if (t.cases != null) {
-        return t.cases();
-    }
-    else {
-        throw new Error(`${t.fullname} is not an F# union type`);
-    }
-}
-export function getRecordElements(t) {
-    if (t.fields != null) {
-        return t.fields();
-    }
-    else {
-        throw new Error(`${t.fullname} is not an F# record type`);
-    }
-}
-export function getTupleElements(t) {
-    if (isTuple(t) && t.generics != null) {
-        return t.generics;
-    }
-    else {
-        throw new Error(`${t.fullname} is not a tuple type`);
-    }
-}
-export 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`);
-    }
-}
-export function isUnion(t) {
-    return t instanceof TypeInfo ? t.cases != null : t instanceof Union;
-}
-export function isRecord(t) {
-    return t instanceof TypeInfo ? t.fields != null : t instanceof Record;
-}
-export function isTuple(t) {
-    return t.fullname.startsWith("System.Tuple");
-}
-// In .NET this is false for delegates
-export function isFunction(t) {
-    return t.fullname === "Microsoft.FSharp.Core.FSharpFunc`2";
-}
-// FSharpValue
-export 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];
-}
-export 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
-export function getRecordFields(v) {
-    return Object.keys(v).map((k) => v[k]);
-}
-export function getRecordField(v, field) {
-    return v[field[0]];
-}
-export function getTupleFields(v) {
-    return v;
-}
-export function getTupleField(v, i) {
-    return v[i];
-}
-export 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);
-    }
-}
-export 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;
-        }, {});
-}
-export function makeTuple(values, _t) {
-    return values;
-}
-export function makeGenericType(t, generics) {
-    return new TypeInfo(t.fullname, generics, t.construct, t.parent, t.fields, t.cases);
-}
-export 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 Decimal(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}`);
-        }
-    }
-}
-export 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`);
-    }
-}
-export function getCaseTag(x) {
-    assertUnion(x);
-    return x.tag;
-}
-export function getCaseName(x) {
-    assertUnion(x);
-    return x.cases()[x.tag];
-}
-export function getCaseFields(x) {
-    assertUnion(x);
-    return x.fields;
-}

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

@@ -1,10 +0,0 @@
-export type MatchEvaluator = (match: any) => string;
-export declare function create(pattern: string, options?: number): RegExp;
-export declare function escape(str: string): string;
-export declare function unescape(str: string): string;
-export declare function isMatch(reg: RegExp, input: string, startAt?: number): boolean;
-export declare function match(reg: RegExp, input: string, startAt?: number): RegExpExecArray | null;
-export declare function matches(reg: RegExp, input: string, startAt?: number): RegExpExecArray[];
-export declare function options(reg: RegExp): number;
-export declare function replace(reg: string | RegExp, input: string, replacement: string | MatchEvaluator, limit?: number, offset?: number): string;
-export declare function split(reg: string | RegExp, input: string, limit?: number, offset?: number): string[];

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

@@ -1,131 +0,0 @@
-export function create(pattern, options = 0) {
-    // Supported RegexOptions
-    // * IgnoreCase:  0x0001
-    // * Multiline:   0x0002
-    // * Compiled:    0x0008 (ignored)
-    // * Singleline:  0x0010
-    // * ECMAScript:  0x0100 (ignored)
-    if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
-        throw new Error("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
-    }
-    // Set always global and unicode flags for compatibility with dotnet, see #2925
-    let flags = "gu";
-    flags += options & 1 ? "i" : ""; // 0x0001 RegexOptions.IgnoreCase
-    flags += options & 2 ? "m" : "";
-    flags += options & 16 ? "s" : "";
-    return new RegExp(pattern, flags);
-}
-// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
-export function escape(str) {
-    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
-}
-export function unescape(str) {
-    return str.replace(/\\([\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|])/g, "$1");
-}
-export function isMatch(reg, input, startAt = 0) {
-    reg.lastIndex = startAt;
-    return reg.test(input);
-}
-export function match(reg, input, startAt = 0) {
-    reg.lastIndex = startAt;
-    return reg.exec(input);
-}
-export function matches(reg, input, startAt = 0) {
-    if (input == null) {
-        throw new Error("Input cannot ve null");
-    }
-    if (!reg.global) {
-        throw new Error("Non-global RegExp"); // Prevent infinite loop
-    }
-    reg.lastIndex = startAt;
-    const matches = [];
-    let m;
-    let lastMatchIndex = -1;
-    while ((m = reg.exec(input)) != null) {
-        // It can happen even global regex get stuck, see #2845
-        if (m.index === lastMatchIndex) {
-            reg.lastIndex++;
-        }
-        else {
-            lastMatchIndex = m.index;
-            matches.push(m);
-        }
-    }
-    return matches;
-}
-export function options(reg) {
-    let options = 256; // ECMAScript
-    options |= reg.ignoreCase ? 1 : 0;
-    options |= reg.multiline ? 2 : 0;
-    return options;
-}
-export function replace(reg, input, replacement, limit, offset = 0) {
-    function replacer() {
-        let res = arguments[0];
-        if (limit) {
-            limit--;
-            const match = [];
-            const len = arguments.length;
-            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter
-            // * match: matched substring
-            // * p1, p2, ...: nth capture group string
-            // * offset: offset of matched substring
-            // * string: whole string examined
-            // * groups: named capturing groups
-            //           ONLY if regex contains a named capture group AND browser supports named groups
-            // -> last element can be groups OR input string
-            // -> check if last element is string
-            const withGroups = typeof arguments[len - 1] !== "string";
-            let pLast = withGroups ? len - 3 : len - 2;
-            for (let i = 0; i < pLast; i++) {
-                match.push(arguments[i]);
-            }
-            match.index = arguments[pLast++];
-            match.input = arguments[pLast++];
-            if (withGroups) {
-                match.groups = arguments[pLast];
-            }
-            res = replacement(match);
-        }
-        return res;
-    }
-    if (typeof reg === "string") {
-        const tmp = reg;
-        reg = create(input, limit ?? 0);
-        input = tmp;
-        limit = undefined;
-    }
-    if (typeof replacement === "function") {
-        limit = limit == null ? -1 : limit;
-        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
-    }
-    else {
-        replacement =
-            replacement
-                // $0 doesn't work with JS regex, see #1155
-                .replace(/\$0/g, (_s) => "$&")
-                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)
-                .replace(/\${([^}]+)}/g, "\$<$1>");
-        if (limit != null) {
-            let m;
-            const sub1 = input.substring(offset);
-            const _matches = matches(reg, sub1);
-            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;
-            return input.substring(0, offset) + sub2.replace(reg, replacement)
-                + input.substring(offset + sub2.length);
-        }
-        else {
-            return input.replace(reg, replacement);
-        }
-    }
-}
-export function split(reg, input, limit, offset = 0) {
-    if (typeof reg === "string") {
-        const tmp = reg;
-        reg = create(input, limit ?? 0);
-        input = tmp;
-        limit = undefined;
-    }
-    input = input.substring(offset);
-    return input.split(reg, limit);
-}

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

@@ -1,37 +0,0 @@
-import { Union } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-import { int32 } from "./Int32.js";
-import { FSharpList } from "./List.js";
-import { Option } from "./Option.js";
-export type FSharpResult$2_$union<T, TError> = FSharpResult$2<T, TError, 0> | FSharpResult$2<T, TError, 1>;
-export type FSharpResult$2_$cases<T, TError> = {
-    0: ["Ok", [T]];
-    1: ["Error", [TError]];
-};
-export declare function FSharpResult$2_Ok<T, TError>(ResultValue: T): FSharpResult$2<T, TError, 0>;
-export declare function FSharpResult$2_Error<T, TError>(ErrorValue: TError): FSharpResult$2<T, TError, 1>;
-export declare class FSharpResult$2<T, TError, Tag extends keyof FSharpResult$2_$cases<T, TError>> extends Union<Tag, FSharpResult$2_$cases<T, TError>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpResult$2_$cases<T, TError>[Tag][1];
-    constructor(tag: Tag, fields: FSharpResult$2_$cases<T, TError>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpResult$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function Result_Map<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
-export declare function Result_MapError<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<c, a>): FSharpResult$2_$union<c, b>;
-export declare function Result_Bind<a, b, c>(binder: ((arg0: a) => FSharpResult$2_$union<b, c>), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
-export declare function Result_IsOk<a, b>(result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_IsError<a, b>(result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Contains<a, b>(value: a, result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Count<a, b>(result: FSharpResult$2_$union<a, b>): int32;
-export declare function Result_DefaultValue<a, b>(defaultValue: a, result: FSharpResult$2_$union<a, b>): a;
-export declare function Result_DefaultWith<b, a>(defThunk: ((arg0: b) => a), result: FSharpResult$2_$union<a, b>): a;
-export declare function Result_Exists<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Fold<a, b, s>(folder: ((arg0: s, arg1: a) => s), state: s, result: FSharpResult$2_$union<a, b>): s;
-export declare function Result_FoldBack<a, b, s>(folder: ((arg0: a, arg1: s) => s), result: FSharpResult$2_$union<a, b>, state: s): s;
-export declare function Result_ForAll<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Iterate<a, b>(action: ((arg0: a) => void), result: FSharpResult$2_$union<a, b>): void;
-export declare function Result_ToArray<a, b>(result: FSharpResult$2_$union<a, b>): a[];
-export declare function Result_ToList<a, b>(result: FSharpResult$2_$union<a, b>): FSharpList<a>;
-export declare function Result_ToOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a>;
-export declare function Result_ToValueOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a>;