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

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

@@ -1,9 +1,10 @@
+import { class_type, record_type, list_type, bool_type, option_type } from './Reflection.js';
 import { value, some } from './Option.js';
-import { isArrayLike, getEnumerator, disposeSafe, equals, toIterator, structuralHash, compare } from './Util.js';
-import { FSharpList, fold, singleton, isEmpty, head, tail, ofArrayWithTail, empty as empty$1 } from './List.js';
-import { item, setItem } from './Array.js';
+import { isArrayLike, getEnumerator, disposeSafe, equals, toIterator, compare, structuralHash } from './Util.js';
+import { cons, empty as empty$1, fold as fold$1, FSharpList, isEmpty as isEmpty$1, tail, head, ofArrayWithTail, singleton } from './List.js';
+import { setItem, fill, item, map as map$2 } from './Array.js';
 import { Record } from './Types.js';
-import { map, compareWith, iterate } from './Seq.js';
+import { unfold, map as map$1, compareWith, iterate as iterate$1, pick as pick$1, tryPick as tryPick$1 } from './Seq.js';
 import { join, format } from './String.js';
 
 class MapTreeLeaf$2 {
@@ -12,6 +13,9 @@ class MapTreeLeaf$2 {
         this.v = v;
     }
 }
+function MapTreeLeaf$2_$reflection(gen0, gen1) {
+    return class_type("Map.MapTreeLeaf`2", [gen0, gen1], MapTreeLeaf$2);
+}
 function MapTreeLeaf$2_$ctor_5BDDA1(k, v) {
     return new MapTreeLeaf$2(k, v);
 }
@@ -29,6 +33,9 @@ class MapTreeNode$2 extends MapTreeLeaf$2 {
         this.h = (h | 0);
     }
 }
+function MapTreeNode$2_$reflection(gen0, gen1) {
+    return class_type("Map.MapTreeNode`2", [gen0, gen1], MapTreeNode$2, MapTreeLeaf$2_$reflection(gen0, gen1));
+}
 function MapTreeNode$2_$ctor_Z39DE9543(k, v, left, right, h) {
     return new MapTreeNode$2(k, v, left, right, h);
 }
@@ -62,6 +69,7 @@ function MapTreeModule_sizeAux(acc_mut, m_mut) {
         else {
             return acc | 0;
         }
+        break;
     }
 }
 function MapTreeModule_size(x) {
@@ -216,6 +224,7 @@ function MapTreeModule_tryFind(comparer_mut, k_mut, m_mut) {
         else {
             return undefined;
         }
+        break;
     }
 }
 function MapTreeModule_find(comparer, k, m) {
@@ -227,6 +236,207 @@ function MapTreeModule_find(comparer, k, m) {
         return value(matchValue);
     }
 }
