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

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,19 @@ 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
@@ -59,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/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

@@ -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) => {
         loop: while (true) {
             const acc = acc_mut, node = node_mut;
             let t;
-            const matchValue = gen(acc);
+            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)));

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() {
@@ -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/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/package.json

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