@fable-org/fable-library-js 1.9.0 → 2.0.0-beta.1

package/Array.js

@@ -4,6 +4,7 @@ import { value as value_2, map as map_1, defaultArg, some } from "./Option.js";
 import { min as min_1, max as max_1 } from "./Double.js";
 import { equals as equals_1, disposeSafe, getEnumerator, copyToArray, defaultOf } from "./Util.js";
 import { SR_indexOutOfBounds } from "./Global.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
 function indexNotFound() {
     throw new Error("An index satisfying the predicate was not found in the collection.");
 }
@@ -182,7 +183,7 @@ export function where(predicate, array) {
 }
 export function indexOf(array, item_1, start, count, eq) {
     const start_1 = defaultArg(start, 0) | 0;
-    const end$0027 = defaultArg(map_1((c) => (start_1 + c), count), array.length) | 0;
+    const end$0027 = defaultArg(map_1((c) => ((start_1 + c) | 0), count), array.length) | 0;
     const loop = (i_mut) => {
         loop: while (true) {
             const i = i_mut;
@@ -338,11 +339,11 @@ export function addRangeInPlace(range, array) {
     }
 }
 export function insertRangeInPlace(index, range, array) {
-    let index_1;
     let i = index;
     const enumerator = getEnumerator(range);
     try {
         while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            let index_1;
             const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
             (index_1 = (i | 0), array.splice(index_1, 0, x));
             i = ((i + 1) | 0);
@@ -645,29 +646,29 @@ export function setSlice(target, lower, upper, source) {
     }
 }
 export function sortInPlaceBy(projection, xs, comparer) {
-    xs.sort((x, y) => comparer.Compare(projection(x), projection(y)));
+    xs.sort((x, y) => (comparer.Compare(projection(x), projection(y)) | 0));
 }
 export function sortInPlace(xs, comparer) {
-    xs.sort((x, y) => comparer.Compare(x, y));
+    xs.sort((x, y) => (comparer.Compare(x, y) | 0));
 }
 export function sort(xs, comparer) {
     const xs_1 = xs.slice();
-    xs_1.sort((x, y) => comparer.Compare(x, y));
+    xs_1.sort((x, y) => (comparer.Compare(x, y) | 0));
     return xs_1;
 }
 export function sortBy(projection, xs, comparer) {
     const xs_1 = xs.slice();
-    xs_1.sort((x, y) => comparer.Compare(projection(x), projection(y)));
+    xs_1.sort((x, y) => (comparer.Compare(projection(x), projection(y)) | 0));
     return xs_1;
 }
 export function sortDescending(xs, comparer) {
     const xs_1 = xs.slice();
-    xs_1.sort((x, y) => (comparer.Compare(x, y) * -1));
+    xs_1.sort((x, y) => ((comparer.Compare(x, y) * -1) | 0));
     return xs_1;
 }
 export function sortByDescending(projection, xs, comparer) {
     const xs_1 = xs.slice();
-    xs_1.sort((x, y) => (comparer.Compare(projection(x), projection(y)) * -1));
+    xs_1.sort((x, y) => ((comparer.Compare(projection(x), projection(y)) * -1) | 0));
     return xs_1;
 }
 export function sortWith(comparer, xs) {
@@ -773,15 +774,15 @@ export function splitAt(index, array) {
     return [array.slice(0, (0 + index)), array.slice(index)];
 }
 export function compareWith(comparer, source1, source2) {
-    if (source1 == null) {
-        if (source2 == null) {
+    if (Operators_IsNull(source1)) {
+        if (Operators_IsNull(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (source2 == null) {
+    else if (Operators_IsNull(source2)) {
         return 1;
     }
     else {
@@ -809,15 +810,15 @@ export function compareWith(comparer, source1, source2) {
     }
 }
 export function compareTo(comparer, source1, source2) {
-    if (source1 == null) {
-        if (source2 == null) {
+    if (Operators_IsNull(source1)) {
+        if (Operators_IsNull(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (source2 == null) {
+    else if (Operators_IsNull(source2)) {
         return 1;
     }
     else {
@@ -841,15 +842,15 @@ export function compareTo(comparer, source1, source2) {
     }
 }
 export function equalsWith(equals, array1, array2) {
-    if (array1 == null) {
-        if (array2 == null) {
+    if (Operators_IsNull(array1)) {
+        if (Operators_IsNull(array2)) {
             return true;
         }
         else {
             return false;
         }
     }
-    else if (array2 == null) {
+    else if (Operators_IsNull(array2)) {
         return false;
     }
     else {
@@ -1223,7 +1224,7 @@ export function resize(xs, newSize, zero, cons) {
         throw new Error("The input must be non-negative.\\nParameter name: newSize");
     }
     const zero_1 = defaultArg(zero, defaultOf());
-    if (xs.contents == null) {
+    if (Operators_IsNull(xs.contents)) {
         xs.contents = ((array = Helpers_allocateArrayFromCons(cons, newSize), array.fill(zero_1, 0, (0 + newSize))));
     }
     else {

package/CHANGELOG.md

@@ -7,11 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0-beta.1 - 2025-02-16
+
+* Compiled with Fable 5.0.0-alpha.10
+
+## 1.10.0 - 2025-01-23
+
+### Added
+
+* [JS/TS] Add `StringBuiler.Append(c: char, repeatCount: int)` overload (by @roboz0r)
+
 ## 1.9.0 - 2025-01-09
 
 ### Added
 
-* [JS/TS] Add new `TimSpan` overload support coming from .NET 9 (by @MangelMaxime)
+* [JS/TS] Add new `TimSpane` overload support coming from .NET 9 (by @MangelMaxime)
 
 ### Fixed
 

package/FSharp.Collections.js

@@ -5,23 +5,23 @@ export function HashIdentity_FromFunctions(hash, eq) {
             return eq(x, y);
         },
         GetHashCode(x_1) {
-            return hash(x_1);
+            return hash(x_1) | 0;
         },
     };
 }
 export function HashIdentity_Structural() {
-    return HashIdentity_FromFunctions(structuralHash, equals);
+    return HashIdentity_FromFunctions((obj) => (structuralHash(obj) | 0), equals);
 }
 export function HashIdentity_Reference() {
-    return HashIdentity_FromFunctions(physicalHash, (e, e_1) => (e === e_1));
+    return HashIdentity_FromFunctions((obj) => (physicalHash(obj) | 0), (e, e_1) => (e === e_1));
 }
 export function ComparisonIdentity_FromFunction(comparer) {
     return {
         Compare(x, y) {
-            return comparer(x, y);
+            return comparer(x, y) | 0;
         },
     };
 }
 export function ComparisonIdentity_Structural() {
-    return ComparisonIdentity_FromFunction(compare);
+    return ComparisonIdentity_FromFunction((e, e_1) => (compare(e, e_1) | 0));
 }

package/FSharp.Core.d.ts

@@ -1,5 +1,6 @@
 import { IDisposable, IEqualityComparer, IComparer } from "./Util.js";
-import { Option } from "./Option.js";
+import { Nullable, Option } from "./Option.js";
+import { FSharpChoice$2_$union } from "./Choice.js";
 import { StringBuilder } from "./System.Text.js";
 export declare const LanguagePrimitives_GenericEqualityComparer: any;
 export declare const LanguagePrimitives_GenericEqualityERComparer: any;
@@ -12,6 +13,19 @@ export declare function Operators_FailurePattern(exn: Error): Option<string>;
 export declare function Operators_NullArg<$a>(x: string): $a;
 export declare function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R;
 export declare function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b;
+export declare function Operators_IsNull<T>(value: T): boolean;
+export declare function Operators_IsNotNull<T>(value: T): boolean;
+export declare function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean;
+export declare function Operators_NonNull<T>(value: T): T;
+export declare function Operators_NonNullV<T extends any>(value: Nullable<T>): T;
+export declare function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T>;
+export declare function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T>;
+export declare function Operators_NonNullQuickPattern<T>(value: T): T;
+export declare function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T;
+export declare function Operators_WithNull<T>(value: T): T;
+export declare function Operators_WithNullV<T extends any>(value: T): T;
+export declare function Operators_NullV<T extends any>(): Nullable<T>;
+export declare function Operators_NullArgCheck<T>(argumentName: string, value: T): T;
 export declare function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a;
 export declare function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b;
 export declare function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a;

package/FSharp.Core.js

@@ -1,12 +1,14 @@
 import { disposeSafe, defaultOf, structuralHash, equals } from "./Util.js";
 import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
+import { value as value_1 } from "./Option.js";
+import { FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
 import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
 export const LanguagePrimitives_GenericEqualityComparer = {
     "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
         return equals(x, y);
     },
     "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
-        return structuralHash(x_1);
+        return structuralHash(x_1) | 0;
     },
 };
 export const LanguagePrimitives_GenericEqualityERComparer = {
@@ -14,7 +16,7 @@ export const LanguagePrimitives_GenericEqualityERComparer = {
         return equals(x, y);
     },
     "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
-        return structuralHash(x_1);
+        return structuralHash(x_1) | 0;
     },
 };
 export function LanguagePrimitives_FastGenericComparer() {
@@ -54,6 +56,90 @@ export function Operators_Using(resource, action) {
 export function Operators_Lock(_lockObj, action) {
     return action();
 }
+export function Operators_IsNull(value) {
+    if (equals(value, defaultOf())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Operators_IsNotNull(value) {
+    if (equals(value, defaultOf())) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function Operators_IsNullV(value) {
+    return !(value != null);
+}
+export function Operators_NonNull(value) {
+    if (equals(value, defaultOf())) {
+        throw new Error();
+    }
+    else {
+        return value;
+    }
+}
+export function Operators_NonNullV(value) {
+    if (value != null) {
+        return value_1(value);
+    }
+    else {
+        throw new Error();
+    }
+}
+export function Operators_NullMatchPattern(value) {
+    if (equals(value, defaultOf())) {
+        return FSharpChoice$2_Choice1Of2(undefined);
+    }
+    else {
+        return FSharpChoice$2_Choice2Of2(value);
+    }
+}
+export function Operators_NullValueMatchPattern(value) {
+    if (value != null) {
+        return FSharpChoice$2_Choice2Of2(value_1(value));
+    }
+    else {
+        return FSharpChoice$2_Choice1Of2(undefined);
+    }
+}
+export function Operators_NonNullQuickPattern(value) {
+    if (equals(value, defaultOf())) {
+        throw new Error();
+    }
+    else {
+        return value;
+    }
+}
+export function Operators_NonNullQuickValuePattern(value) {
+    if (value != null) {
+        return value_1(value);
+    }
+    else {
+        throw new Error();
+    }
+}
+export function Operators_WithNull(value) {
+    return value;
+}
+export function Operators_WithNullV(value) {
+    return value;
+}
+export function Operators_NullV() {
+    return defaultOf();
+}
+export function Operators_NullArgCheck(argumentName, value) {
+    if (equals(value, defaultOf())) {
+        throw new Error(argumentName);
+    }
+    else {
+        return value;
+    }
+}
 export function ExtraTopLevelOperators_LazyPattern(input) {
     return input.Value;
 }

package/List.js

@@ -261,7 +261,7 @@ export function isEmpty(xs) {
     return FSharpList__get_IsEmpty(xs);
 }
 export function length(xs) {
-    return FSharpList__get_Length(xs);
+    return FSharpList__get_Length(xs) | 0;
 }
 export function head(xs) {
     return FSharpList__get_Head(xs);
@@ -405,9 +405,9 @@ export function foldBack2(folder, xs, ys, state) {
 }
 export function unfold(gen, state) {
     const loop = (acc_mut, node_mut) => {
-        let t;
         loop: while (true) {
             const acc = acc_mut, node = node_mut;
+            let t;
             const matchValue = gen(acc);
             if (matchValue != null) {
                 acc_mut = value_1(matchValue)[1];
@@ -462,7 +462,6 @@ export function ofArray(xs) {
     return ofArrayWithTail(xs, FSharpList_get_Empty());
 }
 export function ofSeq(xs) {
-    let xs_3, t;
     if (isArrayLike(xs)) {
         return ofArray(xs);
     }
@@ -475,6 +474,7 @@ export function ofSeq(xs) {
         const enumerator = getEnumerator(xs);
         try {
             while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let xs_3, t;
                 const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
                 node = ((xs_3 = node, (t = (new FSharpList(x, undefined)), (xs_3.tail = t, t))));
             }
@@ -522,7 +522,6 @@ export function concat(lists) {
     return FSharpList__get_Tail(root);
 }
 export function scan(folder, state, xs) {
-    let xs_4, t_2;
     const root = FSharpList_get_Empty();
     let node;
     const t = new FSharpList(state, undefined);
@@ -531,6 +530,7 @@ export function scan(folder, state, xs) {
     let acc = state;
     let xs_3 = xs;
     while (!FSharpList__get_IsEmpty(xs_3)) {
+        let xs_4, t_2;
         acc = folder(acc, FSharpList__get_Head(xs_3));
         node = ((xs_4 = node, (t_2 = (new FSharpList(acc, undefined)), (xs_4.tail = t_2, t_2))));
         xs_3 = FSharpList__get_Tail(xs_3);
@@ -547,13 +547,13 @@ export function append(xs, ys) {
     return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));
 }
 export function collect(mapping, xs) {
-    let xs_1, t;
     const root = FSharpList_get_Empty();
     let node = root;
     let ys = xs;
     while (!FSharpList__get_IsEmpty(ys)) {
         let zs = mapping(FSharpList__get_Head(ys));
         while (!FSharpList__get_IsEmpty(zs)) {
+            let xs_1, t;
             node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head(zs), undefined)), (xs_1.tail = t, t))));
             zs = FSharpList__get_Tail(zs);
         }
@@ -602,9 +602,9 @@ export function map2(mapping, xs, ys) {
 }
 export function mapIndexed2(mapping, xs, ys) {
     const loop = (i_mut, acc_mut, xs_1_mut, ys_1_mut) => {
-        let t;
         loop: while (true) {
             const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+            let t;
             if (FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) {
                 return acc;
             }
@@ -626,9 +626,9 @@ export function mapIndexed2(mapping, xs, ys) {
 }
 export function map3(mapping, xs, ys, zs) {
     const loop = (acc_mut, xs_1_mut, ys_1_mut, zs_1_mut) => {
-        let t;
         loop: while (true) {
             const acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut, zs_1 = zs_1_mut;
+            let t;
             if ((FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) ? true : FSharpList__get_IsEmpty(zs_1)) {
                 return acc;
             }
@@ -841,10 +841,10 @@ export function contains(value, xs, eq) {
     return tryFindIndex((v) => eq.Equals(value, v), xs) != null;
 }
 export function initialize(n, f) {
-    let xs, t;
     const root = FSharpList_get_Empty();
     let node = root;
     for (let i = 0; i <= (n - 1); i++) {
+        let xs, t;
         node = ((xs = node, (t = (new FSharpList(f(i), undefined)), (xs.tail = t, t))));
     }
     const xs_2 = node;
@@ -937,16 +937,16 @@ export function sortWith(comparer, xs) {
     return ofArray(arr);
 }
 export function sort(xs, comparer) {
-    return sortWith((x, y) => comparer.Compare(x, y), xs);
+    return sortWith((x, y) => (comparer.Compare(x, y) | 0), xs);
 }
 export function sortBy(projection, xs, comparer) {
-    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);
+    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) | 0), xs);
 }
 export function sortDescending(xs, comparer) {
-    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);
+    return sortWith((x, y) => ((comparer.Compare(x, y) * -1) | 0), xs);
 }
 export function sortByDescending(projection, xs, comparer) {
-    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);
+    return sortWith((x, y) => ((comparer.Compare(projection(x), projection(y)) * -1) | 0), xs);
 }
 export function sum(xs, adder) {
     return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);
@@ -1041,9 +1041,9 @@ export function take(count, xs) {
         throw new Error((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
     }
     const loop = (i_mut, acc_mut, xs_1_mut) => {
-        let t;
         loop: while (true) {
             const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            let t;
             if (i <= 0) {
                 return acc;
             }
@@ -1067,9 +1067,9 @@ export function take(count, xs) {
 }
 export function takeWhile(predicate, xs) {
     const loop = (acc_mut, xs_1_mut) => {
-        let t;
         loop: while (true) {
             const acc = acc_mut, xs_1 = xs_1_mut;
+            let t;
             if (FSharpList__get_IsEmpty(xs_1)) {
                 return acc;
             }
@@ -1092,9 +1092,9 @@ export function takeWhile(predicate, xs) {
 }
 export function truncate(count, xs) {
     const loop = (i_mut, acc_mut, xs_1_mut) => {
-        let t;
         loop: while (true) {
             const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            let t;
             if (i <= 0) {
                 return acc;
             }

package/Map.js

@@ -45,7 +45,7 @@ export function MapTreeNode$2__get_Right(_) {
     return _.right;
 }
 export function MapTreeNode$2__get_Height(_) {
-    return _.h;
+    return _.h | 0;
 }
 export function MapTreeModule_empty() {
     return undefined;
@@ -72,7 +72,7 @@ export function MapTreeModule_sizeAux(acc_mut, m_mut) {
     }
 }
 export function MapTreeModule_size(x) {
-    return MapTreeModule_sizeAux(0, x);
+    return MapTreeModule_sizeAux(0, x) | 0;
 }
 export function MapTreeModule_mk(l, k, v, r) {
     let mn, mn_1;
@@ -1223,7 +1223,7 @@ export function FSharpMap__Partition(m, predicate) {
     return [FSharpMap_$ctor(m.comparer, patternInput[0]), FSharpMap_$ctor(m.comparer, patternInput[1])];
 }
 export function FSharpMap__get_Count(m) {
-    return MapTreeModule_size(m.tree);
+    return MapTreeModule_size(m.tree) | 0;
 }
 export function FSharpMap__ContainsKey(m, key) {
     return MapTreeModule_mem(m.comparer, key, m.tree);
@@ -1264,7 +1264,7 @@ export function FSharpMap__ToArray(m) {
     return MapTreeModule_toArray(m.tree);
 }
 export function FSharpMap__ComputeHashCode(this$) {
-    const combineHash = (x, y) => (((x << 1) + y) + 631);
+    const combineHash = (x, y) => ((((x << 1) + y) + 631) | 0);
     let res = 0;
     const enumerator = getEnumerator(this$);
     try {
@@ -1392,5 +1392,5 @@ export function empty(comparer) {
     return FSharpMap_Empty(comparer);
 }
 export function count(table) {
-    return FSharpMap__get_Count(table);
+    return FSharpMap__get_Count(table) | 0;
 }

package/Random.js

@@ -1,5 +1,6 @@
 import { class_type } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32, toFloat64, compare, fromInt32, toInt64 } from "./BigInt.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
 import { item, fill, setItem } from "./Array.js";
 function Native_random() {
     return Math.random();
@@ -32,13 +33,13 @@ export class NonSeeded {
     constructor() {
     }
     Next0() {
-        return Native_randomNext(0, 2147483647);
+        return Native_randomNext(0, 2147483647) | 0;
     }
     Next1(maxValue) {
-        return Native_randomNext(0, maxValue);
+        return Native_randomNext(0, maxValue) | 0;
     }
     Next2(minValue, maxValue) {
-        return Native_randomNext(minValue, maxValue);
+        return Native_randomNext(minValue, maxValue) | 0;
     }
     NextDouble() {
         return Native_random();
@@ -111,7 +112,7 @@ export class Seeded {
     }
     NextBytes(buffer) {
         const this$ = this;
-        if (buffer == null) {
+        if (Operators_IsNull(buffer)) {
             throw new Error("buffer");
         }
         for (let i = 0; i <= (buffer.length - 1); i++) {

package/Seq.js

@@ -2,7 +2,7 @@ import { clear, defaultOf, equals, isDisposable, isArrayLike, toIterator, dispos
 import { toString } from "./Types.js";
 import { class_type } from "./Reflection.js";
 import { some, value as value_1 } from "./Option.js";
-import { Operators_Lock, Operators_NullArg } from "./FSharp.Core.js";
+import { Operators_Lock, Operators_NullArg, Operators_IsNull } 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 { SR_indexOutOfBounds } from "./Global.js";
@@ -144,7 +144,6 @@ export function Enumerator_concat(sources) {
             return Enumerator_alreadyFinished();
         }
     }, () => {
-        let copyOfStruct;
         if (!started) {
             started = true;
         }
@@ -154,6 +153,7 @@ export function Enumerator_concat(sources) {
         else {
             let res = undefined;
             while (res == null) {
+                let copyOfStruct;
                 const outerOpt_1 = outerOpt;
                 const innerOpt_1 = innerOpt;
                 if (outerOpt_1 != null) {
@@ -297,7 +297,7 @@ export function indexNotFound() {
     throw new Error(SR_keyNotFoundAlt);
 }
 export function checkNonNull(argName, arg) {
-    if (arg == null) {
+    if (Operators_IsNull(arg)) {
         Operators_NullArg(argName);
     }
 }
@@ -1176,16 +1176,16 @@ export function sortWith(comparer, xs) {
     });
 }
 export function sort(xs, comparer) {
-    return sortWith((x, y) => comparer.Compare(x, y), xs);
+    return sortWith((x, y) => (comparer.Compare(x, y) | 0), xs);
 }
 export function sortBy(projection, xs, comparer) {
-    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);
+    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) | 0), xs);
 }
 export function sortDescending(xs, comparer) {
-    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);
+    return sortWith((x, y) => ((comparer.Compare(x, y) * -1) | 0), xs);
 }
 export function sortByDescending(projection, xs, comparer) {
-    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);
+    return sortWith((x, y) => ((comparer.Compare(projection(x), projection(y)) * -1) | 0), xs);
 }
 export function sum(xs, adder) {
     return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);

package/Seq2.js

@@ -32,7 +32,7 @@ export function countBy(projection, xs, comparer) {
                 const key = projection(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
                 let matchValue;
                 let outArg = 0;
-                matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {
+                matchValue = [tryGetValue(dict, key, new FSharpRef(() => (outArg | 0), (v) => {
                         outArg = (v | 0);
                     })), outArg];
                 if (matchValue[0]) {

package/Set.js

@@ -42,7 +42,7 @@ export function SetTreeNode$1__get_Right(_) {
     return _.right;
 }
 export function SetTreeNode$1__get_Height(_) {
-    return _.h;
+    return _.h | 0;
 }
 export function SetTreeModule_empty() {
     return undefined;
@@ -69,7 +69,7 @@ export function SetTreeModule_countAux(t_mut, acc_mut) {
     }
 }
 export function SetTreeModule_count(s) {
-    return SetTreeModule_countAux(s, 0);
+    return SetTreeModule_countAux(s, 0) | 0;
 }
 export function SetTreeModule_mk(l, k, r) {
     let tn, tn_1;
@@ -1517,7 +1517,7 @@ export function FSharpSet__Remove(s, value) {
     return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_remove(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));
 }
 export function FSharpSet__get_Count(s) {
-    return SetTreeModule_count(FSharpSet__get_Tree(s));
+    return SetTreeModule_count(FSharpSet__get_Tree(s)) | 0;
 }
 export function FSharpSet__Contains(s, value) {
     return SetTreeModule_mem(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s));
@@ -1598,7 +1598,7 @@ export function FSharpSet_Equality(a, b) {
     return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) === 0;
 }
 export function FSharpSet_Compare(a, b) {
-    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b));
+    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) | 0;
 }
 export function FSharpSet__get_Choose(x) {
     return SetTreeModule_choose(FSharpSet__get_Tree(x));
@@ -1696,7 +1696,7 @@ export function map(mapping, set$, comparer) {
     return FSharpSet__Map(set$, mapping, comparer);
 }
 export function count(set$) {
-    return FSharpSet__get_Count(set$);
+    return FSharpSet__get_Count(set$) | 0;
 }
 export function ofList(elements, comparer) {
     return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));

package/System.Collections.Generic.js

@@ -19,13 +19,13 @@ export function Comparer$1_$ctor_47C913C(comparison) {
     return new Comparer$1(comparison);
 }
 export function Comparer$1_get_Default() {
-    return Comparer$1_$ctor_47C913C(compare);
+    return Comparer$1_$ctor_47C913C((e, e_1) => (compare(e, e_1) | 0));
 }
 export function Comparer$1_Create_47C913C(comparison) {
     return Comparer$1_$ctor_47C913C(comparison);
 }
 export function Comparer$1__Compare_5BDDA0(_, x, y) {
-    return _.comparison(x, y);
+    return _.comparison(x, y) | 0;
 }
 export class EqualityComparer$1 {
     constructor(equals, getHashCode) {
@@ -48,7 +48,7 @@ export function EqualityComparer$1_$ctor_Z6EE254AB(equals, getHashCode) {
     return new EqualityComparer$1(equals, getHashCode);
 }
 export function EqualityComparer$1_get_Default() {
-    return EqualityComparer$1_$ctor_Z6EE254AB(equals_1, structuralHash);
+    return EqualityComparer$1_$ctor_Z6EE254AB(equals_1, (obj) => (structuralHash(obj) | 0));
 }
 export function EqualityComparer$1_Create_Z6EE254AB(equals, getHashCode) {
     return EqualityComparer$1_$ctor_Z6EE254AB(equals, getHashCode);
@@ -57,7 +57,7 @@ export function EqualityComparer$1__Equals_5BDDA0(_, x, y) {
     return _.equals(x, y);
 }
 export function EqualityComparer$1__GetHashCode_2B595(_, x) {
-    return _.getHashCode(x);
+    return _.getHashCode(x) | 0;
 }
 export class Stack$1 {
     constructor(initialContents, initialCount) {
@@ -107,7 +107,7 @@ export function Stack$1__Ensure_Z524259A4(_, newSize) {
     }
 }
 export function Stack$1__get_Count(_) {
-    return _.count;
+    return _.count | 0;
 }
 export function Stack$1__Pop(_) {
     _.count = ((_.count - 1) | 0);
@@ -203,7 +203,7 @@ export function Queue$1_$ctor_BB573A(xs) {
     return Queue$1_$ctor_Z3B4C077E(arr, arr.length);
 }
 export function Queue$1__get_Count(_) {
-    return _.count;
+    return _.count | 0;
 }
 export function Queue$1__Enqueue_2B595(_, value) {
     if (_.count === Queue$1__size(_)) {
@@ -288,10 +288,10 @@ export function Queue$1__CopyTo_Z3B4C077E(_, target, start) {
     }
 }
 export function Queue$1__size(this$) {
-    return this$.contents.length;
+    return this$.contents.length | 0;
 }
 export function Queue$1__toIndex_Z524259A4(this$, i) {
-    return (this$.head + i) % Queue$1__size(this$);
+    return ((this$.head + i) % Queue$1__size(this$)) | 0;
 }
 export function Queue$1__ensure_Z524259A4(this$, requiredSize) {
     const newBuffer = fill(new Array(requiredSize), 0, requiredSize, null);

package/System.Text.d.ts

@@ -13,6 +13,7 @@ export declare function StringBuilder_$ctor(): StringBuilder;
 export declare function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
 export declare function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder;
 export declare function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): StringBuilder;
+export declare function StringBuilder__Append_61B1CA(x: StringBuilder, c: string, repeatCount: int32): StringBuilder;
 export declare function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder;
 export declare function StringBuilder__Append_5E38073B(x: StringBuilder, o: float64): StringBuilder;
 export declare function StringBuilder__Append_Z1FBCCD16(x: StringBuilder, o: boolean): StringBuilder;

package/System.Text.js

@@ -1,4 +1,4 @@
-import { replace, format, substring, isNullOrEmpty, join } from "./String.js";
+import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.js";
 import { class_type } from "./Reflection.js";
 import { clear, int32ToString } from "./Util.js";
 import { toString } from "./Types.js";
@@ -41,6 +41,11 @@ export function StringBuilder__Append_244C7CD6(x, c) {
     void (x.buf.push(c));
     return x;
 }
+export function StringBuilder__Append_61B1CA(x, c, repeatCount) {
+    const s = replicate(repeatCount, c);
+    void (x.buf.push(s));
+    return x;
+}
 export function StringBuilder__Append_Z524259A4(x, o) {
     void (x.buf.push(int32ToString(o)));
     return x;

package/Types.js

@@ -19,7 +19,7 @@ export function seqToString(self) {
 }
 export function toString(x, callStack = 0) {
     if (x != null && typeof x === "object") {
-        if (typeof x.toString === "function") {
+        if (typeof x.toString === "function" && x.toString !== Object.prototype.toString) {
             return x.toString();
         }
         else if (Symbol.iterator in x) {

package/package.json

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