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

package/Array.js

@@ -183,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;
@@ -339,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);
@@ -646,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) {

package/CHANGELOG.md

@@ -7,6 +7,10 @@ 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

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.js

@@ -8,7 +8,7 @@ export const LanguagePrimitives_GenericEqualityComparer = {
         return equals(x, y);
     },
     "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
-        return structuralHash(x_1);
+        return structuralHash(x_1) | 0;
     },
 };
 export const LanguagePrimitives_GenericEqualityERComparer = {
@@ -16,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() {

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

@@ -33,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();

package/Seq.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) {
@@ -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/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.10.0",
+  "version": "2.0.0-beta.1",
   "description": "Core library used by F# projects compiled with fable.io",
   "author": "Fable Contributors",
   "license": "MIT",