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

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/Async.d.ts

@@ -20,8 +20,7 @@ export declare function ignore<T>(computation: Async<T>): (ctx: IAsyncContext<un
 export declare function parallel<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<Awaited<T>[]>) => void;
 export declare function sequential<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<T[]>) => void;
 export declare function sleep(millisecondsDueTime: number): (ctx: IAsyncContext<void>) => void;
-export declare function runSynchronously(): never;
 export declare function start<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
 export declare function startImmediate<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
-export declare function startWithContinuations<T>(computation: Async<T>, continuation?: Continuation<T> | CancellationToken, exceptionContinuation?: Continuation<any>, cancellationContinuation?: Continuation<any>, cancelToken?: CancellationToken): void;
+export declare function startWithContinuations<T>(computation: Async<T>, continuation: Continuation<T>, exceptionContinuation: Continuation<any>, cancellationContinuation: Continuation<any>, cancelToken?: CancellationToken): void;
 export declare function startAsPromise<T>(computation: Async<T>, cancellationToken?: CancellationToken): Promise<T>;

package/Async.js

@@ -124,25 +124,18 @@ export function sleep(millisecondsDueTime) {
         });
     });
 }
-export function runSynchronously() {
-    throw new Error("Asynchronous code cannot be run synchronously in JS");
-}
 export function start(computation, cancellationToken) {
-    return startWithContinuations(computation, cancellationToken);
+    return startWithContinuations(computation, emptyContinuation, function (err) { throw err; }, emptyContinuation, cancellationToken);
 }
 export function startImmediate(computation, cancellationToken) {
     return start(computation, cancellationToken);
 }
 export function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
-    if (typeof continuation !== "function") {
-        cancelToken = continuation;
-        continuation = undefined;
-    }
     const trampoline = new Trampoline();
     computation({
         onSuccess: continuation ? continuation : emptyContinuation,
-        onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,
-        onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,
+        onError: exceptionContinuation,
+        onCancel: cancellationContinuation,
         cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
         trampoline,
     });

package/BigInt.d.ts

@@ -80,6 +80,8 @@ export declare function fromChar(c: string): bigint;
 export declare function fromString(s: string): bigint;
 export declare function fromByteArray(bytes: ArrayLike<uint8>): bigint;
 export declare function toByteArray(value: bigint): number[];
+export declare function toIntN_unchecked(bits: number, x: bigint, signed: boolean): bigint;
+export declare function toIntN(bits: number, x: bigint, signed: boolean): bigint;
 export declare function toInt8(x: bigint): int8;
 export declare function toUInt8(x: bigint): uint8;
 export declare function toInt16(x: bigint): int16;
@@ -92,7 +94,19 @@ export declare function toInt128(x: bigint): int128;
 export declare function toUInt128(x: bigint): uint128;
 export declare function toNativeInt(x: bigint): nativeint;
 export declare function toUNativeInt(x: bigint): unativeint;
-export declare function toFloat16(x: bigint): float32;
+export declare function toInt8_unchecked(x: bigint): int8;
+export declare function toUInt8_unchecked(x: bigint): uint8;
+export declare function toInt16_unchecked(x: bigint): int16;
+export declare function toUInt16_unchecked(x: bigint): uint16;
+export declare function toInt32_unchecked(x: bigint): int32;
+export declare function toUInt32_unchecked(x: bigint): uint32;
+export declare function toInt64_unchecked(x: bigint): int64;
+export declare function toUInt64_unchecked(x: bigint): uint64;
+export declare function toInt128_unchecked(x: bigint): int128;
+export declare function toUInt128_unchecked(x: bigint): uint128;
+export declare function toNativeInt_unchecked(x: bigint): nativeint;
+export declare function toUNativeInt_unchecked(x: bigint): unativeint;
+export declare function toFloat16(x: bigint): float16;
 export declare function toFloat32(x: bigint): float32;
 export declare function toFloat64(x: bigint): float64;
 export declare function toDecimal(x: bigint): decimal;

package/BigInt.js

