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

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

@@ -1,3 +1,4 @@
+import { equals } from './Util.js';
 import { Union } from './Types.js';
 
 const CaseRules = {
@@ -73,6 +74,15 @@ function keyValueList(fields, caseRule = CaseRules.None) {
     }
     return obj;
 }
+// TODO: Move these methods to Map and Set modules
+function containsValue(v, map) {
+    for (const kv of map) {
+        if (equals(v, kv[1])) {
+            return true;
+        }
+    }
+    return false;
+}
 function tryGetValue(map, key, defaultValue) {
     if (map.has(key)) {
         defaultValue.contents = map.get(key);
@@ -87,6 +97,13 @@ function addToSet(v, set) {
     set.add(v);
     return true;
 }
+function tryAddToDict(dict, k, v) {
+    if (dict.has(k)) {
+        return false;
+    }
+    dict.set(k, v);
+    return true;
+}
 function addToDict(dict, k, v) {
     if (dict.has(k)) {
         throw new Error("An item with the same key has already been added. Key: " + k);
@@ -101,5 +118,13 @@ function getItemFromDict(map, key) {
         throw new Error(`The given key '${key}' was not present in the dictionary.`);
     }
 }
+function getItemFromDictOrCreate(map, key, createValue) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    const value = createValue(key);
+    map.set(key, value);
+    return value;
+}
 
-export { addToDict, addToSet, getItemFromDict, keyValueList, tryGetValue };
+export { addToDict, addToSet, containsValue, getItemFromDict, getItemFromDictOrCreate, keyValueList, tryAddToDict, tryGetValue };

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

@@ -1,9 +1,10 @@
-import { getEnumerator, disposeSafe, toIterator, equals, defaultOf } from './Util.js';
-import { concat, iterateIndexed, toArray, map, iterate, delay } from './Seq.js';
+import { defaultOf, getEnumerator, disposeSafe, toIterator, equals } from './Util.js';
+import { concat, iterateIndexed, toArray, delay, map, iterate } from './Seq.js';
 import { value } from './Option.js';
 import { setItem } from './Array.js';
 import { FSharpRef } from './Types.js';
-import { getItemFromDict, tryGetValue } from './MapUtil.js';
+import { class_type } from './Reflection.js';
+import { tryGetValue, getItemFromDict } from './MapUtil.js';
 import { format } from './String.js';
 
 class Dictionary {
@@ -53,11 +54,11 @@ class Dictionary {
     "System.Collections.Generic.ICollection`1.Contains2B595"(item) {
         const this$ = this;
         const matchValue = Dictionary__TryFind_2B595(this$, item[0]);
-        let matchResult;
+        let matchResult, p_1;
         if (matchValue != null) {
             if (equals(value(matchValue)[1], item[1])) {
                 matchResult = 0;
-                value(matchValue);
+                p_1 = value(matchValue);
             }
             else {
                 matchResult = 1;
@@ -183,6 +184,12 @@ class Dictionary {
         }, this$);
     }
 }
+function Dictionary_$reflection(gen0, gen1) {
+    return class_type("Fable.Collections.Dictionary", [gen0, gen1], Dictionary);
+}
+function Dictionary_$ctor_6623D9B3(pairs, comparer) {
+    return new Dictionary(pairs, comparer);
+}
 function Dictionary__TryFindIndex_2B595(this$, k) {
     const h = this$.comparer.GetHashCode(k) | 0;
     let matchValue;
@@ -218,6 +225,9 @@ function Dictionary__TryFind_2B595(this$, k) {
             return undefined;
     }
 }
+function Dictionary__get_Comparer(this$) {
+    return this$.comparer;
+}
 function Dictionary__Clear(this$) {
     this$.hashMap.clear();
 }
@@ -251,7 +261,7 @@ function Dictionary__set_Item_5BDDA1(this$, k, v) {
             getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];
         }
         else {
-            void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
         }
     }
     else {
@@ -265,7 +275,7 @@ function Dictionary__Add_5BDDA1(this$, k, v) {
             throw new Error(format("An item with the same key has already been added. Key: {0}", k));
         }
         else {
-            void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
         }
     }
     else {
@@ -317,4 +327,4 @@ function Dictionary__Remove_2B595(this$, k) {
     }
 }
 
-export { Dictionary, Dictionary__Add_5BDDA1, Dictionary__Clear, Dictionary__ContainsKey_2B595, Dictionary__Remove_2B595, Dictionary__TryFind_2B595, Dictionary__get_Count, Dictionary__get_Item_2B595, Dictionary__set_Item_5BDDA1 };
+export { Dictionary, Dictionary_$ctor_6623D9B3, Dictionary_$reflection, Dictionary__Add_5BDDA1, Dictionary__Clear, Dictionary__ContainsKey_2B595, Dictionary__Remove_2B595, Dictionary__TryFind_2B595, Dictionary__get_Comparer, Dictionary__get_Count, Dictionary__get_Item_2B595, Dictionary__set_Item_5BDDA1 };

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

@@ -1,8 +1,10 @@
-import { getEnumerator, disposeSafe, toIterator, defaultOf } from './Util.js';
+import { defaultOf, getEnumerator, disposeSafe, toIterator } from './Util.js';
 import { concat, iterateIndexed, map, iterate } from './Seq.js';
 import { setItem } from './Array.js';
+import { some } from './Option.js';
 import { FSharpRef } from './Types.js';
-import { getItemFromDict, tryGetValue } from './MapUtil.js';
+import { class_type } from './Reflection.js';
+import { tryGetValue, getItemFromDict } from './MapUtil.js';
 
 class HashSet {
     constructor(items, comparer) {
@@ -109,6 +111,12 @@ class HashSet {
         }, this$);
     }
 }
+function HashSet_$reflection(gen0) {
+    return class_type("Fable.Collections.HashSet", [gen0], HashSet);
+}
+function HashSet_$ctor_Z6150332D(items, comparer) {
+    return new HashSet(items, comparer);
+}
 function HashSet__TryFindIndex_2B595(this$, k) {
     const h = this$.comparer.GetHashCode(k) | 0;
     let matchValue;
@@ -123,6 +131,30 @@ function HashSet__TryFindIndex_2B595(this$, k) {
         return [false, h, -1];
     }
 }
+function HashSet__TryFind_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);
+        default:
+            return undefined;
+    }
+}
+function HashSet__get_Comparer(this$) {
+    return this$.comparer;
+}
 function HashSet__Clear(this$) {
     this$.hashMap.clear();
 }
