npm - @nfdi4plants/arctrl - Versions diffs - 3.0.0-beta.4 → 3.0.0-beta.6 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (323) hide show

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

@@ -1,16 +1,21 @@
-import { value } from './Option.js';
+import { class_type, record_type, list_type, bool_type, option_type } from './Reflection.js';
+import { value, some } 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 { isEmpty as isEmpty$1, head, tail, ofArrayWithTail, empty as empty$1, singleton as singleton$1, cons, fold as fold$2, FSharpList } from './List.js';
+import { setItem, fill, fold as fold$1 } from './Array.js';
 import { join } from './String.js';
-import { map, iterate, fold as fold$2 } from './Seq.js';
+import { map as map$1, iterate as iterate$1, reduce, fold as fold$3, forAll as forAll$1, cache, exists as exists$1 } from './Seq.js';
+import { HashSet, HashSet_$ctor_Z6150332D, HashSet__get_Comparer } from './MutableSet.js';
 class SetTreeLeaf$1 {
     constructor(k) {
         this.k = k;
     }
 }
+function SetTreeLeaf$1_$reflection(gen0) {
+    return class_type("Set.SetTreeLeaf`1", [gen0], SetTreeLeaf$1);
+}
 function SetTreeLeaf$1_$ctor_2B595(k) {
     return new SetTreeLeaf$1(k);
 }
@@ -25,6 +30,9 @@ class SetTreeNode$1 extends SetTreeLeaf$1 {
         this.h = (h | 0);
     }
 }
+function SetTreeNode$1_$reflection(gen0) {
+    return class_type("Set.SetTreeNode`1", [gen0], SetTreeNode$1, SetTreeLeaf$1_$reflection(gen0));
+}
 function SetTreeNode$1_$ctor_5F465FC9(v, left, right, h) {
     return new SetTreeNode$1(v, left, right, h);
 }
@@ -58,6 +66,7 @@ function SetTreeModule_countAux(t_mut, acc_mut) {
         else {
             return acc | 0;
         }
+        break;
     }
 }
 function SetTreeModule_count(s) {
@@ -262,6 +271,63 @@ function SetTreeModule_split(comparer, pivot, t) {
         return [SetTreeModule_empty(), false, SetTreeModule_empty()];
     }
 }
