@fable-org/fable-library-ts 2.0.0-beta.4 → 2.0.0-beta.5

package/Map.ts

@@ -1,13 +1,15 @@
 
-import { record_type, bool_type, list_type, option_type, class_type, TypeInfo } from "./Reflection.js";
-import { some, value as value_1, Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { structuralHash, IMap, compare, toIterator, equals, IDisposable, disposeSafe, getEnumerator, isArrayLike, IEnumerator, IComparer, Nullable } from "./Util.js";
-import { singleton, ofArrayWithTail, head, tail, isEmpty as isEmpty_1, fold as fold_1, empty as empty_1, FSharpList, cons } from "./List.js";
-import { map as map_2, item, fill, setItem } from "./Array.js";
-import { FSharpRef, Record } from "./Types.js";
-import { tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, map as map_1, unfold } from "./Seq.js";
-import { format, join } from "./String.js";
+import { record_type, bool_type, list_type, option_type, class_type, TypeInfo } from "./Reflection.ts";
+import { some, value as value_1, Option } from "./Option.ts";
+import { int32 } from "./Int32.ts";
+import { structuralHash, IMap, compare, toIterator, equals, IDisposable, disposeSafe, getEnumerator, isArrayLike, IEnumerator, MutableArray, IComparer, Exception } from "./Util.ts";
+import { KeyNotFoundException_$ctor } from "./System.Collections.Generic.ts";
+import { singleton, ofArrayWithTail, head, tail, isEmpty as isEmpty_1, fold as fold_1, empty as empty_1, FSharpList, cons } from "./List.ts";
+import { map as map_2, item, fill, setItem } from "./Array.ts";
+import { FSharpRef, Record } from "./Types.ts";
+import { tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, map as map_1, unfold } from "./Seq.ts";
+import { format, join } from "./String.ts";
+import { NotSupportedException_$ctor_Z721C83C5 } from "./System.ts";
 
 export class MapTreeLeaf$2<Key, Value> {
     readonly v: Value;
@@ -98,7 +100,7 @@ export function MapTreeModule_size<$a, $b>(x: Option<MapTreeLeaf$2<$a, $b>>): in
 }
 
 export function MapTreeModule_mk<Key, Value>(l: Option<MapTreeLeaf$2<Key, Value>>, k: Key, v: Value, r: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>> {
-    let mn: MapTreeNode$2<Key, Value>, mn_1: MapTreeNode$2<Key, Value>;
+    let mn: MapTreeNode$2<Key, Value> = (undefined as any), mn_1: MapTreeNode$2<Key, Value> = (undefined as any);
     let hl: int32;
     const m: Option<MapTreeLeaf$2<Key, Value>> = l;
     if (m != null) {
@@ -127,7 +129,7 @@ export function MapTreeModule_mk<Key, Value>(l: Option<MapTreeLeaf$2<Key, Value>
 }
 
 export function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key, Value>>, k: Key, v: Value, t2: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>> {
-    let mn: MapTreeNode$2<Key, Value>, mn_1: MapTreeNode$2<Key, Value>, m_2: Option<MapTreeLeaf$2<Key, Value>>, m2_2: MapTreeLeaf$2<Key, Value>, mn_2: MapTreeNode$2<Key, Value>, m_3: Option<MapTreeLeaf$2<Key, Value>>, m2_3: MapTreeLeaf$2<Key, Value>, mn_3: MapTreeNode$2<Key, Value>;
+    let mn: MapTreeNode$2<Key, Value> = (undefined as any), mn_1: MapTreeNode$2<Key, Value> = (undefined as any), m_2: Option<MapTreeLeaf$2<Key, Value>> = (undefined as any), m2_2: MapTreeLeaf$2<Key, Value> = (undefined as any), mn_2: MapTreeNode$2<Key, Value> = (undefined as any), m_3: Option<MapTreeLeaf$2<Key, Value>> = (undefined as any), m2_3: MapTreeLeaf$2<Key, Value> = (undefined as any), mn_3: MapTreeNode$2<Key, Value> = (undefined as any);
     let t1h: int32;
     const m: Option<MapTreeLeaf$2<Key, Value>> = t1;
     if (m != null) {
@@ -157,7 +159,7 @@ export function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key
                     return MapTreeModule_mk<Key, Value>(MapTreeModule_mk<Key, Value>(t1, k, v, MapTreeNode$2__get_Left<Key, Value>(t2l)), MapTreeLeaf$2__get_Key<Key, Value>(t2l), MapTreeLeaf$2__get_Value<Key, Value>(t2l), MapTreeModule_mk<Key, Value>(MapTreeNode$2__get_Right<Key, Value>(t2l), MapTreeLeaf$2__get_Key<Key, Value>(t2$0027), MapTreeLeaf$2__get_Value<Key, Value>(t2$0027), MapTreeNode$2__get_Right<Key, Value>(t2$0027)));
                 }
                 else {
-                    throw new Error("internal error: Map.rebalance");
+                    throw new Exception("internal error: Map.rebalance");
                 }
             }
             else {
@@ -165,7 +167,7 @@ export function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key
             }
         }
         else {
-            throw new Error("internal error: Map.rebalance");
+            throw new Exception("internal error: Map.rebalance");
         }
     }
     else if (t1h > (t2h + 2)) {
@@ -179,7 +181,7 @@ export function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key
                     return MapTreeModule_mk<Key, Value>(MapTreeModule_mk<Key, Value>(MapTreeNode$2__get_Left<Key, Value>(t1$0027), MapTreeLeaf$2__get_Key<Key, Value>(t1$0027), MapTreeLeaf$2__get_Value<Key, Value>(t1$0027), MapTreeNode$2__get_Left<Key, Value>(t1r)), MapTreeLeaf$2__get_Key<Key, Value>(t1r), MapTreeLeaf$2__get_Value<Key, Value>(t1r), MapTreeModule_mk<Key, Value>(MapTreeNode$2__get_Right<Key, Value>(t1r), k, v, t2));
                 }
                 else {
-                    throw new Error("internal error: Map.rebalance");
+                    throw new Exception("internal error: Map.rebalance");
                 }
             }
             else {
@@ -187,7 +189,7 @@ export function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key
             }
         }
         else {
-            throw new Error("internal error: Map.rebalance");
+            throw new Exception("internal error: Map.rebalance");
         }
     }
     else {
@@ -198,7 +200,7 @@ export function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key
 export function MapTreeModule_add<Key, Value>(comparer: IComparer<Key>, k: Key, v: Value, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>> {
     if (m != null) {
         const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
-        const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2)) | 0;
+        const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Key, Value>(m2)) | 0;
         if (m2 instanceof MapTreeNode$2) {
             const mn = m2 as MapTreeNode$2<Key, Value>;
             if (c < 0) {
@@ -232,7 +234,7 @@ export function MapTreeModule_tryFind<Key, Value>(comparer_mut: IComparer<Key>,
         const comparer: IComparer<Key> = comparer_mut, k: Key = k_mut, m: Option<MapTreeLeaf$2<Key, Value>> = m_mut;
         if (m != null) {
             const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
-            const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2)) | 0;
+            const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Key, Value>(m2)) | 0;
             if (c === 0) {
                 return some(MapTreeLeaf$2__get_Value<Key, Value>(m2));
             }
@@ -257,7 +259,7 @@ export function MapTreeModule_tryFind<Key, Value>(comparer_mut: IComparer<Key>,
 export function MapTreeModule_find<Key, Value>(comparer: IComparer<Key>, k: Key, m: Option<MapTreeLeaf$2<Key, Value>>): Value {
     const matchValue: Option<Value> = MapTreeModule_tryFind<Key, Value>(comparer, k, m);
     if (matchValue == null) {
-        throw new Error();
+        throw KeyNotFoundException_$ctor();
     }
     else {
         return value_1(matchValue);
@@ -364,14 +366,14 @@ export function MapTreeModule_spliceOutSuccessor<Key, Value>(m: Option<MapTreeLe
         }
     }
     else {
-        throw new Error("internal error: Map.spliceOutSuccessor");
+        throw new Exception("internal error: Map.spliceOutSuccessor");
     }
 }
 
-export function MapTreeModule_remove<Key, Value>(comparer: IComparer<Key>, k: Nullable<Key>, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>> {
+export function MapTreeModule_remove<Key, Value>(comparer: IComparer<Key>, k: Key, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>> {
     if (m != null) {
         const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
-        const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2)) | 0;
+        const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Key, Value>(m2)) | 0;
         if (m2 instanceof MapTreeNode$2) {
             const mn = m2 as MapTreeNode$2<Key, Value>;
             if (c < 0) {
@@ -410,7 +412,7 @@ export function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Ke
         const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
         if (m2 instanceof MapTreeNode$2) {
             const mn = m2 as MapTreeNode$2<Key, Value>;
-            const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(mn)) | 0;
+            const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Key, Value>(mn)) | 0;
             if (c < 0) {
                 return MapTreeModule_rebalance<Key, Value>(MapTreeModule_change<Key, Value>(comparer, k, u, MapTreeNode$2__get_Left<Key, Value>(mn)), MapTreeLeaf$2__get_Key<Key, Value>(mn), MapTreeLeaf$2__get_Value<Key, Value>(mn), MapTreeNode$2__get_Right<Key, Value>(mn));
             }
@@ -435,7 +437,7 @@ export function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Ke
             }
         }
         else {
-            const c_1: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2)) | 0;
+            const c_1: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Key, Value>(m2)) | 0;
             if (c_1 < 0) {
                 const matchValue_2: Option<Value> = u(undefined);
                 if (matchValue_2 != null) {
@@ -476,13 +478,13 @@ export function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Ke
     }
 }
 
-export function MapTreeModule_mem<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Nullable<Key>, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean {
+export function MapTreeModule_mem<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Key, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean {
     MapTreeModule_mem:
     while (true) {
-        const comparer: IComparer<Key> = comparer_mut, k: Nullable<Key> = k_mut, m: Option<MapTreeLeaf$2<Key, Value>> = m_mut;
+        const comparer: IComparer<Key> = comparer_mut, k: Key = k_mut, m: Option<MapTreeLeaf$2<Key, Value>> = m_mut;
         if (m != null) {
             const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
-            const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2)) | 0;
+            const c: int32 = comparer.Compare(k, MapTreeLeaf$2__get_Key<Key, Value>(m2)) | 0;
             if (m2 instanceof MapTreeNode$2) {
                 const mn = m2 as MapTreeNode$2<Key, Value>;
                 if (c < 0) {
@@ -741,7 +743,7 @@ export function MapTreeModule_fold<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c
     return MapTreeModule_foldOpt<$a, $b, $c>(f, x, m);
 }
 
-export function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<Key>, lo: Nullable<Key>, hi: Nullable<Key>, f: any, m: Option<MapTreeLeaf$2<Key, Value>>, x: a): a {
+export function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<Key>, lo: Key, hi: Key, f: any, m: Option<MapTreeLeaf$2<Key, Value>>, x: a): a {
     const foldFromTo = (f_1_mut: any, m_1_mut: Option<MapTreeLeaf$2<Key, Value>>, x_1_mut: a): a => {
         foldFromTo:
         while (true) {
@@ -750,8 +752,8 @@ export function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<
                 const m2: MapTreeLeaf$2<Key, Value> = value_1(m_1);
                 if (m2 instanceof MapTreeNode$2) {
                     const mn = m2 as MapTreeNode$2<Key, Value>;
-                    const cLoKey: int32 = comparer.Compare(lo, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(mn)) | 0;
-                    const cKeyHi: int32 = comparer.Compare(MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(mn), hi) | 0;
+                    const cLoKey: int32 = comparer.Compare(lo, MapTreeLeaf$2__get_Key<Key, Value>(mn)) | 0;
+                    const cKeyHi: int32 = comparer.Compare(MapTreeLeaf$2__get_Key<Key, Value>(mn), hi) | 0;
                     const x_2: a = (cLoKey < 0) ? foldFromTo(f_1, MapTreeNode$2__get_Left<Key, Value>(mn), x_1) : x_1;
                     const x_3: a = ((cLoKey <= 0) && (cKeyHi <= 0)) ? f_1(MapTreeLeaf$2__get_Key<Key, Value>(mn), MapTreeLeaf$2__get_Value<Key, Value>(mn), x_2) : x_2;
                     if (cKeyHi < 0) {
@@ -764,7 +766,7 @@ export function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<
                         return x_3;
                     }
                 }
-                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2)) <= 0) && (comparer.Compare(MapTreeLeaf$2__get_Key<Nullable<Key>, Value>(m2), hi) <= 0)) {
+                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key<Key, Value>(m2)) <= 0) && (comparer.Compare(MapTreeLeaf$2__get_Key<Key, Value>(m2), hi) <= 0)) {
                     return f_1(MapTreeLeaf$2__get_Key<Key, Value>(m2), MapTreeLeaf$2__get_Value<Key, Value>(m2), x_1);
                 }
                 else {
@@ -785,7 +787,7 @@ export function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<
     }
 }
 
