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

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

@@ -0,0 +1,655 @@
+import { value, some } from './Option.js';
+import { isArrayLike, getEnumerator, disposeSafe, equals, toIterator, structuralHash, compare } from './Util.js';
+import { FSharpList, fold, singleton, isEmpty, head, tail, ofArrayWithTail, empty as empty$1 } from './List.js';
+import { item, setItem } from './Array.js';
+import { Record } from './Types.js';
+import { map, compareWith, iterate } from './Seq.js';
+import { join, format } from './String.js';
+
+class MapTreeLeaf$2 {
+    constructor(k, v) {
+        this.k = k;
+        this.v = v;
+    }
+}
+function MapTreeLeaf$2_$ctor_5BDDA1(k, v) {
+    return new MapTreeLeaf$2(k, v);
+}
+function MapTreeLeaf$2__get_Key(_) {
+    return _.k;
+}
+function MapTreeLeaf$2__get_Value(_) {
+    return _.v;
+}
+class MapTreeNode$2 extends MapTreeLeaf$2 {
+    constructor(k, v, left, right, h) {
+        super(k, v);
+        this.left = left;
+        this.right = right;
+        this.h = (h | 0);
+    }
+}
+function MapTreeNode$2_$ctor_Z39DE9543(k, v, left, right, h) {
+    return new MapTreeNode$2(k, v, left, right, h);
+}
+function MapTreeNode$2__get_Left(_) {
+    return _.left;
+}
+function MapTreeNode$2__get_Right(_) {
+    return _.right;
+}
+function MapTreeNode$2__get_Height(_) {
+    return _.h;
+}
+function MapTreeModule_empty() {
+    return undefined;
+}
+function MapTreeModule_sizeAux(acc_mut, m_mut) {
+    MapTreeModule_sizeAux: while (true) {
+        const acc = acc_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                acc_mut = MapTreeModule_sizeAux(acc + 1, MapTreeNode$2__get_Left(mn));
+                m_mut = MapTreeNode$2__get_Right(mn);
+                continue MapTreeModule_sizeAux;
+            }
+            else {
+                return (acc + 1) | 0;
+            }
+        }
+        else {
+            return acc | 0;
+        }
+    }
+}
+function MapTreeModule_size(x) {
+    return MapTreeModule_sizeAux(0, x);
+}
+function MapTreeModule_mk(l, k, v, r) {
+    let mn, mn_1;
+    let hl;
+    const m = l;
+    if (m != null) {
+        const m2 = value(m);
+        hl = ((m2 instanceof MapTreeNode$2) ? ((mn = m2, MapTreeNode$2__get_Height(mn))) : 1);
+    }
+    else {
+        hl = 0;
+    }
+    let hr;
+    const m_1 = r;
+    if (m_1 != null) {
+        const m2_1 = value(m_1);
+        hr = ((m2_1 instanceof MapTreeNode$2) ? ((mn_1 = m2_1, MapTreeNode$2__get_Height(mn_1))) : 1);
+    }
+    else {
+        hr = 0;
+    }
+    const m_2 = ((hl < hr) ? hr : hl) | 0;
+    if (m_2 === 0) {
+        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);
+    }
+    else {
+        return MapTreeNode$2_$ctor_Z39DE9543(k, v, l, r, m_2 + 1);
+    }
+}
+function MapTreeModule_rebalance(t1, k, v, t2) {
+    let mn, mn_1, m_2, m2_2, mn_2, m_3, m2_3, mn_3;
+    let t1h;
+    const m = t1;
+    if (m != null) {
+        const m2 = value(m);
+        t1h = ((m2 instanceof MapTreeNode$2) ? ((mn = m2, MapTreeNode$2__get_Height(mn))) : 1);
+    }
+    else {
+        t1h = 0;
+    }
+    let t2h;
+    const m_1 = t2;
+    if (m_1 != null) {
+        const m2_1 = value(m_1);
+        t2h = ((m2_1 instanceof MapTreeNode$2) ? ((mn_1 = m2_1, MapTreeNode$2__get_Height(mn_1))) : 1);
+    }
+    else {
+        t2h = 0;
+    }
+    if (t2h > (t1h + 2)) {
+        const matchValue = value(t2);
+        if (matchValue instanceof MapTreeNode$2) {
+            const t2$0027 = matchValue;
+            if (((m_2 = MapTreeNode$2__get_Left(t2$0027), (m_2 != null) ? ((m2_2 = value(m_2), (m2_2 instanceof MapTreeNode$2) ? ((mn_2 = m2_2, MapTreeNode$2__get_Height(mn_2))) : 1)) : 0)) > (t1h + 1)) {
+                const matchValue_1 = value(MapTreeNode$2__get_Left(t2$0027));
+                if (matchValue_1 instanceof MapTreeNode$2) {
+                    const t2l = matchValue_1;
+                    return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(t2l)), MapTreeLeaf$2__get_Key(t2l), MapTreeLeaf$2__get_Value(t2l), MapTreeModule_mk(MapTreeNode$2__get_Right(t2l), MapTreeLeaf$2__get_Key(t2$0027), MapTreeLeaf$2__get_Value(t2$0027), MapTreeNode$2__get_Right(t2$0027)));
+                }
+                else {
+                    throw new Error("internal error: Map.rebalance");
+                }
+            }
+            else {
+                return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(t2$0027)), MapTreeLeaf$2__get_Key(t2$0027), MapTreeLeaf$2__get_Value(t2$0027), MapTreeNode$2__get_Right(t2$0027));
+            }
+        }
+        else {
+            throw new Error("internal error: Map.rebalance");
+        }
+    }
+    else if (t1h > (t2h + 2)) {
+        const matchValue_2 = value(t1);
+        if (matchValue_2 instanceof MapTreeNode$2) {
+            const t1$0027 = matchValue_2;
+            if (((m_3 = MapTreeNode$2__get_Right(t1$0027), (m_3 != null) ? ((m2_3 = value(m_3), (m2_3 instanceof MapTreeNode$2) ? ((mn_3 = m2_3, MapTreeNode$2__get_Height(mn_3))) : 1)) : 0)) > (t2h + 1)) {
+                const matchValue_3 = value(MapTreeNode$2__get_Right(t1$0027));
+                if (matchValue_3 instanceof MapTreeNode$2) {
+                    const t1r = matchValue_3;
+                    return MapTreeModule_mk(MapTreeModule_mk(MapTreeNode$2__get_Left(t1$0027), MapTreeLeaf$2__get_Key(t1$0027), MapTreeLeaf$2__get_Value(t1$0027), MapTreeNode$2__get_Left(t1r)), MapTreeLeaf$2__get_Key(t1r), MapTreeLeaf$2__get_Value(t1r), MapTreeModule_mk(MapTreeNode$2__get_Right(t1r), k, v, t2));
+                }
+                else {
+                    throw new Error("internal error: Map.rebalance");
+                }
+            }
+            else {
+                return MapTreeModule_mk(MapTreeNode$2__get_Left(t1$0027), MapTreeLeaf$2__get_Key(t1$0027), MapTreeLeaf$2__get_Value(t1$0027), MapTreeModule_mk(MapTreeNode$2__get_Right(t1$0027), k, v, t2));
+            }
+        }
+        else {
+            throw new Error("internal error: Map.rebalance");
+        }
+    }
+    else {
+        return MapTreeModule_mk(t1, k, v, t2);
+    }
+}
+function MapTreeModule_add(comparer, k, v, m) {
+    if (m != null) {
+        const m2 = value(m);
+        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;
+        if (m2 instanceof MapTreeNode$2) {
+            const mn = m2;
+            if (c < 0) {
+                return MapTreeModule_rebalance(MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Left(mn)), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeNode$2__get_Right(mn));
+            }
+            else if (c === 0) {
+                return MapTreeNode$2_$ctor_Z39DE9543(k, v, MapTreeNode$2__get_Left(mn), MapTreeNode$2__get_Right(mn), MapTreeNode$2__get_Height(mn));
+            }
+            else {
+                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(mn), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Right(mn)));
+            }
+        }
+        else if (c < 0) {
+            return MapTreeNode$2_$ctor_Z39DE9543(k, v, MapTreeModule_empty(), m, 2);
+        }
+        else if (c === 0) {
+            return MapTreeLeaf$2_$ctor_5BDDA1(k, v);
+        }
+        else {
+            return MapTreeNode$2_$ctor_Z39DE9543(k, v, m, MapTreeModule_empty(), 2);
+        }
+    }
+    else {
+        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);
+    }
+}
+function MapTreeModule_tryFind(comparer_mut, k_mut, m_mut) {
+    MapTreeModule_tryFind: while (true) {
+        const comparer = comparer_mut, k = k_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;
+            if (c === 0) {
+                return some(MapTreeLeaf$2__get_Value(m2));
+            }
+            else if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                comparer_mut = comparer;
+                k_mut = k;
+                m_mut = ((c < 0) ? MapTreeNode$2__get_Left(mn) : MapTreeNode$2__get_Right(mn));
+                continue MapTreeModule_tryFind;
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+function MapTreeModule_find(comparer, k, m) {
+    const matchValue = MapTreeModule_tryFind(comparer, k, m);
+    if (matchValue == null) {
+        throw new Error();
+    }
+    else {
+        return value(matchValue);
+    }
+}
+function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {
+    MapTreeModule_mem: while (true) {
+        const comparer = comparer_mut, k = k_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                if (c < 0) {
+                    comparer_mut = comparer;
+                    k_mut = k;
+                    m_mut = MapTreeNode$2__get_Left(mn);
+                    continue MapTreeModule_mem;
+                }
+                else if (c === 0) {
+                    return true;
+                }
+                else {
+                    comparer_mut = comparer;
+                    k_mut = k;
+                    m_mut = MapTreeNode$2__get_Right(mn);
+                    continue MapTreeModule_mem;
+                }
+            }
+            else {
+                return c === 0;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+}
+function MapTreeModule_iterOpt(f_mut, m_mut) {
+    MapTreeModule_iterOpt: while (true) {
+        const f = f_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                MapTreeModule_iterOpt(f, MapTreeNode$2__get_Left(mn));
+                f(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn));
+                f_mut = f;
+                m_mut = MapTreeNode$2__get_Right(mn);
+                continue MapTreeModule_iterOpt;
+            }
+            else {
+                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));
+            }
+        }
+        break;
+    }
+}
+function MapTreeModule_iter(f, m) {
+    MapTreeModule_iterOpt(f, m);
+}
+function MapTreeModule_copyToArray(m, arr, i) {
+    let j = i;
+    MapTreeModule_iter((x, y) => {
+        setItem(arr, j, [x, y]);
+        j = ((j + 1) | 0);
+    }, m);
+}
+function MapTreeModule_ofList(comparer, l) {
+    return fold((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);
+}
+function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
+    MapTreeModule_mkFromEnumerator: while (true) {
+        const comparer = comparer_mut, acc = acc_mut, e = e_mut;
+        if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            const patternInput = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            comparer_mut = comparer;
+            acc_mut = MapTreeModule_add(comparer, patternInput[0], patternInput[1], acc);
+            e_mut = e;
+            continue MapTreeModule_mkFromEnumerator;
+        }
+        else {
+            return acc;
+        }
+    }
+}
+function MapTreeModule_ofArray(comparer, arr) {
+    let res = MapTreeModule_empty();
+    for (let idx = 0; idx <= (arr.length - 1); idx++) {
+        const forLoopVar = item(idx, arr);
+        res = MapTreeModule_add(comparer, forLoopVar[0], forLoopVar[1], res);
+    }
+    return res;
+}
+function MapTreeModule_ofSeq(comparer, c) {
+    if (isArrayLike(c)) {
+        return MapTreeModule_ofArray(comparer, c);
+    }
+    else if (c instanceof FSharpList) {
+        return MapTreeModule_ofList(comparer, c);
+    }
+    else {
+        const ie = getEnumerator(c);
+        try {
+            return MapTreeModule_mkFromEnumerator(comparer, MapTreeModule_empty(), ie);
+        }
+        finally {
+            disposeSafe(ie);
+        }
+    }
+}
+class MapTreeModule_MapIterator$2 extends Record {
+    constructor(stack, started) {
+        super();
+        this.stack = stack;
+        this.started = started;
+    }
+}
+function MapTreeModule_collapseLHS(stack_mut) {
+    MapTreeModule_collapseLHS: while (true) {
+        const stack = stack_mut;
+        if (!isEmpty(stack)) {
+            const rest = tail(stack);
+            const m = head(stack);
+            if (m != null) {
+                const m2 = value(m);
+                if (m2 instanceof MapTreeNode$2) {
+                    const mn = m2;
+                    stack_mut = ofArrayWithTail([MapTreeNode$2__get_Left(mn), MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn)), MapTreeNode$2__get_Right(mn)], rest);
+                    continue MapTreeModule_collapseLHS;
+                }
+                else {
+                    return stack;
+                }
+            }
+            else {
+                stack_mut = rest;
+                continue MapTreeModule_collapseLHS;
+            }
+        }
+        else {
+            return empty$1();
+        }
+    }
+}
+function MapTreeModule_mkIterator(m) {
+    return new MapTreeModule_MapIterator$2(MapTreeModule_collapseLHS(singleton(m)), false);
+}
+function MapTreeModule_notStarted() {
+    throw new Error("enumeration not started");
+}
+function MapTreeModule_alreadyFinished() {
+    throw new Error("enumeration already finished");
+}
+function MapTreeModule_current(i) {
+    if (i.started) {
+        const matchValue = i.stack;
+        if (!isEmpty(matchValue)) {
+            if (head(matchValue) != null) {
+                const m = value(head(matchValue));
+                if (m instanceof MapTreeNode$2) {
+                    throw new Error("Please report error: Map iterator, unexpected stack for current");
+                }
+                else {
+                    return [MapTreeLeaf$2__get_Key(m), MapTreeLeaf$2__get_Value(m)];
+                }
+            }
+            else {
+                throw new Error("Please report error: Map iterator, unexpected stack for current");
+            }
+        }
+        else {
+            return MapTreeModule_alreadyFinished();
+        }
+    }
+    else {
+        return MapTreeModule_notStarted();
+    }
+}
+function MapTreeModule_moveNext(i) {
+    if (i.started) {
+        const matchValue = i.stack;
+        if (!isEmpty(matchValue)) {
+            if (head(matchValue) != null) {
+                const m = value(head(matchValue));
+                if (m instanceof MapTreeNode$2) {
+                    throw new Error("Please report error: Map iterator, unexpected stack for moveNext");
+                }
+                else {
+                    i.stack = MapTreeModule_collapseLHS(tail(matchValue));
+                    return !isEmpty(i.stack);
+                }
+            }
+            else {
+                throw new Error("Please report error: Map iterator, unexpected stack for moveNext");
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        i.started = true;
+        return !isEmpty(i.stack);
+    }
+}
+function MapTreeModule_mkIEnumerator(m) {
+    let i = MapTreeModule_mkIterator(m);
+    return {
+        "System.Collections.Generic.IEnumerator`1.get_Current"() {
+            return MapTreeModule_current(i);
+        },
+        "System.Collections.IEnumerator.get_Current"() {
+            return MapTreeModule_current(i);
+        },
+        "System.Collections.IEnumerator.MoveNext"() {
+            return MapTreeModule_moveNext(i);
+        },
+        "System.Collections.IEnumerator.Reset"() {
+            i = MapTreeModule_mkIterator(m);
+        },
+        Dispose() {
+        },
+    };
+}
+class FSharpMap {
+    constructor(comparer, tree) {
+        this.comparer = comparer;
+        this.tree = tree;
+    }
+    GetHashCode() {
+        const this$ = this;
+        return FSharpMap__ComputeHashCode(this$) | 0;
+    }
+    Equals(that) {
+        const this$ = this;
+        if (that instanceof FSharpMap) {
+            const that_1 = that;
+            const e1 = getEnumerator(this$);
+            try {
+                const e2 = getEnumerator(that_1);
+                try {
+                    const loop = () => {
+                        const m1 = e1["System.Collections.IEnumerator.MoveNext"]();
+                        if (m1 === e2["System.Collections.IEnumerator.MoveNext"]()) {
+                            if (!m1) {
+                                return true;
+                            }
+                            else {
+                                const e1c = e1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                                const e2c = e2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                                if (equals(e1c[0], e2c[0]) && equals(e1c[1], e2c[1])) {
+                                    return loop();
+                                }
+                                else {
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            return false;
+                        }
+                    };
+                    return loop();
+                }
+                finally {
+                    disposeSafe(e2);
+                }
+            }
+            finally {
+                disposeSafe(e1);
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    toString() {
+        const this$ = this;
+        return ("map [" + join("; ", map((kv) => format("({0}, {1})", kv[0], kv[1]), this$))) + "]";
+    }
+    get [Symbol.toStringTag]() {
+        return "FSharpMap";
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    GetEnumerator() {
+        const _ = this;
+        return MapTreeModule_mkIEnumerator(_.tree);
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const _ = this;
+        return MapTreeModule_mkIEnumerator(_.tree);
+    }
+    CompareTo(obj) {
+        const m = this;
+        if (obj instanceof FSharpMap) {
+            const m2 = obj;
+            return compareWith((kvp1, kvp2) => {
+                const c = m.comparer.Compare(kvp1[0], kvp2[0]) | 0;
+                return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;
+            }, m, m2) | 0;
+        }
+        else {
+            throw new Error("not comparable\\nParameter name: obj");
+        }
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(x) {
+        throw new Error("Map cannot be mutated");
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        throw new Error("Map cannot be mutated");
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(x) {
+        throw new Error("Map cannot be mutated");
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(x) {
+        const m = this;
+        return FSharpMap__ContainsKey(m, x[0]) && equals(FSharpMap__get_Item(m, x[0]), x[1]);
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr, i) {
+        const m = this;
+        MapTreeModule_copyToArray(m.tree, arr, i);
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return true;
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"() {
+        const m = this;
+        return FSharpMap__get_Count(m) | 0;
+    }
+    "System.Collections.Generic.IReadOnlyCollection`1.get_Count"() {
+        const m = this;
+        return FSharpMap__get_Count(m) | 0;
+    }
+    get size() {
+        const m = this;
+        return FSharpMap__get_Count(m) | 0;
+    }
+    clear() {
+        throw new Error("Map cannot be mutated");
+    }
+    delete(_arg) {
+        throw new Error("Map cannot be mutated");
+    }
+    entries() {
+        const m = this;
+        return map((p) => [p[0], p[1]], m);
+    }
+    get(k) {
+        const m = this;
+        return FSharpMap__get_Item(m, k);
+    }
+    has(k) {
+        const m = this;
+        return FSharpMap__ContainsKey(m, k);
+    }
+    keys() {
+        const m = this;
+        return map((p) => p[0], m);
+    }
+    set(k, v) {
+        throw new Error("Map cannot be mutated");
+    }
+    values() {
+        const m = this;
+        return map((p) => p[1], m);
+    }
+    forEach(f, thisArg) {
+        const m = this;
+        iterate((p) => {
+            f(p[1], p[0], m);
+        }, m);
+    }
+}
+function FSharpMap_$ctor(comparer, tree) {
+    return new FSharpMap(comparer, tree);
+}
+function FSharpMap_Empty(comparer) {
+    return FSharpMap_$ctor(comparer, MapTreeModule_empty());
+}
+function FSharpMap__get_Item(m, key) {
+    return MapTreeModule_find(m.comparer, key, m.tree);
+}
+function FSharpMap__get_Count(m) {
+    return MapTreeModule_size(m.tree);
+}
+function FSharpMap__ContainsKey(m, key) {
+    return MapTreeModule_mem(m.comparer, key, m.tree);
+}
+function FSharpMap__TryFind(m, key) {
+    return MapTreeModule_tryFind(m.comparer, key, m.tree);
+}
+function FSharpMap__ComputeHashCode(this$) {
+    const combineHash = (x, y) => (((x << 1) + y) + 631);
+    let res = 0;
+    const enumerator = getEnumerator(this$);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            res = (combineHash(res, structuralHash(activePatternResult[0])) | 0);
+            res = (combineHash(res, structuralHash(activePatternResult[1])) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return res | 0;
+}
+function tryFind(key, table) {
+    return FSharpMap__TryFind(table, key);
+}
+function ofList(elements, comparer) {
+    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, elements));
+}
+function ofSeq(elements, comparer) {
+    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, elements));
+}
+function ofArray(elements, comparer) {
+    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, elements));
+}
+function empty(comparer) {
+    return FSharpMap_Empty(comparer);
+}
+
+export { FSharpMap, FSharpMap_$ctor, FSharpMap_Empty, FSharpMap__ComputeHashCode, FSharpMap__ContainsKey, FSharpMap__TryFind, FSharpMap__get_Count, FSharpMap__get_Item, MapTreeLeaf$2, MapTreeLeaf$2_$ctor_5BDDA1, MapTreeLeaf$2__get_Key, MapTreeLeaf$2__get_Value, MapTreeModule_MapIterator$2, MapTreeModule_add, MapTreeModule_alreadyFinished, MapTreeModule_collapseLHS, MapTreeModule_copyToArray, MapTreeModule_current, MapTreeModule_empty, MapTreeModule_find, MapTreeModule_iter, MapTreeModule_iterOpt, MapTreeModule_mem, MapTreeModule_mk, MapTreeModule_mkFromEnumerator, MapTreeModule_mkIEnumerator, MapTreeModule_mkIterator, MapTreeModule_moveNext, MapTreeModule_notStarted, MapTreeModule_ofArray, MapTreeModule_ofList, MapTreeModule_ofSeq, MapTreeModule_rebalance, MapTreeModule_size, MapTreeModule_sizeAux, MapTreeModule_tryFind, MapTreeNode$2, MapTreeNode$2_$ctor_Z39DE9543, MapTreeNode$2__get_Height, MapTreeNode$2__get_Left, MapTreeNode$2__get_Right, empty, ofArray, ofList, ofSeq, tryFind };