@@ -147,7 +179,7 @@ function HashSet__Add_2B595(this$, k) {
             return false;
         }
         else {
-            void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
             return true;
         }
     }
@@ -201,4 +233,4 @@ function HashSet__Remove_2B595(this$, k) {
     }
 }
 
-export { HashSet, HashSet__Add_2B595, HashSet__Clear, HashSet__Contains_2B595, HashSet__Remove_2B595, HashSet__get_Count };
+export { HashSet, HashSet_$ctor_Z6150332D, HashSet_$reflection, HashSet__Add_2B595, HashSet__Clear, HashSet__Contains_2B595, HashSet__Remove_2B595, HashSet__get_Comparer, HashSet__get_Count };

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

@@ -46,6 +46,17 @@ function unwrap(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)];
 }
@@ -55,11 +66,34 @@ function defaultArg(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, map, some, toArray, unwrap, value };
+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,5 +1,7 @@
 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;
@@ -16,8 +18,31 @@ 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, rangeDouble };
+export { integralRangeStep, makeRangeStepFunction, rangeBigInt, rangeChar, rangeDecimal, rangeDouble, rangeInt64, rangeUInt64 };

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

@@ -1,4 +1,7 @@
+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) {
@@ -8,6 +11,13 @@ class CaseInfo {
         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;
@@ -28,6 +38,11 @@ class TypeInfo {
         return equals(this, other);
     }
 }
+class GenericParameter extends TypeInfo {
+    constructor(name) {
+        super(name);
+    }
+}
 function getGenerics(t) {
     return t.generics != null ? t.generics : [];
 }
@@ -49,6 +64,12 @@ function equals(t1, t2) {
 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();
@@ -56,7 +77,55 @@ function union_type(fullname, generics, construct, cases) {
     });
     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];
@@ -87,9 +156,153 @@ function fullName(t) {
         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) {
@@ -107,5 +320,146 @@ function getRecordElements(t) {
         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, TypeInfo, class_type, equals, fullName, getElementType, getGenerics, getHashCode, getRecordElements, getUnionCases, name, string_type, union_type };
+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 };