-export function MapTreeModule_foldSection<$a, $b, $c>(comparer: IComparer<$a>, lo: Nullable<$a>, hi: Nullable<$a>, f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c {
+export function MapTreeModule_foldSection<$a, $b, $c>(comparer: IComparer<$a>, lo: $a, hi: $a, f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c {
     return MapTreeModule_foldSectionOpt<$a, $b, $c>(comparer, lo, hi, f, m, x);
 }
 
@@ -815,7 +817,7 @@ export function MapTreeModule_toList<Key, Value>(m: Option<MapTreeLeaf$2<Key, Va
     return loop(m, empty_1<[Key, Value]>());
 }
 
-export function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>, arr: [$a, $b][], i: int32): void {
+export function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>, arr: MutableArray<[$a, $b]>, i: int32): void {
     let j: int32 = i;
     MapTreeModule_iter<$a, $b>((x: $a, y: $b): void => {
         setItem(arr, j, [x, y] as [$a, $b]);
@@ -823,9 +825,9 @@ export function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b
     }, m);
 }
 
-export function MapTreeModule_toArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): [$a, $b][] {
+export function MapTreeModule_toArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): MutableArray<[$a, $b]> {
     const n: int32 = MapTreeModule_size<$a, $b>(m) | 0;
-    const res: [$a, $b][] = fill(new Array(n), 0, n, [null, null] as [any, any]);
+    const res: MutableArray<[$a, $b]> = fill(new Array(n), 0, n, [null, null] as [any, any]);
     MapTreeModule_copyToArray<$a, $b>(m, res, 0);
     return res;
 }
@@ -852,7 +854,7 @@ export function MapTreeModule_mkFromEnumerator<$a, $b>(comparer_mut: IComparer<$
     }
 }
 