@@ -95,18 +95,41 @@ export function fromByteArray(bytes) {
 export function toByteArray(value) {
     return toSignedBytes(value, isBigEndian);
 }
-export function toInt8(x) { return Number(BigInt.asIntN(8, x)); }
-export function toUInt8(x) { return Number(BigInt.asUintN(8, x)); }
-export function toInt16(x) { return Number(BigInt.asIntN(16, x)); }
-export function toUInt16(x) { return Number(BigInt.asUintN(16, x)); }
-export function toInt32(x) { return Number(BigInt.asIntN(32, x)); }
-export function toUInt32(x) { return Number(BigInt.asUintN(32, x)); }
-export function toInt64(x) { return BigInt.asIntN(64, x); }
-export function toUInt64(x) { return BigInt.asUintN(64, x); }
-export function toInt128(x) { return BigInt.asIntN(128, x); }
-export function toUInt128(x) { return BigInt.asUintN(128, x); }
-export function toNativeInt(x) { return BigInt.asIntN(64, x); }
-export function toUNativeInt(x) { return BigInt.asUintN(64, x); }
+export function toIntN_unchecked(bits, x, signed) {
+    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+}
+export function toIntN(bits, x, signed) {
+    let higher_bits = abs(x) >> BigInt(bits);
+    if (higher_bits !== 0n) {
+        const s = signed ? "a signed" : "an unsigned";
+        throw new Error(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
+    }
+    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+}
+export function toInt8(x) { return Number(toIntN(8, x, true)); }
+export function toUInt8(x) { return Number(toIntN(8, x, false)); }
+export function toInt16(x) { return Number(toIntN(16, x, true)); }
+export function toUInt16(x) { return Number(toIntN(16, x, false)); }
+export function toInt32(x) { return Number(toIntN(32, x, true)); }
+export function toUInt32(x) { return Number(toIntN(32, x, false)); }
+export function toInt64(x) { return toIntN(64, x, true); }
+export function toUInt64(x) { return toIntN(64, x, false); }
+export function toInt128(x) { return toIntN(128, x, true); }
+export function toUInt128(x) { return toIntN(128, x, false); }
+export function toNativeInt(x) { return toIntN(64, x, true); }
+export function toUNativeInt(x) { return toIntN(64, x, false); }
+export function toInt8_unchecked(x) { return Number(toIntN_unchecked(8, x, true)); }
+export function toUInt8_unchecked(x) { return Number(toIntN_unchecked(8, x, false)); }
+export function toInt16_unchecked(x) { return Number(toIntN_unchecked(16, x, true)); }
+export function toUInt16_unchecked(x) { return Number(toIntN_unchecked(16, x, false)); }
+export function toInt32_unchecked(x) { return Number(toIntN_unchecked(32, x, true)); }
+export function toUInt32_unchecked(x) { return Number(toIntN_unchecked(32, x, false)); }
+export function toInt64_unchecked(x) { return toIntN_unchecked(64, x, true); }
+export function toUInt64_unchecked(x) { return toIntN_unchecked(64, x, false); }
+export function toInt128_unchecked(x) { return toIntN_unchecked(128, x, true); }
+export function toUInt128_unchecked(x) { return toIntN_unchecked(128, x, false); }
+export function toNativeInt_unchecked(x) { return toIntN_unchecked(64, x, true); }
+export function toUNativeInt_unchecked(x) { return toIntN_unchecked(64, x, false); }
 export function toFloat16(x) { return Number(x); }
 export function toFloat32(x) { return Number(x); }
 export function toFloat64(x) { return Number(x); }

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0-beta.2 - 2025-03-03
+
+* [JS/TS] Fix #4049: decimal/bigint to integer conversion checks (by @ncave)
+* [JS/TS] Fix `decimal` to `char` conversion checks (by @ManngelMaxime)
+* [JS/TS] Propagate non-captured exception when running `Async.Start` or `Async.StartImmediate` (by @MangelMaxime)
+* [JS/TS] Remove `Async.RunSynchronously` (by @MangelMaxime)
+* [JS/TS] Change signature of `startWithContinuations` to always require all its arguments (by @MangelMaxime)
+* [JS/TS] Fix short `DateTime` and `DateTimeOffset` short format strings (by @MangelMaxime)
+* [JS/TS] Add `C` and `c` format for numeric types (by @MangelMaxime)
+* [JS/TS] Add `B` and `b` format for numeric types (by @MangelMaxime)
+* [JS/TS] Add `n` format for numeric types (by @MangelMaxime)
+* [JS/TS] Fix numeric formats (by @MangelMaxime)
+
+## 2.0.0-beta.1 - 2025-02-16
+
+* Compiled with Fable 5.0.0-alpha.10
+
 ## 1.10.0 - 2025-01-23
 
 ### Added
@@ -55,7 +72,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * [JS/TS] Fix escaping of `{` and `}` in FormattableString (#3890) (by @roboz0r)
 * [JS/TS] Fix `uri.Host` to return the host name without the port (by @MangelMaxime)
-* [JS/TS] Fix TypeScript compilation by resolving type of `jsOptions` (#3894) (by @ManngelMaxime)
+* [JS/TS] Fix TypeScript compilation by resolving type of `jsOptions` (#3894) (by @MangelMaxime)
 
 ## 1.4.3 - 2024-09-04
 

package/Date.d.ts

@@ -16,7 +16,6 @@ export declare function kind(value: IDateTime): number;
 export declare function unixEpochMillisecondsToTicks(ms: number, offset: number): int64;
 export declare function ticksToUnixEpochMilliseconds(ticks: number | bigint): number;
 export declare function dateOffsetToString(offset: number): string;
-export declare function dateToHalfUTCString(date: IDateTime, half: "first" | "second"): string;
 export declare function toString(date: IDateTime | IDateTimeOffset, format?: string, _provider?: any): string;
 export declare function DateTime(value: number, kind?: DateKind): IDateTime;
 export declare function fromTicks(ticks: number | bigint, kind?: DateKind): IDateTime;

package/Date.js

@@ -91,9 +91,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += shortDays[dayOfWeek(localizedDate)];
                         break;
                     case 4:
-                        result += longDays[dayOfWeek(localizedDate)];
-                        break;
                     default:
+                        result += longDays[dayOfWeek(localizedDate)];
                         break;
                 }
                 break;
@@ -112,6 +111,9 @@ function dateToStringWithCustomFormat(date, format, utc) {
                     // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
                     result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
                 }
+                else {
+                    throw "Input string was not in a correct format.";
+                }
                 break;
             case "F":
                 tokenLength = parseRepeatToken(format, cursorPos, "F");
@@ -132,13 +134,14 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += padWithZeros(value, 3);
                     }
                 }
+                else {
+                    throw "Input string was not in a correct format.";
+                }
                 break;
             case "g":
                 tokenLength = parseRepeatToken(format, cursorPos, "g");
                 cursorPos += tokenLength;
-                if (tokenLength <= 2) {
-                    result += "A.D.";
-                }
+                result += "A.D.";
                 break;
             case "h":
                 tokenLength = parseRepeatToken(format, cursorPos, "h");
@@ -149,11 +152,10 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += h1Value ? h1Value : 12;
                         break;
                     case 2:
+                    default:
                         const h2Value = hour(localizedDate) % 12;
                         result += padWithZeros(h2Value ? h2Value : 12, 2);
                         break;
-                    default:
-                        break;
                 }
                 break;
             case "H":
@@ -164,9 +166,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += hour(localizedDate);
                         break;
                     case 2:
-                        result += padWithZeros(hour(localizedDate), 2);
-                        break;
                     default:
+                        result += padWithZeros(hour(localizedDate), 2);
                         break;
                 }
                 break;
