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

package/Async.ts

@@ -159,12 +159,14 @@ export function sleep(millisecondsDueTime: number) {
   });
 }
 
-export function runSynchronously(): never {
-  throw new Error("Asynchronous code cannot be run synchronously in JS");
-}
-
 export function start<T>(computation: Async<T>, cancellationToken?: CancellationToken) {
-  return startWithContinuations(computation, cancellationToken);
+  return startWithContinuations(
+    computation,
+    emptyContinuation,
+    function (err) { throw err },
+    emptyContinuation,
+    cancellationToken
+  );
 }
 
 export function startImmediate<T>(computation: Async<T>, cancellationToken?: CancellationToken) {
@@ -173,19 +175,16 @@ export function startImmediate<T>(computation: Async<T>, cancellationToken?: Can
 
 export function startWithContinuations<T>(
   computation: Async<T>,
-  continuation?: Continuation<T> | CancellationToken,
-  exceptionContinuation?: Continuation<any>,
-  cancellationContinuation?: Continuation<any>,
+  continuation: Continuation<T>,
+  exceptionContinuation: Continuation<any>,
+  cancellationContinuation: Continuation<any>,
   cancelToken?: CancellationToken) {
-  if (typeof continuation !== "function") {
-    cancelToken = continuation as CancellationToken;
-    continuation = undefined;
-  }
+
   const trampoline = new Trampoline();
   computation({
     onSuccess: continuation ? continuation as Continuation<T> : emptyContinuation,
-    onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,
-    onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,
+    onError: exceptionContinuation,
+    onCancel: cancellationContinuation,
     cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
     trampoline,
   });

package/BigInt.ts

@@ -130,20 +130,46 @@ export function toByteArray(value: bigint): number[] {
     return toSignedBytes(value, isBigEndian) as any as number[];
 }
 
-export function toInt8(x: bigint): int8 { return Number(BigInt.asIntN(8, x)); }
-export function toUInt8(x: bigint): uint8 { return Number(BigInt.asUintN(8, x)); }
-export function toInt16(x: bigint): int16 { return Number(BigInt.asIntN(16, x)); }
-export function toUInt16(x: bigint): uint16 { return Number(BigInt.asUintN(16, x)); }
-export function toInt32(x: bigint): int32 { return Number(BigInt.asIntN(32, x)); }
-export function toUInt32(x: bigint): uint32 { return Number(BigInt.asUintN(32, x)); }
-export function toInt64(x: bigint): int64 { return BigInt.asIntN(64, x); }
-export function toUInt64(x: bigint): uint64 { return BigInt.asUintN(64, x); }
-export function toInt128(x: bigint): int128 { return BigInt.asIntN(128, x); }
-export function toUInt128(x: bigint): uint128 { return BigInt.asUintN(128, x); }
-export function toNativeInt(x: bigint): nativeint { return BigInt.asIntN(64, x); }
-export function toUNativeInt(x: bigint): unativeint { return BigInt.asUintN(64, x); }
-
-export function toFloat16(x: bigint): float32 { return Number(x); }
+export function toIntN_unchecked(bits: number, x: bigint, signed: boolean): bigint {
+    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+}
+
+export function toIntN(bits: number, x: bigint, signed: boolean): bigint {
+    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: bigint): int8 { return Number(toIntN(8, x, true)); }
+export function toUInt8(x: bigint): uint8 { return Number(toIntN(8, x, false)); }
+export function toInt16(x: bigint): int16 { return Number(toIntN(16, x, true)); }
+export function toUInt16(x: bigint): uint16 { return Number(toIntN(16, x, false)); }
+export function toInt32(x: bigint): int32 { return Number(toIntN(32, x, true)); }
+export function toUInt32(x: bigint): uint32 { return Number(toIntN(32, x, false)); }
+export function toInt64(x: bigint): int64 { return toIntN(64, x, true); }
+export function toUInt64(x: bigint): uint64 { return toIntN(64, x, false); }
+export function toInt128(x: bigint): int128 { return toIntN(128, x, true); }
+export function toUInt128(x: bigint): uint128 { return toIntN(128, x, false); }
+export function toNativeInt(x: bigint): nativeint { return toIntN(64, x, true); }
+export function toUNativeInt(x: bigint): unativeint { return toIntN(64, x, false); }
+
+export function toInt8_unchecked(x: bigint): int8 { return Number(toIntN_unchecked(8, x, true)); }
+export function toUInt8_unchecked(x: bigint): uint8 { return Number(toIntN_unchecked(8, x, false)); }
+export function toInt16_unchecked(x: bigint): int16 { return Number(toIntN_unchecked(16, x, true)); }
+export function toUInt16_unchecked(x: bigint): uint16 { return Number(toIntN_unchecked(16, x, false)); }
+export function toInt32_unchecked(x: bigint): int32 { return Number(toIntN_unchecked(32, x, true)); }
+export function toUInt32_unchecked(x: bigint): uint32 { return Number(toIntN_unchecked(32, x, false)); }
+export function toInt64_unchecked(x: bigint): int64 { return toIntN_unchecked(64, x, true); }
+export function toUInt64_unchecked(x: bigint): uint64 { return toIntN_unchecked(64, x, false); }
+export function toInt128_unchecked(x: bigint): int128 { return toIntN_unchecked(128, x, true); }
+export function toUInt128_unchecked(x: bigint): uint128 { return toIntN_unchecked(128, x, false); }
+export function toNativeInt_unchecked(x: bigint): nativeint { return toIntN_unchecked(64, x, true); }
+export function toUNativeInt_unchecked(x: bigint): unativeint { return toIntN_unchecked(64, x, false); }
+
+export function toFloat16(x: bigint): float16 { return Number(x); }
 export function toFloat32(x: bigint): float32 { return Number(x); }
 export function toFloat64(x: bigint): float64 { return Number(x); }
 
@@ -191,14 +217,14 @@ export function modPow(x: bigint, e: bigint, m: bigint): bigint {
 export function divRem(x: bigint, y: bigint): [bigint, bigint];
 export function divRem(x: bigint, y: bigint, out: FSharpRef<bigint>): bigint;
 export function divRem(x: bigint, y: bigint, out?: FSharpRef<bigint>): bigint | [bigint, bigint] {
-  const div = x / y;
-  const rem = x % y;
-  if (out === void 0) {
-    return [div, rem];
-  } else {
-    out.contents = rem;
-    return div;
-  }
+    const div = x / y;
+    const rem = x % y;
+    if (out === void 0) {
+        return [div, rem];
+    } else {
+        out.contents = rem;
+        return div;
+    }
 }
 
 export function greatestCommonDivisor(x: bigint, y: bigint): bigint {

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

@@ -55,7 +55,7 @@ function parseNextChar(format: string, pos: number) {
   return format.charCodeAt(pos + 1);
 }
 
-function parseQuotedString(format: string, pos: number) : [string, number] {
+function parseQuotedString(format: string, pos: number): [string, number] {
   let beginPos = pos;
   // Get the character used to quote the string
   const quoteChar = format[pos];
@@ -114,9 +114,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += shortDays[dayOfWeek(localizedDate)];
             break;
           case 4:
-            result += longDays[dayOfWeek(localizedDate)];
-            break;
           default:
+            result += longDays[dayOfWeek(localizedDate)];
             break;
         }
         break;
@@ -132,7 +131,9 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
           // milliseconds provided to it.
           // This is to have the same behavior as .NET when doing:
           // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
-          result += (""+millisecond(localizedDate)).padEnd(tokenLength, "0");
+          result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
+        } else {
+          throw "Input string was not in a correct format.";
         }
         break;
       case "F":
@@ -152,14 +153,14 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
           if (value != 0) {
             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");
@@ -170,11 +171,10 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             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":
@@ -185,9 +185,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += hour(localizedDate);
             break;
           case 2:
-            result += padWithZeros(hour(localizedDate), 2);
-            break;
           default:
+            result += padWithZeros(hour(localizedDate), 2);
             break;
         }
         break;
@@ -219,9 +218,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += minute(localizedDate);
             break;
           case 2:
-            result += padWithZeros(minute(localizedDate), 2);
-            break;
           default:
+            result += padWithZeros(minute(localizedDate), 2);
             break;
         }
         break;
@@ -239,9 +237,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += shortMonths[month(localizedDate) - 1];
             break;
           case 4:
-            result += longMonths[month(localizedDate) - 1];
-            break;
           default:
+            result += longMonths[month(localizedDate) - 1];
             break;
         }
         break;
@@ -253,9 +250,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += second(localizedDate);
             break;
           case 2:
-            result += padWithZeros(second(localizedDate), 2);
-            break;
           default:
+            result += padWithZeros(second(localizedDate), 2);
             break;
         }
         break;
@@ -267,9 +263,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             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;
@@ -283,16 +278,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
           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;
@@ -393,13 +380,6 @@ export function dateOffsetToString(offset: number) {
     padWithZeros(minutes, 2);
 }
 
-export function dateToHalfUTCString(date: IDateTime, half: "first" | "second") {
-  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: IDateTime, utc: boolean) {
   if (utc) {
     return d.toISOString();
@@ -428,8 +408,10 @@ function dateToStringWithOffset(date: IDateTimeOffset, format?: string) {
     return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString((date.offset ?? 0));
   } 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");
     }
@@ -438,16 +420,40 @@ function dateToStringWithOffset(date: IDateTimeOffset, format?: string) {
   }
 }
 
+function dateToString_D(date: IDateTime) {
+  return longDays[dayOfWeek(date)]
+    + ", " + padWithZeros(day(date), 2)
+    + " " + longMonths[month(date) - 1]
+    + " " + year(date);
+}
+
+function dateToString_d(date: IDateTime) {
+  return padWithZeros(month(date), 2)
+    + "/" + padWithZeros(day(date), 2)
+    + "/" + year(date);
+}
+
+function dateToString_T(date: IDateTime) {
+  return padWithZeros(hour(date), 2)
+    + ":" + padWithZeros(minute(date), 2)
+    + ":" + padWithZeros(second(date), 2);
+}
+
+function dateToString_t(date: IDateTime) {
+  return padWithZeros(hour(date), 2)
+    + ":" + padWithZeros(minute(date), 2);
+}
+
 function dateToStringWithKind(date: IDateTime, format?: string) {
   const utc = date.kind === DateKind.UTC;
   if (typeof format !== "string") {
     return utc ? date.toUTCString() : date.toLocaleString();
   } 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);
       default:

package/Decimal.ts

@@ -2,6 +2,9 @@ import Decimal, { BigSource } from "./lib/big.js";
 import { Numeric, symbol } from "./Numeric.js";
 import { FSharpRef } from "./Types.js";
 import { combineHashCodes } from "./Util.js";
+import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
+import { fromDecimal, int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.js";
+import * as bigInt from "./BigInt.js";
 
 Decimal.prototype.GetHashCode = function () {
   return combineHashCodes([this.s, this.e].concat(this.c))
@@ -139,10 +142,35 @@ export function parse(str: string): Decimal {
   }
 }
 
-export function toNumber(x: Decimal) {
+export function toNumber(x: Decimal): number {
   return +x;
 }
 
+export function toChar(x: Decimal): string {
+  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: Decimal): int8 { return bigInt.toInt8(fromDecimal(x)); }
+export function toUInt8(x: Decimal): uint8 { return bigInt.toUInt8(fromDecimal(x)); }
+export function toInt16(x: Decimal): int16 { return bigInt.toInt16(fromDecimal(x)); }
+export function toUInt16(x: Decimal): uint16 { return bigInt.toUInt16(fromDecimal(x)); }
+export function toInt32(x: Decimal): int32 { return bigInt.toInt32(fromDecimal(x)); }
+export function toUInt32(x: Decimal): uint32 { return bigInt.toUInt32(fromDecimal(x)); }
+export function toInt64(x: Decimal): int64 { return bigInt.toInt64(fromDecimal(x)); }
+export function toUInt64(x: Decimal): uint64 { return bigInt.toUInt64(fromDecimal(x)); }
+export function toInt128(x: Decimal): int128 { return bigInt.toInt128(fromDecimal(x)); }
+export function toUInt128(x: Decimal): uint128 { return bigInt.toUInt128(fromDecimal(x)); }
+export function toNativeInt(x: Decimal): nativeint { return bigInt.toNativeInt(fromDecimal(x)); }
+export function toUNativeInt(x: Decimal): unativeint { return bigInt.toUNativeInt(fromDecimal(x)); }
+
+export function toFloat16(x: Decimal): float16 { return toNumber(x); }
+export function toFloat32(x: Decimal): float32 { return toNumber(x); }
+export function toFloat64(x: Decimal): float64 { return toNumber(x); }
+
 function decimalToHex(dec: Uint8Array, bitSize: number) {
   const hex = new Uint8Array(bitSize / 4 | 0);
   let hexCount = 1;

package/List.ts

@@ -450,13 +450,13 @@ export function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: Sta
     return foldBack2_1<T1, T2, State>(folder, toArray<T1>(xs), toArray<T2>(ys), state);
 }
 
-export function unfold<State, T>(gen: ((arg0: State) => Option<[T, State]>), state: State): FSharpList<T> {
+export function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>), state: State): FSharpList<T> {
     const loop = (acc_mut: State, node_mut: FSharpList<T>): FSharpList<T> => {
         loop:
         while (true) {
             const acc: State = acc_mut, node: FSharpList<T> = node_mut;
             let t: FSharpList<T>;
-            const matchValue: Option<[T, State]> = gen(acc);
+            const matchValue: Option<[T, State]> = 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.ts

@@ -7,6 +7,7 @@ const CaseRules = {
   SnakeCase: 2,
   SnakeCaseAllCaps: 3,
   KebabCase: 4,
+  LowerAll: 5,
 };
 
 function dashify(str: string, separator: string) {
@@ -25,6 +26,8 @@ function changeCase(str: string, caseRule: number) {
       return dashify(str, "_").toUpperCase();
     case CaseRules.KebabCase:
       return dashify(str, "-");
+    case CaseRules.LowerAll:
+      return str.toLowerCase();
     case CaseRules.None:
     default:
       return str;

package/Numeric.ts

@@ -18,6 +18,11 @@ export function isNumeric(x: any) {
     return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
 }
 
+export function isIntegral(x: Numeric) {
+    // 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: Numeric, y: number) {
     if (typeof x === "number") {
         return x < y ? -1 : (x > y ? 1 : 0);
@@ -42,7 +47,7 @@ export function toFixed(x: Numeric, dp?: number) {
     if (typeof x === "number") {
         return x.toFixed(dp);
     } else if (typeof x === "bigint") {
-        return x;
+        return x.toString();
     } else {
         return x[symbol]().toFixed(dp);
     }
@@ -52,7 +57,7 @@ export function toPrecision(x: Numeric, sd?: number) {
     if (typeof x === "number") {
         return x.toPrecision(sd);
     } else if (typeof x === "bigint") {
-        return x;
+        return x.toString();
     } else {
         return x[symbol]().toPrecision(sd);
     }
@@ -77,4 +82,4 @@ export function toHex(x: Numeric) {
     } else {
         return x[symbol]().toHex();
     }
-}
+}

package/Random.ts

@@ -1,6 +1,6 @@
 import { uint8, int32, float64 } from "./Int32.js";
 import { class_type, TypeInfo } from "./Reflection.js";
-import { fromFloat64, op_Addition, toInt32, toFloat64, compare, int64, fromInt32, toInt64 } from "./BigInt.js";
+import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, int64, fromInt32, toInt64_unchecked } from "./BigInt.js";
 import { Operators_IsNull } from "./FSharp.Core.js";
 import { item, fill, setItem } from "./Array.js";
 
@@ -121,8 +121,8 @@ export class Seeded implements IRandom {
         if (minValue > maxValue) {
             throw new Error("minValue must be less than maxValue");
         }
-        const range: int64 = 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: int64 = 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(): float64 {
         const this$: Seeded = this;

package/Range.ts

@@ -2,7 +2,7 @@ import { compare } from "./Util.js";
 import { float64, int32 } from "./Int32.js";
 import { Option } from "./Option.js";
 import { unfold, delay } from "./Seq.js";
-import { uint64, toUInt64, int64, toInt64, op_Addition, fromZero } from "./BigInt.js";
+import { uint64, toUInt64_unchecked, int64, toInt64_unchecked, op_Addition, fromZero } from "./BigInt.js";
 import { decimal, op_Addition as op_Addition_1, fromParts } from "./Decimal.js";
 
 export function makeRangeStepFunction<T>(step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): ((arg0: T) => Option<[T, T]>) {
@@ -35,18 +35,18 @@ export function rangeDouble(start: float64, step: float64, stop: float64): Itera
 }
 
 export function rangeInt64(start: int64, step: int64, stop: int64): Iterable<int64> {
-    return integralRangeStep<int64>(start, step, stop, 0n, (x: int64, y: int64): int64 => toInt64(op_Addition(x, y)));
+    return integralRangeStep<int64>(start, step, stop, 0n, (x: int64, y: int64): int64 => toInt64_unchecked(op_Addition(x, y)));
 }
 
 export function rangeUInt64(start: uint64, step: uint64, stop: uint64): Iterable<uint64> {
-    return integralRangeStep<uint64>(start, step, stop, 0n, (x: uint64, y: uint64): uint64 => toUInt64(op_Addition(x, y)));
+    return integralRangeStep<uint64>(start, step, stop, 0n, (x: uint64, y: uint64): uint64 => toUInt64_unchecked(op_Addition(x, y)));
 }
 
 export function rangeChar(start: string, stop: string): Iterable<string> {
     const intStop: int32 = ~~stop.charCodeAt(0) | 0;
-    return delay<string>((): Iterable<string> => unfold<int32, string>((c: int32): Option<[string, int32]> => {
-        if (c <= intStop) {
-            return [String.fromCharCode(c), c + 1] as [string, int32];
+    return delay<string>((): Iterable<string> => unfold<int32, string>((i: int32): Option<[string, int32]> => {
+        if (i <= intStop) {
+            return [String.fromCharCode(i & 0xFFFF), i + 1] as [string, int32];
         }
         else {
             return undefined;

package/String.ts

@@ -1,5 +1,5 @@
 import { toString as dateToString } from "./Date.js";
-import { compare as numericCompare, isNumeric, multiply, Numeric, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
+import { compare as numericCompare, isNumeric, isIntegral, multiply, Numeric, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
 import { escape } from "./RegExp.js";
 import { toString } from "./Types.js";
 
@@ -295,6 +295,19 @@ export function fsFormat(str: string) {
   };
 }
 
+function splitIntAndDecimalPart(value: string) {
+  let [repInt, repDecimal] = value.split(".");
+  repDecimal === undefined && (repDecimal = "");
+  return {
+    integral: repInt,
+    decimal: repDecimal
+  }
+}
+
+function thousandSeparate(value: string) {
+  return value.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
 export function format(str: string | object, ...args: any[]) {
   let str2: string;
   if (typeof str === "object") {
@@ -310,31 +323,89 @@ export function format(str: string | object, ...args: any[]) {
       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 (format === "X") { rep = rep.toUpperCase(); }
+          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 as string).replace(/([0#,]+)(\.[0#]+)?/, (_, intPart: string, decimalPart: string) => {

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "name": "@fable-org/fable-library-ts",
-  "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",