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

package/Result.ts

@@ -1,10 +1,10 @@
 
-import { Union } from "./Types.js";
-import { union_type, TypeInfo } from "./Reflection.js";
-import { int32 } from "./Int32.js";
-import { equals } from "./Util.js";
-import { FSharpList, empty, singleton } from "./List.js";
-import { Option, some } from "./Option.js";
+import { Union } from "./Types.ts";
+import { union_type, TypeInfo } from "./Reflection.ts";
+import { int32 } from "./Int32.ts";
+import { MutableArray, equals } from "./Util.ts";
+import { FSharpList, empty, singleton } from "./List.ts";
+import { Option, some } from "./Option.ts";
 
 export type FSharpResult$2_$union<T, TError> = 
     | FSharpResult$2<T, TError, 0>
@@ -24,9 +24,13 @@ export function FSharpResult$2_Error$<T, TError>(ErrorValue: TError) {
 }
 
 export class FSharpResult$2<T, TError, Tag extends keyof FSharpResult$2_$cases<T, TError>> extends Union<Tag, FSharpResult$2_$cases<T, TError>[Tag][0]> {
-    constructor(readonly tag: Tag, readonly fields: FSharpResult$2_$cases<T, TError>[Tag][1]) {
+    constructor(tag: Tag, fields: FSharpResult$2_$cases<T, TError>[Tag][1]) {
         super();
+        this.tag = tag;
+        this.fields = fields;
     }
+    readonly tag: Tag;
+    readonly fields: FSharpResult$2_$cases<T, TError>[Tag][1];
     cases() {
         return ["Ok", "Error"];
     }
@@ -38,28 +42,28 @@ export function FSharpResult$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): Type
 
 export function Result_Map<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return FSharpResult$2_Ok<b, c>(mapping(result.fields[0] as any));
+        return FSharpResult$2_Ok<b, c>(mapping(result.fields[0] as a));
     }
     else {
-        return FSharpResult$2_Error$<b, c>(result.fields[0] as any);
+        return FSharpResult$2_Error$<b, c>(result.fields[0] as c);
     }
 }
 
 export function Result_MapError<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<c, a>): FSharpResult$2_$union<c, b> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return FSharpResult$2_Ok<c, b>(result.fields[0] as any);
+        return FSharpResult$2_Ok<c, b>(result.fields[0] as c);
     }
     else {
-        return FSharpResult$2_Error$<c, b>(mapping(result.fields[0] as any));
+        return FSharpResult$2_Error$<c, b>(mapping(result.fields[0] as a));
     }
 }
 
 export function Result_Bind<a, b, c>(binder: ((arg0: a) => FSharpResult$2_$union<b, c>), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return binder(result.fields[0] as any);
+        return binder(result.fields[0] as a);
     }
     else {
-        return FSharpResult$2_Error$<b, c>(result.fields[0] as any);
+        return FSharpResult$2_Error$<b, c>(result.fields[0] as c);
     }
 }
 