@@ -198,9 +199,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += minute(localizedDate);
                         break;
                     case 2:
-                        result += padWithZeros(minute(localizedDate), 2);
-                        break;
                     default:
+                        result += padWithZeros(minute(localizedDate), 2);
                         break;
                 }
                 break;
@@ -218,9 +218,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += shortMonths[month(localizedDate) - 1];
                         break;
                     case 4:
-                        result += longMonths[month(localizedDate) - 1];
-                        break;
                     default:
+                        result += longMonths[month(localizedDate) - 1];
                         break;
                 }
                 break;
@@ -232,9 +231,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += second(localizedDate);
                         break;
                     case 2:
-                        result += padWithZeros(second(localizedDate), 2);
-                        break;
                     default:
+                        result += padWithZeros(second(localizedDate), 2);
                         break;
                 }
                 break;
@@ -246,9 +244,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                         result += localizedDate.getHours() < 12 ? "A" : "P";
                         break;
                     case 2:
-                        result += localizedDate.getHours() < 12 ? "AM" : "PM";
-                        break;
                     default:
+                        result += localizedDate.getHours() < 12 ? "AM" : "PM";
                         break;
                 }
                 break;
@@ -262,16 +259,8 @@ function dateToStringWithCustomFormat(date, format, utc) {
                     case 2:
                         result += padWithZeros(localizedDate.getFullYear() % 100, 2);
                         break;
-                    case 3:
-                        result += padWithZeros(localizedDate.getFullYear(), 3);
-                        break;
-                    case 4:
-                        result += padWithZeros(localizedDate.getFullYear(), 4);
-                        break;
-                    case 5:
-                        result += padWithZeros(localizedDate.getFullYear(), 5);
-                        break;
                     default:
+                        result += padWithZeros(localizedDate.getFullYear(), tokenLength);
                         break;
                 }
                 break;
