@fable-org/fable-library-ts 1.4.0 → 1.4.2

package/Array.ts

@@ -51,7 +51,7 @@ export function last<T>(array: T[]): T {
 
 export function tryLast<T>(array: T[]): Option<T> {
     if (array.length === 0) {
-        return void 0;
+        return undefined;
     }
     else {
         return some(item_2(array.length - 1, array));
@@ -228,7 +228,7 @@ export function indexOf<T>(array: T[], item_1: T, start: Option<int32>, count: O
 }
 
 export function contains<T>(value: T, array: T[], eq: IEqualityComparer<T>): boolean {
-    return indexOf<T>(array, value, void 0, void 0, eq) >= 0;
+    return indexOf<T>(array, value, undefined, undefined, eq) >= 0;
 }
 
 export function empty<$a>(cons: any): $a[] {
@@ -397,7 +397,7 @@ export function insertRangeInPlace<T>(index: int32, range: Iterable<T>, array: T
 }
 
 export function removeInPlace<T>(item_1: T, array: T[], eq: IEqualityComparer<T>): boolean {
-    const i: int32 = indexOf<T>(array, item_1, void 0, void 0, eq) | 0;
+    const i: int32 = indexOf<T>(array, item_1, undefined, undefined, eq) | 0;
     if (i > -1) {
         array.splice(i, 1);
         return true;
@@ -471,7 +471,7 @@ export function tryFindIndex<T>(predicate: ((arg0: T) => boolean), array: T[]):
         return matchValue;
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 
@@ -505,7 +505,7 @@ export function tryPick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]
         while (true) {
             const i: int32 = i_mut;
             if (i >= array.length) {
-                return void 0;
+                return undefined;
             }
             else {
                 const matchValue: Option<$b> = chooser(item_2(i, array));
@@ -550,7 +550,7 @@ export function tryFindBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[])
         while (true) {
             const i: int32 = i_mut;
             if (i < 0) {
-                return void 0;
+                return undefined;
             }
             else if (predicate(item_2(i, array))) {
                 return some(item_2(i, array));
@@ -614,7 +614,7 @@ export function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array:
         while (true) {
             const i: int32 = i_mut;
             if (i < 0) {
-                return void 0;
+                return undefined;
             }
             else if (predicate(item_2(i, array))) {
                 return i;
@@ -983,7 +983,7 @@ export function tryExactlyOne<T>(array: T[]): Option<T> {
         return some(item_2(0, array));
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 
@@ -998,7 +998,7 @@ export function head<T>(array: T[]): T {
 
 export function tryHead<T>(array: T[]): Option<T> {
     if (array.length === 0) {
-        return void 0;
+        return undefined;
     }
     else {
         return some(item_2(0, array));
@@ -1032,7 +1032,7 @@ export function setItem<T>(array: T[], index: int32, value: T): void {
 
 export function tryItem<T>(index: int32, array: T[]): Option<T> {
     if ((index < 0) ? true : (index >= array.length)) {
-        return void 0;
+        return undefined;
     }
     else {
         return some(array[index]);

package/BigInt.ts

@@ -148,10 +148,11 @@ export function toFloat32(x: bigint): float32 { return Number(x); }
 export function toFloat64(x: bigint): float64 { return Number(x); }
 
 export function toDecimal(x: bigint): decimal {
-    const low = Number(BigInt.asUintN(32, x))
-    const mid = Number(BigInt.asUintN(32, x >> 32n))
-    const high = Number(BigInt.asUintN(32, x >> 64n))
     const isNegative = x < zero;
+    const bits = abs(x);
+    const low = Number(BigInt.asUintN(32, bits));
+    const mid = Number(BigInt.asUintN(32, bits >> 32n));
+    const high = Number(BigInt.asUintN(32, bits >> 64n));
     const scale = 0;
     return fromParts(low, mid, high, isNegative, scale)
 }

package/CHANGELOG.md

@@ -7,7 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-## 1.4.0 - 2024-03-18
+## 1.4.2 - 2024-06-13
+
+### Fixed
+
+* [JS/TS] Fixed BigInt.ToDecimal with negative values (#3500) (by @ncave)
+
+## 1.4.1 - 2024-06-13
+
+### Fixed
+
+* [JS/TS] Fixed DateTime.MinValue, DateTime.MaxValue (#3836) (by @ncave)
+
+## 1.4.0 - 2024-03-20
 
 ### Added
 

package/Choice.ts

@@ -285,7 +285,7 @@ export function Choice_tryValueIfChoice1Of2<T1, T2>(x: FSharpChoice$2_$union<T1,
         return some(x.fields[0]);
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 
@@ -294,7 +294,7 @@ export function Choice_tryValueIfChoice2Of2<T1, T2>(x: FSharpChoice$2_$union<T1,
         return some(x.fields[0]);
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 

package/Date.ts

@@ -105,10 +105,10 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
         cursorPos += tokenLength;
         switch (tokenLength) {
           case 1:
-            result += localizedDate.getDate();
+            result += day(localizedDate);
             break;
           case 2:
-            result += padWithZeros(localizedDate.getDate(), 2);
+            result += padWithZeros(day(localizedDate), 2);
             break;
           case 3:
             result += shortDays[dayOfWeek(localizedDate)];
@@ -498,12 +498,12 @@ export function getTicks(date: IDateTime | IDateTimeOffset) {
 
 export function minValue() {
   // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
-  return DateTime(-62135596800000, DateKind.Unspecified);
+  return DateTime(-62135596800000, DateKind.UTC);
 }
 
 export function maxValue() {
   // This is "9999-12-31T23:59:59.999Z", actual JS max value is 8640000000000000
-  return DateTime(253402300799999, DateKind.Unspecified);
+  return DateTime(253402300799999, DateKind.UTC);
 }
 
 export function parseRaw(input: string): [Date, Offset] {

package/List.ts

@@ -193,7 +193,7 @@ export function ListEnumerator$1_$ctor_3002E699<T>(xs: FSharpList<T>): ListEnume
 }
 
 export function FSharpList_get_Empty<T>(): FSharpList<T> {
-    return new FSharpList(defaultOf(), void 0);
+    return new FSharpList(defaultOf(), undefined);
 }
 
 export function FSharpList_Cons_305B8EAC<T>(x: T, xs: FSharpList<T>): FSharpList<T> {
@@ -299,7 +299,7 @@ export function head<T>(xs: FSharpList<T>): T {
 
 export function tryHead<T>(xs: FSharpList<T>): Option<T> {
     if (FSharpList__get_IsEmpty<T>(xs)) {
-        return void 0;
+        return undefined;
     }
     else {
         return some(FSharpList__get_Head<T>(xs));
@@ -315,7 +315,7 @@ export function tryLast<T>(xs_mut: FSharpList<T>): Option<T> {
     while (true) {
         const xs: FSharpList<T> = xs_mut;
         if (FSharpList__get_IsEmpty<T>(xs)) {
-            return void 0;
+            return undefined;
         }
         else {
             const t: FSharpList<T> = FSharpList__get_Tail<T>(xs);
@@ -459,7 +459,7 @@ export function unfold<State, T>(gen: ((arg0: State) => Option<[T, State]>), sta
             const matchValue: Option<[T, State]> = gen(acc);
             if (matchValue != null) {
                 acc_mut = value_1(matchValue)[1];
-                node_mut = ((t = (new FSharpList(value_1(matchValue)[0], void 0)), (node.tail = t, t)));
+                node_mut = ((t = (new FSharpList(value_1(matchValue)[0], undefined)), (node.tail = t, t)));
                 continue loop;
             }
             else {
@@ -478,13 +478,13 @@ export function unfold<State, T>(gen: ((arg0: State) => Option<[T, State]>), sta
 export function iterate<$a>(action: ((arg0: $a) => void), xs: FSharpList<$a>): void {
     fold<$a, void>((unitVar: void, x: $a): void => {
         action(x);
-    }, void 0, xs);
+    }, undefined, xs);
 }
 
 export function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: FSharpList<$a>, ys: FSharpList<$b>): void {
     fold2<$a, $b, void>((unitVar: void, x: $a, y: $b): void => {
         action(x, y);
-    }, void 0, xs, ys);
+    }, undefined, xs, ys);
 }
 
 export function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: FSharpList<$a>): void {
@@ -532,7 +532,7 @@ export function ofSeq<T>(xs: Iterable<T>): FSharpList<T> {
         try {
             while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
                 const x: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                node = ((xs_3 = node, (t = (new FSharpList(x, void 0)), (xs_3.tail = t, t))));
+                node = ((xs_3 = node, (t = (new FSharpList(x, undefined)), (xs_3.tail = t, t))));
             }
         }
         finally {
@@ -550,7 +550,7 @@ export function concat<T>(lists: Iterable<FSharpList<T>>): FSharpList<T> {
     let node: FSharpList<T> = root;
     const action = (xs: FSharpList<T>): void => {
         node = fold<T, FSharpList<T>>((acc: FSharpList<T>, x: T): FSharpList<T> => {
-            const t: FSharpList<T> = new FSharpList(x, void 0);
+            const t: FSharpList<T> = new FSharpList(x, undefined);
             acc.tail = t;
             return t;
         }, node, xs);
@@ -583,14 +583,14 @@ export function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state:
     let xs_4: FSharpList<State>, t_2: FSharpList<State>;
     const root: FSharpList<State> = FSharpList_get_Empty<State>();
     let node: FSharpList<State>;
-    const t: FSharpList<State> = new FSharpList(state, void 0);
+    const t: FSharpList<State> = new FSharpList(state, undefined);
     root.tail = t;
     node = t;
     let acc: State = state;
     let xs_3: FSharpList<T> = xs;
     while (!FSharpList__get_IsEmpty<T>(xs_3)) {
         acc = folder(acc, FSharpList__get_Head<T>(xs_3));
-        node = ((xs_4 = node, (t_2 = (new FSharpList(acc, void 0)), (xs_4.tail = t_2, t_2))));
+        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);
     }
     const xs_6: FSharpList<State> = node;
@@ -615,7 +615,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)) {
-            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head<U>(zs), void 0)), (xs_1.tail = t, t))));
+            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head<U>(zs), undefined)), (xs_1.tail = t, t))));
             zs = FSharpList__get_Tail<U>(zs);
         }
         ys = FSharpList__get_Tail<T>(ys);
@@ -629,7 +629,7 @@ export function collect<T, U>(mapping: ((arg0: T) => FSharpList<U>), xs: FSharpL
 export function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: FSharpList<T>): FSharpList<U> {
     const root: FSharpList<U> = FSharpList_get_Empty<U>();
     const node: FSharpList<U> = foldIndexed<FSharpList<U>, T>((i: int32, acc: FSharpList<U>, x: T): FSharpList<U> => {
-        const t: FSharpList<U> = new FSharpList(mapping(i, x), void 0);
+        const t: FSharpList<U> = new FSharpList(mapping(i, x), undefined);
         acc.tail = t;
         return t;
     }, root, xs);
@@ -641,7 +641,7 @@ export function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: FSh
 export function map<T, U>(mapping: ((arg0: T) => U), xs: FSharpList<T>): FSharpList<U> {
     const root: FSharpList<U> = FSharpList_get_Empty<U>();
     const node: FSharpList<U> = fold<T, FSharpList<U>>((acc: FSharpList<U>, x: T): FSharpList<U> => {
-        const t: FSharpList<U> = new FSharpList(mapping(x), void 0);
+        const t: FSharpList<U> = new FSharpList(mapping(x), undefined);
         acc.tail = t;
         return t;
     }, root, xs);
@@ -657,7 +657,7 @@ export function indexed<$a>(xs: FSharpList<$a>): FSharpList<[int32, $a]> {
 export function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<U> {
     const root: FSharpList<U> = FSharpList_get_Empty<U>();
     const node: FSharpList<U> = fold2<T1, T2, FSharpList<U>>((acc: FSharpList<U>, x: T1, y: T2): FSharpList<U> => {
-        const t: FSharpList<U> = new FSharpList(mapping(x, y), void 0);
+        const t: FSharpList<U> = new FSharpList(mapping(x, y), undefined);
         acc.tail = t;
         return t;
     }, root, xs, ys);
@@ -677,7 +677,7 @@ export function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T
             }
             else {
                 i_mut = (i + 1);
-                acc_mut = ((t = (new FSharpList(mapping(i, FSharpList__get_Head<T1>(xs_1), FSharpList__get_Head<T2>(ys_1)), void 0)), (acc.tail = t, t)));
+                acc_mut = ((t = (new FSharpList(mapping(i, FSharpList__get_Head<T1>(xs_1), FSharpList__get_Head<T2>(ys_1)), undefined)), (acc.tail = t, t)));
                 xs_1_mut = FSharpList__get_Tail<T1>(xs_1);
                 ys_1_mut = FSharpList__get_Tail<T2>(ys_1);
                 continue loop;
@@ -702,7 +702,7 @@ export function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) =>
                 return acc;
             }
             else {
-                acc_mut = ((t = (new FSharpList(mapping(FSharpList__get_Head<T1>(xs_1), FSharpList__get_Head<T2>(ys_1), FSharpList__get_Head<T3>(zs_1)), void 0)), (acc.tail = t, t)));
+                acc_mut = ((t = (new FSharpList(mapping(FSharpList__get_Head<T1>(xs_1), FSharpList__get_Head<T2>(ys_1), FSharpList__get_Head<T3>(zs_1)), undefined)), (acc.tail = t, t)));
                 xs_1_mut = FSharpList__get_Tail<T1>(xs_1);
                 ys_1_mut = FSharpList__get_Tail<T2>(ys_1);
                 zs_1_mut = FSharpList__get_Tail<T3>(zs_1);
@@ -723,7 +723,7 @@ export function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [R
     const patternInput_1: [FSharpList<Result>, State] = fold<T, [FSharpList<Result>, State]>((tupledArg: [FSharpList<Result>, State], x: T): [FSharpList<Result>, State] => {
         let t: FSharpList<Result>;
         const patternInput: [Result, State] = mapping(tupledArg[1], x);
-        return [(t = (new FSharpList(patternInput[0], void 0)), (tupledArg[0].tail = t, t)), patternInput[1]] as [FSharpList<Result>, State];
+        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);
     const t_2: FSharpList<Result> = FSharpList_get_Empty<Result>();
     patternInput_1[0].tail = t_2;
@@ -740,7 +740,7 @@ export function tryPick<T, $a>(f: ((arg0: T) => Option<$a>), xs: FSharpList<T>):
         while (true) {
             const xs_1: FSharpList<T> = xs_1_mut;
             if (FSharpList__get_IsEmpty<T>(xs_1)) {
-                return void 0;
+                return undefined;
             }
             else {
                 const matchValue: Option<$a> = f(FSharpList__get_Head<T>(xs_1));
@@ -769,7 +769,7 @@ export function pick<$a, $b>(f: ((arg0: $a) => Option<$b>), xs: FSharpList<$a>):
 }
 
 export function tryFind<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<$a> {
-    return tryPick<$a, $a>((x: $a): Option<$a> => (f(x) ? some(x) : void 0), xs);
+    return tryPick<$a, $a>((x: $a): Option<$a> => (f(x) ? some(x) : undefined), xs);
 }
 
 export function find<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): $a {
@@ -802,7 +802,7 @@ export function tryFindIndex<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): O
         while (true) {
             const i: int32 = i_mut, xs_1: FSharpList<T> = xs_1_mut;
             if (FSharpList__get_IsEmpty<T>(xs_1)) {
-                return void 0;
+                return undefined;
             }
             else if (f(FSharpList__get_Head<T>(xs_1))) {
                 return i;
@@ -850,7 +850,7 @@ export function tryItem<T>(n: int32, xs: FSharpList<T>): Option<T> {
         while (true) {
             const i: int32 = i_mut, xs_1: FSharpList<T> = xs_1_mut;
             if (FSharpList__get_IsEmpty<T>(xs_1)) {
-                return void 0;
+                return undefined;
             }
             else if (i === n) {
                 return some(FSharpList__get_Head<T>(xs_1));
@@ -874,7 +874,7 @@ export function filter<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpL
     const root: FSharpList<T> = FSharpList_get_Empty<T>();
     const node: FSharpList<T> = fold<T, FSharpList<T>>((acc: FSharpList<T>, x: T): FSharpList<T> => {
         if (f(x)) {
-            const t: FSharpList<T> = new FSharpList(x, void 0);
+            const t: FSharpList<T> = new FSharpList(x, undefined);
             acc.tail = t;
             return t;
         }
@@ -896,10 +896,10 @@ export function partition<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): [FSh
         const lacc: FSharpList<T> = tupledArg[0];
         const racc: FSharpList<T> = tupledArg[1];
         if (f(x)) {
-            return [(t = (new FSharpList(x, void 0)), (lacc.tail = t, t)), racc] as [FSharpList<T>, FSharpList<T>];
+            return [(t = (new FSharpList(x, undefined)), (lacc.tail = t, t)), racc] as [FSharpList<T>, FSharpList<T>];
         }
         else {
-            return [lacc, (t_2 = (new FSharpList(x, void 0)), (racc.tail = t_2, t_2))] as [FSharpList<T>, FSharpList<T>];
+            return [lacc, (t_2 = (new FSharpList(x, undefined)), (racc.tail = t_2, t_2))] as [FSharpList<T>, FSharpList<T>];
         }
     }, [root1, root2] as [FSharpList<T>, FSharpList<T>], xs);
     const t_4: FSharpList<T> = FSharpList_get_Empty<T>();
@@ -917,7 +917,7 @@ export function choose<T, U>(f: ((arg0: T) => Option<U>), xs: FSharpList<T>): FS
             return acc;
         }
         else {
-            const t: FSharpList<U> = new FSharpList(value_1(matchValue), void 0);
+            const t: FSharpList<U> = new FSharpList(value_1(matchValue), undefined);
             acc.tail = t;
             return t;
         }
@@ -936,7 +936,7 @@ 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++) {
-        node = ((xs = node, (t = (new FSharpList(f(i), void 0)), (xs.tail = t, t))));
+        node = ((xs = node, (t = (new FSharpList(f(i), undefined)), (xs.tail = t, t))));
     }
     const xs_2: FSharpList<T> = node;
     const t_2: FSharpList<T> = FSharpList_get_Empty<T>();
@@ -1113,7 +1113,7 @@ export function allPairs<T1, T2>(xs: FSharpList<T1>, ys: FSharpList<T2>): FSharp
     iterate<T1>((x: T1): void => {
         iterate<T2>((y: T2): void => {
             let xs_1: FSharpList<[T1, T2]>, t: FSharpList<[T1, T2]>;
-            node = ((xs_1 = node, (t = (new FSharpList([x, y] as [T1, T2], void 0)), (xs_1.tail = t, t))));
+            node = ((xs_1 = node, (t = (new FSharpList([x, y] as [T1, T2], undefined)), (xs_1.tail = t, t))));
         }, ys);
     }, xs);
     const xs_3: FSharpList<[T1, T2]> = node;
@@ -1177,7 +1177,7 @@ export function take<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
             }
             else {
                 i_mut = (i - 1);
-                acc_mut = ((t = (new FSharpList(FSharpList__get_Head<T>(xs_1), void 0)), (acc.tail = t, t)));
+                acc_mut = ((t = (new FSharpList(FSharpList__get_Head<T>(xs_1), undefined)), (acc.tail = t, t)));
                 xs_1_mut = FSharpList__get_Tail<T>(xs_1);
                 continue loop;
             }
@@ -1204,7 +1204,7 @@ export function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: FSharpList<T
                 return acc;
             }
             else {
-                acc_mut = ((t = (new FSharpList(FSharpList__get_Head<T>(xs_1), void 0)), (acc.tail = t, t)));
+                acc_mut = ((t = (new FSharpList(FSharpList__get_Head<T>(xs_1), undefined)), (acc.tail = t, t)));
                 xs_1_mut = FSharpList__get_Tail<T>(xs_1);
                 continue loop;
             }
@@ -1232,7 +1232,7 @@ export function truncate<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
             }
             else {
                 i_mut = (i - 1);
-                acc_mut = ((t = (new FSharpList(FSharpList__get_Head<T>(xs_1), void 0)), (acc.tail = t, t)));
+                acc_mut = ((t = (new FSharpList(FSharpList__get_Head<T>(xs_1), undefined)), (acc.tail = t, t)));
                 xs_1_mut = FSharpList__get_Tail<T>(xs_1);
                 continue loop;
             }
@@ -1289,7 +1289,7 @@ export function tryExactlyOne<T>(xs: FSharpList<T>): Option<T> {
         return some(FSharpList__get_Head<T>(xs));
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 

package/Map.ts

@@ -66,7 +66,7 @@ export function MapTreeNode$2__get_Height<Key, Value>(_: MapTreeNode$2<Key, Valu
 }
 
 export function MapTreeModule_empty<Key, Value>(): Option<MapTreeLeaf$2<Key, Value>> {
-    return void 0;
+    return undefined;
 }
 
 export function MapTreeModule_sizeAux<Key, Value>(acc_mut: int32, m_mut: Option<MapTreeLeaf$2<Key, Value>>): int32 {
@@ -243,11 +243,11 @@ export function MapTreeModule_tryFind<Key, Value>(comparer_mut: IComparer<Key>,
                 continue MapTreeModule_tryFind;
             }
             else {
-                return void 0;
+                return undefined;
             }
         }
         else {
-            return void 0;
+            return undefined;
         }
         break;
     }
@@ -436,7 +436,7 @@ export function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Ke
         else {
             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(void 0);
+                const matchValue_2: Option<Value> = u(undefined);
                 if (matchValue_2 != null) {
                     return MapTreeNode$2_$ctor_Z39DE9543<Key, Value>(k, value_1(matchValue_2), MapTreeModule_empty<Key, Value>(), m, 2);
                 }
@@ -454,7 +454,7 @@ export function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Ke
                 }
             }
             else {
-                const matchValue_4: Option<Value> = u(void 0);
+                const matchValue_4: Option<Value> = u(undefined);
                 if (matchValue_4 != null) {
                     return MapTreeNode$2_$ctor_Z39DE9543<Key, Value>(k, value_1(matchValue_4), m, MapTreeModule_empty<Key, Value>(), 2);
                 }
@@ -465,7 +465,7 @@ export function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Ke
         }
     }
     else {
-        const matchValue: Option<Value> = u(void 0);
+        const matchValue: Option<Value> = u(undefined);
         if (matchValue != null) {
             return MapTreeLeaf$2_$ctor_5BDDA1<Key, Value>(k, value_1(matchValue));
         }
@@ -566,7 +566,7 @@ export function MapTreeModule_tryPickOpt<Key, Value, $a>(f_mut: any, m_mut: Opti
             }
         }
         else {
-            return void 0;
+            return undefined;
         }
         break;
     }
@@ -1014,7 +1014,7 @@ export function MapTreeModule_toSeq<$a, $b>(s: Option<MapTreeLeaf$2<$a, $b>>): I
             return [en_1["System.Collections.Generic.IEnumerator`1.get_Current"](), en_1] as [[$a, $b], IEnumerator<[$a, $b]>];
         }
         else {
-            return void 0;
+            return undefined;
         }
     }, MapTreeModule_mkIEnumerator<$a, $b>(s));
 }
@@ -1489,7 +1489,7 @@ export function findKey<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), ta
             return some(k);
         }
         else {
-            return void 0;
+            return undefined;
         }
     }, table);
 }
@@ -1501,7 +1501,7 @@ export function tryFindKey<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean),
             return some(k);
         }
         else {
-            return void 0;
+            return undefined;
         }
     }, table);
 }

package/MutableMap.ts

@@ -230,7 +230,7 @@ export function Dictionary__TryFind_2B595<Key, Value>(this$: Dictionary<Key, Val
         case 0:
             return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];
         default:
-            return void 0;
+            return undefined;
     }
 }
 

package/MutableSet.ts

@@ -157,7 +157,7 @@ function HashSet__TryFind_2B595<T>(this$: HashSet<T>, k: T): Option<T> {
         case 0:
             return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);
         default:
-            return void 0;
+            return undefined;
     }
 }
 

package/Random.ts

@@ -60,7 +60,7 @@ export class NonSeeded implements IRandom {
 }
 
 export function NonSeeded_$reflection(): TypeInfo {
-    return class_type("Random.NonSeeded", void 0, NonSeeded);
+    return class_type("Random.NonSeeded", undefined, NonSeeded);
 }
 
 export function NonSeeded_$ctor(): NonSeeded {
@@ -139,7 +139,7 @@ export class Seeded implements IRandom {
 }
 
 export function Seeded_$reflection(): TypeInfo {
-    return class_type("Random.Seeded", void 0, Seeded);
+    return class_type("Random.Seeded", undefined, Seeded);
 }
 
 export function Seeded_$ctor_Z524259A4(seed: int32): Seeded {

package/Range.ts

@@ -13,7 +13,7 @@ export function makeRangeStepFunction<T>(step: T, stop: T, zero: T, add: ((arg0:
     const stepGreaterThanZero: boolean = stepComparedWithZero > 0;
     return (x: T): Option<[T, T]> => {
         const comparedWithLast: int32 = compare(x, stop) | 0;
-        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? ([x, add(x, step)] as [T, T]) : void 0;
+        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? ([x, add(x, step)] as [T, T]) : undefined;
     };
 }
 
@@ -43,14 +43,14 @@ export function rangeUInt64(start: uint64, step: uint64, stop: uint64): Iterable
 }
 
 export function rangeChar(start: string, stop: string): Iterable<string> {
-    const intStop: int32 = stop.charCodeAt(0) | 0;
+    const intStop: int32 = ~~stop.charCodeAt(0) | 0;
     return delay<string>((): Iterable<string> => unfold<int32, string>((c: int32): Option<[string, int32]> => {
         if (c <= intStop) {
             return [String.fromCharCode(c), c + 1] as [string, int32];
         }
         else {
-            return void 0;
+            return undefined;
         }
-    }, start.charCodeAt(0)));
+    }, ~~start.charCodeAt(0)));
 }
 

package/Result.ts

@@ -181,7 +181,7 @@ export function Result_ToOption<a, b>(result: FSharpResult$2_$union<a, b>): Opti
         return some(result.fields[0]);
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 
@@ -190,7 +190,7 @@ export function Result_ToValueOption<a, b>(result: FSharpResult$2_$union<a, b>):
         return some(result.fields[0]);
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 

package/Seq.ts

@@ -122,17 +122,16 @@ export function Enumerator_FromFunctions$1_$ctor_58C54629<T>(current: (() => T),
 
 export function Enumerator_cast<T>(e: IEnumerator<T>): IEnumerator<T> {
     return Enumerator_FromFunctions$1_$ctor_58C54629<T>((): T => e["System.Collections.Generic.IEnumerator`1.get_Current"](), (): boolean => e["System.Collections.IEnumerator.MoveNext"](), (): void => {
-        const e_1 = e as IDisposable;
-        disposeSafe(e_1);
+        disposeSafe(e);
     });
 }
 
 export function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>): IEnumerator<T> {
-    let outerOpt: Option<IEnumerator<U>> = void 0;
-    let innerOpt: Option<IEnumerator<T>> = void 0;
+    let outerOpt: Option<IEnumerator<U>> = undefined;
+    let innerOpt: Option<IEnumerator<T>> = undefined;
     let started = false;
     let finished = false;
-    let curr: Option<T> = void 0;
+    let curr: Option<T> = undefined;
     const finish = (): void => {
         finished = true;
         if (innerOpt != null) {
@@ -141,7 +140,7 @@ export function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>
                 disposeSafe(inner);
             }
             finally {
-                innerOpt = void 0;
+                innerOpt = undefined;
             }
         }
         if (outerOpt != null) {
@@ -150,7 +149,7 @@ export function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>
                 disposeSafe(outer);
             }
             finally {
-                outerOpt = void 0;
+                outerOpt = undefined;
             }
         }
     };
@@ -176,7 +175,7 @@ export function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>
             return false;
         }
         else {
-            let res: Option<boolean> = void 0;
+            let res: Option<boolean> = undefined;
             while (res == null) {
                 const outerOpt_1: Option<IEnumerator<U>> = outerOpt;
                 const innerOpt_1: Option<IEnumerator<T>> = innerOpt;
@@ -192,7 +191,7 @@ export function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>
                                 disposeSafe(inner_1);
                             }
                             finally {
-                                innerOpt = void 0;
+                                innerOpt = undefined;
                             }
                         }
                     }