@@ -83,7 +87,7 @@ export function Result_IsError<a, b>(result: FSharpResult$2_$union<a, b>): boole
 
 export function Result_Contains<a, b>(value: a, result: FSharpResult$2_$union<a, b>): boolean {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return equals(result.fields[0] as any, value);
+        return equals(result.fields[0] as a, value);
     }
     else {
         return false;
@@ -101,7 +105,7 @@ export function Result_Count<a, b>(result: FSharpResult$2_$union<a, b>): int32 {
 
 export function Result_DefaultValue<a, b>(defaultValue: a, result: FSharpResult$2_$union<a, b>): a {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return result.fields[0] as any;
+        return result.fields[0] as a;
     }
     else {
         return defaultValue;
@@ -110,16 +114,16 @@ export function Result_DefaultValue<a, b>(defaultValue: a, result: FSharpResult$
 
 export function Result_DefaultWith<b, a>(defThunk: ((arg0: b) => a), result: FSharpResult$2_$union<a, b>): a {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return result.fields[0] as any;
+        return result.fields[0] as a;
     }
     else {
-        return defThunk(result.fields[0] as any);
+        return defThunk(result.fields[0] as b);
     }
 }
 
 export function Result_Exists<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return predicate(result.fields[0] as any);
+        return predicate(result.fields[0] as a);
     }
     else {
         return false;
@@ -128,7 +132,7 @@ export function Result_Exists<a, b>(predicate: ((arg0: a) => boolean), result: F
 
 export function Result_Fold<a, b, s>(folder: ((arg0: s, arg1: a) => s), state: s, result: FSharpResult$2_$union<a, b>): s {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return folder(state, result.fields[0] as any);
+        return folder(state, result.fields[0] as a);
     }
     else {
         return state;
@@ -137,7 +141,7 @@ export function Result_Fold<a, b, s>(folder: ((arg0: s, arg1: a) => s), state: s
 
 export function Result_FoldBack<a, b, s>(folder: ((arg0: a, arg1: s) => s), result: FSharpResult$2_$union<a, b>, state: s): s {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return folder(result.fields[0] as any, state);
+        return folder(result.fields[0] as a, state);
     }
     else {
         return state;
@@ -146,7 +150,7 @@ export function Result_FoldBack<a, b, s>(folder: ((arg0: a, arg1: s) => s), resu
 
 export function Result_ForAll<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return predicate(result.fields[0] as any);
+        return predicate(result.fields[0] as a);
     }
     else {
         return true;
@@ -155,13 +159,13 @@ export function Result_ForAll<a, b>(predicate: ((arg0: a) => boolean), result: F
 
 export function Result_Iterate<a, b>(action: ((arg0: a) => void), result: FSharpResult$2_$union<a, b>): void {
     if ((result.tag as int32) === /* Ok */ 0) {
-        action(result.fields[0] as any);
+        action(result.fields[0] as a);
     }
 }
 
-export function Result_ToArray<a, b>(result: FSharpResult$2_$union<a, b>): a[] {
+export function Result_ToArray<a, b>(result: FSharpResult$2_$union<a, b>): MutableArray<a> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return [result.fields[0] as any];
+        return [result.fields[0] as a];
     }
     else {
         return [];
@@ -170,7 +174,7 @@ export function Result_ToArray<a, b>(result: FSharpResult$2_$union<a, b>): a[] {
 
 export function Result_ToList<a, b>(result: FSharpResult$2_$union<a, b>): FSharpList<a> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return singleton(result.fields[0] as any);
+        return singleton(result.fields[0] as a);
     }
     else {
         return empty<a>();
@@ -179,7 +183,7 @@ export function Result_ToList<a, b>(result: FSharpResult$2_$union<a, b>): FSharp
 
 export function Result_ToOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return some(result.fields[0] as any);
+        return some(result.fields[0] as a);
     }
     else {
         return undefined;
@@ -188,7 +192,7 @@ export function Result_ToOption<a, b>(result: FSharpResult$2_$union<a, b>): Opti
 
 export function Result_ToValueOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a> {
     if ((result.tag as int32) === /* Ok */ 0) {
-        return some(result.fields[0] as any);
+        return some(result.fields[0] as a);
     }
     else {
         return undefined;

package/Seq.ts

@@ -1,13 +1,15 @@
 
-import { IComparer, clear, isDisposable, IEqualityComparer, isArrayLike, Nullable, toIterator, IDisposable, disposeSafe, IEnumerator, getEnumerator } from "./Util.js";
-import { toString } from "./Types.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { some, value as value_1, Option } from "./Option.js";
-import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.js";
-import { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
-import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.js";
-import { int32 } from "./Int32.js";
-import { SR_indexOutOfBounds } from "./Global.js";
+import { InvalidOperationException_$ctor_Z721C83C5, NotSupportedException_$ctor_Z721C83C5 } from "./System.ts";
+import { IComparer, clear, Exception, isDisposable, IEqualityComparer, isArrayLike, MutableArray, toIterator, IDisposable, disposeSafe, IEnumerator, getEnumerator } from "./Util.ts";
+import { toString } from "./Types.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { some, value as value_1, Option } from "./Option.ts";
+import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
+import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.ts";
+import { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.ts";
+import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.ts";
+import { int32 } from "./Int32.ts";
+import { SR_indexOutOfBounds } from "./Global.ts";
 
 export const SR_enumerationAlreadyFinished = "Enumeration already finished.";
 
@@ -24,15 +26,15 @@ export const SR_notEnoughElements = "The input sequence has an insufficient numb
 export const SR_resetNotSupported = "Reset is not supported on this enumerator.";
 
 export function Enumerator_noReset<$a>(): $a {
-    throw new Error(SR_resetNotSupported);
+    throw NotSupportedException_$ctor_Z721C83C5(SR_resetNotSupported);
 }
 
 export function Enumerator_notStarted<$a>(): $a {
-    throw new Error(SR_enumerationNotStarted);
+    throw InvalidOperationException_$ctor_Z721C83C5(SR_enumerationNotStarted);
 }
 
 export function Enumerator_alreadyFinished<$a>(): $a {
-    throw new Error(SR_enumerationAlreadyFinished);
+    throw InvalidOperationException_$ctor_Z721C83C5(SR_enumerationAlreadyFinished);
 }
 
 export class Enumerator_Seq<T> implements Iterable<T> {
@@ -96,7 +98,7 @@ export class Enumerator_FromFunctions$1<T> implements IEnumerator<T>, IDisposabl
         const _: Enumerator_FromFunctions$1<T> = this;
         return _.current();
     }
-    "System.Collections.IEnumerator.get_Current"(): Nullable<any> {
+    "System.Collections.IEnumerator.get_Current"(): any {
         const _: Enumerator_FromFunctions$1<T> = this;
         return _.current();
     }
@@ -177,7 +179,7 @@ export function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>
         else {
             let res: Option<boolean> = undefined;
             while (res == null) {
-                let copyOfStruct: U;
+                let copyOfStruct: U = undefined as any;
                 const outerOpt_1: Option<IEnumerator<U>> = outerOpt;
                 const innerOpt_1: Option<IEnumerator<T>> = innerOpt;
                 if (outerOpt_1 != null) {
@@ -322,7 +324,7 @@ export function Enumerator_unfold<State, T>(f: ((arg0: State) => Option<[T, Stat
 }
 
 export function indexNotFound<$a>(): $a {
-    throw new Error(SR_keyNotFoundAlt);
+    throw KeyNotFoundException_$ctor_Z721C83C5(SR_keyNotFoundAlt);
 }
 
 export function mkSeq<T>(f: (() => IEnumerator<T>)): Iterable<T> {
@@ -353,11 +355,11 @@ export function singleton<T>(x: T): Iterable<T> {
     return delay<T>((): Iterable<T> => singleton_1<T>(x));
 }
 
-export function ofArray<T>(arr: T[]): Iterable<T> {
+export function ofArray<T>(arr: MutableArray<T>): Iterable<T> {
     return arr;
 }
 
-export function toArray<T>(xs: Iterable<T>): T[] {
+export function toArray<T>(xs: Iterable<T>): MutableArray<T> {
     if (xs instanceof FSharpList) {
         const a = xs as FSharpList<T>;
         return toArray_1<T>(a);
@@ -459,7 +461,7 @@ export function contains<T>(value: T, xs: Iterable<T>, comparer: IEqualityCompar
 
 export function enumerateFromFunctions<$a, $b>(create: (() => $a), moveNext: ((arg0: $a) => boolean), current: ((arg0: $a) => $b)): Iterable<$b> {
     return generate<$a, $b>(create, (x: $a): Option<$b> => (moveNext(x) ? some(current(x)) : undefined), (x_1: $a): void => {
-        const matchValue: Nullable<any> = x_1;
+        const matchValue: any = x_1;
         if (isDisposable(matchValue)) {
             const id = matchValue as IDisposable;
             disposeSafe(id);
@@ -555,14 +557,14 @@ export function exactlyOne<T>(xs: Iterable<T>): T {
         if (e["System.Collections.IEnumerator.MoveNext"]()) {
             const v: T = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
             if (e["System.Collections.IEnumerator.MoveNext"]()) {
-                throw new Error((SR_inputSequenceTooLong + "\\nParameter name: ") + "source");
+                throw new Exception((SR_inputSequenceTooLong + "\\nParameter name: ") + "source");
             }
             else {
                 return v;
             }
         }
         else {
-            throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+            throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
         }
     }
     finally {
@@ -753,7 +755,7 @@ export function tryHead<T>(xs: Iterable<T>): Option<T> {
 export function head<T>(xs: Iterable<T>): T {
     const matchValue: Option<T> = tryHead<T>(xs);
     if (matchValue == null) {
-        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
     }
     else {
         return value_1(matchValue);
@@ -770,7 +772,7 @@ export function initializeInfinite<$a>(f: ((arg0: int32) => $a)): Iterable<$a> {
 
 export function isEmpty<T>(xs: Iterable<T>): boolean {
     if (isArrayLike(xs)) {
-        const a: T[] = xs;
+        const a: MutableArray<T> = xs;
         return a.length === 0;
     }
     else if (xs instanceof FSharpList) {
@@ -825,7 +827,7 @@ export function tryItem<T>(index: int32, xs: Iterable<T>): Option<T> {
 export function item<T>(index: int32, xs: Iterable<T>): T {
     const matchValue: Option<T> = tryItem<T>(index, xs);
     if (matchValue == null) {
-        throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "index");
+        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "index");
     }
     else {
         return value_1(matchValue);
@@ -885,7 +887,7 @@ export function tryLast<T>(xs: Iterable<T>): Option<T> {
 export function last<T>(xs: Iterable<T>): T {
     const matchValue: Option<T> = tryLast<T>(xs);
     if (matchValue == null) {
-        throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "source");
+        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "source");
     }
     else {
         return value_1(matchValue);
@@ -894,7 +896,7 @@ export function last<T>(xs: Iterable<T>): T {
 
 export function length<T>(xs: Iterable<T>): int32 {
     if (isArrayLike(xs)) {
-        const a: T[] = xs;
+        const a: MutableArray<T> = xs;
         return a.length | 0;
     }
     else if (xs instanceof FSharpList) {
@@ -1029,7 +1031,7 @@ export function cache<T>(source: Iterable<T>): Iterable<T> {
     return CachedSeq$1_$ctor_Z7A8347D4<T>((): void => {
         Operators_Lock<T[], void>(prefix, (): void => {
             clear(prefix);
-            let matchResult: int32, e: IEnumerator<T>;
+            let matchResult: int32 = (undefined as any), e: IEnumerator<T> = (undefined as any);
             if (enumeratorR != null) {
                 if (value_1(enumeratorR) != null) {
                     matchResult = 0;
@@ -1094,12 +1096,12 @@ export function allPairs<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[
 }
 
 export function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: Iterable<T>): [Iterable<Result>, State] {
-    const patternInput: [Result[], State] = mapFold_1<T, State, Result>(mapping, state, toArray<T>(xs));
+    const patternInput: [MutableArray<Result>, State] = mapFold_1<T, State, Result>(mapping, state, toArray<T>(xs));
     return [readOnly<Result>(patternInput[0]), patternInput[1]] as [Iterable<Result>, State];
 }
 
 export function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), xs: Iterable<T>, state: State): [Iterable<Result>, State] {
-    const patternInput: [Result[], State] = mapFoldBack_1<T, State, Result>(mapping, toArray<T>(xs), state);
+    const patternInput: [MutableArray<Result>, State] = mapFoldBack_1<T, State, Result>(mapping, toArray<T>(xs), state);
     return [readOnly<Result>(patternInput[0]), patternInput[1]] as [Iterable<Result>, State];
 }
 
@@ -1148,7 +1150,7 @@ export function reduce<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T
             return loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
         }
         else {
-            throw new Error(SR_inputSequenceEmpty);
+            throw new Exception(SR_inputSequenceEmpty);
         }
     }
     finally {
@@ -1157,12 +1159,12 @@ export function reduce<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T
 }
 
 export function reduceBack<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T {
-    const arr: T[] = toArray<T>(xs);
+    const arr: MutableArray<T> = toArray<T>(xs);
     if (arr.length > 0) {
         return arr.reduceRight(folder);
     }
     else {
-        throw new Error(SR_inputSequenceEmpty);
+        throw new Exception(SR_inputSequenceEmpty);
     }
 }
 
@@ -1194,7 +1196,7 @@ export function skip<T>(count: int32, source: Iterable<T>): Iterable<T> {
         try {
             for (let _ = 1; _ <= count; _++) {
                 if (!e["System.Collections.IEnumerator.MoveNext"]()) {
-                    throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "source");
+                    throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "source");
                 }
             }
             return Enumerator_enumerateThenFinally<T>((): void => {
@@ -1230,7 +1232,7 @@ export function take<T>(count: int32, xs: Iterable<T>): Iterable<T> {
                 return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
             }
             else {
-                throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "source");
+                throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "source");
             }
         }
         else {
@@ -1273,21 +1275,21 @@ export function pairwise<T>(xs: Iterable<T>): Iterable<[T, T]> {
     return delay<[T, T]>((): Iterable<[T, T]> => ofArray<[T, T]>(pairwise_1<T>(toArray<T>(xs))));
 }
 
-export function splitInto<T>(chunks: int32, xs: Iterable<T>): Iterable<T[]> {
-    return delay<T[]>((): Iterable<T[]> => ofArray<T[]>(splitInto_1<T>(chunks, toArray<T>(xs))));
+export function splitInto<T>(chunks: int32, xs: Iterable<T>): Iterable<MutableArray<T>> {
+    return delay<MutableArray<T>>((): Iterable<MutableArray<T>> => ofArray<MutableArray<T>>(splitInto_1<T>(chunks, toArray<T>(xs))));
 }
 
-export function windowed<T>(windowSize: int32, xs: Iterable<T>): Iterable<T[]> {
-    return delay<T[]>((): Iterable<T[]> => ofArray<T[]>(windowed_1<T>(windowSize, toArray<T>(xs))));
+export function windowed<T>(windowSize: int32, xs: Iterable<T>): Iterable<MutableArray<T>> {
+    return delay<MutableArray<T>>((): Iterable<MutableArray<T>> => ofArray<MutableArray<T>>(windowed_1<T>(windowSize, toArray<T>(xs))));
 }
 
 export function transpose<$a extends Iterable<T>, T>(xss: Iterable<$a>): Iterable<Iterable<T>> {
-    return delay<Iterable<T>>((): Iterable<Iterable<T>> => ofArray<Iterable<T>>(map_1<T[], Iterable<T>>(ofArray, transpose_1<T>(map_1<$a, T[]>(toArray, toArray<$a>(xss))))));
+    return delay<Iterable<T>>((): Iterable<Iterable<T>> => ofArray<Iterable<T>>(map_1<MutableArray<T>, Iterable<T>>(ofArray, transpose_1<T>(map_1<$a, MutableArray<T>>(toArray, toArray<$a>(xss))))));
 }
 
 export function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>): Iterable<T> {
     return delay<T>((): Iterable<T> => {
-        const arr: T[] = toArray<T>(xs);
+        const arr: MutableArray<T> = toArray<T>(xs);
         arr.sort(comparer);
         return ofArray<T>(arr);
     });
@@ -1340,7 +1342,7 @@ export function average<T>(xs: Iterable<T>, averager: any): T {
         return averager.Add(acc, x);
     }, averager.GetZero(), xs);
     if (count === 0) {
-        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
     }
     else {
         return averager.DivideByInt(total, count);
@@ -1354,7 +1356,7 @@ export function averageBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, averager:
         return averager.Add(acc, f(x));
     }, averager.GetZero(), xs);
     if (count === 0) {
-        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
     }
     else {
         return averager.DivideByInt(total, count);
@@ -1365,14 +1367,14 @@ export function permute<T>(f: ((arg0: int32) => int32), xs: Iterable<T>): Iterab
     return delay<T>((): Iterable<T> => ofArray<T>(permute_1<T>(f, toArray<T>(xs))));
 }
 
-export function chunkBySize<T>(chunkSize: int32, xs: Iterable<T>): Iterable<T[]> {
-    return delay<T[]>((): Iterable<T[]> => ofArray<T[]>(chunkBySize_1<T>(chunkSize, toArray<T>(xs))));
+export function chunkBySize<T>(chunkSize: int32, xs: Iterable<T>): Iterable<MutableArray<T>> {
+    return delay<MutableArray<T>>((): Iterable<MutableArray<T>> => ofArray<MutableArray<T>>(chunkBySize_1<T>(chunkSize, toArray<T>(xs))));
 }
 
 export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
     let isDone = false;
     if (index < 0) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1384,7 +1386,7 @@ export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
         }
         else {
             if (!isDone) {
-                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
             return undefined;
         }
@@ -1396,7 +1398,7 @@ export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
 export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>): Iterable<T> {
     let status = -1;
     if (index < 0) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return generateIndexed<[IEnumerator<T>, IEnumerator<T>], T>((): [IEnumerator<T>, IEnumerator<T>] => ([ofSeq<T>(xs), ofSeq<T>(ys)] as [IEnumerator<T>, IEnumerator<T>]), (i: int32, tupledArg: [IEnumerator<T>, IEnumerator<T>]): Option<T> => {
         const e1: IEnumerator<T> = tupledArg[0];
@@ -1423,7 +1425,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>):
             }
             else {
                 if (status < 1) {
-                    throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                    throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
                 }
                 return undefined;
             }
@@ -1440,7 +1442,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>):
 export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
     let isDone = false;
     if (index < 0) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1452,7 +1454,7 @@ export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
         }
         else {
             if (!isDone) {
-                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
             return undefined;
         }
@@ -1463,7 +1465,7 @@ export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
 
 export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): Iterable<T> {
     if (index < 0) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if (i < index) {
@@ -1471,14 +1473,14 @@ export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): It
                 return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
             }
             else {
-                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
         }
         else {
             if (i === index) {
                 for (let _ = 1; _ <= count; _++) {
                     if (!e["System.Collections.IEnumerator.MoveNext"]()) {
-                        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "count");
+                        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "count");
                     }
                 }
             }
@@ -1492,7 +1494,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): It
 export function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
     let isDone = false;
     if (index < 0) {
-        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1504,7 +1506,7 @@ export function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
         }
         else {
             if (!isDone) {
-                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
             return undefined;
         }

package/Seq2.ts

@@ -1,12 +1,12 @@
 
-import { toList, toArray, map, filter, delay } from "./Seq.js";
-import { HashSet } from "./MutableSet.js";
-import { defaultOf, IDisposable, disposeSafe, IEnumerator, getEnumerator, IMap, IEqualityComparer, ISet } from "./Util.js";
-import { addToDict, getItemFromDict, tryGetValue, addToSet } from "./MapUtil.js";
-import { Dictionary } from "./MutableMap.js";
-import { int32 } from "./Int32.js";
-import { FSharpRef } from "./Types.js";
-import { FSharpList } from "./List.js";
+import { toList, toArray, map, filter, delay } from "./Seq.ts";
+import { HashSet } from "./MutableSet.ts";
+import { MutableArray, defaultOf, IDisposable, disposeSafe, IEnumerator, getEnumerator, IMap, IEqualityComparer, ISet } from "./Util.ts";
+import { addToDict, getItemFromDict, tryGetValue, addToSet } from "./MapUtil.ts";
+import { Dictionary } from "./MutableMap.ts";
+import { int32 } from "./Int32.ts";
+import { FSharpRef } from "./Types.ts";
+import { FSharpList } from "./List.ts";
 
 export function distinct<T>(xs: Iterable<T>, comparer: IEqualityComparer<T>): Iterable<T> {
     return delay<T>((): Iterable<T> => {
@@ -88,24 +88,24 @@ export function groupBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>,
     });
 }
 
-export function Array_distinct<T>(xs: T[], comparer: IEqualityComparer<T>): T[] {
+export function Array_distinct<T>(xs: MutableArray<T>, comparer: IEqualityComparer<T>): MutableArray<T> {
     return toArray<T>(distinct<T>(xs, comparer));
 }
 
-export function Array_distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): T[] {
+export function Array_distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: MutableArray<T>, comparer: IEqualityComparer<Key>): MutableArray<T> {
     return toArray<T>(distinctBy<T, Key>(projection, xs, comparer));
 }
 
-export function Array_except<T>(itemsToExclude: Iterable<T>, xs: T[], comparer: IEqualityComparer<T>): T[] {
+export function Array_except<T>(itemsToExclude: Iterable<T>, xs: MutableArray<T>, comparer: IEqualityComparer<T>): MutableArray<T> {
     return toArray<T>(except<T>(itemsToExclude, xs, comparer));
 }
 
-export function Array_countBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): [Key, int32][] {
+export function Array_countBy<T, Key>(projection: ((arg0: T) => Key), xs: MutableArray<T>, comparer: IEqualityComparer<Key>): MutableArray<[Key, int32]> {
     return toArray<[Key, int32]>(countBy<T, Key>(projection, xs, comparer));
 }
 
-export function Array_groupBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): [Key, T[]][] {
-    return toArray<[Key, T[]]>(map<[Key, Iterable<T>], [Key, T[]]>((tupledArg: [Key, Iterable<T>]): [Key, T[]] => ([tupledArg[0], toArray<T>(tupledArg[1])] as [Key, T[]]), groupBy<T, Key>(projection, xs, comparer)));
+export function Array_groupBy<T, Key>(projection: ((arg0: T) => Key), xs: MutableArray<T>, comparer: IEqualityComparer<Key>): MutableArray<[Key, MutableArray<T>]> {
+    return toArray<[Key, MutableArray<T>]>(map<[Key, Iterable<T>], [Key, MutableArray<T>]>((tupledArg: [Key, Iterable<T>]): [Key, MutableArray<T>] => ([tupledArg[0], toArray<T>(tupledArg[1])] as [Key, MutableArray<T>]), groupBy<T, Key>(projection, xs, comparer)));
 }
 
 export function List_distinct<T>(xs: FSharpList<T>, comparer: IEqualityComparer<T>): FSharpList<T> {