+function MapTreeModule_partition1(comparer, f, k, v, acc1, acc2) {
+    if (f(k, v)) {
+        return [MapTreeModule_add(comparer, k, v, acc1), acc2];
+    }
+    else {
+        return [acc1, MapTreeModule_add(comparer, k, v, acc2)];
+    }
+}
+function MapTreeModule_partitionAux(comparer_mut, f_mut, m_mut, acc__mut, acc__1_mut) {
+    MapTreeModule_partitionAux: while (true) {
+        const comparer = comparer_mut, f = f_mut, m = m_mut, acc_ = acc__mut, acc__1 = acc__1_mut;
+        const acc = [acc_, acc__1];
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                const acc_1 = MapTreeModule_partitionAux(comparer, f, MapTreeNode$2__get_Right(mn), acc[0], acc[1]);
+                const acc_4 = MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), acc_1[0], acc_1[1]);
+                comparer_mut = comparer;
+                f_mut = f;
+                m_mut = MapTreeNode$2__get_Left(mn);
+                acc__mut = acc_4[0];
+                acc__1_mut = acc_4[1];
+                continue MapTreeModule_partitionAux;
+            }
+            else {
+                return MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc[0], acc[1]);
+            }
+        }
+        else {
+            return acc;
+        }
+        break;
+    }
+}
+function MapTreeModule_partition(comparer, f, m) {
+    return MapTreeModule_partitionAux(comparer, f, m, MapTreeModule_empty(), MapTreeModule_empty());
+}
+function MapTreeModule_filter1(comparer, f, k, v, acc) {
+    if (f(k, v)) {
+        return MapTreeModule_add(comparer, k, v, acc);
+    }
+    else {
+        return acc;
+    }
+}
+function MapTreeModule_filterAux(comparer_mut, f_mut, m_mut, acc_mut) {
+    MapTreeModule_filterAux: while (true) {
+        const comparer = comparer_mut, f = f_mut, m = m_mut, acc = acc_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                const acc_1 = MapTreeModule_filterAux(comparer, f, MapTreeNode$2__get_Left(mn), acc);
+                const acc_2 = MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), acc_1);
+                comparer_mut = comparer;
+                f_mut = f;
+                m_mut = MapTreeNode$2__get_Right(mn);
+                acc_mut = acc_2;
+                continue MapTreeModule_filterAux;
+            }
+            else {
+                return MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc);
+            }
+        }
+        else {
+            return acc;
+        }
+        break;
+    }
+}
+function MapTreeModule_filter(comparer, f, m) {
+    return MapTreeModule_filterAux(comparer, f, m, MapTreeModule_empty());
+}
+function MapTreeModule_spliceOutSuccessor(m) {
+    if (m != null) {
+        const m2 = value(m);
+        if (m2 instanceof MapTreeNode$2) {
+            const mn = m2;
+            if (MapTreeNode$2__get_Left(mn) == null) {
+                return [MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeNode$2__get_Right(mn)];
+            }
+            else {
+                const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Left(mn));
+                return [patternInput[0], patternInput[1], MapTreeModule_mk(patternInput[2], MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeNode$2__get_Right(mn))];
+            }
+        }
+        else {
+            return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_empty()];
+        }
+    }
+    else {
+        throw new Error("internal error: Map.spliceOutSuccessor");
+    }
+}
+function MapTreeModule_remove(comparer, k, m) {
+    if (m != null) {
+        const m2 = value(m);
+        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;
+        if (m2 instanceof MapTreeNode$2) {
+            const mn = m2;
+            if (c < 0) {
+                return MapTreeModule_rebalance(MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Left(mn)), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeNode$2__get_Right(mn));
+            }
+            else if (c === 0) {
+                if (MapTreeNode$2__get_Left(mn) == null) {
+                    return MapTreeNode$2__get_Right(mn);
+                }
+                else if (MapTreeNode$2__get_Right(mn) == null) {
+                    return MapTreeNode$2__get_Left(mn);
+                }
+                else {
+                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(mn));
+                    return MapTreeModule_mk(MapTreeNode$2__get_Left(mn), patternInput[0], patternInput[1], patternInput[2]);
+                }
+            }
+            else {
+                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(mn), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Right(mn)));
+            }
+        }
+        else if (c === 0) {
+            return MapTreeModule_empty();
+        }
+        else {
+            return m;
+        }
+    }
+    else {
+        return MapTreeModule_empty();
+    }
+}
+function MapTreeModule_change(comparer, k, u, m) {
+    if (m != null) {
+        const m2 = value(m);
+        if (m2 instanceof MapTreeNode$2) {
+            const mn = m2;
+            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(mn)) | 0;
+            if (c < 0) {
+                return MapTreeModule_rebalance(MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Left(mn)), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeNode$2__get_Right(mn));
+            }
+            else if (c === 0) {
+                const matchValue_1 = u(some(MapTreeLeaf$2__get_Value(mn)));
+                if (matchValue_1 != null) {
+                    return MapTreeNode$2_$ctor_Z39DE9543(k, value(matchValue_1), MapTreeNode$2__get_Left(mn), MapTreeNode$2__get_Right(mn), MapTreeNode$2__get_Height(mn));
+                }
+                else if (MapTreeNode$2__get_Left(mn) == null) {
+                    return MapTreeNode$2__get_Right(mn);
+                }
+                else if (MapTreeNode$2__get_Right(mn) == null) {
+                    return MapTreeNode$2__get_Left(mn);
+                }
+                else {
+                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(mn));
+                    return MapTreeModule_mk(MapTreeNode$2__get_Left(mn), patternInput[0], patternInput[1], patternInput[2]);
+                }
+            }
+            else {
+                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(mn), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Right(mn)));
+            }
+        }
+        else {
+            const c_1 = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;
+            if (c_1 < 0) {
+                const matchValue_2 = u(undefined);
+                if (matchValue_2 != null) {
+                    return MapTreeNode$2_$ctor_Z39DE9543(k, value(matchValue_2), MapTreeModule_empty(), m, 2);
+                }
+                else {
+                    return m;
+                }
+            }
+            else if (c_1 === 0) {
+                const matchValue_3 = u(some(MapTreeLeaf$2__get_Value(m2)));
+                if (matchValue_3 != null) {
+                    return MapTreeLeaf$2_$ctor_5BDDA1(k, value(matchValue_3));
+                }
+                else {
+                    return MapTreeModule_empty();
+                }
+            }
+            else {
+                const matchValue_4 = u(undefined);
+                if (matchValue_4 != null) {
+                    return MapTreeNode$2_$ctor_Z39DE9543(k, value(matchValue_4), m, MapTreeModule_empty(), 2);
+                }
+                else {
+                    return m;
+                }
+            }
+        }
+    }
+    else {
+        const matchValue = u(undefined);
+        if (matchValue != null) {
+            return MapTreeLeaf$2_$ctor_5BDDA1(k, value(matchValue));
+        }
+        else {
+            return m;
+        }
+    }
+}
 function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {
     MapTreeModule_mem: while (true) {
         const comparer = comparer_mut, k = k_mut, m = m_mut;
@@ -258,6 +468,7 @@ function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {
         else {
             return false;
         }
+        break;
     }
 }
 function MapTreeModule_iterOpt(f_mut, m_mut) {
@@ -283,6 +494,260 @@ function MapTreeModule_iterOpt(f_mut, m_mut) {
 function MapTreeModule_iter(f, m) {
     MapTreeModule_iterOpt(f, m);
 }
+function MapTreeModule_tryPickOpt(f_mut, m_mut) {
+    MapTreeModule_tryPickOpt: while (true) {
+        const f = f_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                const matchValue = MapTreeModule_tryPickOpt(f, MapTreeNode$2__get_Left(mn));
+                if (matchValue == null) {
+                    const matchValue_1 = f(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn));
+                    if (matchValue_1 == null) {
+                        f_mut = f;
+                        m_mut = MapTreeNode$2__get_Right(mn);
+                        continue MapTreeModule_tryPickOpt;
+                    }
+                    else {
+                        return matchValue_1;
+                    }
+                }
+                else {
+                    return matchValue;
+                }
+            }
+            else {
+                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));
+            }
+        }
+        else {
+            return undefined;
+        }
+        break;
+    }
+}
+function MapTreeModule_tryPick(f, m) {
+    return MapTreeModule_tryPickOpt(f, m);
+}
+function MapTreeModule_existsOpt(f_mut, m_mut) {
+    MapTreeModule_existsOpt: while (true) {
+        const f = f_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                if (MapTreeModule_existsOpt(f, MapTreeNode$2__get_Left(mn)) ? true : f(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn))) {
+                    return true;
+                }
+                else {
+                    f_mut = f;
+                    m_mut = MapTreeNode$2__get_Right(mn);
+                    continue MapTreeModule_existsOpt;
+                }
+            }
+            else {
+                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));
+            }
+        }
+        else {
+            return false;
+        }
+        break;
+    }
+}
+function MapTreeModule_exists(f, m) {
+    return MapTreeModule_existsOpt(f, m);
+}
+function MapTreeModule_forallOpt(f_mut, m_mut) {
+    MapTreeModule_forallOpt: while (true) {
+        const f = f_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                if (MapTreeModule_forallOpt(f, MapTreeNode$2__get_Left(mn)) && f(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn))) {
+                    f_mut = f;
+                    m_mut = MapTreeNode$2__get_Right(mn);
+                    continue MapTreeModule_forallOpt;
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));
+            }
+        }
+        else {
+            return true;
+        }
+        break;
+    }
+}
+function MapTreeModule_forall(f, m) {
+    return MapTreeModule_forallOpt(f, m);
+}
+function MapTreeModule_map(f, m) {
+    if (m != null) {
+        const m2 = value(m);
+        if (m2 instanceof MapTreeNode$2) {
+            const mn = m2;
+            const l2 = MapTreeModule_map(f, MapTreeNode$2__get_Left(mn));
+            const v2 = f(MapTreeLeaf$2__get_Value(mn));
+            const r2 = MapTreeModule_map(f, MapTreeNode$2__get_Right(mn));
+            return MapTreeNode$2_$ctor_Z39DE9543(MapTreeLeaf$2__get_Key(mn), v2, l2, r2, MapTreeNode$2__get_Height(mn));
+        }
+        else {
+            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Value(m2)));
+        }
+    }
+    else {
+        return MapTreeModule_empty();
+    }
+}
+function MapTreeModule_mapiOpt(f, m) {
+    if (m != null) {
+        const m2 = value(m);
+        if (m2 instanceof MapTreeNode$2) {
+            const mn = m2;
+            const l2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Left(mn));
+            const v2 = f(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn));
+            const r2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Right(mn));
+            return MapTreeNode$2_$ctor_Z39DE9543(MapTreeLeaf$2__get_Key(mn), v2, l2, r2, MapTreeNode$2__get_Height(mn));
+        }
+        else {
+            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)));
+        }
+    }
+    else {
+        return MapTreeModule_empty();
+    }
+}
+function MapTreeModule_mapi(f, m) {
+    return MapTreeModule_mapiOpt(f, m);
+}
+function MapTreeModule_foldBackOpt(f_mut, m_mut, x_mut) {
+    MapTreeModule_foldBackOpt: while (true) {
+        const f = f_mut, m = m_mut, x = x_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                const x_1 = MapTreeModule_foldBackOpt(f, MapTreeNode$2__get_Right(mn), x);
+                const x_2 = f(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), x_1);
+                f_mut = f;
+                m_mut = MapTreeNode$2__get_Left(mn);
+                x_mut = x_2;
+                continue MapTreeModule_foldBackOpt;
+            }
+            else {
+                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x);
+            }
+        }
+        else {
+            return x;
+        }
+        break;
+    }
+}
+function MapTreeModule_foldBack(f, m, x) {
+    return MapTreeModule_foldBackOpt(f, m, x);
+}
+function MapTreeModule_foldOpt(f_mut, x_mut, m_mut) {
+    MapTreeModule_foldOpt: while (true) {
+        const f = f_mut, x = x_mut, m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            if (m2 instanceof MapTreeNode$2) {
+                const mn = m2;
+                f_mut = f;
+                x_mut = f(MapTreeModule_foldOpt(f, x, MapTreeNode$2__get_Left(mn)), MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn));
+                m_mut = MapTreeNode$2__get_Right(mn);
+                continue MapTreeModule_foldOpt;
+            }
+            else {
+                return f(x, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));
+            }
+        }
+        else {
+            return x;
+        }
+        break;
+    }
+}
+function MapTreeModule_fold(f, x, m) {
+    return MapTreeModule_foldOpt(f, x, m);
+}
+function MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x) {
+    const foldFromTo = (f_1_mut, m_1_mut, x_1_mut) => {
+        foldFromTo: while (true) {
+            const f_1 = f_1_mut, m_1 = m_1_mut, x_1 = x_1_mut;
+            if (m_1 != null) {
+                const m2 = value(m_1);
+                if (m2 instanceof MapTreeNode$2) {
+                    const mn = m2;
+                    const cLoKey = comparer.Compare(lo, MapTreeLeaf$2__get_Key(mn)) | 0;
+                    const cKeyHi = comparer.Compare(MapTreeLeaf$2__get_Key(mn), hi) | 0;
+                    const x_2 = (cLoKey < 0) ? foldFromTo(f_1, MapTreeNode$2__get_Left(mn), x_1) : x_1;
+                    const x_3 = ((cLoKey <= 0) && (cKeyHi <= 0)) ? f_1(MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn), x_2) : x_2;
+                    if (cKeyHi < 0) {
+                        f_1_mut = f_1;
+                        m_1_mut = MapTreeNode$2__get_Right(mn);
+                        x_1_mut = x_3;
+                        continue foldFromTo;
+                    }
+                    else {
+                        return x_3;
+                    }
+                }
+                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) <= 0) && (comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) <= 0)) {
+                    return f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);
+                }
+                else {
+                    return x_1;
+                }
+            }
+            else {
+                return x_1;
+            }
+            break;
+        }
+    };
+    if (comparer.Compare(lo, hi) === 1) {
+        return x;
+    }
+    else {
+        return foldFromTo(f, m, x);
+    }
+}
+function MapTreeModule_foldSection(comparer, lo, hi, f, m, x) {
+    return MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x);
+}
+function MapTreeModule_toList(m) {
+    const loop = (m_1_mut, acc_mut) => {
+        loop: while (true) {
+            const m_1 = m_1_mut, acc = acc_mut;
+            if (m_1 != null) {
+                const m2 = value(m_1);
+                if (m2 instanceof MapTreeNode$2) {
+                    const mn = m2;
+                    m_1_mut = MapTreeNode$2__get_Left(mn);
+                    acc_mut = cons([MapTreeLeaf$2__get_Key(mn), MapTreeLeaf$2__get_Value(mn)], loop(MapTreeNode$2__get_Right(mn), acc));
+                    continue loop;
+                }
+                else {
+                    return cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], acc);
+                }
+            }
+            else {
+                return acc;
+            }
+            break;
+        }
+    };
+    return loop(m, empty$1());
+}
 function MapTreeModule_copyToArray(m, arr, i) {
     let j = i;
     MapTreeModule_iter((x, y) => {
@@ -290,8 +755,14 @@ function MapTreeModule_copyToArray(m, arr, i) {
         j = ((j + 1) | 0);
     }, m);
 }
+function MapTreeModule_toArray(m) {
+    const n = MapTreeModule_size(m) | 0;
+    const res = fill(new Array(n), 0, n, [null, null]);
+    MapTreeModule_copyToArray(m, res, 0);
+    return res;
+}
 function MapTreeModule_ofList(comparer, l) {
-    return fold((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);
+    return fold$1((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);
 }
 function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
     MapTreeModule_mkFromEnumerator: while (true) {
@@ -306,6 +777,7 @@ function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
         else {
             return acc;
         }
+        break;
     }
 }
 function MapTreeModule_ofArray(comparer, arr) {
@@ -340,10 +812,13 @@ class MapTreeModule_MapIterator$2 extends Record {
         this.started = started;
     }
 }
+function MapTreeModule_MapIterator$2_$reflection(gen0, gen1) {
+    return record_type("Map.MapTreeModule.MapIterator`2", [gen0, gen1], MapTreeModule_MapIterator$2, () => [["stack", list_type(option_type(MapTreeLeaf$2_$reflection(gen0, gen1)))], ["started", bool_type]]);
+}
 function MapTreeModule_collapseLHS(stack_mut) {
     MapTreeModule_collapseLHS: while (true) {
         const stack = stack_mut;
-        if (!isEmpty(stack)) {
+        if (!isEmpty$1(stack)) {
             const rest = tail(stack);
             const m = head(stack);
             if (m != null) {
@@ -365,6 +840,7 @@ function MapTreeModule_collapseLHS(stack_mut) {
         else {
             return empty$1();
         }
+        break;
     }
 }
 function MapTreeModule_mkIterator(m) {
@@ -379,7 +855,7 @@ function MapTreeModule_alreadyFinished() {
 function MapTreeModule_current(i) {
     if (i.started) {
         const matchValue = i.stack;
-        if (!isEmpty(matchValue)) {
+        if (!isEmpty$1(matchValue)) {
             if (head(matchValue) != null) {
                 const m = value(head(matchValue));
                 if (m instanceof MapTreeNode$2) {
@@ -404,7 +880,7 @@ function MapTreeModule_current(i) {
 function MapTreeModule_moveNext(i) {
     if (i.started) {
         const matchValue = i.stack;
-        if (!isEmpty(matchValue)) {
+        if (!isEmpty$1(matchValue)) {
             if (head(matchValue) != null) {
                 const m = value(head(matchValue));
                 if (m instanceof MapTreeNode$2) {
@@ -412,7 +888,7 @@ function MapTreeModule_moveNext(i) {
                 }
                 else {
                     i.stack = MapTreeModule_collapseLHS(tail(matchValue));
-                    return !isEmpty(i.stack);
+                    return !isEmpty$1(i.stack);
                 }
             }
             else {
@@ -425,7 +901,7 @@ function MapTreeModule_moveNext(i) {
     }
     else {
         i.started = true;
-        return !isEmpty(i.stack);
+        return !isEmpty$1(i.stack);
     }
 }
 function MapTreeModule_mkIEnumerator(m) {
@@ -447,6 +923,90 @@ function MapTreeModule_mkIEnumerator(m) {
         },
     };
 }
+function MapTreeModule_toSeq(s) {
+    return unfold((en_1) => {
+        if (en_1["System.Collections.IEnumerator.MoveNext"]()) {
+            return [en_1["System.Collections.Generic.IEnumerator`1.get_Current"](), en_1];
+        }
+        else {
+            return undefined;
+        }
+    }, MapTreeModule_mkIEnumerator(s));
+}
+function MapTreeModule_leftmost(m_mut) {
+    MapTreeModule_leftmost: while (true) {
+        const m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            let matchResult, nd_1;
+            if (m2 instanceof MapTreeNode$2) {
+                if (MapTreeNode$2__get_Height(m2) > 1) {
+                    matchResult = 0;
+                    nd_1 = m2;
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    if (MapTreeNode$2__get_Left(nd_1) == null) {
+                        return [MapTreeLeaf$2__get_Key(nd_1), MapTreeLeaf$2__get_Value(nd_1)];
+                    }
+                    else {
+                        m_mut = MapTreeNode$2__get_Left(nd_1);
+                        continue MapTreeModule_leftmost;
+                    }
+                default:
+                    return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)];
+            }
+        }
+        else {
+            throw new Error();
+        }
+        break;
+    }
+}
+function MapTreeModule_rightmost(m_mut) {
+    MapTreeModule_rightmost: while (true) {
+        const m = m_mut;
+        if (m != null) {
+            const m2 = value(m);
+            let matchResult, nd_1;
+            if (m2 instanceof MapTreeNode$2) {
+                if (MapTreeNode$2__get_Height(m2) > 1) {
+                    matchResult = 0;
+                    nd_1 = m2;
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    if (MapTreeNode$2__get_Right(nd_1) == null) {
+                        return [MapTreeLeaf$2__get_Key(nd_1), MapTreeLeaf$2__get_Value(nd_1)];
+                    }
+                    else {
+                        m_mut = MapTreeNode$2__get_Right(nd_1);
+                        continue MapTreeModule_rightmost;
+                    }
+                default:
+                    return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)];
+            }
+        }
+        else {
+            throw new Error();
+        }
+        break;
+    }
+}
 class FSharpMap {
     constructor(comparer, tree) {
         this.comparer = comparer;
@@ -501,7 +1061,7 @@ class FSharpMap {
     }
     toString() {
         const this$ = this;
-        return ("map [" + join("; ", map((kv) => format("({0}, {1})", kv[0], kv[1]), this$))) + "]";
+        return ("map [" + join("; ", map$1((kv) => format("({0}, {1})", kv[0], kv[1]), this$))) + "]";
     }
     get [Symbol.toStringTag]() {
         return "FSharpMap";
@@ -571,10 +1131,11 @@ class FSharpMap {
     }
     delete(_arg) {
         throw new Error("Map cannot be mutated");
+        return false;
     }
     entries() {
         const m = this;
-        return map((p) => [p[0], p[1]], m);
+        return map$1((p) => [p[0], p[1]], m);
     }
     get(k) {
         const m = this;
@@ -586,40 +1147,123 @@ class FSharpMap {
     }
     keys() {
         const m = this;
-        return map((p) => p[0], m);
+        return map$1((p) => p[0], m);
     }
     set(k, v) {
+        const m = this;
         throw new Error("Map cannot be mutated");
+        return m;
     }
     values() {
         const m = this;
-        return map((p) => p[1], m);
+        return map$1((p) => p[1], m);
     }
     forEach(f, thisArg) {
         const m = this;
-        iterate((p) => {
+        iterate$1((p) => {
             f(p[1], p[0], m);
         }, m);
     }
 }
+function FSharpMap_$reflection(gen0, gen1) {
+    return class_type("Map.FSharpMap", [gen0, gen1], FSharpMap);
+}
 function FSharpMap_$ctor(comparer, tree) {
     return new FSharpMap(comparer, tree);
 }
 function FSharpMap_Empty(comparer) {
     return FSharpMap_$ctor(comparer, MapTreeModule_empty());
 }
+function FSharpMap__get_Comparer(m) {
+    return m.comparer;
+}
+function FSharpMap__get_Tree(m) {
+    return m.tree;
+}
+function FSharpMap__Add(m, key, value) {
+    return FSharpMap_$ctor(m.comparer, MapTreeModule_add(m.comparer, key, value, m.tree));
+}
+function FSharpMap__Change(m, key, f) {
+    return FSharpMap_$ctor(m.comparer, MapTreeModule_change(m.comparer, key, f, m.tree));
+}
+function FSharpMap__get_IsEmpty(m) {
+    return m.tree == null;
+}
 function FSharpMap__get_Item(m, key) {
     return MapTreeModule_find(m.comparer, key, m.tree);
 }
+function FSharpMap__TryPick(m, f) {
+    return MapTreeModule_tryPick(f, m.tree);
+}
+function FSharpMap__Exists(m, predicate) {
+    return MapTreeModule_exists(predicate, m.tree);
+}
+function FSharpMap__Filter(m, predicate) {
+    return FSharpMap_$ctor(m.comparer, MapTreeModule_filter(m.comparer, predicate, m.tree));
+}
+function FSharpMap__ForAll(m, predicate) {
+    return MapTreeModule_forall(predicate, m.tree);
+}
+function FSharpMap__Fold(m, f, acc) {
+    return MapTreeModule_foldBack(f, m.tree, acc);
+}
+function FSharpMap__FoldSection(m, lo, hi, f, acc) {
+    return MapTreeModule_foldSection(m.comparer, lo, hi, f, m.tree, acc);
+}
+function FSharpMap__Iterate(m, f) {
+    MapTreeModule_iter(f, m.tree);
+}
+function FSharpMap__MapRange(m, f) {
+    return FSharpMap_$ctor(m.comparer, MapTreeModule_map(f, m.tree));
+}
+function FSharpMap__Map(m, f) {
+    return FSharpMap_$ctor(m.comparer, MapTreeModule_mapi(f, m.tree));
+}
+function FSharpMap__Partition(m, predicate) {
+    const patternInput = MapTreeModule_partition(m.comparer, predicate, m.tree);
+    return [FSharpMap_$ctor(m.comparer, patternInput[0]), FSharpMap_$ctor(m.comparer, patternInput[1])];
+}
 function FSharpMap__get_Count(m) {
     return MapTreeModule_size(m.tree);
 }
 function FSharpMap__ContainsKey(m, key) {
     return MapTreeModule_mem(m.comparer, key, m.tree);
 }
+function FSharpMap__Remove(m, key) {
+    return FSharpMap_$ctor(m.comparer, MapTreeModule_remove(m.comparer, key, m.tree));
+}
+function FSharpMap__TryGetValue(_, key, value$1) {
+    const matchValue = MapTreeModule_tryFind(_.comparer, key, _.tree);
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        const v = value(matchValue);
+        value$1.contents = v;
+        return true;
+    }
+}
+function FSharpMap__get_Keys(_) {
+    return map$2((kvp) => kvp[0], MapTreeModule_toArray(_.tree));
+}
+function FSharpMap__get_Values(_) {
+    return map$2((kvp) => kvp[1], MapTreeModule_toArray(_.tree));
+}
+function FSharpMap__get_MinKeyValue(m) {
+    return MapTreeModule_leftmost(m.tree);
+}
+function FSharpMap__get_MaxKeyValue(m) {
+    return MapTreeModule_rightmost(m.tree);
+}
 function FSharpMap__TryFind(m, key) {
     return MapTreeModule_tryFind(m.comparer, key, m.tree);
 }
+function FSharpMap__ToList(m) {
+    return MapTreeModule_toList(m.tree);
+}
+function FSharpMap__ToArray(m) {
+    return MapTreeModule_toArray(m.tree);
+}
 function FSharpMap__ComputeHashCode(this$) {
     const combineHash = (x, y) => (((x << 1) + y) + 631);
     let res = 0;
@@ -636,9 +1280,88 @@ function FSharpMap__ComputeHashCode(this$) {
     }
     return res | 0;
 }
+function isEmpty(table) {
+    return FSharpMap__get_IsEmpty(table);
+}
+function add(key, value, table) {
+    return FSharpMap__Add(table, key, value);
+}
+function change(key, f, table) {
+    return FSharpMap__Change(table, key, f);
+}
+function find(key, table) {
+    return FSharpMap__get_Item(table, key);
+}
 function tryFind(key, table) {
     return FSharpMap__TryFind(table, key);
 }
+function remove(key, table) {
+    return FSharpMap__Remove(table, key);
+}
+function containsKey(key, table) {
+    return FSharpMap__ContainsKey(table, key);
+}
+function iterate(action, table) {
+    FSharpMap__Iterate(table, action);
+}
+function tryPick(chooser, table) {
+    return FSharpMap__TryPick(table, chooser);
+}
+function pick(chooser, table) {
+    const matchValue = tryPick(chooser, table);
+    if (matchValue != null) {
+        return value(matchValue);
+    }
+    else {
+        throw new Error();
+    }
+}
+function exists(predicate, table) {
+    return FSharpMap__Exists(table, predicate);
+}
+function filter(predicate, table) {
+    return FSharpMap__Filter(table, predicate);
+}
+function partition(predicate, table) {
+    return FSharpMap__Partition(table, predicate);
+}
+function forAll(predicate, table) {
+    return FSharpMap__ForAll(table, predicate);
+}
+function map(mapping, table) {
+    return FSharpMap__Map(table, mapping);
+}
+function fold(folder, state, table) {
+    return MapTreeModule_fold(folder, state, FSharpMap__get_Tree(table));
+}
+function foldBack(folder, table, state) {
+    return MapTreeModule_foldBack(folder, FSharpMap__get_Tree(table), state);
+}
+function toSeq(table) {
+    return map$1((kvp) => [kvp[0], kvp[1]], table);
+}
+function findKey(predicate, table) {
+    return pick$1((kvp) => {
+        const k = kvp[0];
+        if (predicate(k, kvp[1])) {
+            return some(k);
+        }
+        else {
+            return undefined;
+        }
+    }, table);
+}
+function tryFindKey(predicate, table) {
+    return tryPick$1((kvp) => {
+        const k = kvp[0];
+        if (predicate(k, kvp[1])) {
+            return some(k);
+        }
+        else {
+            return undefined;
+        }
+    }, table);
+}
 function ofList(elements, comparer) {
     return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, elements));
 }
@@ -648,8 +1371,29 @@ function ofSeq(elements, comparer) {
 function ofArray(elements, comparer) {
     return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, elements));
 }
+function toList(table) {
+    return FSharpMap__ToList(table);
+}
+function toArray(table) {
+    return FSharpMap__ToArray(table);
+}
+function keys(table) {
+    return FSharpMap__get_Keys(table);
+}
+function values(table) {
+    return FSharpMap__get_Values(table);
+}
+function minKeyValue(table) {
+    return FSharpMap__get_MinKeyValue(table);
+}
+function maxKeyValue(table) {
+    return FSharpMap__get_MaxKeyValue(table);
+}
 function empty(comparer) {
     return FSharpMap_Empty(comparer);
 }
+function count(table) {
+    return FSharpMap__get_Count(table);
+}
 
-export { FSharpMap, FSharpMap_$ctor, FSharpMap_Empty, FSharpMap__ComputeHashCode, FSharpMap__ContainsKey, FSharpMap__TryFind, FSharpMap__get_Count, FSharpMap__get_Item, MapTreeLeaf$2, MapTreeLeaf$2_$ctor_5BDDA1, MapTreeLeaf$2__get_Key, MapTreeLeaf$2__get_Value, MapTreeModule_MapIterator$2, MapTreeModule_add, MapTreeModule_alreadyFinished, MapTreeModule_collapseLHS, MapTreeModule_copyToArray, MapTreeModule_current, MapTreeModule_empty, MapTreeModule_find, MapTreeModule_iter, MapTreeModule_iterOpt, MapTreeModule_mem, MapTreeModule_mk, MapTreeModule_mkFromEnumerator, MapTreeModule_mkIEnumerator, MapTreeModule_mkIterator, MapTreeModule_moveNext, MapTreeModule_notStarted, MapTreeModule_ofArray, MapTreeModule_ofList, MapTreeModule_ofSeq, MapTreeModule_rebalance, MapTreeModule_size, MapTreeModule_sizeAux, MapTreeModule_tryFind, MapTreeNode$2, MapTreeNode$2_$ctor_Z39DE9543, MapTreeNode$2__get_Height, MapTreeNode$2__get_Left, MapTreeNode$2__get_Right, empty, ofArray, ofList, ofSeq, tryFind };
+export { FSharpMap, FSharpMap_$ctor, FSharpMap_$reflection, FSharpMap_Empty, FSharpMap__Add, FSharpMap__Change, FSharpMap__ComputeHashCode, FSharpMap__ContainsKey, FSharpMap__Exists, FSharpMap__Filter, FSharpMap__Fold, FSharpMap__FoldSection, FSharpMap__ForAll, FSharpMap__Iterate, FSharpMap__Map, FSharpMap__MapRange, FSharpMap__Partition, FSharpMap__Remove, FSharpMap__ToArray, FSharpMap__ToList, FSharpMap__TryFind, FSharpMap__TryGetValue, FSharpMap__TryPick, FSharpMap__get_Comparer, FSharpMap__get_Count, FSharpMap__get_IsEmpty, FSharpMap__get_Item, FSharpMap__get_Keys, FSharpMap__get_MaxKeyValue, FSharpMap__get_MinKeyValue, FSharpMap__get_Tree, FSharpMap__get_Values, MapTreeLeaf$2, MapTreeLeaf$2_$ctor_5BDDA1, MapTreeLeaf$2_$reflection, MapTreeLeaf$2__get_Key, MapTreeLeaf$2__get_Value, MapTreeModule_MapIterator$2, MapTreeModule_MapIterator$2_$reflection, MapTreeModule_add, MapTreeModule_alreadyFinished, MapTreeModule_change, MapTreeModule_collapseLHS, MapTreeModule_copyToArray, MapTreeModule_current, MapTreeModule_empty, MapTreeModule_exists, MapTreeModule_existsOpt, MapTreeModule_filter, MapTreeModule_filter1, MapTreeModule_filterAux, MapTreeModule_find, MapTreeModule_fold, MapTreeModule_foldBack, MapTreeModule_foldBackOpt, MapTreeModule_foldOpt, MapTreeModule_foldSection, MapTreeModule_foldSectionOpt, MapTreeModule_forall, MapTreeModule_forallOpt, MapTreeModule_iter, MapTreeModule_iterOpt, MapTreeModule_leftmost, MapTreeModule_map, MapTreeModule_mapi, MapTreeModule_mapiOpt, MapTreeModule_mem, MapTreeModule_mk, MapTreeModule_mkFromEnumerator, MapTreeModule_mkIEnumerator, MapTreeModule_mkIterator, MapTreeModule_moveNext, MapTreeModule_notStarted, MapTreeModule_ofArray, MapTreeModule_ofList, MapTreeModule_ofSeq, MapTreeModule_partition, MapTreeModule_partition1, MapTreeModule_partitionAux, MapTreeModule_rebalance, MapTreeModule_remove, MapTreeModule_rightmost, MapTreeModule_size, MapTreeModule_sizeAux, MapTreeModule_spliceOutSuccessor, MapTreeModule_toArray, MapTreeModule_toList, MapTreeModule_toSeq, MapTreeModule_tryFind, MapTreeModule_tryPick, MapTreeModule_tryPickOpt, MapTreeNode$2, MapTreeNode$2_$ctor_Z39DE9543, MapTreeNode$2_$reflection, MapTreeNode$2__get_Height, MapTreeNode$2__get_Left, MapTreeNode$2__get_Right, add, change, containsKey, count, empty, exists, filter, find, findKey, fold, foldBack, forAll, isEmpty, iterate, keys, map, maxKeyValue, minKeyValue, ofArray, ofList, ofSeq, partition, pick, remove, toArray, toList, toSeq, tryFind, tryFindKey, tryPick, values };