@@ -234,7 +233,7 @@ export function Enumerator_enumerateThenFinally<T>(f: (() => void), e: IEnumerat
 
 export function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((arg0: T) => Option<U>), closef: ((arg0: T) => void)): IEnumerator<U> {
     let started = false;
-    let curr: Option<U> = void 0;
+    let curr: Option<U> = undefined;
     let state: Option<T> = some(openf());
     const dispose = (): void => {
         if (state != null) {
@@ -243,7 +242,7 @@ export function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((
                 closef(x_1);
             }
             finally {
-                state = void 0;
+                state = undefined;
             }
         }
     };
@@ -252,7 +251,7 @@ export function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((
             dispose();
         }
         finally {
-            curr = void 0;
+            curr = undefined;
         }
     };
     return Enumerator_FromFunctions$1_$ctor_58C54629<U>((): U => {
@@ -295,7 +294,7 @@ export function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((
 }
 
 export function Enumerator_unfold<State, T>(f: ((arg0: State) => Option<[T, State]>), state: State): IEnumerator<T> {
-    let curr: Option<[T, State]> = void 0;
+    let curr: Option<[T, State]> = undefined;
     let acc: State = state;
     return Enumerator_FromFunctions$1_$ctor_58C54629<T>((): T => {
         if (curr != null) {
@@ -417,7 +416,7 @@ export function cast<T>(xs: Iterable<T>): Iterable<T> {
 
 export function choose<T, U>(chooser: ((arg0: T) => Option<U>), xs: Iterable<T>): Iterable<U> {
     return generate<IEnumerator<T>, U>((): IEnumerator<T> => ofSeq<T>(xs), (e: IEnumerator<T>): Option<U> => {
-        let curr: Option<U> = void 0;
+        let curr: Option<U> = undefined;
         while ((curr == null) && e["System.Collections.IEnumerator.MoveNext"]()) {
             curr = chooser(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
         }
@@ -468,7 +467,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)) : void 0), (x_1: $a): void => {
+    return generate<$a, $b>(create, (x: $a): Option<$b> => (moveNext(x) ? some(current(x)) : undefined), (x_1: $a): void => {
         const matchValue: any = x_1;
         if (isDisposable(matchValue)) {
             const id = matchValue as IDisposable;
@@ -511,7 +510,7 @@ export function enumerateUsing<T extends IDisposable, $a extends Iterable<U>, U>
 }
 
 export function enumerateWhile<T>(guard: (() => boolean), xs: Iterable<T>): Iterable<T> {
-    return concat<Iterable<T>, T>(unfold<int32, Iterable<T>>((i: int32): Option<[Iterable<T>, int32]> => (guard() ? ([xs, i + 1] as [Iterable<T>, int32]) : void 0), 0));
+    return concat<Iterable<T>, T>(unfold<int32, Iterable<T>>((i: int32): Option<[Iterable<T>, int32]> => (guard() ? ([xs, i + 1] as [Iterable<T>, int32]) : undefined), 0));
 }
 
 export function filter<T>(f: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T> {
@@ -520,7 +519,7 @@ export function filter<T>(f: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<
             return some(x);
         }
         else {
-            return void 0;
+            return undefined;
         }
     }, xs);
 }
@@ -585,10 +584,10 @@ export function tryExactlyOne<T>(xs: Iterable<T>): Option<T> {
     try {
         if (e["System.Collections.IEnumerator.MoveNext"]()) {
             const v: T = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            return e["System.Collections.IEnumerator.MoveNext"]() ? void 0 : some(v);
+            return e["System.Collections.IEnumerator.MoveNext"]() ? undefined : some(v);
         }
         else {
-            return void 0;
+            return undefined;
         }
     }
     finally {
@@ -599,7 +598,7 @@ export function tryExactlyOne<T>(xs: Iterable<T>): Option<T> {
 export function tryFind<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T> {
     const e: IEnumerator<T> = ofSeq<T>(xs);
     try {
-        let res: Option<T> = void 0;
+        let res: Option<T> = undefined;
         while ((res == null) && e["System.Collections.IEnumerator.MoveNext"]()) {
             const c: T = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
             if (predicate(c)) {
@@ -654,7 +653,7 @@ export function tryFindIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<
                     }
                 }
                 else {
-                    return void 0;
+                    return undefined;
                 }
                 break;
             }
@@ -752,7 +751,7 @@ export function tryHead<T>(xs: Iterable<T>): Option<T> {
     else {
         const e: IEnumerator<T> = ofSeq<T>(xs);
         try {
-            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0;
+            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
         }
         finally {
             disposeSafe(e as IDisposable);
@@ -771,7 +770,7 @@ export function head<T>(xs: Iterable<T>): T {
 }
 
 export function initialize<$a>(count: int32, f: ((arg0: int32) => $a)): Iterable<$a> {
-    return unfold<int32, $a>((i: int32): Option<[$a, int32]> => ((i < count) ? ([f(i), i + 1] as [$a, int32]) : void 0), 0);
+    return unfold<int32, $a>((i: int32): Option<[$a, int32]> => ((i < count) ? ([f(i), i + 1] as [$a, int32]) : undefined), 0);
 }
 
 export function initializeInfinite<$a>(f: ((arg0: int32) => $a)): Iterable<$a> {
@@ -812,7 +811,7 @@ export function tryItem<T>(index: int32, xs: Iterable<T>): Option<T> {
                 while (true) {
                     const index_1: int32 = index_1_mut;
                     if (!e["System.Collections.IEnumerator.MoveNext"]()) {
-                        return void 0;
+                        return undefined;
                     }
                     else if (index_1 === 0) {
                         return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
@@ -845,13 +844,13 @@ export function item<T>(index: int32, xs: Iterable<T>): T {
 export function iterate<$a>(action: ((arg0: $a) => void), xs: Iterable<$a>): void {
     fold<$a, void>((unitVar: void, x: $a): void => {
         action(x);
-    }, void 0, xs);
+    }, undefined, xs);
 }
 
 export function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void {
     fold2<$a, $b, void>((unitVar: void, x: $a, y: $b): void => {
         action(x, y);
-    }, void 0, xs, ys);
+    }, undefined, xs, ys);
 }
 
 export function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: Iterable<$a>): void {
@@ -885,7 +884,7 @@ export function tryLast<T>(xs: Iterable<T>): Option<T> {
                 break;
             }
         };
-        return e["System.Collections.IEnumerator.MoveNext"]() ? some(loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+        return e["System.Collections.IEnumerator.MoveNext"]() ? some(loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
     }
     finally {
         disposeSafe(e as IDisposable);
@@ -926,13 +925,13 @@ export function length<T>(xs: Iterable<T>): int32 {
 }
 
 export function map<T, U>(mapping: ((arg0: T) => U), xs: Iterable<T>): Iterable<U> {
-    return generate<IEnumerator<T>, U>((): IEnumerator<T> => ofSeq<T>(xs), (e: IEnumerator<T>): Option<U> => (e["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0), (e_1: IEnumerator<T>): void => {
+    return generate<IEnumerator<T>, U>((): IEnumerator<T> => ofSeq<T>(xs), (e: IEnumerator<T>): Option<U> => (e["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined), (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
     });
 }
 
 export function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: Iterable<T>): Iterable<U> {
-    return generateIndexed<IEnumerator<T>, U>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<U> => (e["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(i, e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0), (e_1: IEnumerator<T>): void => {
+    return generateIndexed<IEnumerator<T>, U>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<U> => (e["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(i, e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined), (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
     });
 }
@@ -945,7 +944,7 @@ export function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: Iterab
     return generate<[IEnumerator<T1>, IEnumerator<T2>], U>((): [IEnumerator<T1>, IEnumerator<T2>] => ([ofSeq<T1>(xs), ofSeq<T2>(ys)] as [IEnumerator<T1>, IEnumerator<T2>]), (tupledArg: [IEnumerator<T1>, IEnumerator<T2>]): Option<U> => {
         const e1: IEnumerator<T1> = tupledArg[0];
         const e2: IEnumerator<T2> = tupledArg[1];
-        return (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+        return (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
     }, (tupledArg_1: [IEnumerator<T1>, IEnumerator<T2>]): void => {
         try {
             disposeSafe(tupledArg_1[0]);
@@ -960,7 +959,7 @@ export function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T
     return generateIndexed<[IEnumerator<T1>, IEnumerator<T2>], U>((): [IEnumerator<T1>, IEnumerator<T2>] => ([ofSeq<T1>(xs), ofSeq<T2>(ys)] as [IEnumerator<T1>, IEnumerator<T2>]), (i: int32, tupledArg: [IEnumerator<T1>, IEnumerator<T2>]): Option<U> => {
         const e1: IEnumerator<T1> = tupledArg[0];
         const e2: IEnumerator<T2> = tupledArg[1];
-        return (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(i, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+        return (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(i, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
     }, (tupledArg_1: [IEnumerator<T1>, IEnumerator<T2>]): void => {
         try {
             disposeSafe(tupledArg_1[0]);
@@ -976,7 +975,7 @@ export function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) =>
         const e1: IEnumerator<T1> = tupledArg[0];
         const e2: IEnumerator<T2> = tupledArg[1];
         const e3: IEnumerator<T3> = tupledArg[2];
-        return ((e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) && e3["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"](), e3["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+        return ((e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) && e3["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"](), e3["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
     }, (tupledArg_1: [IEnumerator<T1>, IEnumerator<T2>, IEnumerator<T3>]): void => {
         try {
             disposeSafe(tupledArg_1[0]);
@@ -1036,7 +1035,7 @@ export function CachedSeq$1__Clear<T>(_: CachedSeq$1<T>): void {
 export function cache<T>(source: Iterable<T>): Iterable<T> {
     checkNonNull<Iterable<T>>("source", source);
     const prefix: T[] = [];
-    let enumeratorR: Option<Option<IEnumerator<T>>> = void 0;
+    let enumeratorR: Option<Option<IEnumerator<T>>> = undefined;
     return CachedSeq$1_$ctor_Z7A8347D4<T>((): void => {
         Operators_Lock<T[], void>(prefix, (): void => {
             clear(prefix);
@@ -1059,7 +1058,7 @@ export function cache<T>(source: Iterable<T>): Iterable<T> {
                     break;
                 }
             }
-            enumeratorR = void 0;
+            enumeratorR = undefined;
         });
     }, unfold<int32, T>((i_1: int32): Option<[T, int32]> => Operators_Lock<T[], Option<[T, int32]>>(prefix, (): Option<[T, int32]> => {
         if (i_1 < prefix.length) {
@@ -1085,7 +1084,7 @@ export function cache<T>(source: Iterable<T>): Iterable<T> {
                     }
                     else {
                         disposeSafe(enumerator);
-                        enumeratorR = some(void 0);
+                        enumeratorR = some(undefined);
                     }
                 }
             }
@@ -1093,7 +1092,7 @@ export function cache<T>(source: Iterable<T>): Iterable<T> {
                 return [prefix[i_1], i_1 + 1] as [T, int32];
             }
             else {
-                return void 0;
+                return undefined;
             }
         }
     }), 0));
@@ -1117,7 +1116,7 @@ export function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) =
 export function tryPick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): Option<$a> {
     const e: IEnumerator<T> = ofSeq<T>(xs);
     try {
-        let res: Option<$a> = void 0;
+        let res: Option<$a> = undefined;
         while ((res == null) && e["System.Collections.IEnumerator.MoveNext"]()) {
             res = chooser(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
         }
@@ -1245,7 +1244,7 @@ export function take<T>(count: int32, xs: Iterable<T>): Iterable<T> {
             }
         }
         else {
-            return void 0;
+            return undefined;
         }
     }, (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
@@ -1253,13 +1252,13 @@ export function take<T>(count: int32, xs: Iterable<T>): Iterable<T> {
 }
 
 export function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T> {
-    return generate<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (e: IEnumerator<T>): Option<T> => ((e["System.Collections.IEnumerator.MoveNext"]() && predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0), (e_1: IEnumerator<T>): void => {
+    return generate<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (e: IEnumerator<T>): Option<T> => ((e["System.Collections.IEnumerator.MoveNext"]() && predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined), (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
     });
 }
 
 export function truncate<T>(count: int32, xs: Iterable<T>): Iterable<T> {
-    return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => (((i < count) && e["System.Collections.IEnumerator.MoveNext"]()) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0), (e_1: IEnumerator<T>): void => {
+    return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => (((i < count) && e["System.Collections.IEnumerator.MoveNext"]()) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined), (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
     });
 }
@@ -1397,7 +1396,7 @@ export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
             if (!isDone) {
                 throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
-            return void 0;
+            return undefined;
         }
     }, (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
@@ -1422,11 +1421,11 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>):
             }
             else {
                 status = 1;
-                inserted = void 0;
+                inserted = undefined;
             }
         }
         else {
-            inserted = void 0;
+            inserted = undefined;
         }
         if (inserted == null) {
             if (e1["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1436,7 +1435,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>):
                 if (status < 1) {
                     throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
                 }
-                return void 0;
+                return undefined;
             }
         }
         else {
@@ -1459,13 +1458,13 @@ export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
         }
         else if ((i === index) && e["System.Collections.IEnumerator.MoveNext"]()) {
             isDone = true;
-            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0;
+            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
         }
         else {
             if (!isDone) {
                 throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
-            return void 0;
+            return undefined;
         }
     }, (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
@@ -1493,7 +1492,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): It
                     }
                 }
             }
-            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0;
+            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
         }
     }, (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);
@@ -1517,7 +1516,7 @@ export function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
             if (!isDone) {
                 throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
-            return void 0;
+            return undefined;
         }
     }, (e_1: IEnumerator<T>): void => {
         disposeSafe(e_1);

package/Set.ts

@@ -61,7 +61,7 @@ export function SetTreeNode$1__get_Height<T>(_: SetTreeNode$1<T>): int32 {
 }
 
 export function SetTreeModule_empty<T>(): Option<SetTreeLeaf$1<T>> {
-    return void 0;
+    return undefined;
 }
 
 export function SetTreeModule_countAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: int32): int32 {
@@ -747,7 +747,7 @@ export function SetTreeModule_minimumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>):
         }
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 
@@ -786,7 +786,7 @@ export function SetTreeModule_maximumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>):
         }
     }
     else {
-        return void 0;
+        return undefined;
     }
 }
 

package/System.Text.ts

@@ -19,7 +19,7 @@ export class StringBuilder {
 }
 
 export function StringBuilder_$reflection(): TypeInfo {
-    return class_type("System.Text.StringBuilder", void 0, StringBuilder);
+    return class_type("System.Text.StringBuilder", undefined, StringBuilder);
 }
 
 export function StringBuilder_$ctor_Z18115A39(value: string, capacity: int32): StringBuilder {

package/TimeSpan.ts

@@ -1,7 +1,7 @@
 // tslint:disable:max-line-length
 import { FSharpRef } from "./Types.js";
 import { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
-import { toInt64 } from "./BigInt.js";
+import { toInt64, fromFloat64 } from "./BigInt.js";
 
 // TimeSpan in runtime just becomes a number representing milliseconds
 export type TimeSpan = number;
@@ -73,7 +73,7 @@ export function milliseconds(ts: TimeSpan) {
 }
 
 export function ticks(ts: TimeSpan) {
-  return toInt64(BigInt(ts) * 10000n);
+  return toInt64(fromFloat64(ts * 10000));
 }
 
 export function totalDays(ts: TimeSpan) {

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "name": "@fable-org/fable-library-ts",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Core library used by F# projects compiled with fable.io",
   "author": "Fable Contributors",
   "license": "MIT",