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

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

@@ -0,0 +1,1160 @@
+import { value } from './Option.js';
+import { isArrayLike, getEnumerator, disposeSafe, toIterator, structuralHash } from './Util.js';
+import { Record, toString } from './Types.js';
+import { FSharpList, fold as fold$1, singleton, isEmpty, head, cons, tail, ofArrayWithTail, empty } from './List.js';
+import { fold, setItem } from './Array.js';
+import { join } from './String.js';
+import { map, iterate, fold as fold$2 } from './Seq.js';
+
+class SetTreeLeaf$1 {
+    constructor(k) {
+        this.k = k;
+    }
+}
+function SetTreeLeaf$1_$ctor_2B595(k) {
+    return new SetTreeLeaf$1(k);
+}
+function SetTreeLeaf$1__get_Key(_) {
+    return _.k;
+}
+class SetTreeNode$1 extends SetTreeLeaf$1 {
+    constructor(v, left, right, h) {
+        super(v);
+        this.left = left;
+        this.right = right;
+        this.h = (h | 0);
+    }
+}
+function SetTreeNode$1_$ctor_5F465FC9(v, left, right, h) {
+    return new SetTreeNode$1(v, left, right, h);
+}
+function SetTreeNode$1__get_Left(_) {
+    return _.left;
+}
+function SetTreeNode$1__get_Right(_) {
+    return _.right;
+}
+function SetTreeNode$1__get_Height(_) {
+    return _.h;
+}
+function SetTreeModule_empty() {
+    return undefined;
+}
+function SetTreeModule_countAux(t_mut, acc_mut) {
+    SetTreeModule_countAux: while (true) {
+        const t = t_mut, acc = acc_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                acc_mut = SetTreeModule_countAux(SetTreeNode$1__get_Right(tn), acc + 1);
+                continue SetTreeModule_countAux;
+            }
+            else {
+                return (acc + 1) | 0;
+            }
+        }
+        else {
+            return acc | 0;
+        }
+    }
+}
+function SetTreeModule_count(s) {
+    return SetTreeModule_countAux(s, 0);
+}
+function SetTreeModule_mk(l, k, r) {
+    let tn, tn_1;
+    let hl;
+    const t = l;
+    if (t != null) {
+        const t2 = value(t);
+        hl = ((t2 instanceof SetTreeNode$1) ? ((tn = t2, SetTreeNode$1__get_Height(tn))) : 1);
+    }
+    else {
+        hl = 0;
+    }
+    let hr;
+    const t_1 = r;
+    if (t_1 != null) {
+        const t2_1 = value(t_1);
+        hr = ((t2_1 instanceof SetTreeNode$1) ? ((tn_1 = t2_1, SetTreeNode$1__get_Height(tn_1))) : 1);
+    }
+    else {
+        hr = 0;
+    }
+    const m = ((hl < hr) ? hr : hl) | 0;
+    if (m === 0) {
+        return SetTreeLeaf$1_$ctor_2B595(k);
+    }
+    else {
+        return SetTreeNode$1_$ctor_5F465FC9(k, l, r, m + 1);
+    }
+}
+function SetTreeModule_rebalance(t1, v, t2) {
+    let tn, tn_1, t_2, t2_3, tn_2, t_3, t2_4, tn_3;
+    let t1h;
+    const t = t1;
+    if (t != null) {
+        const t2_1 = value(t);
+        t1h = ((t2_1 instanceof SetTreeNode$1) ? ((tn = t2_1, SetTreeNode$1__get_Height(tn))) : 1);
+    }
+    else {
+        t1h = 0;
+    }
+    let t2h;
+    const t_1 = t2;
+    if (t_1 != null) {
+        const t2_2 = value(t_1);
+        t2h = ((t2_2 instanceof SetTreeNode$1) ? ((tn_1 = t2_2, SetTreeNode$1__get_Height(tn_1))) : 1);
+    }
+    else {
+        t2h = 0;
+    }
+    if (t2h > (t1h + 2)) {
+        const matchValue = value(t2);
+        if (matchValue instanceof SetTreeNode$1) {
+            const t2$0027 = matchValue;
+            if (((t_2 = SetTreeNode$1__get_Left(t2$0027), (t_2 != null) ? ((t2_3 = value(t_2), (t2_3 instanceof SetTreeNode$1) ? ((tn_2 = t2_3, SetTreeNode$1__get_Height(tn_2))) : 1)) : 0)) > (t1h + 1)) {
+                const matchValue_1 = value(SetTreeNode$1__get_Left(t2$0027));
+                if (matchValue_1 instanceof SetTreeNode$1) {
+                    const t2l = matchValue_1;
+                    return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(t2l)), SetTreeLeaf$1__get_Key(t2l), SetTreeModule_mk(SetTreeNode$1__get_Right(t2l), SetTreeLeaf$1__get_Key(t2$0027), SetTreeNode$1__get_Right(t2$0027)));
+                }
+                else {
+                    throw new Error("internal error: Set.rebalance");
+                }
+            }
+            else {
+                return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(t2$0027)), SetTreeLeaf$1__get_Key(t2$0027), SetTreeNode$1__get_Right(t2$0027));
+            }
+        }
+        else {
+            throw new Error("internal error: Set.rebalance");
+        }
+    }
+    else if (t1h > (t2h + 2)) {
+        const matchValue_2 = value(t1);
+        if (matchValue_2 instanceof SetTreeNode$1) {
+            const t1$0027 = matchValue_2;
+            if (((t_3 = SetTreeNode$1__get_Right(t1$0027), (t_3 != null) ? ((t2_4 = value(t_3), (t2_4 instanceof SetTreeNode$1) ? ((tn_3 = t2_4, SetTreeNode$1__get_Height(tn_3))) : 1)) : 0)) > (t2h + 1)) {
+                const matchValue_3 = value(SetTreeNode$1__get_Right(t1$0027));
+                if (matchValue_3 instanceof SetTreeNode$1) {
+                    const t1r = matchValue_3;
+                    return SetTreeModule_mk(SetTreeModule_mk(SetTreeNode$1__get_Left(t1$0027), SetTreeLeaf$1__get_Key(t1$0027), SetTreeNode$1__get_Left(t1r)), SetTreeLeaf$1__get_Key(t1r), SetTreeModule_mk(SetTreeNode$1__get_Right(t1r), v, t2));
+                }
+                else {
+                    throw new Error("internal error: Set.rebalance");
+                }
+            }
+            else {
+                return SetTreeModule_mk(SetTreeNode$1__get_Left(t1$0027), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_mk(SetTreeNode$1__get_Right(t1$0027), v, t2));
+            }
+        }
+        else {
+            throw new Error("internal error: Set.rebalance");
+        }
+    }
+    else {
+        return SetTreeModule_mk(t1, v, t2);
+    }
+}
+function SetTreeModule_add(comparer, k, t) {
+    if (t != null) {
+        const t2 = value(t);
+        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;
+        if (t2 instanceof SetTreeNode$1) {
+            const tn = t2;
+            if (c < 0) {
+                return SetTreeModule_rebalance(SetTreeModule_add(comparer, k, SetTreeNode$1__get_Left(tn)), SetTreeLeaf$1__get_Key(tn), SetTreeNode$1__get_Right(tn));
+            }
+            else if (c === 0) {
+                return t;
+            }
+            else {
+                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(tn), SetTreeLeaf$1__get_Key(tn), SetTreeModule_add(comparer, k, SetTreeNode$1__get_Right(tn)));
+            }
+        }
+        else {
+            const c_1 = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;
+            if (c_1 < 0) {
+                return SetTreeNode$1_$ctor_5F465FC9(k, SetTreeModule_empty(), t, 2);
+            }
+            else if (c_1 === 0) {
+                return t;
+            }
+            else {
+                return SetTreeNode$1_$ctor_5F465FC9(k, t, SetTreeModule_empty(), 2);
+            }
+        }
+    }
+    else {
+        return SetTreeLeaf$1_$ctor_2B595(k);
+    }
+}
+function SetTreeModule_balance(comparer, t1, k, t2) {
+    if (t1 != null) {
+        const t1$0027 = value(t1);
+        if (t2 != null) {
+            const t2$0027 = value(t2);
+            if (t1$0027 instanceof SetTreeNode$1) {
+                const t1n = t1$0027;
+                if (t2$0027 instanceof SetTreeNode$1) {
+                    const t2n = t2$0027;
+                    if ((SetTreeNode$1__get_Height(t1n) + 2) < SetTreeNode$1__get_Height(t2n)) {
+                        return SetTreeModule_rebalance(SetTreeModule_balance(comparer, t1, k, SetTreeNode$1__get_Left(t2n)), SetTreeLeaf$1__get_Key(t2n), SetTreeNode$1__get_Right(t2n));
+                    }
+                    else if ((SetTreeNode$1__get_Height(t2n) + 2) < SetTreeNode$1__get_Height(t1n)) {
+                        return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t1n), SetTreeLeaf$1__get_Key(t1n), SetTreeModule_balance(comparer, SetTreeNode$1__get_Right(t1n), k, t2));
+                    }
+                    else {
+                        return SetTreeModule_mk(t1, k, t2);
+                    }
+                }
+                else {
+                    return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1));
+                }
+            }
+            else {
+                return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2));
+            }
+        }
+        else {
+            return SetTreeModule_add(comparer, k, t1);
+        }
+    }
+    else {
+        return SetTreeModule_add(comparer, k, t2);
+    }
+}
+function SetTreeModule_split(comparer, pivot, t) {
+    if (t != null) {
+        const t2 = value(t);
+        if (t2 instanceof SetTreeNode$1) {
+            const tn = t2;
+            const c = comparer.Compare(pivot, SetTreeLeaf$1__get_Key(tn)) | 0;
+            if (c < 0) {
+                const patternInput = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Left(tn));
+                return [patternInput[0], patternInput[1], SetTreeModule_balance(comparer, patternInput[2], SetTreeLeaf$1__get_Key(tn), SetTreeNode$1__get_Right(tn))];
+            }
+            else if (c === 0) {
+                return [SetTreeNode$1__get_Left(tn), true, SetTreeNode$1__get_Right(tn)];
+            }
+            else {
+                const patternInput_1 = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Right(tn));
+                return [SetTreeModule_balance(comparer, SetTreeNode$1__get_Left(tn), SetTreeLeaf$1__get_Key(tn), patternInput_1[0]), patternInput_1[1], patternInput_1[2]];
+            }
+        }
+        else {
+            const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(t2), pivot) | 0;
+            if (c_1 < 0) {
+                return [t, false, SetTreeModule_empty()];
+            }
+            else if (c_1 === 0) {
+                return [SetTreeModule_empty(), true, SetTreeModule_empty()];
+            }
+            else {
+                return [SetTreeModule_empty(), false, t];
+            }
+        }
+    }
+    else {
+        return [SetTreeModule_empty(), false, SetTreeModule_empty()];
+    }
+}
+function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {
+    SetTreeModule_mem: while (true) {
+        const comparer = comparer_mut, k = k_mut, t = t_mut;
+        if (t != null) {
+            const t2 = value(t);
+            const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                if (c < 0) {
+                    comparer_mut = comparer;
+                    k_mut = k;
+                    t_mut = SetTreeNode$1__get_Left(tn);
+                    continue SetTreeModule_mem;
+                }
+                else if (c === 0) {
+                    return true;
+                }
+                else {
+                    comparer_mut = comparer;
+                    k_mut = k;
+                    t_mut = SetTreeNode$1__get_Right(tn);
+                    continue SetTreeModule_mem;
+                }
+            }
+            else {
+                return c === 0;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+}
+function SetTreeModule_iter(f_mut, t_mut) {
+    SetTreeModule_iter: while (true) {
+        const f = f_mut, t = t_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                SetTreeModule_iter(f, SetTreeNode$1__get_Left(tn));
+                f(SetTreeLeaf$1__get_Key(tn));
+                f_mut = f;
+                t_mut = SetTreeNode$1__get_Right(tn);
+                continue SetTreeModule_iter;
+            }
+            else {
+                f(SetTreeLeaf$1__get_Key(t2));
+            }
+        }
+        break;
+    }
+}
+function SetTreeModule_union(comparer, t1, t2) {
+    if (t1 != null) {
+        const t1$0027 = value(t1);
+        if (t2 != null) {
+            const t2$0027 = value(t2);
+            if (t1$0027 instanceof SetTreeNode$1) {
+                const t1n = t1$0027;
+                if (t2$0027 instanceof SetTreeNode$1) {
+                    const t2n = t2$0027;
+                    if (SetTreeNode$1__get_Height(t1n) > SetTreeNode$1__get_Height(t2n)) {
+                        const patternInput = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t1n), t2);
+                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t1n), patternInput[0]), SetTreeLeaf$1__get_Key(t1n), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t1n), patternInput[2]));
+                    }
+                    else {
+                        const patternInput_1 = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t2n), t1);
+                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t2n), patternInput_1[0]), SetTreeLeaf$1__get_Key(t2n), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t2n), patternInput_1[2]));
+                    }
+                }
+                else {
+                    return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);
+                }
+            }
+            else {
+                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);
+            }
+        }
+        else {
+            return t1;
+        }
+    }
+    else {
+        return t2;
+    }
+}
+function SetTreeModule_intersectionAux(comparer_mut, b_mut, t_mut, acc_mut) {
+    SetTreeModule_intersectionAux: while (true) {
+        const comparer = comparer_mut, b = b_mut, t = t_mut, acc = acc_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                const acc_1 = SetTreeModule_intersectionAux(comparer, b, SetTreeNode$1__get_Right(tn), acc);
+                const acc_2 = SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(tn), b) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(tn), acc_1) : acc_1;
+                comparer_mut = comparer;
+                b_mut = b;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                acc_mut = acc_2;
+                continue SetTreeModule_intersectionAux;
+            }
+            else if (SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b)) {
+                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);
+            }
+            else {
+                return acc;
+            }
+        }
+        else {
+            return acc;
+        }
+    }
+}
+function SetTreeModule_intersection(comparer, a, b) {
+    return SetTreeModule_intersectionAux(comparer, b, a, SetTreeModule_empty());
+}
+class SetTreeModule_SetIterator$1 extends Record {
+    constructor(stack, started) {
+        super();
+        this.stack = stack;
+        this.started = started;
+    }
+}
+function SetTreeModule_collapseLHS(stack_mut) {
+    SetTreeModule_collapseLHS: while (true) {
+        const stack = stack_mut;
+        if (!isEmpty(stack)) {
+            const x = head(stack);
+            const rest = tail(stack);
+            if (x != null) {
+                const x2 = value(x);
+                if (x2 instanceof SetTreeNode$1) {
+                    const xn = x2;
+                    stack_mut = ofArrayWithTail([SetTreeNode$1__get_Left(xn), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(xn)), SetTreeNode$1__get_Right(xn)], rest);
+                    continue SetTreeModule_collapseLHS;
+                }
+                else {
+                    return stack;
+                }
+            }
+            else {
+                stack_mut = rest;
+                continue SetTreeModule_collapseLHS;
+            }
+        }
+        else {
+            return empty();
+        }
+    }
+}
+function SetTreeModule_mkIterator(s) {
+    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(singleton(s)), false);
+}
+function SetTreeModule_notStarted() {
+    throw new Error("Enumeration not started");
+}
+function SetTreeModule_alreadyFinished() {
+    throw new Error("Enumeration already started");
+}
+function SetTreeModule_current(i) {
+    if (i.started) {
+        const matchValue = i.stack;
+        if (isEmpty(matchValue)) {
+            return SetTreeModule_alreadyFinished();
+        }
+        else if (head(matchValue) != null) {
+            const t = value(head(matchValue));
+            return SetTreeLeaf$1__get_Key(t);
+        }
+        else {
+            throw new Error("Please report error: Set iterator, unexpected stack for current");
+        }
+    }
+    else {
+        return SetTreeModule_notStarted();
+    }
+}
+function SetTreeModule_moveNext(i) {
+    if (i.started) {
+        const matchValue = i.stack;
+        if (!isEmpty(matchValue)) {
+            if (head(matchValue) != null) {
+                const t = value(head(matchValue));
+                if (t instanceof SetTreeNode$1) {
+                    throw new Error("Please report error: Set iterator, unexpected stack for moveNext");
+                }
+                else {
+                    i.stack = SetTreeModule_collapseLHS(tail(matchValue));
+                    return !isEmpty(i.stack);
+                }
+            }
+            else {
+                throw new Error("Please report error: Set iterator, unexpected stack for moveNext");
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        i.started = true;
+        return !isEmpty(i.stack);
+    }
+}
+function SetTreeModule_mkIEnumerator(s) {
+    let i = SetTreeModule_mkIterator(s);
+    return {
+        "System.Collections.Generic.IEnumerator`1.get_Current"() {
+            return SetTreeModule_current(i);
+        },
+        "System.Collections.IEnumerator.get_Current"() {
+            return SetTreeModule_current(i);
+        },
+        "System.Collections.IEnumerator.MoveNext"() {
+            return SetTreeModule_moveNext(i);
+        },
+        "System.Collections.IEnumerator.Reset"() {
+            i = SetTreeModule_mkIterator(s);
+        },
+        Dispose() {
+        },
+    };
+}
+/**
+ * Set comparison.  Note this can be expensive.
+ */
+function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
+    SetTreeModule_compareStacks: while (true) {
+        const comparer = comparer_mut, l1 = l1_mut, l2 = l2_mut;
+        if (!isEmpty(l1)) {
+            if (!isEmpty(l2)) {
+                if (head(l2) != null) {
+                    if (head(l1) != null) {
+                        const x1_3 = value(head(l1));
+                        const x2_3 = value(head(l2));
+                        if (x1_3 instanceof SetTreeNode$1) {
+                            const x1n_2 = x1_3;
+                            if (SetTreeNode$1__get_Left(x1n_2) == null) {
+                                if (x2_3 instanceof SetTreeNode$1) {
+                                    const x2n_2 = x2_3;
+                                    if (SetTreeNode$1__get_Left(x2n_2) == null) {
+                                        const c = comparer.Compare(SetTreeLeaf$1__get_Key(x1n_2), SetTreeLeaf$1__get_Key(x2n_2)) | 0;
+                                        if (c !== 0) {
+                                            return c | 0;
+                                        }
+                                        else {
+                                            comparer_mut = comparer;
+                                            l1_mut = cons(SetTreeNode$1__get_Right(x1n_2), tail(l1));
+                                            l2_mut = cons(SetTreeNode$1__get_Right(x2n_2), tail(l2));
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                    }
+                                    else {
+                                        let matchResult, t1_6, x1_4, t2_6, x2_4;
+                                        if (!isEmpty(l1)) {
+                                            if (head(l1) != null) {
+                                                matchResult = 0;
+                                                t1_6 = tail(l1);
+                                                x1_4 = value(head(l1));
+                                            }
+                                            else if (!isEmpty(l2)) {
+                                                if (head(l2) != null) {
+                                                    matchResult = 1;
+                                                    t2_6 = tail(l2);
+                                                    x2_4 = value(head(l2));
+                                                }
+                                                else {
+                                                    matchResult = 2;
+                                                }
+                                            }
+                                            else {
+                                                matchResult = 2;
+                                            }
+                                        }
+                                        else if (!isEmpty(l2)) {
+                                            if (head(l2) != null) {
+                                                matchResult = 1;
+                                                t2_6 = tail(l2);
+                                                x2_4 = value(head(l2));
+                                            }
+                                            else {
+                                                matchResult = 2;
+                                            }
+                                        }
+                                        else {
+                                            matchResult = 2;
+                                        }
+                                        switch (matchResult) {
+                                            case 0:
+                                                if (x1_4 instanceof SetTreeNode$1) {
+                                                    const x1n_3 = x1_4;
+                                                    comparer_mut = comparer;
+                                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1n_3), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x1n_3), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1n_3), 0)], t1_6);
+                                                    l2_mut = l2;
+                                                    continue SetTreeModule_compareStacks;
+                                                }
+                                                else {
+                                                    comparer_mut = comparer;
+                                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_4))], t1_6);
+                                                    l2_mut = l2;
+                                                    continue SetTreeModule_compareStacks;
+                                                }
+                                            case 1:
+                                                if (x2_4 instanceof SetTreeNode$1) {
+                                                    const x2n_3 = x2_4;
+                                                    comparer_mut = comparer;
+                                                    l1_mut = l1;
+                                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2n_3), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x2n_3), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2n_3), 0)], t2_6);
+                                                    continue SetTreeModule_compareStacks;
+                                                }
+                                                else {
+                                                    comparer_mut = comparer;
+                                                    l1_mut = l1;
+                                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_4))], t2_6);
+                                                    continue SetTreeModule_compareStacks;
+                                                }
+                                            default:
+                                                throw new Error("unexpected state in SetTree.compareStacks");
+                                        }
+                                    }
+                                }
+                                else {
+                                    const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(x1n_2), SetTreeLeaf$1__get_Key(x2_3)) | 0;
+                                    if (c_1 !== 0) {
+                                        return c_1 | 0;
+                                    }
+                                    else {
+                                        comparer_mut = comparer;
+                                        l1_mut = cons(SetTreeNode$1__get_Right(x1n_2), tail(l1));
+                                        l2_mut = cons(SetTreeModule_empty(), tail(l2));
+                                        continue SetTreeModule_compareStacks;
+                                    }
+                                }
+                            }
+                            else {
+                                let matchResult_1, t1_7, x1_5, t2_7, x2_5;
+                                if (!isEmpty(l1)) {
+                                    if (head(l1) != null) {
+                                        matchResult_1 = 0;
+                                        t1_7 = tail(l1);
+                                        x1_5 = value(head(l1));
+                                    }
+                                    else if (!isEmpty(l2)) {
+                                        if (head(l2) != null) {
+                                            matchResult_1 = 1;
+                                            t2_7 = tail(l2);
+                                            x2_5 = value(head(l2));
+                                        }
+                                        else {
+                                            matchResult_1 = 2;
+                                        }
+                                    }
+                                    else {
+                                        matchResult_1 = 2;
+                                    }
+                                }
+                                else if (!isEmpty(l2)) {
+                                    if (head(l2) != null) {
+                                        matchResult_1 = 1;
+                                        t2_7 = tail(l2);
+                                        x2_5 = value(head(l2));
+                                    }
+                                    else {
+                                        matchResult_1 = 2;
+                                    }
+                                }
+                                else {
+                                    matchResult_1 = 2;
+                                }
+                                switch (matchResult_1) {
+                                    case 0:
+                                        if (x1_5 instanceof SetTreeNode$1) {
+                                            const x1n_4 = x1_5;
+                                            comparer_mut = comparer;
+                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1n_4), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x1n_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1n_4), 0)], t1_7);
+                                            l2_mut = l2;
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                        else {
+                                            comparer_mut = comparer;
+                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_5))], t1_7);
+                                            l2_mut = l2;
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                    case 1:
+                                        if (x2_5 instanceof SetTreeNode$1) {
+                                            const x2n_4 = x2_5;
+                                            comparer_mut = comparer;
+                                            l1_mut = l1;
+                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2n_4), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x2n_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2n_4), 0)], t2_7);
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                        else {
+                                            comparer_mut = comparer;
+                                            l1_mut = l1;
+                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_5))], t2_7);
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                    default:
+                                        throw new Error("unexpected state in SetTree.compareStacks");
+                                }
+                            }
+                        }
+                        else if (x2_3 instanceof SetTreeNode$1) {
+                            const x2n_5 = x2_3;
+                            if (SetTreeNode$1__get_Left(x2n_5) == null) {
+                                const c_2 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2n_5)) | 0;
+                                if (c_2 !== 0) {
+                                    return c_2 | 0;
+                                }
+                                else {
+                                    comparer_mut = comparer;
+                                    l1_mut = cons(SetTreeModule_empty(), tail(l1));
+                                    l2_mut = cons(SetTreeNode$1__get_Right(x2n_5), tail(l2));
+                                    continue SetTreeModule_compareStacks;
+                                }
+                            }
+                            else {
+                                let matchResult_2, t1_8, x1_6, t2_8, x2_6;
+                                if (!isEmpty(l1)) {
+                                    if (head(l1) != null) {
+                                        matchResult_2 = 0;
+                                        t1_8 = tail(l1);
+                                        x1_6 = value(head(l1));
+                                    }
+                                    else if (!isEmpty(l2)) {
+                                        if (head(l2) != null) {
+                                            matchResult_2 = 1;
+                                            t2_8 = tail(l2);
+                                            x2_6 = value(head(l2));
+                                        }
+                                        else {
+                                            matchResult_2 = 2;
+                                        }
+                                    }
+                                    else {
+                                        matchResult_2 = 2;
+                                    }
+                                }
+                                else if (!isEmpty(l2)) {
+                                    if (head(l2) != null) {
+                                        matchResult_2 = 1;
+                                        t2_8 = tail(l2);
+                                        x2_6 = value(head(l2));
+                                    }
+                                    else {
+                                        matchResult_2 = 2;
+                                    }
+                                }
+                                else {
+                                    matchResult_2 = 2;
+                                }
+                                switch (matchResult_2) {
+                                    case 0:
+                                        if (x1_6 instanceof SetTreeNode$1) {
+                                            const x1n_5 = x1_6;
+                                            comparer_mut = comparer;
+                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1n_5), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x1n_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1n_5), 0)], t1_8);
+                                            l2_mut = l2;
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                        else {
+                                            comparer_mut = comparer;
+                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_6))], t1_8);
+                                            l2_mut = l2;
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                    case 1:
+                                        if (x2_6 instanceof SetTreeNode$1) {
+                                            const x2n_6 = x2_6;
+                                            comparer_mut = comparer;
+                                            l1_mut = l1;
+                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2n_6), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x2n_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2n_6), 0)], t2_8);
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                        else {
+                                            comparer_mut = comparer;
+                                            l1_mut = l1;
+                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_6))], t2_8);
+                                            continue SetTreeModule_compareStacks;
+                                        }
+                                    default:
+                                        throw new Error("unexpected state in SetTree.compareStacks");
+                                }
+                            }
+                        }
+                        else {
+                            const c_3 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;
+                            if (c_3 !== 0) {
+                                return c_3 | 0;
+                            }
+                            else {
+                                comparer_mut = comparer;
+                                l1_mut = tail(l1);
+                                l2_mut = tail(l2);
+                                continue SetTreeModule_compareStacks;
+                            }
+                        }
+                    }
+                    else {
+                        value(head(l2));
+                        let matchResult_3, t1_2, x1, t2_2, x2_1;
+                        if (!isEmpty(l1)) {
+                            if (head(l1) != null) {
+                                matchResult_3 = 0;
+                                t1_2 = tail(l1);
+                                x1 = value(head(l1));
+                            }
+                            else if (!isEmpty(l2)) {
+                                if (head(l2) != null) {
+                                    matchResult_3 = 1;
+                                    t2_2 = tail(l2);
+                                    x2_1 = value(head(l2));
+                                }
+                                else {
+                                    matchResult_3 = 2;
+                                }
+                            }
+                            else {
+                                matchResult_3 = 2;
+                            }
+                        }
+                        else if (!isEmpty(l2)) {
+                            if (head(l2) != null) {
+                                matchResult_3 = 1;
+                                t2_2 = tail(l2);
+                                x2_1 = value(head(l2));
+                            }
+                            else {
+                                matchResult_3 = 2;
+                            }
+                        }
+                        else {
+                            matchResult_3 = 2;
+                        }
+                        switch (matchResult_3) {
+                            case 0:
+                                if (x1 instanceof SetTreeNode$1) {
+                                    const x1n = x1;
+                                    comparer_mut = comparer;
+                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1n), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x1n), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1n), 0)], t1_2);
+                                    l2_mut = l2;
+                                    continue SetTreeModule_compareStacks;
+                                }
+                                else {
+                                    comparer_mut = comparer;
+                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1))], t1_2);
+                                    l2_mut = l2;
+                                    continue SetTreeModule_compareStacks;
+                                }
+                            case 1:
+                                if (x2_1 instanceof SetTreeNode$1) {
+                                    const x2n = x2_1;
+                                    comparer_mut = comparer;
+                                    l1_mut = l1;
+                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2n), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x2n), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2n), 0)], t2_2);
+                                    continue SetTreeModule_compareStacks;
+                                }
+                                else {
+                                    comparer_mut = comparer;
+                                    l1_mut = l1;
+                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_1))], t2_2);
+                                    continue SetTreeModule_compareStacks;
+                                }
+                            default:
+                                throw new Error("unexpected state in SetTree.compareStacks");
+                        }
+                    }
+                }
+                else if (head(l1) != null) {
+                    value(head(l1));
+                    let matchResult_4, t1_4, x1_2, t2_4, x2_2;
+                    if (!isEmpty(l1)) {
+                        if (head(l1) != null) {
+                            matchResult_4 = 0;
+                            t1_4 = tail(l1);
+                            x1_2 = value(head(l1));
+                        }
+                        else if (!isEmpty(l2)) {
+                            if (head(l2) != null) {
+                                matchResult_4 = 1;
+                                t2_4 = tail(l2);
+                                x2_2 = value(head(l2));
+                            }
+                            else {
+                                matchResult_4 = 2;
+                            }
+                        }
+                        else {
+                            matchResult_4 = 2;
+                        }
+                    }
+                    else if (!isEmpty(l2)) {
+                        if (head(l2) != null) {
+                            matchResult_4 = 1;
+                            t2_4 = tail(l2);
+                            x2_2 = value(head(l2));
+                        }
+                        else {
+                            matchResult_4 = 2;
+                        }
+                    }
+                    else {
+                        matchResult_4 = 2;
+                    }
+                    switch (matchResult_4) {
+                        case 0:
+                            if (x1_2 instanceof SetTreeNode$1) {
+                                const x1n_1 = x1_2;
+                                comparer_mut = comparer;
+                                l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1n_1), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x1n_1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1n_1), 0)], t1_4);
+                                l2_mut = l2;
+                                continue SetTreeModule_compareStacks;
+                            }
+                            else {
+                                comparer_mut = comparer;
+                                l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_2))], t1_4);
+                                l2_mut = l2;
+                                continue SetTreeModule_compareStacks;
+                            }
+                        case 1:
+                            if (x2_2 instanceof SetTreeNode$1) {
+                                const x2n_1 = x2_2;
+                                comparer_mut = comparer;
+                                l1_mut = l1;
+                                l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2n_1), SetTreeNode$1_$ctor_5F465FC9(SetTreeLeaf$1__get_Key(x2n_1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2n_1), 0)], t2_4);
+                                continue SetTreeModule_compareStacks;
+                            }
+                            else {
+                                comparer_mut = comparer;
+                                l1_mut = l1;
+                                l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_2))], t2_4);
+                                continue SetTreeModule_compareStacks;
+                            }
+                        default:
+                            throw new Error("unexpected state in SetTree.compareStacks");
+                    }
+                }
+                else {
+                    comparer_mut = comparer;
+                    l1_mut = tail(l1);
+                    l2_mut = tail(l2);
+                    continue SetTreeModule_compareStacks;
+                }
+            }
+            else {
+                return 1;
+            }
+        }
+        else if (isEmpty(l2)) {
+            return 0;
+        }
+        else {
+            return -1;
+        }
+    }
+}
+function SetTreeModule_compare(comparer, t1, t2) {
+    if (t1 == null) {
+        if (t2 == null) {
+            return 0;
+        }
+        else {
+            return -1;
+        }
+    }
+    else if (t2 == null) {
+        return 1;
+    }
+    else {
+        return SetTreeModule_compareStacks(comparer, singleton(t1), singleton(t2)) | 0;
+    }
+}
+function SetTreeModule_copyToArray(s, arr, i) {
+    let j = i;
+    SetTreeModule_iter((x) => {
+        setItem(arr, j, x);
+        j = ((j + 1) | 0);
+    }, s);
+}
+function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
+    SetTreeModule_mkFromEnumerator: while (true) {
+        const comparer = comparer_mut, acc = acc_mut, e = e_mut;
+        if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            comparer_mut = comparer;
+            acc_mut = SetTreeModule_add(comparer, e["System.Collections.Generic.IEnumerator`1.get_Current"](), acc);
+            e_mut = e;
+            continue SetTreeModule_mkFromEnumerator;
+        }
+        else {
+            return acc;
+        }
+    }
+}
+function SetTreeModule_ofArray(comparer, l) {
+    return fold((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);
+}
+function SetTreeModule_ofList(comparer, l) {
+    return fold$1((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);
+}
+function SetTreeModule_ofSeq(comparer, c) {
+    if (isArrayLike(c)) {
+        return SetTreeModule_ofArray(comparer, c);
+    }
+    else if (c instanceof FSharpList) {
+        return SetTreeModule_ofList(comparer, c);
+    }
+    else {
+        const ie = getEnumerator(c);
+        try {
+            return SetTreeModule_mkFromEnumerator(comparer, SetTreeModule_empty(), ie);
+        }
+        finally {
+            disposeSafe(ie);
+        }
+    }
+}
+class FSharpSet {
+    constructor(comparer, tree) {
+        this.comparer = comparer;
+        this.tree = tree;
+    }
+    GetHashCode() {
+        const this$ = this;
+        return FSharpSet__ComputeHashCode(this$) | 0;
+    }
+    Equals(that) {
+        let that_1;
+        const this$ = this;
+        return (that instanceof FSharpSet) && ((that_1 = that, SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that_1)) === 0));
+    }
+    toString() {
+        const this$ = this;
+        return ("set [" + join("; ", map((x) => {
+            let copyOfStruct = x;
+            return toString(copyOfStruct);
+        }, this$))) + "]";
+    }
+    get [Symbol.toStringTag]() {
+        return "FSharpSet";
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    CompareTo(that) {
+        const s = this;
+        return SetTreeModule_compare(FSharpSet__get_Comparer(s), FSharpSet__get_Tree(s), FSharpSet__get_Tree(that)) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(x) {
+        throw new Error("ReadOnlyCollection");
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        throw new Error("ReadOnlyCollection");
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(x) {
+        throw new Error("ReadOnlyCollection");
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(x) {
+        const s = this;
+        return SetTreeModule_mem(FSharpSet__get_Comparer(s), x, FSharpSet__get_Tree(s));
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr, i) {
+        const s = this;
+        SetTreeModule_copyToArray(FSharpSet__get_Tree(s), arr, i);
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return true;
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"() {
+        const s = this;
+        return FSharpSet__get_Count(s) | 0;
+    }
+    "System.Collections.Generic.IReadOnlyCollection`1.get_Count"() {
+        const s = this;
+        return FSharpSet__get_Count(s) | 0;
+    }
+    GetEnumerator() {
+        const s = this;
+        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const s = this;
+        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));
+    }
+    get size() {
+        const s = this;
+        return FSharpSet__get_Count(s) | 0;
+    }
+    add(k) {
+        throw new Error("Set cannot be mutated");
+    }
+    clear() {
+        throw new Error("Set cannot be mutated");
+    }
+    delete(k) {
+        throw new Error("Set cannot be mutated");
+    }
+    has(k) {
+        const s = this;
+        return FSharpSet__Contains(s, k);
+    }
+    keys() {
+        const s = this;
+        return map((x) => x, s);
+    }
+    values() {
+        const s = this;
+        return map((x) => x, s);
+    }
+    entries() {
+        const s = this;
+        return map((v) => [v, v], s);
+    }
+    forEach(f, thisArg) {
+        const s = this;
+        iterate((x) => {
+            f(x, x, s);
+        }, s);
+    }
+}
+function FSharpSet_$ctor(comparer, tree) {
+    return new FSharpSet(comparer, tree);
+}
+function FSharpSet__get_Comparer(set$) {
+    return set$.comparer;
+}
+function FSharpSet__get_Tree(set$) {
+    return set$.tree;
+}
+function FSharpSet_Empty(comparer) {
+    return FSharpSet_$ctor(comparer, SetTreeModule_empty());
+}
+function FSharpSet__get_Count(s) {
+    return SetTreeModule_count(FSharpSet__get_Tree(s));
+}
+function FSharpSet__Contains(s, value) {
+    return SetTreeModule_mem(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s));
+}
+function FSharpSet__get_IsEmpty(s) {
+    return FSharpSet__get_Tree(s) == null;
+}
+function FSharpSet_op_Addition(set1, set2) {
+    if (FSharpSet__get_Tree(set2) == null) {
+        return set1;
+    }
+    else if (FSharpSet__get_Tree(set1) == null) {
+        return set2;
+    }
+    else {
+        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_union(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));
+    }
+}
+function FSharpSet_Intersection(a, b) {
+    if (FSharpSet__get_Tree(b) == null) {
+        return b;
+    }
+    else if (FSharpSet__get_Tree(a) == null) {
+        return a;
+    }
+    else {
+        return FSharpSet_$ctor(FSharpSet__get_Comparer(a), SetTreeModule_intersection(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)));
+    }
+}
+function FSharpSet__ComputeHashCode(this$) {
+    let res = 0;
+    const enumerator = getEnumerator(this$);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const x_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            res = ((((res << 1) + structuralHash(x_1)) + 631) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return Math.abs(res) | 0;
+}
+function contains(element, set$) {
+    return FSharpSet__Contains(set$, element);
+}
+function unionMany(sets, comparer) {
+    return fold$2(FSharpSet_op_Addition, FSharpSet_Empty(comparer), sets);
+}
+function intersect(set1, set2) {
+    return FSharpSet_Intersection(set1, set2);
+}
+function ofSeq(elements, comparer) {
+    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));
+}
+
+export { FSharpSet, FSharpSet_$ctor, FSharpSet_Empty, FSharpSet_Intersection, FSharpSet__ComputeHashCode, FSharpSet__Contains, FSharpSet__get_Comparer, FSharpSet__get_Count, FSharpSet__get_IsEmpty, FSharpSet__get_Tree, FSharpSet_op_Addition, SetTreeLeaf$1, SetTreeLeaf$1_$ctor_2B595, SetTreeLeaf$1__get_Key, SetTreeModule_SetIterator$1, SetTreeModule_add, SetTreeModule_alreadyFinished, SetTreeModule_balance, SetTreeModule_collapseLHS, SetTreeModule_compare, SetTreeModule_compareStacks, SetTreeModule_copyToArray, SetTreeModule_count, SetTreeModule_countAux, SetTreeModule_current, SetTreeModule_empty, SetTreeModule_intersection, SetTreeModule_intersectionAux, SetTreeModule_iter, SetTreeModule_mem, SetTreeModule_mk, SetTreeModule_mkFromEnumerator, SetTreeModule_mkIEnumerator, SetTreeModule_mkIterator, SetTreeModule_moveNext, SetTreeModule_notStarted, SetTreeModule_ofArray, SetTreeModule_ofList, SetTreeModule_ofSeq, SetTreeModule_rebalance, SetTreeModule_split, SetTreeModule_union, SetTreeNode$1, SetTreeNode$1_$ctor_5F465FC9, SetTreeNode$1__get_Height, SetTreeNode$1__get_Left, SetTreeNode$1__get_Right, contains, intersect, ofSeq, unionMany };