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

package/List.ts

@@ -1,12 +1,13 @@
 
-import { join } from "./String.js";
-import { defaultArg, some, value as value_1, Option } from "./Option.js";
-import { IComparer, IEqualityComparer, disposeSafe, isArrayLike, IDisposable, defaultOf, toIterator, getEnumerator, IEnumerator, compare, structuralHash, Nullable, equals } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { Record } from "./Types.js";
-import { class_type, record_type, option_type, TypeInfo } from "./Reflection.js";
-import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.js";
-import { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.js";
+import { join } from "./String.ts";
+import { defaultArg, some, value as value_1, Option } from "./Option.ts";
+import { IComparer, IEqualityComparer, disposeSafe, isArrayLike, MutableArray, Exception, IDisposable, defaultOf, toIterator, getEnumerator, IEnumerator, compare, structuralHash, equals } from "./Util.ts";
+import { int32 } from "./Int32.ts";
+import { Record } from "./Types.ts";
+import { class_type, record_type, option_type, TypeInfo } from "./Reflection.ts";
+import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.ts";
+import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
+import { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.ts";
 
 export class FSharpList<T> extends Record implements Iterable<T> {
     readonly head: T;
@@ -20,7 +21,7 @@ export class FSharpList<T> extends Record implements Iterable<T> {
         const xs: FSharpList<T> = this;
         return ("[" + join("; ", xs)) + "]";
     }
-    Equals(other: Nullable<any>): boolean {
+    Equals(other: any): boolean {
         const xs: FSharpList<T> = this;
         if (xs === other) {
             return true;
@@ -96,7 +97,7 @@ export class FSharpList<T> extends Record implements Iterable<T> {
         const this$: FSharpList<T> = this;
         return Array.from(this$);
     }
-    CompareTo(other: Nullable<any>): int32 {
+    CompareTo(other: any): int32 {
         const xs: FSharpList<T> = this;
         if (other instanceof FSharpList) {
             const ys = other as FSharpList<T>;
@@ -169,7 +170,7 @@ export class ListEnumerator$1<T> implements IEnumerator<T>, IDisposable {
         const _: ListEnumerator$1<T> = this;
         return _.current;
     }
-    "System.Collections.IEnumerator.get_Current"(): Nullable<any> {
+    "System.Collections.IEnumerator.get_Current"(): any {
         const _: ListEnumerator$1<T> = this;
         return _.current;
     }
@@ -241,7 +242,7 @@ export function FSharpList__get_Head<T>(xs: FSharpList<T>): T {
         return xs.head;
     }
     else {
-        throw new Error((SR_inputWasEmpty + "\\nParameter name: ") + "list");
+        throw new Exception((SR_inputWasEmpty + "\\nParameter name: ") + "list");
     }
 }
 
@@ -251,7 +252,7 @@ export function FSharpList__get_Tail<T>(xs: FSharpList<T>): FSharpList<T> {
         return value_1(matchValue);
     }
     else {
-        throw new Error((SR_inputWasEmpty + "\\nParameter name: ") + "list");
+        throw new Exception((SR_inputWasEmpty + "\\nParameter name: ") + "list");
     }
 }
 
@@ -272,7 +273,7 @@ export function FSharpList__get_Item_Z524259A4<T>(xs: FSharpList<T>, index: int3
                 }
             }
             else {
-                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
             break;
         }
@@ -281,7 +282,7 @@ export function FSharpList__get_Item_Z524259A4<T>(xs: FSharpList<T>, index: int3
 }
 
 export function indexNotFound<$a>(): $a {
-    throw new Error(SR_keyNotFoundAlt);
+    throw KeyNotFoundException_$ctor_Z721C83C5(SR_keyNotFoundAlt);
 }
 
 export function empty<$a>(): FSharpList<$a> {
@@ -345,7 +346,7 @@ export function tryLast<T>(xs_mut: FSharpList<T>): Option<T> {
 export function last<T>(xs: FSharpList<T>): T {
     const matchValue: Option<T> = tryLast<T>(xs);
     if (matchValue == null) {
-        throw new Error(SR_inputWasEmpty);
+        throw new Exception(SR_inputWasEmpty);
     }
     else {
         return value_1(matchValue);
@@ -387,9 +388,9 @@ export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: FSha
     return loop(xs, ys) | 0;
 }
 
-export function toArray<T>(xs: FSharpList<T>): T[] {
+export function toArray<T>(xs: FSharpList<T>): MutableArray<T> {
     const len: int32 = FSharpList__get_Length<T>(xs) | 0;
-    const res: T[] = fill(new Array(len), 0, len, null);
+    const res: MutableArray<T> = fill(new Array(len), 0, len, null);
     const loop = (i_mut: int32, xs_1_mut: FSharpList<T>): void => {
         loop:
         while (true) {
@@ -466,7 +467,7 @@ export function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>
         loop:
         while (true) {
             const acc: State = acc_mut, node: FSharpList<T> = node_mut;
-            let t: FSharpList<T>;
+            let t: FSharpList<T> = undefined as any;
             const matchValue: Option<[T, State]> = generator(acc);
             if (matchValue != null) {
                 acc_mut = value_1(matchValue)[1];
@@ -516,7 +517,7 @@ export function toSeq<T>(xs: FSharpList<T>): Iterable<T> {
     return xs;
 }
 
-export function ofArrayWithTail<T>(xs: T[], tail_1: FSharpList<T>): FSharpList<T> {
+export function ofArrayWithTail<T>(xs: MutableArray<T>, tail_1: FSharpList<T>): FSharpList<T> {
     let res: FSharpList<T> = tail_1;
     for (let i: int32 = xs.length - 1; i >= 0; i--) {
         res = FSharpList_Cons_305B8EAC<T>(item_1(i, xs), res);
@@ -524,7 +525,7 @@ export function ofArrayWithTail<T>(xs: T[], tail_1: FSharpList<T>): FSharpList<T
     return res;
 }
 
-export function ofArray<T>(xs: T[]): FSharpList<T> {
+export function ofArray<T>(xs: MutableArray<T>): FSharpList<T> {
     return ofArrayWithTail<T>(xs, FSharpList_get_Empty<T>());
 }
 
@@ -541,7 +542,7 @@ export function ofSeq<T>(xs: Iterable<T>): FSharpList<T> {
         const enumerator: IEnumerator<T> = getEnumerator(xs);
         try {
             while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                let xs_3: FSharpList<T>, t: FSharpList<T>;
+                let xs_3: FSharpList<T> = (undefined as any), t: FSharpList<T> = (undefined as any);
                 const x: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
                 node = ((xs_3 = node, (t = (new FSharpList(x, undefined)), (xs_3.tail = t, t))));
             }
@@ -567,7 +568,7 @@ export function concat<T>(lists: Iterable<FSharpList<T>>): FSharpList<T> {
         }, node, xs);
     };
     if (isArrayLike(lists)) {
-        const xs_3: FSharpList<T>[] = lists;
+        const xs_3: MutableArray<FSharpList<T>> = lists;
         xs_3.forEach(action);
     }
     else if (lists instanceof FSharpList) {
@@ -599,7 +600,7 @@ export function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state:
     let acc: State = state;
     let xs_3: FSharpList<T> = xs;
     while (!FSharpList__get_IsEmpty<T>(xs_3)) {
-        let xs_4: FSharpList<State>, t_2: FSharpList<State>;
+        let xs_4: FSharpList<State> = (undefined as any), t_2: FSharpList<State> = (undefined as any);
         acc = folder(acc, FSharpList__get_Head<T>(xs_3));
         node = ((xs_4 = node, (t_2 = (new FSharpList(acc, undefined)), (xs_4.tail = t_2, t_2))));
         xs_3 = FSharpList__get_Tail<T>(xs_3);
@@ -625,7 +626,7 @@ export function collect<T, U>(mapping: ((arg0: T) => FSharpList<U>), xs: FSharpL
     while (!FSharpList__get_IsEmpty<T>(ys)) {
         let zs: FSharpList<U> = mapping(FSharpList__get_Head<T>(ys));
         while (!FSharpList__get_IsEmpty<U>(zs)) {
-            let xs_1: FSharpList<U>, t: FSharpList<U>;
+            let xs_1: FSharpList<U> = (undefined as any), t: FSharpList<U> = (undefined as any);
             node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head<U>(zs), undefined)), (xs_1.tail = t, t))));
             zs = FSharpList__get_Tail<U>(zs);
         }
@@ -682,7 +683,7 @@ export function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T
         loop:
         while (true) {
             const i: int32 = i_mut, acc: FSharpList<U> = acc_mut, xs_1: FSharpList<T1> = xs_1_mut, ys_1: FSharpList<T2> = ys_1_mut;
-            let t: FSharpList<U>;
+            let t: FSharpList<U> = undefined as any;
             if (FSharpList__get_IsEmpty<T1>(xs_1) ? true : FSharpList__get_IsEmpty<T2>(ys_1)) {
                 return acc;
             }
@@ -708,7 +709,7 @@ export function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) =>
         loop:
         while (true) {
             const acc: FSharpList<U> = acc_mut, xs_1: FSharpList<T1> = xs_1_mut, ys_1: FSharpList<T2> = ys_1_mut, zs_1: FSharpList<T3> = zs_1_mut;
-            let t: FSharpList<U>;
+            let t: FSharpList<U> = undefined as any;
             if ((FSharpList__get_IsEmpty<T1>(xs_1) ? true : FSharpList__get_IsEmpty<T2>(ys_1)) ? true : FSharpList__get_IsEmpty<T3>(zs_1)) {
                 return acc;
             }
@@ -732,7 +733,7 @@ export function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) =>
 export function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: FSharpList<T>): [FSharpList<Result>, State] {
     const root: FSharpList<Result> = FSharpList_get_Empty<Result>();
     const patternInput_1: [FSharpList<Result>, State] = fold<T, [FSharpList<Result>, State]>((tupledArg: [FSharpList<Result>, State], x: T): [FSharpList<Result>, State] => {
-        let t: FSharpList<Result>;
+        let t: FSharpList<Result> = undefined as any;
         const patternInput: [Result, State] = mapping(tupledArg[1], x);
         return [(t = (new FSharpList(patternInput[0], undefined)), (tupledArg[0].tail = t, t)), patternInput[1]] as [FSharpList<Result>, State];
     }, [root, state] as [FSharpList<Result>, State], xs);
@@ -903,7 +904,7 @@ export function partition<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): [FSh
     const root2: FSharpList<T> = FSharpList_get_Empty<T>();
     const root1: FSharpList<T> = matchValue;
     const patternInput_1: [FSharpList<T>, FSharpList<T>] = fold<T, [FSharpList<T>, FSharpList<T>]>((tupledArg: [FSharpList<T>, FSharpList<T>], x: T): [FSharpList<T>, FSharpList<T>] => {
-        let t: FSharpList<T>, t_2: FSharpList<T>;
+        let t: FSharpList<T> = (undefined as any), t_2: FSharpList<T> = (undefined as any);
         const lacc: FSharpList<T> = tupledArg[0];
         const racc: FSharpList<T> = tupledArg[1];
         if (f(x)) {
@@ -939,14 +940,14 @@ export function choose<T, U>(f: ((arg0: T) => Option<U>), xs: FSharpList<T>): FS
 }
 
 export function contains<T>(value: T, xs: FSharpList<T>, eq: IEqualityComparer<T>): boolean {
-    return tryFindIndex<Nullable<T>>((v: Nullable<T>): boolean => eq.Equals(value, v), xs) != null;
+    return tryFindIndex<T>((v: T): boolean => eq.Equals(value, v), xs) != null;
 }
 
 export function initialize<T>(n: int32, f: ((arg0: int32) => T)): FSharpList<T> {
     const root: FSharpList<T> = FSharpList_get_Empty<T>();
     let node: FSharpList<T> = root;
     for (let i = 0; i <= (n - 1); i++) {
-        let xs: FSharpList<T>, t: FSharpList<T>;
+        let xs: FSharpList<T> = (undefined as any), t: FSharpList<T> = (undefined as any);
         node = ((xs = node, (t = (new FSharpList(f(i), undefined)), (xs.tail = t, t))));
     }
     const xs_2: FSharpList<T> = node;
@@ -961,7 +962,7 @@ export function replicate<$a>(n: int32, x: $a): FSharpList<$a> {
 
 export function reduce<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T {
     if (FSharpList__get_IsEmpty<T>(xs)) {
-        throw new Error(SR_inputWasEmpty);
+        throw new Exception(SR_inputWasEmpty);
     }
     else {
         return fold<T, T>(f, head<T>(xs), tail<T>(xs));
@@ -970,7 +971,7 @@ export function reduce<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T {
 
 export function reduceBack<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T {
     if (FSharpList__get_IsEmpty<T>(xs)) {
-        throw new Error(SR_inputWasEmpty);
+        throw new Exception(SR_inputWasEmpty);
     }
     else {
         return foldBack<T, T>(f, tail<T>(xs), head<T>(xs));
@@ -995,7 +996,7 @@ export function exists2<T1, T2>(f_mut: ((arg0: T1, arg1: T2) => boolean), xs_mut
         const f: ((arg0: T1, arg1: T2) => boolean) = f_mut, xs: FSharpList<T1> = xs_mut, ys: FSharpList<T2> = ys_mut;
         const matchValue: boolean = FSharpList__get_IsEmpty<T1>(xs);
         const matchValue_1: boolean = FSharpList__get_IsEmpty<T2>(ys);
-        let matchResult: int32;
+        let matchResult: int32 = undefined as any;
         if (matchValue) {
             if (matchValue_1) {
                 matchResult = 0;
@@ -1024,7 +1025,7 @@ export function exists2<T1, T2>(f_mut: ((arg0: T1, arg1: T2) => boolean), xs_mut
                     continue exists2;
                 }
             default:
-                throw new Error((SR_differentLengths + "\\nParameter name: ") + "list2");
+                throw new Exception((SR_differentLengths + "\\nParameter name: ") + "list2");
         }
         break;
     }
@@ -1047,7 +1048,7 @@ export function zip3<$a, $b, $c>(xs: FSharpList<$a>, ys: FSharpList<$b>, zs: FSh
 }
 
 export function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: FSharpList<T>): FSharpList<T> {
-    const arr: T[] = toArray<T>(xs);
+    const arr: MutableArray<T> = toArray<T>(xs);
     arr.sort(comparer);
     return ofArray<T>(arr);
 }
@@ -1115,7 +1116,7 @@ export function permute<T>(f: ((arg0: int32) => int32), xs: FSharpList<T>): FSha
 }
 
 export function chunkBySize<T>(chunkSize: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>> {
-    return ofArray<FSharpList<T>>(map_1<T[], FSharpList<T>>(ofArray, chunkBySize_1<T>(chunkSize, toArray<T>(xs))));
+    return ofArray<FSharpList<T>>(map_1<MutableArray<T>, FSharpList<T>>(ofArray, chunkBySize_1<T>(chunkSize, toArray<T>(xs))));
 }
 
 export function allPairs<T1, T2>(xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<[T1, T2]> {
@@ -1123,7 +1124,7 @@ export function allPairs<T1, T2>(xs: FSharpList<T1>, ys: FSharpList<T2>): FSharp
     let node: FSharpList<[T1, T2]> = root;
     iterate<T1>((x: T1): void => {
         iterate<T2>((y: T2): void => {
-            let xs_1: FSharpList<[T1, T2]>, t: FSharpList<[T1, T2]>;
+            let xs_1: FSharpList<[T1, T2]> = (undefined as any), t: FSharpList<[T1, T2]> = (undefined as any);
             node = ((xs_1 = node, (t = (new FSharpList([x, y] as [T1, T2], undefined)), (xs_1.tail = t, t))));
         }, ys);
     }, xs);
@@ -1141,7 +1142,7 @@ export function skip<T>(count_mut: int32, xs_mut: FSharpList<T>): FSharpList<T>
             return xs;
         }
         else if (FSharpList__get_IsEmpty<T>(xs)) {
-            throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "list");
+            throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "list");
         }
         else {
             count_mut = (count - 1);
@@ -1173,18 +1174,18 @@ export function skipWhile<T>(predicate_mut: ((arg0: T) => boolean), xs_mut: FSha
 
 export function take<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
     if (count < 0) {
-        throw new Error((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
     }
     const loop = (i_mut: int32, acc_mut: FSharpList<T>, xs_1_mut: FSharpList<T>): FSharpList<T> => {
         loop:
         while (true) {
             const i: int32 = i_mut, acc: FSharpList<T> = acc_mut, xs_1: FSharpList<T> = xs_1_mut;
-            let t: FSharpList<T>;
+            let t: FSharpList<T> = undefined as any;
             if (i <= 0) {
                 return acc;
             }
             else if (FSharpList__get_IsEmpty<T>(xs_1)) {
-                throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "list");
+                throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "list");
             }
             else {
                 i_mut = (i - 1);
@@ -1207,7 +1208,7 @@ export function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: FSharpList<T
         loop:
         while (true) {
             const acc: FSharpList<T> = acc_mut, xs_1: FSharpList<T> = xs_1_mut;
-            let t: FSharpList<T>;
+            let t: FSharpList<T> = undefined as any;
             if (FSharpList__get_IsEmpty<T>(xs_1)) {
                 return acc;
             }
@@ -1234,7 +1235,7 @@ export function truncate<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
         loop:
         while (true) {
             const i: int32 = i_mut, acc: FSharpList<T> = acc_mut, xs_1: FSharpList<T> = xs_1_mut;
-            let t: FSharpList<T>;
+            let t: FSharpList<T> = undefined as any;
             if (i <= 0) {
                 return acc;
             }
@@ -1275,23 +1276,23 @@ export function getSlice<T>(startIndex: Option<int32>, endIndex: Option<int32>,
 
 export function splitAt<T>(index: int32, xs: FSharpList<T>): [FSharpList<T>, FSharpList<T>] {
     if (index < 0) {
-        throw new Error((SR_inputMustBeNonNegative + "\\nParameter name: ") + "index");
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "index");
     }
     if (index > FSharpList__get_Length<T>(xs)) {
-        throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "index");
+        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "index");
     }
     return [take<T>(index, xs), skip<T>(index, xs)] as [FSharpList<T>, FSharpList<T>];
 }
 
 export function exactlyOne<T>(xs: FSharpList<T>): T {
     if (FSharpList__get_IsEmpty<T>(xs)) {
-        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "list");
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "list");
     }
     else if (FSharpList__get_IsEmpty<T>(FSharpList__get_Tail<T>(xs))) {
         return FSharpList__get_Head<T>(xs);
     }
     else {
-        throw new Error((SR_inputSequenceTooLong + "\\nParameter name: ") + "list");
+        throw new Exception((SR_inputSequenceTooLong + "\\nParameter name: ") + "list");
     }
 }
 
@@ -1313,15 +1314,15 @@ export function pairwise<T>(xs: FSharpList<T>): FSharpList<[T, T]> {
 }
 
 export function windowed<T>(windowSize: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>> {
-    return ofArray<FSharpList<T>>(map_1<T[], FSharpList<T>>(ofArray, windowed_1<T>(windowSize, toArray<T>(xs))));
+    return ofArray<FSharpList<T>>(map_1<MutableArray<T>, FSharpList<T>>(ofArray, windowed_1<T>(windowSize, toArray<T>(xs))));
 }
 
 export function splitInto<T>(chunks: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>> {
-    return ofArray<FSharpList<T>>(map_1<T[], FSharpList<T>>(ofArray, splitInto_1<T>(chunks, toArray<T>(xs))));
+    return ofArray<FSharpList<T>>(map_1<MutableArray<T>, FSharpList<T>>(ofArray, splitInto_1<T>(chunks, toArray<T>(xs))));
 }
 
 export function transpose<T>(lists: Iterable<FSharpList<T>>): FSharpList<FSharpList<T>> {
-    return ofArray<FSharpList<T>>(map_1<T[], FSharpList<T>>(ofArray, transpose_1<T>(map_1<FSharpList<T>, T[]>(toArray, Array.from(lists)))));
+    return ofArray<FSharpList<T>>(map_1<MutableArray<T>, FSharpList<T>>(ofArray, transpose_1<T>(map_1<FSharpList<T>, MutableArray<T>>(toArray, Array.from(lists)))));
 }
 
 export function insertAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T> {
@@ -1338,7 +1339,7 @@ export function insertAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T
         }
     }, FSharpList_get_Empty<T>(), xs);
     return reverse<T>(isDone ? result : (((i + 1) === index) ? FSharpList_Cons_305B8EAC<T>(y, result) : (() => {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     })()));
 }
 
@@ -1357,7 +1358,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: FSharpList<T>
         }
     }, FSharpList_get_Empty<T>(), xs);
     return reverse<T>(isDone ? result : (((i + 1) === index) ? append<T>(ys_1, result) : (() => {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     })()));
 }
 
@@ -1375,7 +1376,7 @@ export function removeAt<T>(index: int32, xs: FSharpList<T>): FSharpList<T> {
         }
     }, xs);
     if (!isDone) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return ys;
 }
@@ -1404,7 +1405,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: FSharpList<T>):
     }, xs);
     const status_1: int32 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;
     if (status_1 < 1) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
     }
     return ys;
 }
@@ -1421,7 +1422,7 @@ export function updateAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T
         }
     }, xs);
     if (!isDone) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return ys;
 }

package/Long.ts

@@ -1,6 +1,7 @@
-import { getPrefix, isValid } from "./Int32.js";
-import { fromString } from "./BigInt.js";
-import { FSharpRef } from "./Types.js";
+import { getPrefix, isValid } from "./Int32.ts";
+import { fromString } from "./BigInt.ts";
+import { FSharpRef } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
 function getMaxValue(unsigned: boolean, radix: number, isNegative: boolean) {
   switch (radix) {
@@ -17,7 +18,7 @@ function getMaxValue(unsigned: boolean, radix: number, isNegative: boolean) {
     case 16: return unsigned ?
       "FFFFFFFFFFFFFFFF" :
       (isNegative ? "8000000000000000" : "7FFFFFFFFFFFFFFF");
-    default: throw new Error("Invalid radix.");
+    default: throw new Exception("Invalid radix.");
   }
 }
 
@@ -36,7 +37,7 @@ export function parse(str: string, style: number, unsigned: boolean, _bitsize: n
       return fromString(str);
     }
   }
-  throw new Error(`The input string ${str} was not in a correct format.`);
+  throw new Exception(`The input string ${str} was not in a correct format.`);
 }
 
 export function tryParse(str: string, style: number, unsigned: boolean, bitsize: number, defValue: FSharpRef<bigint>) {

package/MailboxProcessor.ts

@@ -1,9 +1,10 @@
-import { defaultCancellationToken } from "./Async.js";
-import { fromContinuations } from "./Async.js";
-import { startImmediate } from "./Async.js";
-import { Async } from "./AsyncBuilder.js";
-import { Continuation, Continuations } from "./AsyncBuilder.js";
-import { CancellationToken } from "./AsyncBuilder.js";
+import { defaultCancellationToken } from "./Async.ts";
+import { fromContinuations } from "./Async.ts";
+import { startImmediate } from "./Async.ts";
+import { Async } from "./AsyncBuilder.ts";
+import { Continuation, Continuations } from "./AsyncBuilder.ts";
+import { CancellationToken } from "./AsyncBuilder.ts";
+import { Exception } from "./Util.ts";
 
 class QueueCell<Msg> {
   public value: Msg;
@@ -79,7 +80,7 @@ export function startInstance<Msg>($this: MailboxProcessor<Msg>) {
 export function receive<Msg>($this: MailboxProcessor<Msg>) {
   return fromContinuations((conts: Continuations<Msg>) => {
     if ($this.continuation) {
-      throw new Error("Receive can only be called once!");
+      throw new Exception("Receive can only be called once!");
     }
     $this.continuation = conts[0];
     __processEvents($this);