-export function MapTreeModule_ofArray<Key, Value>(comparer: IComparer<Key>, arr: [Key, Value][]): Option<MapTreeLeaf$2<Key, Value>> {
+export function MapTreeModule_ofArray<Key, Value>(comparer: IComparer<Key>, arr: MutableArray<[Key, Value]>): Option<MapTreeLeaf$2<Key, Value>> {
     let res: Option<MapTreeLeaf$2<Key, Value>> = MapTreeModule_empty<Key, Value>();
     for (let idx = 0; idx <= (arr.length - 1); idx++) {
         const forLoopVar: [Key, Value] = item(idx, arr);
@@ -928,11 +930,11 @@ export function MapTreeModule_mkIterator<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>
 }
 
 export function MapTreeModule_notStarted<$a>(): $a {
-    throw new Error("enumeration not started");
+    throw new Exception("enumeration not started");
 }
 
 export function MapTreeModule_alreadyFinished<$a>(): $a {
-    throw new Error("enumeration already finished");
+    throw new Exception("enumeration already finished");
 }
 
 export function MapTreeModule_current<Key, Value>(i: MapTreeModule_MapIterator$2<Key, Value>): [Key, Value] {
@@ -942,14 +944,14 @@ export function MapTreeModule_current<Key, Value>(i: MapTreeModule_MapIterator$2
             if (head(matchValue) != null) {
                 const m: MapTreeLeaf$2<Key, Value> = value_1(head(matchValue));
                 if (m instanceof MapTreeNode$2) {
-                    throw new Error("Please report error: Map iterator, unexpected stack for current");
+                    throw new Exception("Please report error: Map iterator, unexpected stack for current");
                 }
                 else {
                     return [MapTreeLeaf$2__get_Key<Key, Value>(m), MapTreeLeaf$2__get_Value<Key, Value>(m)] as [Key, Value];
                 }
             }
             else {
-                throw new Error("Please report error: Map iterator, unexpected stack for current");
+                throw new Exception("Please report error: Map iterator, unexpected stack for current");
             }
         }
         else {
@@ -968,7 +970,7 @@ export function MapTreeModule_moveNext<Key, Value>(i: MapTreeModule_MapIterator$
             if (head(matchValue) != null) {
                 const m: MapTreeLeaf$2<Key, Value> = value_1(head(matchValue));
                 if (m instanceof MapTreeNode$2) {
-                    throw new Error("Please report error: Map iterator, unexpected stack for moveNext");
+                    throw new Exception("Please report error: Map iterator, unexpected stack for moveNext");
                 }
                 else {
                     i.stack = MapTreeModule_collapseLHS<Key, Value>(tail(matchValue));
@@ -976,7 +978,7 @@ export function MapTreeModule_moveNext<Key, Value>(i: MapTreeModule_MapIterator$
                 }
             }
             else {
-                throw new Error("Please report error: Map iterator, unexpected stack for moveNext");
+                throw new Exception("Please report error: Map iterator, unexpected stack for moveNext");
             }
         }
         else {
@@ -995,7 +997,7 @@ export function MapTreeModule_mkIEnumerator<a, b>(m: Option<MapTreeLeaf$2<a, b>>
         "System.Collections.Generic.IEnumerator`1.get_Current"(): [a, b] {
             return MapTreeModule_current<a, b>(i);
         },
-        "System.Collections.IEnumerator.get_Current"(): Nullable<any> {
+        "System.Collections.IEnumerator.get_Current"(): any {
             return MapTreeModule_current<a, b>(i);
         },
         "System.Collections.IEnumerator.MoveNext"(): boolean {
@@ -1026,7 +1028,7 @@ export function MapTreeModule_leftmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<K
         const m: Option<MapTreeLeaf$2<Key, Value>> = m_mut;
         if (m != null) {
             const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
-            let matchResult: int32, nd_1: MapTreeNode$2<Key, Value>;
+            let matchResult: int32 = (undefined as any), nd_1: MapTreeNode$2<Key, Value> = (undefined as any);
             if (m2 instanceof MapTreeNode$2) {
                 if (MapTreeNode$2__get_Height<Key, Value>(m2 as MapTreeNode$2<Key, Value>) > 1) {
                     matchResult = 0;
@@ -1053,7 +1055,7 @@ export function MapTreeModule_leftmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<K
             }
         }
         else {
-            throw new Error();
+            throw KeyNotFoundException_$ctor();
         }
         break;
     }
@@ -1065,7 +1067,7 @@ export function MapTreeModule_rightmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<
         const m: Option<MapTreeLeaf$2<Key, Value>> = m_mut;
         if (m != null) {
             const m2: MapTreeLeaf$2<Key, Value> = value_1(m);
-            let matchResult: int32, nd_1: MapTreeNode$2<Key, Value>;
+            let matchResult: int32 = (undefined as any), nd_1: MapTreeNode$2<Key, Value> = (undefined as any);
             if (m2 instanceof MapTreeNode$2) {
                 if (MapTreeNode$2__get_Height<Key, Value>(m2 as MapTreeNode$2<Key, Value>) > 1) {
                     matchResult = 0;
@@ -1092,7 +1094,7 @@ export function MapTreeModule_rightmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<
             }
         }
         else {
-            throw new Error();
+            throw KeyNotFoundException_$ctor();
         }
         break;
     }
@@ -1109,7 +1111,7 @@ export class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, V
         const this$: FSharpMap<Key, Value> = this;
         return FSharpMap__ComputeHashCode<Key, Value>(this$) | 0;
     }
-    Equals(other: Nullable<any>): boolean {
+    Equals(other: any): boolean {
         const this$: FSharpMap<Key, Value> = this;
         if (other instanceof FSharpMap) {
             const that = other as FSharpMap<Key, Value>;
@@ -1174,8 +1176,8 @@ export class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, V
         const _: FSharpMap<Key, Value> = this;
         return MapTreeModule_mkIEnumerator<Key, Value>(_.tree);
     }
-    CompareTo(other: Nullable<any>): int32 {
-        let that: FSharpMap<Key, Value>;
+    CompareTo(other: any): int32 {
+        let that: FSharpMap<Key, Value> = undefined as any;
         const this$: FSharpMap<Key, Value> = this;
         return ((other instanceof FSharpMap) ? ((that = (other as FSharpMap<Key, Value>), compareWith<[Key, Value]>((kvp1: [Key, Value], kvp2: [Key, Value]): int32 => {
             const c: int32 = this$.comparer.Compare(kvp1[0], kvp2[0]) | 0;
@@ -1183,19 +1185,19 @@ export class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, V
         }, this$, that))) : 1) | 0;
     }
     "System.Collections.Generic.ICollection`1.Add2B595"(x: [Key, Value]): void {
-        throw new Error("Map cannot be mutated");
+        throw NotSupportedException_$ctor_Z721C83C5("Map cannot be mutated");
     }
     "System.Collections.Generic.ICollection`1.Clear"(): void {
-        throw new Error("Map cannot be mutated");
+        throw NotSupportedException_$ctor_Z721C83C5("Map cannot be mutated");
     }
     "System.Collections.Generic.ICollection`1.Remove2B595"(x: [Key, Value]): boolean {
-        throw new Error("Map cannot be mutated");
+        throw NotSupportedException_$ctor_Z721C83C5("Map cannot be mutated");
     }
     "System.Collections.Generic.ICollection`1.Contains2B595"(x: [Key, Value]): boolean {
         const m: FSharpMap<Key, Value> = this;
         return FSharpMap__ContainsKey<Key, Value>(m, x[0]) && equals(FSharpMap__get_Item<Key, Value>(m, x[0]), x[1]);
     }
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: [Key, Value][], i: int32): void {
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: MutableArray<[Key, Value]>, i: int32): void {
         const m: FSharpMap<Key, Value> = this;
         MapTreeModule_copyToArray<Key, Value>(m.tree, arr, i);
     }
@@ -1215,10 +1217,10 @@ export class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, V
         return FSharpMap__get_Count<Key, Value>(m) | 0;
     }
     clear(): void {
-        throw new Error("Map cannot be mutated");
+        throw new Exception("Map cannot be mutated");
     }
     delete(_arg: Key): boolean {
-        throw new Error("Map cannot be mutated");
+        throw new Exception("Map cannot be mutated");
         return false;
     }
     entries(): Iterable<[Key, Value]> {
@@ -1239,7 +1241,7 @@ export class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, V
     }
     set(k: Key, v: Value): IMap<Key, Value> {
         const m: FSharpMap<Key, Value> = this;
-        throw new Error("Map cannot be mutated");
+        throw new Exception("Map cannot be mutated");
         return m;
     }
     values(): Iterable<Value> {
@@ -1310,7 +1312,7 @@ export function FSharpMap__Fold<Key, Value, $a>(m: FSharpMap<Key, Value>, f: ((a
     return MapTreeModule_foldBack<Key, Value, $a>(f, m.tree, acc);
 }
 
-export function FSharpMap__FoldSection<Key, Value, $a>(m: FSharpMap<Key, Value>, lo: Nullable<Key>, hi: Nullable<Key>, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a {
+export function FSharpMap__FoldSection<Key, Value, $a>(m: FSharpMap<Key, Value>, lo: Key, hi: Key, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a {
     return MapTreeModule_foldSection<Key, Value, $a>(m.comparer, lo, hi, f, m.tree, acc);
 }
 
@@ -1335,11 +1337,11 @@ export function FSharpMap__get_Count<Key, Value>(m: FSharpMap<Key, Value>): int3
     return MapTreeModule_size<Key, Value>(m.tree) | 0;
 }
 
-export function FSharpMap__ContainsKey<Key, Value>(m: FSharpMap<Key, Value>, key: Nullable<Key>): boolean {
+export function FSharpMap__ContainsKey<Key, Value>(m: FSharpMap<Key, Value>, key: Key): boolean {
     return MapTreeModule_mem<Key, Value>(m.comparer, key, m.tree);
 }
 
-export function FSharpMap__Remove<Key, Value>(m: FSharpMap<Key, Value>, key: Nullable<Key>): FSharpMap<Key, Value> {
+export function FSharpMap__Remove<Key, Value>(m: FSharpMap<Key, Value>, key: Key): FSharpMap<Key, Value> {
     return FSharpMap_$ctor<Key, Value>(m.comparer, MapTreeModule_remove<Key, Value>(m.comparer, key, m.tree));
 }
 
@@ -1379,7 +1381,7 @@ export function FSharpMap__ToList<Key, Value>(m: FSharpMap<Key, Value>): FSharpL
     return MapTreeModule_toList<Key, Value>(m.tree);
 }
 
-export function FSharpMap__ToArray<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value][] {
+export function FSharpMap__ToArray<Key, Value>(m: FSharpMap<Key, Value>): MutableArray<[Key, Value]> {
     return MapTreeModule_toArray<Key, Value>(m.tree);
 }
 
@@ -1420,11 +1422,11 @@ export function tryFind<$a, $b>(key: $a, table: FSharpMap<$a, $b>): Option<$b> {
     return FSharpMap__TryFind<$a, $b>(table, key);
 }
 
-export function remove<$a, $b>(key: Nullable<$a>, table: FSharpMap<$a, $b>): FSharpMap<$a, $b> {
+export function remove<$a, $b>(key: $a, table: FSharpMap<$a, $b>): FSharpMap<$a, $b> {
     return FSharpMap__Remove<$a, $b>(table, key);
 }
 
-export function containsKey<$a, $b>(key: Nullable<$a>, table: FSharpMap<$a, $b>): boolean {
+export function containsKey<$a, $b>(key: $a, table: FSharpMap<$a, $b>): boolean {
     return FSharpMap__ContainsKey<$a, $b>(table, key);
 }
 
@@ -1442,7 +1444,7 @@ export function pick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>),
         return value_1(matchValue);
     }
     else {
-        throw new Error();
+        throw KeyNotFoundException_$ctor();
     }
 }
 
@@ -1510,7 +1512,7 @@ export function ofSeq<T, $a>(elements: Iterable<[T, $a]>, comparer: IComparer<T>
     return FSharpMap_$ctor<T, $a>(comparer, MapTreeModule_ofSeq<T, $a>(comparer, elements));
 }
 
-export function ofArray<Key, Value>(elements: [Key, Value][], comparer: IComparer<Key>): FSharpMap<Key, Value> {
+export function ofArray<Key, Value>(elements: MutableArray<[Key, Value]>, comparer: IComparer<Key>): FSharpMap<Key, Value> {
     return FSharpMap_$ctor<Key, Value>(comparer, MapTreeModule_ofSeq<Key, Value>(comparer, elements));
 }
 
@@ -1518,7 +1520,7 @@ export function toList<$a, $b>(table: FSharpMap<$a, $b>): FSharpList<[$a, $b]> {
     return FSharpMap__ToList<$a, $b>(table);
 }
 
-export function toArray<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b][] {
+export function toArray<$a, $b>(table: FSharpMap<$a, $b>): MutableArray<[$a, $b]> {
     return FSharpMap__ToArray<$a, $b>(table);
 }
 

package/MapUtil.ts

@@ -1,5 +1,5 @@
-import { equals, IMap, IMapOrWeakMap, ISet } from "./Util.js";
-import { FSharpRef, Union } from "./Types.js";
+import { Exception, equals, IMap, IMapOrWeakMap, ISet } from "./Util.ts";
+import { FSharpRef, Union } from "./Types.ts";
 
 const CaseRules = {
   None: 0,
@@ -39,7 +39,7 @@ export function keyValueList(fields: Iterable<any>, caseRule = CaseRules.None) {
   const definedCaseRule = caseRule;
 
   function fail(kvPair: any) {
-    throw new Error("Cannot infer key and value of " + String(kvPair));
+    throw new Exception("Cannot infer key and value of " + String(kvPair));
   }
   function assign(key: string, caseRule: number, value: any) {
     key = changeCase(key, caseRule);
@@ -117,7 +117,7 @@ export function tryAddToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V) {
 
 export function addToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V) {
   if (dict.has(k)) {
-    throw new Error("An item with the same key has already been added. Key: " + k);
+    throw new Exception("An item with the same key has already been added. Key: " + k);
   }
   dict.set(k, v);
 }
@@ -126,7 +126,7 @@ export function getItemFromDict<K, V>(map: IMap<K, V>, key: K) {
   if (map.has(key)) {
     return map.get(key) as V;
   } else {
-    throw new Error(`The given key '${key}' was not present in the dictionary.`);
+    throw new Exception(`The given key '${key}' was not present in the dictionary.`);
   }
 }
 

package/MutableMap.ts

@@ -1,13 +1,15 @@
 
-import { IEqualityComparer, IDisposable, disposeSafe, defaultOf, IMap, equals, toIterator, IEnumerator, getEnumerator } from "./Util.js";
-import { iterate, map, delay, toArray, iterateIndexed, concat } from "./Seq.js";
-import { value as value_1, Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { setItem } from "./Array.js";
-import { FSharpRef } from "./Types.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { getItemFromDict, tryGetValue } from "./MapUtil.js";
-import { format } from "./String.js";
+import { IEqualityComparer, IDisposable, disposeSafe, defaultOf, IMap, MutableArray, equals, toIterator, IEnumerator, getEnumerator } from "./Util.ts";
+import { iterate, map, delay, toArray, iterateIndexed, concat } from "./Seq.ts";
+import { value as value_1, Option } from "./Option.ts";
+import { int32 } from "./Int32.ts";
+import { setItem } from "./Array.ts";
+import { FSharpRef } from "./Types.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { getItemFromDict, tryGetValue } from "./MapUtil.ts";
+import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
+import { ArgumentException_$ctor_Z721C83C5 } from "./System.ts";
+import { format } from "./String.ts";
 
 export class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key, Value]>, Iterable<[Key, Value]> {
     readonly comparer: IEqualityComparer<Key>;
@@ -59,11 +61,11 @@ export class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key,
     "System.Collections.Generic.ICollection`1.Contains2B595"(item: [Key, Value]): boolean {
         const this$: Dictionary<Key, Value> = this;
         const matchValue: Option<[Key, Value]> = Dictionary__TryFind_2B595<Key, Value>(this$, item[0]);
-        let matchResult: int32, p_1: [Key, Value];
+        let matchResult: int32 = (undefined as any), pair_1: [Key, Value] = (undefined as any);
         if (matchValue != null) {
             if (equals(value_1(matchValue)[1], item[1])) {
                 matchResult = 0;
-                p_1 = value_1(matchValue);
+                pair_1 = value_1(matchValue);
             }
             else {
                 matchResult = 1;
@@ -79,7 +81,7 @@ export class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key,
                 return false;
         }
     }
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: [Key, Value][], arrayIndex: int32): void {
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: MutableArray<[Key, Value]>, arrayIndex: int32): void {
         const this$: Dictionary<Key, Value> = this;
         iterateIndexed<[Key, Value]>((i: int32, e: [Key, Value]): void => {
             setItem(array, arrayIndex + i, e);
@@ -95,14 +97,24 @@ export class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key,
     "System.Collections.Generic.ICollection`1.Remove2B595"(item: [Key, Value]): boolean {
         const this$: Dictionary<Key, Value> = this;
         const matchValue: Option<[Key, Value]> = Dictionary__TryFind_2B595<Key, Value>(this$, item[0]);
+        let matchResult: int32 = (undefined as any), pair_1: [Key, Value] = (undefined as any);
         if (matchValue != null) {
             if (equals(value_1(matchValue)[1], item[1])) {
-                Dictionary__Remove_2B595<Key, Value>(this$, item[0]);
+                matchResult = 0;
+                pair_1 = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
             }
-            return true;
         }
         else {
-            return false;
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return Dictionary__Remove_2B595<Key, Value>(this$, item[0]);
+            default:
+                return false;
         }
     }
     "System.Collections.Generic.IDictionary`2.Add5BDDA1"(key: Key, value: Value): void {
@@ -215,7 +227,7 @@ function Dictionary__TryFindIndex_2B595<Key, Value>(this$: Dictionary<Key, Value
 
 export function Dictionary__TryFind_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Option<[Key, Value]> {
     const matchValue: [boolean, int32, int32] = Dictionary__TryFindIndex_2B595<Key, Value>(this$, k);
-    let matchResult: int32;
+    let matchResult: int32 = undefined as any;
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
             matchResult = 0;
@@ -264,7 +276,7 @@ export function Dictionary__get_Item_2B595<Key, Value>(this$: Dictionary<Key, Va
         return value_1(matchValue)[1];
     }
     else {
-        throw new Error("The item was not found in collection");
+        throw KeyNotFoundException_$ctor_Z721C83C5("The item was not found in collection");
     }
 }
 
@@ -287,7 +299,7 @@ export function Dictionary__Add_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>
     const matchValue: [boolean, int32, int32] = Dictionary__TryFindIndex_2B595<Key, Value>(this$, k);
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
-            throw new Error(format("An item with the same key has already been added. Key: {0}", k));
+            throw ArgumentException_$ctor_Z721C83C5(format("An item with the same key has already been added. Key: {0}", k));
         }
         else {
             const value: any = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v] as [Key, Value]));
@@ -300,7 +312,7 @@ export function Dictionary__Add_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>
 
 export function Dictionary__ContainsKey_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean {
     const matchValue: [boolean, int32, int32] = Dictionary__TryFindIndex_2B595<Key, Value>(this$, k);
-    let matchResult: int32;
+    let matchResult: int32 = undefined as any;
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
             matchResult = 0;
@@ -322,7 +334,7 @@ export function Dictionary__ContainsKey_2B595<Key, Value>(this$: Dictionary<Key,
 
 export function Dictionary__Remove_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean {
     const matchValue: [boolean, int32, int32] = Dictionary__TryFindIndex_2B595<Key, Value>(this$, k);
-    let matchResult: int32;
+    let matchResult: int32 = undefined as any;
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
             matchResult = 0;