@@ -365,12 +354,6 @@ export function dateOffsetToString(offset) {
         padWithZeros(hours, 2) + ":" +
         padWithZeros(minutes, 2);
 }
-export function dateToHalfUTCString(date, half) {
-    const str = date.toISOString();
-    return half === "first"
-        ? str.substring(0, str.indexOf("T"))
-        : str.substring(str.indexOf("T") + 1, str.length - 1);
-}
 function dateToISOString(d, utc) {
     if (utc) {
         return d.toISOString();
@@ -399,10 +382,10 @@ function dateToStringWithOffset(date, format) {
     }
     else if (format.length === 1) {
         switch (format) {
-            case "D":
-            case "d": return dateToHalfUTCString(d, "first");
-            case "T":
-            case "t": return dateToHalfUTCString(d, "second");
+            case "D": return dateToString_D(d);
+            case "d": return dateToString_d(d);
+            case "T": return dateToString_T(toUniversalTime(d));
+            case "t": return dateToString_t(toUniversalTime(d));
             case "O":
             case "o": return dateToISOStringWithOffset(d, (date.offset ?? 0));
             default: throw new Error("Unrecognized Date print format");
@@ -412,6 +395,26 @@ function dateToStringWithOffset(date, format) {
         return dateToStringWithCustomFormat(d, format, true);
     }
 }
+function dateToString_D(date) {
+    return longDays[dayOfWeek(date)]
+        + ", " + padWithZeros(day(date), 2)
+        + " " + longMonths[month(date) - 1]
+        + " " + year(date);
+}
+function dateToString_d(date) {
+    return padWithZeros(month(date), 2)
+        + "/" + padWithZeros(day(date), 2)
+        + "/" + year(date);
+}
+function dateToString_T(date) {
+    return padWithZeros(hour(date), 2)
+        + ":" + padWithZeros(minute(date), 2)
+        + ":" + padWithZeros(second(date), 2);
+}
+function dateToString_t(date) {
+    return padWithZeros(hour(date), 2)
+        + ":" + padWithZeros(minute(date), 2);
+}
 function dateToStringWithKind(date, format) {
     const utc = date.kind === 1 /* DateKind.UTC */;
     if (typeof format !== "string") {
@@ -419,12 +422,10 @@ function dateToStringWithKind(date, format) {
     }
     else if (format.length === 1) {
         switch (format) {
-            case "D":
-            case "d":
-                return utc ? dateToHalfUTCString(date, "first") : date.toLocaleDateString();
-            case "T":
-            case "t":
-                return utc ? dateToHalfUTCString(date, "second") : date.toLocaleTimeString();
+            case "D": return dateToString_D(date);
+            case "d": return dateToString_d(date);
+            case "T": return dateToString_T(date);
+            case "t": return dateToString_t(date);
             case "O":
             case "o":
                 return dateToISOString(date, utc);

package/Decimal.d.ts

@@ -1,5 +1,7 @@
 import Decimal from "./lib/big.js";
 import { FSharpRef } from "./Types.js";
+import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
+import { int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.js";
 export default Decimal;
 export type decimal = Decimal;
 export declare const get_Zero: Decimal;
@@ -39,6 +41,22 @@ export declare function toString(x: Decimal): string;
 export declare function tryParse(str: string, defValue: FSharpRef<Decimal>): boolean;
 export declare function parse(str: string): Decimal;
 export declare function toNumber(x: Decimal): number;
+export declare function toChar(x: Decimal): string;
+export declare function toInt8(x: Decimal): int8;
+export declare function toUInt8(x: Decimal): uint8;
+export declare function toInt16(x: Decimal): int16;
+export declare function toUInt16(x: Decimal): uint16;
+export declare function toInt32(x: Decimal): int32;
+export declare function toUInt32(x: Decimal): uint32;
+export declare function toInt64(x: Decimal): int64;
+export declare function toUInt64(x: Decimal): uint64;
+export declare function toInt128(x: Decimal): int128;
+export declare function toUInt128(x: Decimal): uint128;
+export declare function toNativeInt(x: Decimal): nativeint;
+export declare function toUNativeInt(x: Decimal): unativeint;
+export declare function toFloat16(x: Decimal): float16;
+export declare function toFloat32(x: Decimal): float32;
+export declare function toFloat64(x: Decimal): float64;
 export declare function fromIntArray(bits: ArrayLike<number>): Decimal;
 export declare function fromInts(low: number, mid: number, high: number, signExp: number): Decimal;
 export declare function fromParts(low: number, mid: number, high: number, isNegative: boolean, scale: number): Decimal;

package/Decimal.js

@@ -2,6 +2,8 @@ import Decimal from "./lib/big.js";
 import { symbol } from "./Numeric.js";
 import { FSharpRef } from "./Types.js";
 import { combineHashCodes } from "./Util.js";
+import { fromDecimal } from "./BigInt.js";
+import * as bigInt from "./BigInt.js";
 Decimal.prototype.GetHashCode = function () {
     return combineHashCodes([this.s, this.e].concat(this.c));
 };
@@ -113,6 +115,28 @@ export function parse(str) {
 export function toNumber(x) {
     return +x;
 }
+export function toChar(x) {
+    const n = toNumber(x);
+    if (n < 0 || n > 65535 || isNaN(n)) {
+        throw new Error("Value was either too large or too small for a character.");
+    }
+    return String.fromCharCode(n);
+}
+export function toInt8(x) { return bigInt.toInt8(fromDecimal(x)); }
+export function toUInt8(x) { return bigInt.toUInt8(fromDecimal(x)); }
+export function toInt16(x) { return bigInt.toInt16(fromDecimal(x)); }
+export function toUInt16(x) { return bigInt.toUInt16(fromDecimal(x)); }
+export function toInt32(x) { return bigInt.toInt32(fromDecimal(x)); }
+export function toUInt32(x) { return bigInt.toUInt32(fromDecimal(x)); }
+export function toInt64(x) { return bigInt.toInt64(fromDecimal(x)); }
+export function toUInt64(x) { return bigInt.toUInt64(fromDecimal(x)); }
+export function toInt128(x) { return bigInt.toInt128(fromDecimal(x)); }
+export function toUInt128(x) { return bigInt.toUInt128(fromDecimal(x)); }
+export function toNativeInt(x) { return bigInt.toNativeInt(fromDecimal(x)); }
+export function toUNativeInt(x) { return bigInt.toUNativeInt(fromDecimal(x)); }
+export function toFloat16(x) { return toNumber(x); }
+export function toFloat32(x) { return toNumber(x); }
+export function toFloat64(x) { return toNumber(x); }
 function decimalToHex(dec, bitSize) {
     const hex = new Uint8Array(bitSize / 4 | 0);
     let hexCount = 1;

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.d.ts

@@ -56,7 +56,7 @@ export declare function foldBack<T, State>(folder: ((arg0: T, arg1: State) => St
 export declare function foldIndexed<State, T>(folder: ((arg0: int32, arg1: State, arg2: T) => State), state: State, xs: FSharpList<T>): State;
 export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, xs: FSharpList<T1>, ys: FSharpList<T2>): State;
 export declare function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: FSharpList<T1>, ys: FSharpList<T2>, state: State): State;
-export declare function unfold<State, T>(gen: ((arg0: State) => Option<[T, State]>), state: State): FSharpList<T>;
+export declare function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>), state: State): FSharpList<T>;
 export declare function iterate<$a>(action: ((arg0: $a) => void), xs: FSharpList<$a>): void;
 export declare function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: FSharpList<$a>, ys: FSharpList<$b>): void;
 export declare function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: FSharpList<$a>): void;

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);
@@ -403,12 +403,12 @@ export function fold2(folder, state, xs, ys) {
 export function foldBack2(folder, xs, ys, state) {
     return foldBack2_1(folder, toArray(xs), toArray(ys), state);
 }
-export function unfold(gen, state) {
+export function unfold(generator, state) {
     const loop = (acc_mut, node_mut) => {
-        let t;
         loop: while (true) {
             const acc = acc_mut, node = node_mut;
-            const matchValue = gen(acc);
+            let t;
+            const matchValue = generator(acc);
             if (matchValue != null) {
                 acc_mut = value_1(matchValue)[1];
                 node_mut = ((t = (new FSharpList(value_1(matchValue)[0], undefined)), (node.tail = t, t)));
@@ -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/MapUtil.js

@@ -6,6 +6,7 @@ const CaseRules = {
     SnakeCase: 2,
     SnakeCaseAllCaps: 3,
     KebabCase: 4,
+    LowerAll: 5,
 };
 function dashify(str, separator) {
     return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1
@@ -22,6 +23,8 @@ function changeCase(str, caseRule) {
             return dashify(str, "_").toUpperCase();
         case CaseRules.KebabCase:
             return dashify(str, "-");
+        case CaseRules.LowerAll:
+            return str.toLowerCase();
         case CaseRules.None:
         default:
             return str;

package/Numeric.d.ts

@@ -11,9 +11,10 @@ export interface CustomNumeric extends IComparable<Numeric> {
 }
 export type Numeric = number | bigint | CustomNumeric;
 export declare function isNumeric(x: any): any;
+export declare function isIntegral(x: Numeric): boolean;
 export declare function compare(x: Numeric, y: number): number;
 export declare function multiply(x: Numeric, y: number): Numeric;
-export declare function toFixed(x: Numeric, dp?: number): string | bigint;
-export declare function toPrecision(x: Numeric, sd?: number): string | bigint;
+export declare function toFixed(x: Numeric, dp?: number): string;
+export declare function toPrecision(x: Numeric, sd?: number): string;
 export declare function toExponential(x: Numeric, dp?: number): string | bigint;
 export declare function toHex(x: Numeric): string;

package/Numeric.js

@@ -2,6 +2,10 @@ export const symbol = Symbol("numeric");
 export function isNumeric(x) {
     return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
 }
+export function isIntegral(x) {
+    // Not perfect, because in JS we can't distinguish between 1.0 and 1
+    return typeof x === "number" && Number.isInteger(x) || typeof x === "bigint";
+}
 export function compare(x, y) {
     if (typeof x === "number") {
         return x < y ? -1 : (x > y ? 1 : 0);
@@ -29,7 +33,7 @@ export function toFixed(x, dp) {
         return x.toFixed(dp);
     }
     else if (typeof x === "bigint") {
-        return x;
+        return x.toString();
     }
     else {
         return x[symbol]().toFixed(dp);
@@ -40,7 +44,7 @@ export function toPrecision(x, sd) {
         return x.toPrecision(sd);
     }
     else if (typeof x === "bigint") {
-        return x;
+        return x.toString();
     }
     else {
         return x[symbol]().toPrecision(sd);

package/Random.js

@@ -1,5 +1,5 @@
 import { class_type } from "./Reflection.js";
-import { fromFloat64, op_Addition, toInt32, toFloat64, compare, fromInt32, toInt64 } from "./BigInt.js";
+import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, fromInt32, toInt64_unchecked } from "./BigInt.js";
 import { Operators_IsNull } from "./FSharp.Core.js";
 import { item, fill, setItem } from "./Array.js";
 function Native_random() {
@@ -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();
@@ -103,8 +103,8 @@ export class Seeded {
         if (minValue > maxValue) {
             throw new Error("minValue must be less than maxValue");
         }
-        const range = toInt64(fromInt32(maxValue - minValue));
-        return ((compare(range, toInt64(fromInt32(2147483647))) <= 0) ? (~~(Seeded__Sample(this$) * toFloat64(range)) + minValue) : ~~toInt32(toInt64(op_Addition(toInt64(fromFloat64(Seeded__GetSampleForLargeRange(this$) * toFloat64(range))), toInt64(fromInt32(minValue)))))) | 0;
+        const range = toInt64_unchecked(fromInt32(maxValue - minValue));
+        return ((compare(range, toInt64_unchecked(fromInt32(2147483647))) <= 0) ? (~~(Seeded__Sample(this$) * toFloat64(range)) + minValue) : ~~toInt32_unchecked(toInt64_unchecked(op_Addition(toInt64_unchecked(fromFloat64(Seeded__GetSampleForLargeRange(this$) * toFloat64(range))), toInt64_unchecked(fromInt32(minValue)))))) | 0;
     }
     NextDouble() {
         const this$ = this;

package/Range.js

@@ -1,6 +1,6 @@
 import { compare } from "./Util.js";
 import { unfold, delay } from "./Seq.js";
-import { toUInt64, toInt64, op_Addition, fromZero } from "./BigInt.js";
+import { toUInt64_unchecked, toInt64_unchecked, op_Addition, fromZero } from "./BigInt.js";
 import { op_Addition as op_Addition_1, fromParts } from "./Decimal.js";
 export function makeRangeStepFunction(step, stop, zero, add) {
     const stepComparedWithZero = compare(step, zero) | 0;
@@ -27,16 +27,16 @@ export function rangeDouble(start, step, stop) {
     return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));
 }
 export function rangeInt64(start, step, stop) {
-    return integralRangeStep(start, step, stop, 0n, (x, y) => toInt64(op_Addition(x, y)));
+    return integralRangeStep(start, step, stop, 0n, (x, y) => toInt64_unchecked(op_Addition(x, y)));
 }
 export function rangeUInt64(start, step, stop) {
-    return integralRangeStep(start, step, stop, 0n, (x, y) => toUInt64(op_Addition(x, y)));
+    return integralRangeStep(start, step, stop, 0n, (x, y) => toUInt64_unchecked(op_Addition(x, y)));
 }
 export function rangeChar(start, stop) {
     const intStop = ~~stop.charCodeAt(0) | 0;
-    return delay(() => unfold((c) => {
-        if (c <= intStop) {
-            return [String.fromCharCode(c), c + 1];
+    return delay(() => unfold((i) => {
+        if (i <= intStop) {
+            return [String.fromCharCode(i & 0xFFFF), i + 1];
         }
         else {
             return undefined;

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

@@ -1,5 +1,5 @@
 import { toString as dateToString } from "./Date.js";
-import { compare as numericCompare, isNumeric, multiply, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
+import { compare as numericCompare, isNumeric, isIntegral, multiply, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
 import { escape } from "./RegExp.js";
 import { toString } from "./Types.js";
 const fsFormatRegExp = /(^|[^%])%([0+\- ]*)(\*|\d+)?(?:\.(\d+))?(\w)/g;
@@ -276,6 +276,17 @@ export function fsFormat(str) {
         }
     };
 }
+function splitIntAndDecimalPart(value) {
+    let [repInt, repDecimal] = value.split(".");
+    repDecimal === undefined && (repDecimal = "");
+    return {
+        integral: repInt,
+        decimal: repDecimal
+    };
+}
+function thousandSeparate(value) {
+    return value.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
 export function format(str, ...args) {
     let str2;
     if (typeof str === "object") {
@@ -291,39 +302,99 @@ export function format(str, ...args) {
             throw new Error("Index must be greater or equal to zero and less than the arguments' length.");
         }
         let rep = args[idx];
+        let parts;
         if (isNumeric(rep)) {
-            precision = precision == null ? null : parseInt(precision, 10);
+            precision = precision == "" ? null : parseInt(precision, 10);
             switch (format) {
+                case "b":
+                case "B":
+                    if (!isIntegral(rep)) {
+                        throw new Error("Format specifier was invalid.");
+                    }
+                    rep = (rep >>> 0).toString(2).replace(/^0+/, "").padStart(precision || 1, "0");
+                    break;
+                case "c":
+                case "C":
+                    const isNegative = isLessThan(rep, 0);
+                    if (isLessThan(rep, 0)) {
+                        rep = multiply(rep, -1);
+                    }
+                    precision = precision == null ? 2 : precision;
+                    rep = toFixed(rep, precision);
+                    parts = splitIntAndDecimalPart(rep);
+                    rep = "¤" + thousandSeparate(parts.integral) + "." + padRight(parts.decimal, precision, "0");
+                    if (isNegative) {
+                        rep = "(" + rep + ")";
+                    }
+                    break;
+                case "d":
+                case "D":
+                    if (!isIntegral(rep)) {
+                        throw new Error("Format specifier was invalid.");
+                    }
+                    rep = String(rep);
+                    if (precision != null) {
+                        if (rep.startsWith("-")) {
+                            rep = "-" + padLeft(rep.substring(1), precision, "0");
+                        }
+                        else {
+                            rep = padLeft(rep, precision, "0");
+                        }
+                    }
+                    break;
+                case "e":
+                case "E":
+                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);
+                    break;
                 case "f":
                 case "F":
                     precision = precision != null ? precision : 2;
                     rep = toFixed(rep, precision);
+                    if (precision > 0) {
+                        parts = splitIntAndDecimalPart(rep);
+                        rep = parts.integral + "." + padRight(parts.decimal, precision, "0");
+                    }
                     break;
                 case "g":
                 case "G":
                     rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);
+                    // TODO: Check why some numbers are formatted with decimal part
+                    rep = trimEnd(trimEnd(rep, "0"), ".");
                     break;
-                case "e":
-                case "E":
-                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);
+                case "n":
+                case "N":
+                    precision = precision != null ? precision : 2;
+                    rep = toFixed(rep, precision);
+                    parts = splitIntAndDecimalPart(rep);
+                    rep = thousandSeparate(parts.integral) + "." + padRight(parts.decimal, precision, "0");
                     break;
                 case "p":
                 case "P":
                     precision = precision != null ? precision : 2;
-                    rep = toFixed(multiply(rep, 100), precision) + " %";
-                    break;
-                case "d":
-                case "D":
-                    rep = precision != null ? padLeft(String(rep), precision, "0") : String(rep);
+                    rep = toFixed(multiply(rep, 100), precision);
+                    parts = splitIntAndDecimalPart(rep);
+                    rep = thousandSeparate(parts.integral) + "." + padRight(parts.decimal, precision, "0") + " %";
                     break;
+                case "r":
+                case "R":
+                    throw new Error("The round-trip format is not supported by Fable");
                 case "x":
                 case "X":
-                    rep = precision != null ? padLeft(toHex(rep), precision, "0") : toHex(rep);
+                    if (!isIntegral(rep)) {
+                        throw new Error("Format specifier was invalid.");
+                    }
+                    precision = precision != null ? precision : 2;
+                    rep = padLeft(toHex(rep), precision, "0");
                     if (format === "X") {
                         rep = rep.toUpperCase();
                     }
                     break;
                 default:
+                    // If we have format and were not able to handle it throw
+                    // See: https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#standard-format-specifiers
+                    if (format) {
+                        throw new Error("Format specifier was invalid.");
+                    }
                     if (pattern) {
                         let sign = "";
                         rep = pattern.replace(/([0#,]+)(\.[0#]+)?/, (_, intPart, decimalPart) => {

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.2",
   "description": "Core library used by F# projects compiled with fable.io",
   "author": "Fable Contributors",
   "license": "MIT",