+function SetTreeModule_spliceOutSuccessor(t) {
+    if (t != null) {
+        const t2 = value(t);
+        if (t2 instanceof SetTreeNode$1) {
+            const tn = t2;
+            if (SetTreeNode$1__get_Left(tn) == null) {
+                return [SetTreeLeaf$1__get_Key(tn), SetTreeNode$1__get_Right(tn)];
+            }
+            else {
+                const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Left(tn));
+                return [patternInput[0], SetTreeModule_mk(patternInput[1], SetTreeLeaf$1__get_Key(tn), SetTreeNode$1__get_Right(tn))];
+            }
+        }
+        else {
+            return [SetTreeLeaf$1__get_Key(t2), SetTreeModule_empty()];
+        }
+    }
+    else {
+        throw new Error("internal error: Set.spliceOutSuccessor");
+    }
+}
+function SetTreeModule_remove(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_remove(comparer, k, SetTreeNode$1__get_Left(tn)), SetTreeLeaf$1__get_Key(tn), SetTreeNode$1__get_Right(tn));
+            }
+            else if (c === 0) {
+                if (SetTreeNode$1__get_Left(tn) == null) {
+                    return SetTreeNode$1__get_Right(tn);
+                }
+                else if (SetTreeNode$1__get_Right(tn) == null) {
+                    return SetTreeNode$1__get_Left(tn);
+                }
+                else {
+                    const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Right(tn));
+                    return SetTreeModule_mk(SetTreeNode$1__get_Left(tn), patternInput[0], patternInput[1]);
+                }
+            }
+            else {
+                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(tn), SetTreeLeaf$1__get_Key(tn), SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Right(tn)));
+            }
+        }
+        else if (c === 0) {
+            return SetTreeModule_empty();
+        }
+        else {
+            return t;
+        }
+    }
+    else {
+        return t;
+    }
+}
 function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {
     SetTreeModule_mem: while (true) {
         const comparer = comparer_mut, k = k_mut, t = t_mut;
@@ -293,6 +359,7 @@ function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {
         else {
             return false;
         }
+        break;
     }
 }
 function SetTreeModule_iter(f_mut, t_mut) {
@@ -315,6 +382,177 @@ function SetTreeModule_iter(f_mut, t_mut) {
         break;
     }
 }
+function SetTreeModule_foldBackOpt(f_mut, t_mut, x_mut) {
+    SetTreeModule_foldBackOpt: while (true) {
+        const f = f_mut, t = t_mut, x = x_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                f_mut = f;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                x_mut = f(SetTreeLeaf$1__get_Key(tn), SetTreeModule_foldBackOpt(f, SetTreeNode$1__get_Right(tn), x));
+                continue SetTreeModule_foldBackOpt;
+            }
+            else {
+                return f(SetTreeLeaf$1__get_Key(t2), x);
+            }
+        }
+        else {
+            return x;
+        }
+        break;
+    }
+}
+function SetTreeModule_foldBack(f, m, x) {
+    return SetTreeModule_foldBackOpt(f, m, x);
+}
+function SetTreeModule_foldOpt(f_mut, x_mut, t_mut) {
+    SetTreeModule_foldOpt: while (true) {
+        const f = f_mut, x = x_mut, t = t_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                f_mut = f;
+                x_mut = f(SetTreeModule_foldOpt(f, x, SetTreeNode$1__get_Left(tn)), SetTreeLeaf$1__get_Key(tn));
+                t_mut = SetTreeNode$1__get_Right(tn);
+                continue SetTreeModule_foldOpt;
+            }
+            else {
+                return f(x, SetTreeLeaf$1__get_Key(t2));
+            }
+        }
+        else {
+            return x;
+        }
+        break;
+    }
+}
+function SetTreeModule_fold(f, x, m) {
+    return SetTreeModule_foldOpt(f, x, m);
+}
+function SetTreeModule_forall(f_mut, t_mut) {
+    SetTreeModule_forall: while (true) {
+        const f = f_mut, t = t_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                if (f(SetTreeLeaf$1__get_Key(tn)) && SetTreeModule_forall(f, SetTreeNode$1__get_Left(tn))) {
+                    f_mut = f;
+                    t_mut = SetTreeNode$1__get_Right(tn);
+                    continue SetTreeModule_forall;
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                return f(SetTreeLeaf$1__get_Key(t2));
+            }
+        }
+        else {
+            return true;
+        }
+        break;
+    }
+}
+function SetTreeModule_exists(f_mut, t_mut) {
+    SetTreeModule_exists: while (true) {
+        const f = f_mut, t = t_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                if (f(SetTreeLeaf$1__get_Key(tn)) ? true : SetTreeModule_exists(f, SetTreeNode$1__get_Left(tn))) {
+                    return true;
+                }
+                else {
+                    f_mut = f;
+                    t_mut = SetTreeNode$1__get_Right(tn);
+                    continue SetTreeModule_exists;
+                }
+            }
+            else {
+                return f(SetTreeLeaf$1__get_Key(t2));
+            }
+        }
+        else {
+            return false;
+        }
+        break;
+    }
+}
+function SetTreeModule_subset(comparer, a, b) {
+    return SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a);
+}
+function SetTreeModule_properSubset(comparer, a, b) {
+    if (SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a)) {
+        return SetTreeModule_exists((x_1) => !SetTreeModule_mem(comparer, x_1, a), b);
+    }
+    else {
+        return false;
+    }
+}
+function SetTreeModule_filterAux(comparer_mut, f_mut, t_mut, acc_mut) {
+    SetTreeModule_filterAux: while (true) {
+        const comparer = comparer_mut, f = f_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 = f(SetTreeLeaf$1__get_Key(tn)) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(tn), acc) : acc;
+                comparer_mut = comparer;
+                f_mut = f;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                acc_mut = SetTreeModule_filterAux(comparer, f, SetTreeNode$1__get_Right(tn), acc_1);
+                continue SetTreeModule_filterAux;
+            }
+            else if (f(SetTreeLeaf$1__get_Key(t2))) {
+                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);
+            }
+            else {
+                return acc;
+            }
+        }
+        else {
+            return acc;
+        }
+        break;
+    }
+}
+function SetTreeModule_filter(comparer, f, s) {
+    return SetTreeModule_filterAux(comparer, f, s, SetTreeModule_empty());
+}
+function SetTreeModule_diffAux(comparer_mut, t_mut, acc_mut) {
+    SetTreeModule_diffAux: while (true) {
+        const comparer = comparer_mut, t = t_mut, acc = acc_mut;
+        if (acc == null) {
+            return acc;
+        }
+        else if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                comparer_mut = comparer;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                acc_mut = SetTreeModule_diffAux(comparer, SetTreeNode$1__get_Right(tn), SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(tn), acc));
+                continue SetTreeModule_diffAux;
+            }
+            else {
+                return SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc);
+            }
+        }
+        else {
+            return acc;
+        }
+        break;
+    }
+}
+function SetTreeModule_diff(comparer, a, b) {
+    return SetTreeModule_diffAux(comparer, b, a);
+}
 function SetTreeModule_union(comparer, t1, t2) {
     if (t1 != null) {
         const t1$0027 = value(t1);
@@ -374,11 +612,140 @@ function SetTreeModule_intersectionAux(comparer_mut, b_mut, t_mut, acc_mut) {
         else {
             return acc;
         }
+        break;
     }
 }
 function SetTreeModule_intersection(comparer, a, b) {
     return SetTreeModule_intersectionAux(comparer, b, a, SetTreeModule_empty());
 }
+function SetTreeModule_partition1(comparer, f, k, acc1, acc2) {
+    if (f(k)) {
+        return [SetTreeModule_add(comparer, k, acc1), acc2];
+    }
+    else {
+        return [acc1, SetTreeModule_add(comparer, k, acc2)];
+    }
+}
+function SetTreeModule_partitionAux(comparer_mut, f_mut, t_mut, acc__mut, acc__1_mut) {
+    SetTreeModule_partitionAux: while (true) {
+        const comparer = comparer_mut, f = f_mut, t = t_mut, acc_ = acc__mut, acc__1 = acc__1_mut;
+        const acc = [acc_, acc__1];
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                const acc_1 = SetTreeModule_partitionAux(comparer, f, SetTreeNode$1__get_Right(tn), acc[0], acc[1]);
+                const acc_4 = SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(tn), acc_1[0], acc_1[1]);
+                comparer_mut = comparer;
+                f_mut = f;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                acc__mut = acc_4[0];
+                acc__1_mut = acc_4[1];
+                continue SetTreeModule_partitionAux;
+            }
+            else {
+                return SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc[0], acc[1]);
+            }
+        }
+        else {
+            return acc;
+        }
+        break;
+    }
+}
+function SetTreeModule_partition(comparer, f, s) {
+    return SetTreeModule_partitionAux(comparer, f, s, SetTreeModule_empty(), SetTreeModule_empty());
+}
+function SetTreeModule_minimumElementAux(t_mut, n_mut) {
+    SetTreeModule_minimumElementAux: while (true) {
+        const t = t_mut, n = n_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                t_mut = SetTreeNode$1__get_Left(tn);
+                n_mut = SetTreeLeaf$1__get_Key(tn);
+                continue SetTreeModule_minimumElementAux;
+            }
+            else {
+                return SetTreeLeaf$1__get_Key(t2);
+            }
+        }
+        else {
+            return n;
+        }
+        break;
+    }
+}
+function SetTreeModule_minimumElementOpt(t) {
+    if (t != null) {
+        const t2 = value(t);
+        if (t2 instanceof SetTreeNode$1) {
+            const tn = t2;
+            return some(SetTreeModule_minimumElementAux(SetTreeNode$1__get_Left(tn), SetTreeLeaf$1__get_Key(tn)));
+        }
+        else {
+            return some(SetTreeLeaf$1__get_Key(t2));
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+function SetTreeModule_maximumElementAux(t_mut, n_mut) {
+    SetTreeModule_maximumElementAux: while (true) {
+        const t = t_mut, n = n_mut;
+        if (t != null) {
+            const t2 = value(t);
+            if (t2 instanceof SetTreeNode$1) {
+                const tn = t2;
+                t_mut = SetTreeNode$1__get_Right(tn);
+                n_mut = SetTreeLeaf$1__get_Key(tn);
+                continue SetTreeModule_maximumElementAux;
+            }
+            else {
+                return SetTreeLeaf$1__get_Key(t2);
+            }
+        }
+        else {
+            return n;
+        }
+        break;
+    }
+}
+function SetTreeModule_maximumElementOpt(t) {
+    if (t != null) {
+        const t2 = value(t);
+        if (t2 instanceof SetTreeNode$1) {
+            const tn = t2;
+            return some(SetTreeModule_maximumElementAux(SetTreeNode$1__get_Right(tn), SetTreeLeaf$1__get_Key(tn)));
+        }
+        else {
+            return some(SetTreeLeaf$1__get_Key(t2));
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+function SetTreeModule_minimumElement(s) {
+    const matchValue = SetTreeModule_minimumElementOpt(s);
+    if (matchValue == null) {
+        throw new Error("Set contains no elements");
+    }
+    else {
+        return value(matchValue);
+    }
+}
+function SetTreeModule_maximumElement(s) {
+    const matchValue = SetTreeModule_maximumElementOpt(s);
+    if (matchValue == null) {
+        throw new Error("Set contains no elements");
+    }
+    else {
+        return value(matchValue);
+    }
+}
 class SetTreeModule_SetIterator$1 extends Record {
     constructor(stack, started) {
         super();
@@ -386,10 +753,13 @@ class SetTreeModule_SetIterator$1 extends Record {
         this.started = started;
     }
 }
+function SetTreeModule_SetIterator$1_$reflection(gen0) {
+    return record_type("Set.SetTreeModule.SetIterator`1", [gen0], SetTreeModule_SetIterator$1, () => [["stack", list_type(option_type(SetTreeLeaf$1_$reflection(gen0)))], ["started", bool_type]]);
+}
 function SetTreeModule_collapseLHS(stack_mut) {
     SetTreeModule_collapseLHS: while (true) {
         const stack = stack_mut;
-        if (!isEmpty(stack)) {
+        if (!isEmpty$1(stack)) {
             const x = head(stack);
             const rest = tail(stack);
             if (x != null) {
@@ -409,12 +779,13 @@ function SetTreeModule_collapseLHS(stack_mut) {
             }
         }
         else {
-            return empty();
+            return empty$1();
         }
+        break;
     }
 }
 function SetTreeModule_mkIterator(s) {
-    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(singleton(s)), false);
+    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(singleton$1(s)), false);
 }
 function SetTreeModule_notStarted() {
     throw new Error("Enumeration not started");
@@ -425,7 +796,7 @@ function SetTreeModule_alreadyFinished() {
 function SetTreeModule_current(i) {
     if (i.started) {
         const matchValue = i.stack;
-        if (isEmpty(matchValue)) {
+        if (isEmpty$1(matchValue)) {
             return SetTreeModule_alreadyFinished();
         }
         else if (head(matchValue) != null) {
@@ -443,7 +814,7 @@ function SetTreeModule_current(i) {
 function SetTreeModule_moveNext(i) {
     if (i.started) {
         const matchValue = i.stack;
-        if (!isEmpty(matchValue)) {
+        if (!isEmpty$1(matchValue)) {
             if (head(matchValue) != null) {
                 const t = value(head(matchValue));
                 if (t instanceof SetTreeNode$1) {
@@ -451,7 +822,7 @@ function SetTreeModule_moveNext(i) {
                 }
                 else {
                     i.stack = SetTreeModule_collapseLHS(tail(matchValue));
-                    return !isEmpty(i.stack);
+                    return !isEmpty$1(i.stack);
                 }
             }
             else {
@@ -464,7 +835,7 @@ function SetTreeModule_moveNext(i) {
     }
     else {
         i.started = true;
-        return !isEmpty(i.stack);
+        return !isEmpty$1(i.stack);
     }
 }
 function SetTreeModule_mkIEnumerator(s) {
@@ -492,8 +863,8 @@ function SetTreeModule_mkIEnumerator(s) {
 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 (!isEmpty$1(l1)) {
+            if (!isEmpty$1(l2)) {
                 if (head(l2) != null) {
                     if (head(l1) != null) {
                         const x1_3 = value(head(l1));
@@ -517,13 +888,13 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                                     }
                                     else {
                                         let matchResult, t1_6, x1_4, t2_6, x2_4;
-                                        if (!isEmpty(l1)) {
+                                        if (!isEmpty$1(l1)) {
                                             if (head(l1) != null) {
                                                 matchResult = 0;
                                                 t1_6 = tail(l1);
                                                 x1_4 = value(head(l1));
                                             }
-                                            else if (!isEmpty(l2)) {
+                                            else if (!isEmpty$1(l2)) {
                                                 if (head(l2) != null) {
                                                     matchResult = 1;
                                                     t2_6 = tail(l2);
@@ -537,7 +908,7 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                                                 matchResult = 2;
                                             }
                                         }
-                                        else if (!isEmpty(l2)) {
+                                        else if (!isEmpty$1(l2)) {
                                             if (head(l2) != null) {
                                                 matchResult = 1;
                                                 t2_6 = tail(l2);
@@ -599,13 +970,13 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                             }
                             else {
                                 let matchResult_1, t1_7, x1_5, t2_7, x2_5;
-                                if (!isEmpty(l1)) {
+                                if (!isEmpty$1(l1)) {
                                     if (head(l1) != null) {
                                         matchResult_1 = 0;
                                         t1_7 = tail(l1);
                                         x1_5 = value(head(l1));
                                     }
-                                    else if (!isEmpty(l2)) {
+                                    else if (!isEmpty$1(l2)) {
                                         if (head(l2) != null) {
                                             matchResult_1 = 1;
                                             t2_7 = tail(l2);
@@ -619,7 +990,7 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                                         matchResult_1 = 2;
                                     }
                                 }
-                                else if (!isEmpty(l2)) {
+                                else if (!isEmpty$1(l2)) {
                                     if (head(l2) != null) {
                                         matchResult_1 = 1;
                                         t2_7 = tail(l2);
@@ -682,13 +1053,13 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                             }
                             else {
                                 let matchResult_2, t1_8, x1_6, t2_8, x2_6;
-                                if (!isEmpty(l1)) {
+                                if (!isEmpty$1(l1)) {
                                     if (head(l1) != null) {
                                         matchResult_2 = 0;
                                         t1_8 = tail(l1);
                                         x1_6 = value(head(l1));
                                     }
-                                    else if (!isEmpty(l2)) {
+                                    else if (!isEmpty$1(l2)) {
                                         if (head(l2) != null) {
                                             matchResult_2 = 1;
                                             t2_8 = tail(l2);
@@ -702,7 +1073,7 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                                         matchResult_2 = 2;
                                     }
                                 }
-                                else if (!isEmpty(l2)) {
+                                else if (!isEmpty$1(l2)) {
                                     if (head(l2) != null) {
                                         matchResult_2 = 1;
                                         t2_8 = tail(l2);
@@ -763,15 +1134,15 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                         }
                     }
                     else {
-                        value(head(l2));
+                        const x2 = value(head(l2));
                         let matchResult_3, t1_2, x1, t2_2, x2_1;
-                        if (!isEmpty(l1)) {
+                        if (!isEmpty$1(l1)) {
                             if (head(l1) != null) {
                                 matchResult_3 = 0;
                                 t1_2 = tail(l1);
                                 x1 = value(head(l1));
                             }
-                            else if (!isEmpty(l2)) {
+                            else if (!isEmpty$1(l2)) {
                                 if (head(l2) != null) {
                                     matchResult_3 = 1;
                                     t2_2 = tail(l2);
@@ -785,7 +1156,7 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                                 matchResult_3 = 2;
                             }
                         }
-                        else if (!isEmpty(l2)) {
+                        else if (!isEmpty$1(l2)) {
                             if (head(l2) != null) {
                                 matchResult_3 = 1;
                                 t2_2 = tail(l2);
@@ -833,15 +1204,15 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                     }
                 }
                 else if (head(l1) != null) {
-                    value(head(l1));
+                    const x1_1 = value(head(l1));
                     let matchResult_4, t1_4, x1_2, t2_4, x2_2;
-                    if (!isEmpty(l1)) {
+                    if (!isEmpty$1(l1)) {
                         if (head(l1) != null) {
                             matchResult_4 = 0;
                             t1_4 = tail(l1);
                             x1_2 = value(head(l1));
                         }
-                        else if (!isEmpty(l2)) {
+                        else if (!isEmpty$1(l2)) {
                             if (head(l2) != null) {
                                 matchResult_4 = 1;
                                 t2_4 = tail(l2);
@@ -855,7 +1226,7 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                             matchResult_4 = 2;
                         }
                     }
-                    else if (!isEmpty(l2)) {
+                    else if (!isEmpty$1(l2)) {
                         if (head(l2) != null) {
                             matchResult_4 = 1;
                             t2_4 = tail(l2);
@@ -912,12 +1283,13 @@ function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {
                 return 1;
             }
         }
-        else if (isEmpty(l2)) {
+        else if (isEmpty$1(l2)) {
             return 0;
         }
         else {
             return -1;
         }
+        break;
     }
 }
 function SetTreeModule_compare(comparer, t1, t2) {
@@ -933,9 +1305,36 @@ function SetTreeModule_compare(comparer, t1, t2) {
         return 1;
     }
     else {
-        return SetTreeModule_compareStacks(comparer, singleton(t1), singleton(t2)) | 0;
+        return SetTreeModule_compareStacks(comparer, singleton$1(t1), singleton$1(t2)) | 0;
     }
 }
+function SetTreeModule_choose(s) {
+    return SetTreeModule_minimumElement(s);
+}
+function SetTreeModule_toList(t) {
+    const loop = (t$0027_mut, acc_mut) => {
+        loop: while (true) {
+            const t$0027 = t$0027_mut, acc = acc_mut;
+            if (t$0027 != null) {
+                const t2 = value(t$0027);
+                if (t2 instanceof SetTreeNode$1) {
+                    const tn = t2;
+                    t$0027_mut = SetTreeNode$1__get_Left(tn);
+                    acc_mut = cons(SetTreeLeaf$1__get_Key(tn), loop(SetTreeNode$1__get_Right(tn), acc));
+                    continue loop;
+                }
+                else {
+                    return cons(SetTreeLeaf$1__get_Key(t2), acc);
+                }
+            }
+            else {
+                return acc;
+            }
+            break;
+        }
+    };
+    return loop(t, empty$1());
+}
 function SetTreeModule_copyToArray(s, arr, i) {
     let j = i;
     SetTreeModule_iter((x) => {
@@ -943,6 +1342,12 @@ function SetTreeModule_copyToArray(s, arr, i) {
         j = ((j + 1) | 0);
     }, s);
 }
+function SetTreeModule_toArray(s) {
+    const n = SetTreeModule_count(s) | 0;
+    const res = fill(new Array(n), 0, n, null);
+    SetTreeModule_copyToArray(s, res, 0);
+    return res;
+}
 function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
     SetTreeModule_mkFromEnumerator: while (true) {
         const comparer = comparer_mut, acc = acc_mut, e = e_mut;
@@ -955,13 +1360,14 @@ function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
         else {
             return acc;
         }
+        break;
     }
 }
 function SetTreeModule_ofArray(comparer, l) {
-    return fold((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);
+    return fold$1((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);
+    return fold$2((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);
 }
 function SetTreeModule_ofSeq(comparer, c) {
     if (isArrayLike(c)) {
@@ -996,7 +1402,7 @@ class FSharpSet {
     }
     toString() {
         const this$ = this;
-        return ("set [" + join("; ", map((x) => {
+        return ("set [" + join("; ", map$1((x) => {
             let copyOfStruct = x;
             return toString(copyOfStruct);
         }, this$))) + "]";
@@ -1056,13 +1462,16 @@ class FSharpSet {
         return FSharpSet__get_Count(s) | 0;
     }
     add(k) {
+        const s = this;
         throw new Error("Set cannot be mutated");
+        return s;
     }
     clear() {
         throw new Error("Set cannot be mutated");
     }
     delete(k) {
         throw new Error("Set cannot be mutated");
+        return false;
     }
     has(k) {
         const s = this;
@@ -1070,23 +1479,26 @@ class FSharpSet {
     }
     keys() {
         const s = this;
-        return map((x) => x, s);
+        return map$1((x) => x, s);
     }
     values() {
         const s = this;
-        return map((x) => x, s);
+        return map$1((x) => x, s);
     }
     entries() {
         const s = this;
-        return map((v) => [v, v], s);
+        return map$1((v) => [v, v], s);
     }
     forEach(f, thisArg) {
         const s = this;
-        iterate((x) => {
+        iterate$1((x) => {
             f(x, x, s);
         }, s);
     }
 }
+function FSharpSet_$reflection(gen0) {
+    return class_type("Set.FSharpSet", [gen0], FSharpSet);
+}
 function FSharpSet_$ctor(comparer, tree) {
     return new FSharpSet(comparer, tree);
 }
@@ -1099,15 +1511,65 @@ function FSharpSet__get_Tree(set$) {
 function FSharpSet_Empty(comparer) {
     return FSharpSet_$ctor(comparer, SetTreeModule_empty());
 }
+function FSharpSet__Add(s, value) {
+    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_add(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));
+}
+function FSharpSet__Remove(s, value) {
+    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_remove(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));
+}
 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__Iterate(s, x) {
+    SetTreeModule_iter(x, FSharpSet__get_Tree(s));
+}
+function FSharpSet__Fold(s, f, z) {
+    const f_1 = f;
+    return SetTreeModule_fold((x, z_1) => f_1(z_1, x), z, FSharpSet__get_Tree(s));
+}
 function FSharpSet__get_IsEmpty(s) {
     return FSharpSet__get_Tree(s) == null;
 }
+function FSharpSet__Partition(s, f) {
+    if (FSharpSet__get_Tree(s) == null) {
+        return [s, s];
+    }
+    else {
+        const patternInput = SetTreeModule_partition(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s));
+        return [FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[0]), FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[1])];
+    }
+}
+function FSharpSet__Filter(s, f) {
+    if (FSharpSet__get_Tree(s) == null) {
+        return s;
+    }
+    else {
+        return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_filter(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s)));
+    }
+}
+function FSharpSet__Map(s, f, comparer) {
+    return FSharpSet_$ctor(comparer, SetTreeModule_fold((acc, k) => SetTreeModule_add(comparer, f(k), acc), SetTreeModule_empty(), FSharpSet__get_Tree(s)));
+}
+function FSharpSet__Exists(s, f) {
+    return SetTreeModule_exists(f, FSharpSet__get_Tree(s));
+}
+function FSharpSet__ForAll(s, f) {
+    return SetTreeModule_forall(f, FSharpSet__get_Tree(s));
+}
+function FSharpSet_op_Subtraction(set1, set2) {
+    if (FSharpSet__get_Tree(set1) == null) {
+        return set1;
+    }
+    else if (FSharpSet__get_Tree(set2) == null) {
+        return set1;
+    }
+    else {
+        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_diff(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));
+    }
+}
 function FSharpSet_op_Addition(set1, set2) {
     if (FSharpSet__get_Tree(set2) == null) {
         return set1;
@@ -1130,6 +1592,42 @@ function FSharpSet_Intersection(a, b) {
         return FSharpSet_$ctor(FSharpSet__get_Comparer(a), SetTreeModule_intersection(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)));
     }
 }
+function FSharpSet_IntersectionMany(sets) {
+    return reduce(FSharpSet_Intersection, sets);
+}
+function FSharpSet_Equality(a, b) {
+    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) === 0;
+}
+function FSharpSet_Compare(a, b) {
+    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b));
+}
+function FSharpSet__get_Choose(x) {
+    return SetTreeModule_choose(FSharpSet__get_Tree(x));
+}
+function FSharpSet__get_MinimumElement(x) {
+    return SetTreeModule_minimumElement(FSharpSet__get_Tree(x));
+}
+function FSharpSet__get_MaximumElement(x) {
+    return SetTreeModule_maximumElement(FSharpSet__get_Tree(x));
+}
+function FSharpSet__IsSubsetOf(x, otherSet) {
+    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));
+}
+function FSharpSet__IsSupersetOf(x, otherSet) {
+    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));
+}
+function FSharpSet__IsProperSubsetOf(x, otherSet) {
+    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));
+}
+function FSharpSet__IsProperSupersetOf(x, otherSet) {
+    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));
+}
+function FSharpSet__ToList(x) {
+    return SetTreeModule_toList(FSharpSet__get_Tree(x));
+}
+function FSharpSet__ToArray(x) {
+    return SetTreeModule_toArray(FSharpSet__get_Tree(x));
+}
 function FSharpSet__ComputeHashCode(this$) {
     let res = 0;
     const enumerator = getEnumerator(this$);
@@ -1144,17 +1642,151 @@ function FSharpSet__ComputeHashCode(this$) {
     }
     return Math.abs(res) | 0;
 }
+function isEmpty(set$) {
+    return FSharpSet__get_IsEmpty(set$);
+}
 function contains(element, set$) {
     return FSharpSet__Contains(set$, element);
 }
+function add(value, set$) {
+    return FSharpSet__Add(set$, value);
+}
+function singleton(value, comparer) {
+    return FSharpSet__Add(FSharpSet_Empty(comparer), value);
+}
+function remove(value, set$) {
+    return FSharpSet__Remove(set$, value);
+}
+function union(set1, set2) {
+    return FSharpSet_op_Addition(set1, set2);
+}
 function unionMany(sets, comparer) {
-    return fold$2(FSharpSet_op_Addition, FSharpSet_Empty(comparer), sets);
+    return fold$3(FSharpSet_op_Addition, FSharpSet_Empty(comparer), sets);
 }
 function intersect(set1, set2) {
     return FSharpSet_Intersection(set1, set2);
 }
+function intersectMany(sets) {
+    return FSharpSet_IntersectionMany(sets);
+}
+function iterate(action, set$) {
+    FSharpSet__Iterate(set$, action);
+}
+function empty(comparer) {
+    return FSharpSet_Empty(comparer);
+}
+function forAll(predicate, set$) {
+    return FSharpSet__ForAll(set$, predicate);
+}
+function exists(predicate, set$) {
+    return FSharpSet__Exists(set$, predicate);
+}
+function filter(predicate, set$) {
+    return FSharpSet__Filter(set$, predicate);
+}
+function partition(predicate, set$) {
+    return FSharpSet__Partition(set$, predicate);
+}
+function fold(folder, state, set$) {
+    return SetTreeModule_fold(folder, state, FSharpSet__get_Tree(set$));
+}
+function foldBack(folder, set$, state) {
+    return SetTreeModule_foldBack(folder, FSharpSet__get_Tree(set$), state);
+}
+function map(mapping, set$, comparer) {
+    return FSharpSet__Map(set$, mapping, comparer);
+}
+function count(set$) {
+    return FSharpSet__get_Count(set$);
+}
+function ofList(elements, comparer) {
+    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));
+}
+function ofArray(array, comparer) {
+    return FSharpSet_$ctor(comparer, SetTreeModule_ofArray(comparer, array));
+}
+function toList(set$) {
+    return FSharpSet__ToList(set$);
+}
+function toArray(set$) {
+    return FSharpSet__ToArray(set$);
+}
+function toSeq(set$) {
+    return map$1((x) => x, set$);
+}
 function ofSeq(elements, comparer) {
     return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));
 }
+function difference(set1, set2) {
+    return FSharpSet_op_Subtraction(set1, set2);
+}
+function isSubset(set1, set2) {
+    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));
+}
+function isSuperset(set1, set2) {
+    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));
+}
+function isProperSubset(set1, set2) {
+    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));
+}
+function isProperSuperset(set1, set2) {
+    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));
+}
+function minElement(set$) {
+    return FSharpSet__get_MinimumElement(set$);
+}
+function maxElement(set$) {
+    return FSharpSet__get_MaximumElement(set$);
+}
+function unionWith(s1, s2) {
+    return fold$3((acc, x) => acc.add(x), s1, s2);
+}
+function newMutableSetWith(s1, s2) {
+    if (s1 instanceof HashSet) {
+        const s1_1 = s1;
+        return HashSet_$ctor_Z6150332D(s2, HashSet__get_Comparer(s1_1));
+    }
+    else {
+        return new Set(s2);
+    }
+}
+function intersectWith(s1, s2) {
+    const s2_1 = newMutableSetWith(s1, s2);
+    iterate$1((x) => {
+        if (!s2_1.has(x)) {
+            s1.delete(x);
+        }
+    }, s1.values());
+}
+function exceptWith(s1, s2) {
+    iterate$1((x) => {
+        s1.delete(x);
+    }, s2);
+}
+function isSubsetOf(s1, s2) {
+    const s2_1 = newMutableSetWith(s1, s2);
+    return forAll$1((value) => s2_1.has(value), s1.values());
+}
+function isSupersetOf(s1, s2) {
+    return forAll$1((value) => s1.has(value), s2);
+}
+function isProperSubsetOf(s1, s2) {
+    const s2_1 = newMutableSetWith(s1, s2);
+    if (s2_1.size > s1.size) {
+        return forAll$1((value) => s2_1.has(value), s1.values());
+    }
+    else {
+        return false;
+    }
+}
+function isProperSupersetOf(s1, s2) {
+    const s2_1 = cache(s2);
+    if (exists$1((arg) => !s1.has(arg), s2_1)) {
+        return forAll$1((value_2) => s1.has(value_2), s2_1);
+    }
+    else {
+        return false;
+    }
+}
-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 };
+export { FSharpSet, FSharpSet_$ctor, FSharpSet_$reflection, FSharpSet_Compare, FSharpSet_Empty, FSharpSet_Equality, FSharpSet_Intersection, FSharpSet_IntersectionMany, FSharpSet__Add, FSharpSet__ComputeHashCode, FSharpSet__Contains, FSharpSet__Exists, FSharpSet__Filter, FSharpSet__Fold, FSharpSet__ForAll, FSharpSet__IsProperSubsetOf, FSharpSet__IsProperSupersetOf, FSharpSet__IsSubsetOf, FSharpSet__IsSupersetOf, FSharpSet__Iterate, FSharpSet__Map, FSharpSet__Partition, FSharpSet__Remove, FSharpSet__ToArray, FSharpSet__ToList, FSharpSet__get_Choose, FSharpSet__get_Comparer, FSharpSet__get_Count, FSharpSet__get_IsEmpty, FSharpSet__get_MaximumElement, FSharpSet__get_MinimumElement, FSharpSet__get_Tree, FSharpSet_op_Addition, FSharpSet_op_Subtraction, SetTreeLeaf$1, SetTreeLeaf$1_$ctor_2B595, SetTreeLeaf$1_$reflection, SetTreeLeaf$1__get_Key, SetTreeModule_SetIterator$1, SetTreeModule_SetIterator$1_$reflection, SetTreeModule_add, SetTreeModule_alreadyFinished, SetTreeModule_balance, SetTreeModule_choose, SetTreeModule_collapseLHS, SetTreeModule_compare, SetTreeModule_compareStacks, SetTreeModule_copyToArray, SetTreeModule_count, SetTreeModule_countAux, SetTreeModule_current, SetTreeModule_diff, SetTreeModule_diffAux, SetTreeModule_empty, SetTreeModule_exists, SetTreeModule_filter, SetTreeModule_filterAux, SetTreeModule_fold, SetTreeModule_foldBack, SetTreeModule_foldBackOpt, SetTreeModule_foldOpt, SetTreeModule_forall, SetTreeModule_intersection, SetTreeModule_intersectionAux, SetTreeModule_iter, SetTreeModule_maximumElement, SetTreeModule_maximumElementAux, SetTreeModule_maximumElementOpt, SetTreeModule_mem, SetTreeModule_minimumElement, SetTreeModule_minimumElementAux, SetTreeModule_minimumElementOpt, SetTreeModule_mk, SetTreeModule_mkFromEnumerator, SetTreeModule_mkIEnumerator, SetTreeModule_mkIterator, SetTreeModule_moveNext, SetTreeModule_notStarted, SetTreeModule_ofArray, SetTreeModule_ofList, SetTreeModule_ofSeq, SetTreeModule_partition, SetTreeModule_partition1, SetTreeModule_partitionAux, SetTreeModule_properSubset, SetTreeModule_rebalance, SetTreeModule_remove, SetTreeModule_spliceOutSuccessor, SetTreeModule_split, SetTreeModule_subset, SetTreeModule_toArray, SetTreeModule_toList, SetTreeModule_union, SetTreeNode$1, SetTreeNode$1_$ctor_5F465FC9, SetTreeNode$1_$reflection, SetTreeNode$1__get_Height, SetTreeNode$1__get_Left, SetTreeNode$1__get_Right, add, contains, count, difference, empty, exceptWith, exists, filter, fold, foldBack, forAll, intersect, intersectMany, intersectWith, isEmpty, isProperSubset, isProperSubsetOf, isProperSuperset, isProperSupersetOf, isSubset, isSubsetOf, isSuperset, isSupersetOf, iterate, map, maxElement, minElement, newMutableSetWith, ofArray, ofList, ofSeq, partition, remove, singleton, toArray, toList, toSeq, union, unionMany, unionWith };