@fable-org/fable-library-js 2.4.0 → 2.4.2

package/Async.js

@@ -7,10 +7,6 @@ import { Exception } from "./Util.js";
 function emptyContinuation(_x) {
     // NOP
 }
-// see AsyncBuilder.Delay
-function delay(generator) {
-    return protectedCont((ctx) => generator()(ctx));
-}
 // MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
 export function makeAsync(body) {
     return body;
@@ -49,18 +45,27 @@ export function throwIfCancellationRequested(token) {
     }
 }
 export function startChild(computation, ms) {
-    const promise = startAsPromise(computation);
-    let promiseToRun = promise;
-    if (ms) {
-        // Race the computation against a timeout: whichever settles first wins.
-        promiseToRun = new Promise((resolve, reject) => {
-            const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
-            promise.then(value => { clearTimeout(timeoutId); resolve(value); }, error => { clearTimeout(timeoutId); reject(error); });
-        });
-    }
-    // JS Promises are hot, computation has already started
-    // but we delay returning the result
-    return protectedCont((ctx) => protectedReturn(awaitPromise(promiseToRun))(ctx));
+    return protectedCont((ctx) => {
+        // Share the parent's cancellation token so cancelling the parent
+        // cancels the child, like .NET Async.StartChild
+        const promise = startAsPromise(computation, ctx.cancelToken);
+        let promiseToRun = promise;
+        if (ms) {
+            // Race the computation against a timeout: whichever settles first wins.
+            promiseToRun = new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
+                promise.then(value => { clearTimeout(timeoutId); resolve(value); }, error => { clearTimeout(timeoutId); reject(error); });
+            });
+        }
+        // Prevent an unhandled rejection when the child is cancelled or fails
+        // while nobody awaits it (in F# an unobserved child's cancellation or
+        // failure is simply not propagated). awaitPromise attaches its own
+        // handlers to the same promise, so awaiting still observes the result.
+        promiseToRun.catch(emptyContinuation);
+        // JS Promises are hot, computation has already started
+        // but we delay returning the result
+        protectedReturn(awaitPromise(promiseToRun))(ctx);
+    });
 }
 export function awaitPromise(p) {
     return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledException
@@ -106,17 +111,19 @@ export function ignore(computation) {
     return protectedBind(computation, (_x) => protectedReturn(void 0));
 }
 export function parallel(computations) {
-    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
+    // Children share the parent's cancellation token, like .NET Async.Parallel
+    return protectedCont((ctx) => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w, ctx.cancelToken))))(ctx));
 }
 export function sequential(computations) {
-    function _sequential(computations) {
+    function _sequential(computations, cancelToken) {
         let pr = Promise.resolve([]);
         for (const c of computations) {
-            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));
+            pr = pr.then(results => startAsPromise(c, cancelToken).then(r => results.concat([r])));
         }
         return pr;
     }
-    return delay(() => awaitPromise(_sequential(computations)));
+    // Children share the parent's cancellation token, like .NET Async.Sequential
+    return protectedCont((ctx) => awaitPromise(_sequential(computations, ctx.cancelToken))(ctx));
 }
 export function sleep(millisecondsDueTime) {
     return protectedCont((ctx) => {
@@ -139,10 +146,14 @@ export function startImmediate(computation, cancellationToken) {
 }
 export function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
     const trampoline = new Trampoline();
+    // Mark the computation completed as soon as a terminal continuation is entered
+    // so protectedCont lets exceptions from continuation code propagate instead of
+    // routing them to onError (see Trampoline.completed).
+    const done = (cont) => (x) => { trampoline.completed = true; return cont(x); };
     computation({
-        onSuccess: continuation ? continuation : emptyContinuation,
-        onError: exceptionContinuation,
-        onCancel: cancellationContinuation,
+        onSuccess: done(continuation ? continuation : emptyContinuation),
+        onError: done(exceptionContinuation),
+        onCancel: done(cancellationContinuation),
         cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
         trampoline,
     });

package/AsyncBuilder.js

@@ -47,6 +47,7 @@ export class Trampoline {
     }
     constructor() {
         this.callCount = 0;
+        this.completed = false;
     }
     incrementAndCheck() {
         return this.callCount++ > Trampoline.maxTrampolineCallCount;
@@ -67,6 +68,9 @@ export function protectedCont(f) {
                     f(ctx);
                 }
                 catch (err) {
+                    if (ctx.trampoline.completed) {
+                        throw err;
+                    }
                     ctx.onError(ensureErrorOrException(err));
                 }
             });
@@ -76,6 +80,13 @@ export function protectedCont(f) {
                 f(ctx);
             }
             catch (err) {
+                // Once a terminal continuation has run the computation is complete, so
+                // an exception from user continuation code must propagate rather than be
+                // routed to onError (which would resolve the computation a second time,
+                // e.g. a succeeded try/with body re-entering its with handler).
+                if (ctx.trampoline.completed) {
+                    throw err;
+                }
                 ctx.onError(ensureErrorOrException(err));
             }
         }
@@ -85,12 +96,18 @@ export function protectedBind(computation, binder) {
     return protectedCont((ctx) => {
         computation({
             onSuccess: (x) => {
+                // Only guard the binder evaluation itself: the resulting computation
+                // is protected on its own, and re-catching what it throws would
+                // route continuation exceptions back into onError (double-resolve).
+                let bound;
                 try {
-                    binder(x)(ctx);
+                    bound = binder(x);
                 }
                 catch (err) {
                     ctx.onError(ensureErrorOrException(err));
+                    return;
                 }
+                bound(ctx);
             },
             onError: ctx.onError,
             onCancel: ctx.onCancel,
@@ -155,12 +172,16 @@ export class AsyncBuilder {
                 cancelToken: ctx.cancelToken,
                 trampoline: ctx.trampoline,
                 onError: (ex) => {
+                    // See protectedBind: only guard the handler evaluation itself.
+                    let handled;
                     try {
-                        catchHandler(ex)(ctx);
+                        handled = catchHandler(ex);
                     }
                     catch (err) {
                         ctx.onError(ensureErrorOrException(err));
+                        return;
                     }
+                    handled(ctx);
                 },
             });
         });

package/BigInt.js

@@ -99,12 +99,12 @@ 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 truncated = signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+    if (truncated !== x) {
         const s = signed ? "a signed" : "an unsigned";
         throw new Exception(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
     }
-    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+    return truncated;
 }
 export function toInt8(x) { return Number(toIntN(8, x, true)); }
 export function toUInt8(x) { return Number(toIntN(8, x, false)); }
@@ -136,6 +136,9 @@ export function toFloat64(x) { return Number(x); }
 export function toDecimal(x) {
     const isNegative = x < zero;
     const bits = abs(x);
+    if ((bits >> 96n) !== zero) {
+        throw new Exception("Value was either too large or too small for a Decimal.");
+    }
     const low = Number(BigInt.asUintN(32, bits));
     const mid = Number(BigInt.asUintN(32, bits >> 32n));
     const high = Number(BigInt.asUintN(32, bits >> 64n));
@@ -178,6 +181,8 @@ export function divRem(x, y, out) {
     }
 }
 export function greatestCommonDivisor(x, y) {
+    x = abs(x);
+    y = abs(y);
     while (y > zero) {
         const q = x / y;
         const r = x - q * y;
@@ -186,8 +191,16 @@ export function greatestCommonDivisor(x, y) {
     }
     return x;
 }
+// Number of bits in the binary representation of x (x must be positive)
+function bitLength(x) {
+    const hex = x.toString(16);
+    return (hex.length - 1) * 4 + (32 - Math.clz32(fromHexCode(hex.charCodeAt(0))));
+}
 export function getBitLength(x) {
-    return fromFloat64(x === zero ? 1 : log2(abs(x)) + 1);
+    if (x < zero) {
+        x = -x - one; // two's complement bit length excluding the sign bit
+    }
+    return x === zero ? zero : BigInt(bitLength(x));
 }
 export function log2(x) {
     const n = Number(x);
@@ -219,7 +232,10 @@ export function log(x, base) {
     return log2(x) / Math.log2(base);
 }
 export function ilog2(x) {
-    return BigInt(log2(x));
+    if (x < zero) {
+        throw new Exception("Value must be non-negative.");
+    }
+    return x === zero ? zero : BigInt(bitLength(x) - 1);
 }
 // export function copySign
 // export function createChecked
@@ -248,35 +264,20 @@ function fromHexCode(code) {
 }
 function toSignedBytes(x, isBigEndian) {
     const isNeg = x < 0n;
-    if (isNeg) {
-        const len = log2(-x);
-        const bits = len + (8 - len % 8);
-        const pow2 = (1n << BigInt(bits));
-        x = x + pow2; // two's complement
-    }
-    const hex = x.toString(16);
-    const len = hex.length;
-    const odd = len % 2;
-    const first = hex.charCodeAt(0);
-    const isLow = 48 <= first && first <= 55; // 0..7
-    const start = (isNeg && isLow) || (!isNeg && !isLow) ? 1 : 0;
-    const bytes = new Uint8Array(start + (len + odd) / 2);
-    const inc = isBigEndian ? 1 : -1;
-    let pos = isBigEndian ? 0 : bytes.length - 1;
-    if (start > 0) {
-        bytes[pos] = isNeg ? 255 : 0;
-        pos += inc;
-    }
-    if (odd > 0) {
-        bytes[pos] = fromHexCode(first);
-        pos += inc;
+    const sentinel = isNeg ? -1n : 0n;
+    const bytes = []; // little-endian
+    do {
+        bytes.push(Number(BigInt.asUintN(8, x)));
+        x = x >> 8n;
+    } while (x !== sentinel);
+    // extra byte if the top byte's sign bit would misrepresent the sign
+    if (isNeg !== (bytes[bytes.length - 1] > 127)) {
+        bytes.push(isNeg ? 255 : 0);
     }
-    for (let i = odd; i < len; i += 2, pos += inc) {
-        const a = fromHexCode(hex.charCodeAt(i));
-        const b = fromHexCode(hex.charCodeAt(i + 1));
-        bytes[pos] = (a << 4) | b;
+    if (isBigEndian) {
+        bytes.reverse();
     }
-    return bytes;
+    return new Uint8Array(bytes);
 }
 function fromSignedBytes(bytes, isBigEndian) {
     if (bytes == null) {

package/BitConverter.js

@@ -77,7 +77,7 @@ export function doubleToInt64Bits(value) {
 export function toBoolean(bytes, offset) {
     const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
     const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
-    return view.getUint8(offset) === 1 ? true : false;
+    return view.getUint8(offset) !== 0;
 }
 export function toChar(bytes, offset) {
     const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
@@ -134,5 +134,5 @@ export function toString(bytes, offset, count) {
     else if (offset != null) {
         buffer = buffer.subarray(offset);
     }
-    return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2)).join("-");
+    return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2).toUpperCase()).join("-");
 }

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: 7f915f1dd66b9a5fbbd56f858b07d39b98519b65
+last_commit_released: a8d9bf5f0b7cc4560bb107963348e765695c22b6
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 2.4.2 - 2026-07-11
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Async cancellation propagation and continuation double-resolve (#4746) ([c78a9a8e](https://github.com/fable-compiler/Fable/commit/c78a9a8ed20234feddf3375b61e91098f9261bee))
+* *(js/ts)* Date arithmetic: PM parsing, AddMonths day clamp, AddYears offset (#4744) ([be0558eb](https://github.com/fable-compiler/Fable/commit/be0558ebe07f78f7a93ec0c34592d7c066b59fc7))
+* *(js/ts)* Int64 non-decimal parsing and BitConverter .NET mismatches (#4748) ([2704d9c5](https://github.com/fable-compiler/Fable/commit/2704d9c5daab87eb1791c0ea1b6b8b06b987247c))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/d6ae6bd3790b57b31941a118cdffaeb6a59155c3..a8d9bf5f0b7cc4560bb107963348e765695c22b6)</small></strong>
+
+## 2.4.1 - 2026-07-09
+
+### 🐞 Bug Fixes
+
+* MailboxProcessor dropping falsy messages and unit replies ([8299b2e7](https://github.com/fable-compiler/Fable/commit/8299b2e7f690e9136906653155883a08607aa4a4))
+* *(all)* Add `Seq.enumerateTryWith` for try/with in seq, list, array comprehensions (#4750) ([448c90d7](https://github.com/fable-compiler/Fable/commit/448c90d7ccba80ee3d3c38432a2a1d1407f6dc69))
+* *(js/ts)* Match .NET NaN semantics in JS comparison, min and max ([7e5106f9](https://github.com/fable-compiler/Fable/commit/7e5106f9d93cb55ae4aca4656868fa0c53493991))
+* *(js/ts)* BigInteger byte-array corruption, checked conversions, gcd, log2 (#4743) ([f3cb7f2b](https://github.com/fable-compiler/Fable/commit/f3cb7f2bfc9e46e558763867d6c1ba323bcf281c))
+* *(js/ts)* Observable/Event dropping null/undefined/unit values (#4742) ([75bff73b](https://github.com/fable-compiler/Fable/commit/75bff73be3743fe0af37f99c541b10f6978150f3))
+* *(js/ts)* EndsWith regression for empty pattern with non-ordinal comparison ([7793ed7b](https://github.com/fable-compiler/Fable/commit/7793ed7b0fc1f33bf3da6c0ea31607e172726267))
+* *(js/ts/python)* Quote strings with the %A format specifier (#4749) ([75321f3b](https://github.com/fable-compiler/Fable/commit/75321f3b2cb70ea345a0a45d6343cbb6e0de466f))
+* *(ts/js)* `Regex.Replace` count/substitutions and `Regex.Split` semantics (#4741) ([d6ae6bd3](https://github.com/fable-compiler/Fable/commit/d6ae6bd3790b57b31941a118cdffaeb6a59155c3))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/7f915f1dd66b9a5fbbd56f858b07d39b98519b65..d6ae6bd3790b57b31941a118cdffaeb6a59155c3)</small></strong>
+
 ## 2.4.0 - 2026-07-05
 
 ### 🚀 Features

package/Date.js

@@ -595,7 +595,10 @@ export function parseRaw(input) {
                         parseInt(timeParts[1] || "0", 10) * 60 +
                         parseFloat(timeParts[2] || "0");
                 if (m[3] != null && m[3].toUpperCase() === "PM" && hourPart < 12) {
-                    timeInSeconds += 720;
+                    timeInSeconds += 12 * 3600;
+                }
+                else if (m[3] != null && m[3].toUpperCase() === "AM" && hourPart === 12) {
+                    timeInSeconds -= 12 * 3600;
                 }
             }
             if (m[4] != null) { // There's an offset, parse as UTC
@@ -784,19 +787,9 @@ export function addYears(d, v) {
     return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);
 }
 export function addMonths(d, v) {
-    let newMonth = month(d) + v;
-    let newMonth_ = 0;
-    let yearOffset = 0;
-    if (newMonth > 12) {
-        newMonth_ = newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12);
-        newMonth = newMonth_;
-    }
-    else if (newMonth < 1) {
-        newMonth_ = 12 + newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
-        newMonth = newMonth_;
-    }
+    const totalMonths = month(d) + v;
+    const newMonth = ((totalMonths - 1) % 12 + 12) % 12 + 1;
+    const yearOffset = Math.floor((totalMonths - 1) / 12);
     const newYear = year(d) + yearOffset;
     const _daysInMonth = daysInMonth(newYear, newMonth);
     const newDay = Math.min(_daysInMonth, day(d));

package/DateOffset.js

@@ -203,27 +203,18 @@ export function addTicks(d, v) {
     return add(d, toFloat64(v / 10000n));
 }
 export function addYears(d, v) {
-    const newMonth = d.getUTCMonth() + 1;
-    const newYear = d.getUTCFullYear() + v;
+    const d2 = new Date(d.getTime() + offset(d));
+    const newMonth = d2.getUTCMonth() + 1;
+    const newYear = d2.getUTCFullYear() + v;
     const _daysInMonth = daysInMonth(newYear, newMonth);
-    const newDay = Math.min(_daysInMonth, d.getUTCDate());
-    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), offset(d));
+    const newDay = Math.min(_daysInMonth, d2.getUTCDate());
+    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), offset(d));
 }
 export function addMonths(d, v) {
     const d2 = new Date(d.getTime() + offset(d));
-    let newMonth = d2.getUTCMonth() + 1 + v;
-    let newMonth_ = 0;
-    let yearOffset = 0;
-    if (newMonth > 12) {
-        newMonth_ = newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12);
-        newMonth = newMonth_;
-    }
-    else if (newMonth < 1) {
-        newMonth_ = 12 + newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
-        newMonth = newMonth_;
-    }
+    const totalMonths = d2.getUTCMonth() + 1 + v;
+    const newMonth = ((totalMonths - 1) % 12 + 12) % 12 + 1;
+    const yearOffset = Math.floor((totalMonths - 1) / 12);
     const newYear = d2.getUTCFullYear() + yearOffset;
     const _daysInMonth = daysInMonth(newYear, newMonth);
     const newDay = Math.min(_daysInMonth, d2.getUTCDate());

package/Double.js

@@ -31,15 +31,21 @@ export function isInfinity(x) {
     return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;
 }
 export function max(x, y) {
-    return x > y ? x : y;
+    return Math.max(x, y);
 }
 export function min(x, y) {
-    return x < y ? x : y;
+    return Math.min(x, y);
 }
 export function maxMagnitude(x, y) {
+    if (Number.isNaN(x) || Number.isNaN(y)) {
+        return NaN;
+    }
     return Math.abs(x) > Math.abs(y) ? x : y;
 }
 export function minMagnitude(x, y) {
+    if (Number.isNaN(x) || Number.isNaN(y)) {
+        return NaN;
+    }
     return Math.abs(x) < Math.abs(y) ? x : y;
 }
 export function clamp(x, min, max) {

package/Event.js

@@ -18,8 +18,17 @@ export class Event$2 {
         return createEvent(h => { this._add(h); }, h => { this._remove(h); });
     }
     Trigger(senderOrValue, valueOrUndefined) {
+        // Disambiguate the overloads by arity, not by value: a two-argument call may
+        // legitimately pass `undefined` as the event value (e.g. unit events).
         let sender = null;
-        const value = valueOrUndefined === undefined ? senderOrValue : (sender = senderOrValue, valueOrUndefined);
+        let value;
+        if (arguments.length <= 1) {
+            value = senderOrValue;
+        }
+        else {
+            sender = senderOrValue;
+            value = valueOrUndefined;
+        }
         this.delegates.forEach(f => { f(sender, value); });
     }
 }

package/List.js

@@ -1,7 +1,6 @@
-import { join } from "./String.js";
+import { isArrayLike, Exception, defaultOf, toIterator, compare, structuralHash, equals, disposeSafe, getEnumerator } from "./Util.js";
+import { Record, toString } from "./Types.js";
 import { defaultArg, some, value as value_1 } from "./Option.js";
-import { disposeSafe, isArrayLike, Exception, defaultOf, toIterator, getEnumerator, compare, structuralHash, equals } from "./Util.js";
-import { Record } from "./Types.js";
 import { class_type, record_type, option_type } from "./Reflection.js";
 import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.js";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.js";
@@ -15,7 +14,21 @@ export class FSharpList extends Record {
     }
     toString() {
         const xs = this;
-        return ("[" + join("; ", xs)) + "]";
+        let result = "[";
+        let first = true;
+        const enumerator = getEnumerator(xs);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let x = undefined, matchValue = undefined, s = undefined;
+                const x_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                result = ((first ? result : (result + "; ")) + ((x = x_1, (matchValue = x, (typeof matchValue === "string") ? ((s = matchValue, ("\"" + s) + "\"")) : toString(x)))));
+                first = false;
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        return result + "]";
     }
     Equals(other) {
         const xs = this;

package/Long.js

@@ -1,37 +1,28 @@
 import { getPrefix, isValid } from "./Int32.js";
 import { fromString } from "./BigInt.js";
 import { Exception } from "./Util.js";
-function getMaxValue(unsigned, radix, isNegative) {
-    switch (radix) {
-        case 2: return unsigned ?
-            "1111111111111111111111111111111111111111111111111111111111111111" :
-            (isNegative ? "1000000000000000000000000000000000000000000000000000000000000000"
-                : "111111111111111111111111111111111111111111111111111111111111111");
-        case 8: return unsigned ?
-            "1777777777777777777777" :
-            (isNegative ? "1000000000000000000000" : "777777777777777777777");
-        case 10: return unsigned ?
-            "18446744073709551615" :
-            (isNegative ? "9223372036854775808" : "9223372036854775807");
-        case 16: return unsigned ?
-            "FFFFFFFFFFFFFFFF" :
-            (isNegative ? "8000000000000000" : "7FFFFFFFFFFFFFFF");
-        default: throw new Exception("Invalid radix.");
+function getRange(unsigned, bitsize) {
+    switch (bitsize) {
+        case 64: return unsigned ?
+            [0n, 18446744073709551615n] :
+            [-9223372036854775808n, 9223372036854775807n];
+        default: throw new Exception("Invalid bit size.");
     }
 }
-export function parse(str, style, unsigned, _bitsize, radix) {
+export function parse(str, style, unsigned, bitsize, radix) {
     const res = isValid(str, style, radix);
     if (res != null) {
-        const lessOrEqual = (x, y) => {
-            const len = Math.max(x.length, y.length);
-            return x.padStart(len, "0") <= y.padStart(len, "0");
-        };
-        const isNegative = res.sign === "-";
-        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);
-        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {
-            str = getPrefix(res.radix) + res.digits;
-            str = isNegative ? res.sign + str : str;
-            return fromString(str);
+        let v = fromString(getPrefix(res.radix) + res.digits);
+        if (res.sign === "-") {
+            v = -v;
+        }
+        const [umin, umax] = getRange(true, bitsize);
+        if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {
+            v = BigInt.asIntN(bitsize, v);
+        }
+        const [min, max] = getRange(unsigned, bitsize);
+        if (v >= min && v <= max) {
+            return v;
         }
     }
     throw new Exception(`The input string ${str} was not in a correct format.`);

package/MailboxProcessor.js

@@ -27,7 +27,9 @@ class MailboxQueue {
             else {
                 delete this.firstAndLast;
             }
-            return value;
+            // Wrap the value so falsy messages (0, false, "", null, undefined/unit)
+            // can be distinguished from an empty queue.
+            return { value };
         }
         return void 0;
     }
@@ -41,11 +43,11 @@ export class MailboxProcessor {
 }
 function __processEvents($this) {
     if ($this.continuation) {
-        const value = $this.messages.tryGet();
-        if (value) {
+        const dequeued = $this.messages.tryGet();
+        if (dequeued !== void 0) {
             const cont = $this.continuation;
             delete $this.continuation;
-            cont(value);
+            cont(dequeued.value);
         }
     }
 }
@@ -67,15 +69,19 @@ export function post($this, message) {
 }
 export function postAndAsyncReply($this, buildMessage) {
     let result;
+    // Use an explicit flag because the reply value itself may be undefined
+    // (e.g. AsyncReplyChannel<unit>), which must still complete the async.
+    let replied = false;
     let continuation;
     function checkCompletion() {
-        if (result !== void 0 && continuation !== void 0) {
+        if (replied && continuation !== void 0) {
             continuation(result);
         }
     }
     const reply = {
         reply: (res) => {
             result = res;
+            replied = true;
             checkCompletion();
         },
     };

package/Observable.js

@@ -1,5 +1,5 @@
 import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
-import { value } from "./Option.js";
+import { some, value } from "./Option.js";
 export class Observer {
     constructor(onNext, onError, onCompleted) {
         this.OnNext = onNext;
@@ -29,7 +29,7 @@ export function choose(chooser, source) {
     } }, observer.OnError), observer.OnError, observer.OnCompleted)));
 }
 export function filter(predicate, source) {
-    return choose((x) => predicate(x) ? x : void 0, source);
+    return choose((x) => predicate(x) ? some(x) : undefined, source);
 }
 export function map(mapping, source) {
     return new Observable((observer) => source.Subscribe(new Observer((t) => {
@@ -84,11 +84,13 @@ export function merge(source1, source2) {
 export function pairwise(source) {
     return new Observable((observer) => {
         let last;
+        let haveLast = false;
         return source.Subscribe(new Observer((next) => {
-            if (last != null) {
+            if (haveLast) {
                 observer.OnNext([last, next]);
             }
             last = next;
+            haveLast = true;
         }, observer.OnError, observer.OnCompleted));
     });
 }

package/RegExp.js

@@ -105,29 +105,38 @@ export function replace(reg, input, replacement, limit, offset = 0) {
         input = tmp;
         limit = undefined;
     }
-    if (typeof replacement === "function") {
-        limit = limit == null ? -1 : limit;
-        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
-    }
-    else {
-        replacement =
-            replacement
-                // $0 doesn't work with JS regex, see #1155
-                .replace(/\$0/g, (_s) => "$&")
-                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)
-                .replace(/\${([^}]+)}/g, "\$<$1>");
-        if (limit != null) {
-            let m;
-            const sub1 = input.substring(offset);
-            const _matches = matches(reg, sub1);
-            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;
-            return input.substring(0, offset) + sub2.replace(reg, replacement)
-                + input.substring(offset + sub2.length);
-        }
-        else {
-            return input.replace(reg, replacement);
-        }
+    if (typeof replacement === "string") {
+        const rep = replacement;
+        // .NET replacement patterns cannot be rewritten as JS replacement strings unambiguously
+        // (e.g. `$$0` must stay literal "$0", `$0` doesn't work with JS regex (see #1155), and
+        // `${1}` followed by a digit must not become `$1` + digit), so interpret them with an
+        // evaluator instead, honoring the `$$` escape left-to-right
+        replacement = (match) => rep.replace(/\$(?:(\$)|(&)|(`)|(')|(\d+)|\{(\d+)\}|\{([^}]+)\})/g, (s, dollar, and, before, after, num, numBraced, name) => {
+            if (dollar != null) {
+                return "$";
+            }
+            if (and != null) {
+                return match[0];
+            }
+            if (before != null) {
+                return match.input.substring(0, match.index);
+            }
+            if (after != null) {
+                return match.input.substring(match.index + match[0].length);
+            }
+            const n = num ?? numBraced;
+            if (n != null) {
+                const i = parseInt(n, 10);
+                // Same as .NET: an unmatched group is replaced by an empty string,
+                // a nonexistent group number keeps the substitution pattern literally
+                return i < match.length ? (match[i] ?? "") : s;
+            }
+            // Named groups are `${name}` in .NET (in regex: groups are `(?<name>...)` in both)
+            return match.groups != null && name in match.groups ? (match.groups[name] ?? "") : s;
+        });
     }
+    limit = limit == null ? -1 : limit;
+    return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
 }
 export function split(reg, input, limit, offset = 0) {
     if (typeof reg === "string") {
@@ -136,6 +145,26 @@ export function split(reg, input, limit, offset = 0) {
         input = tmp;
         limit = undefined;
     }
-    input = input.substring(offset);
-    return input.split(reg, limit);
+    // JS String.split(regex, limit) truncates the result and discards the remainder,
+    // whereas .NET keeps it in the last element (`limit` is the max number of elements),
+    // keeps the text before `offset` in the first element and includes the values of
+    // matched capture groups, so iterate the matches manually like .NET Regex.Split does
+    const result = [];
+    let prev = 0;
+    let count = limit == null ? -1 : limit - 1;
+    for (const m of matches(reg, input, offset)) {
+        if (count === 0) {
+            break;
+        }
+        result.push(input.substring(prev, m.index));
+        prev = m.index + m[0].length;
+        for (let i = 1; i < m.length; i++) {
+            if (m[i] !== undefined) {
+                result.push(m[i]);
+            }
+        }
+        count--;
+    }
+    result.push(input.substring(prev));
+    return result;
 }

package/Seq.js

@@ -457,6 +457,93 @@ export function enumerateUsing(resource, source) {
 export function enumerateWhile(guard, xs) {
     return concat(unfold((i) => (guard() ? [xs, i + 1] : undefined), 0));
 }
+export function enumerateTryWith(source, catchFilter, catchHandler) {
+    return mkSeq(() => {
+        let e = undefined;
+        let caught = false;
+        let started = false;
+        let finished = false;
+        let curr = undefined;
+        const tryNext = () => {
+            try {
+                let en_2;
+                if (e == null) {
+                    const en_1 = getEnumerator(source);
+                    e = en_1;
+                    en_2 = en_1;
+                }
+                else {
+                    en_2 = value_1(e);
+                }
+                if (en_2["System.Collections.IEnumerator.MoveNext"]()) {
+                    curr = some(en_2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+                    return true;
+                }
+                else {
+                    finished = true;
+                    return false;
+                }
+            }
+            catch (matchValue) {
+                if (!caught) {
+                    const ex_1 = matchValue;
+                    if (catchFilter(ex_1) !== 0) {
+                        caught = true;
+                        if (e == null) {
+                        }
+                        else {
+                            const en_3 = value_1(e);
+                            try {
+                                disposeSafe(en_3);
+                            }
+                            catch (matchValue_1) {
+                            }
+                            e = undefined;
+                        }
+                        e = getEnumerator(catchHandler(ex_1));
+                        return tryNext();
+                    }
+                    else {
+                        throw matchValue;
+                    }
+                }
+                else {
+                    throw matchValue;
+                }
+            }
+        };
+        return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+            if (!started) {
+                Enumerator_notStarted();
+            }
+            else if (finished) {
+                Enumerator_alreadyFinished();
+            }
+            if (curr != null) {
+                return value_1(curr);
+            }
+            else {
+                return Enumerator_alreadyFinished();
+            }
+        }, () => {
+            if (!started) {
+                started = true;
+            }
+            if (finished) {
+                return false;
+            }
+            else {
+                return tryNext();
+            }
+        }, () => {
+            if (e == null) {
+            }
+            else {
+                disposeSafe(value_1(e));
+            }
+        });
+    });
+}
 export function filter(f, xs) {
     return choose((x) => {
         if (f(x)) {

package/Set.js

@@ -1,10 +1,9 @@
 import { record_type, bool_type, list_type, option_type, class_type } from "./Reflection.js";
 import { some, value as value_2 } from "./Option.js";
 import { structuralHash, toIterator, disposeSafe, getEnumerator, isArrayLike, Exception } from "./Util.js";
-import { Record } from "./Types.js";
+import { toString, Record } from "./Types.js";
 import { fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1, FSharpList } from "./List.js";
 import { fold as fold_1, fill, setItem } from "./Array.js";
-import { join } from "./String.js";
 import { NotSupportedException_$ctor_Z721C83C5 } from "./System.js";
 import { skip, truncate, iterateIndexed, exists as exists_1, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from "./Seq.js";
 import { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from "./MutableSet.js";
@@ -1402,7 +1401,21 @@ export class FSharpSet {
     }
     toString() {
         const this$ = this;
-        return ("set [" + join("; ", this$)) + "]";
+        let result = "set [";
+        let first = true;
+        const enumerator = getEnumerator(this$);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let x = undefined, matchValue = undefined, s = undefined;
+                const x_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                result = ((first ? result : (result + "; ")) + ((x = x_1, (matchValue = x, (typeof matchValue === "string") ? ((s = matchValue, ("\"" + s) + "\"")) : toString(x)))));
+                first = false;
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        return result + "]";
     }
     get [Symbol.toStringTag]() {
         return "FSharpSet";

package/String.js

@@ -80,7 +80,7 @@ export function endsWith(str, pattern, ic) {
         return str.endsWith(pattern);
     }
     if (str.length >= pattern.length) {
-        return cmp(str.slice(-pattern.length), pattern, ic) === 0;
+        return cmp(str.slice(str.length - pattern.length), pattern, ic) === 0;
     }
     return false;
 }
@@ -239,6 +239,9 @@ function formatReplacement(rep, flags, padLength, precision, format) {
     else if (rep instanceof Date) {
         rep = dateToString(rep);
     }
+    else if (format === "A" && typeof rep === "string") {
+        rep = "\"" + rep + "\"";
+    }
     else {
         rep = toString(rep);
     }

package/Types.js

@@ -4,19 +4,25 @@ export function seqToString(self) {
     let str = "[";
     for (const x of self) {
         if (count === 0) {
-            str += toString(x);
+            str += toStringQuoted(x);
         }
         else if (count === 100) {
             str += "; ...";
             break;
         }
         else {
-            str += "; " + toString(x);
+            str += "; " + toStringQuoted(x);
         }
         count++;
     }
     return str + "]";
 }
+// Structured (%A-style) rendering of a value used as an element/field of a
+// container. F#'s structured formatting (which records, unions, lists, etc.
+// use in their ToString) quotes strings, e.g. `["a"; "b"]` and `{ Name = "John" }`.
+function toStringQuoted(x, callStack = 0) {
+    return typeof x === "string" ? "\"" + x + "\"" : toString(x, callStack);
+}
 export function toString(x, callStack = 0) {
     if (x != null && typeof x === "object") {
         if (typeof x.toString === "function" && x.toString !== Object.prototype.toString) {
@@ -29,19 +35,13 @@ export function toString(x, callStack = 0) {
             const cons = Object.getPrototypeOf(x)?.constructor;
             return cons === Object && callStack < 10
                 // Same format as recordToString
-                ? "{ " + Object.entries(x).map(([k, v]) => k + " = " + toString(v, callStack + 1)).join("\n  ") + " }"
+                ? "{ " + Object.entries(x).map(([k, v]) => k + " = " + toStringQuoted(v, callStack + 1)).join("\n  ") + " }"
                 : cons?.name ?? "";
         }
     }
     return String(x);
 }
 export function unionToString(name, fields) {
-    function unionFieldToString(x) {
-        if (typeof x === "string") {
-            return '"' + x + '"';
-        }
-        return toString(x);
-    }
     if (fields.length === 0) {
         return name;
     }
@@ -49,11 +49,11 @@ export function unionToString(name, fields) {
         let fieldStr;
         let withParens = true;
         if (fields.length === 1) {
-            fieldStr = unionFieldToString(fields[0]);
+            fieldStr = toStringQuoted(fields[0]);
             withParens = fieldStr.indexOf(" ") >= 0;
         }
         else {
-            fieldStr = fields.map((x) => unionFieldToString(x)).join(", ");
+            fieldStr = fields.map((x) => toStringQuoted(x)).join(", ");
         }
         return name + (withParens ? " (" : " ") + fieldStr + (withParens ? ")" : "");
     }
@@ -111,7 +111,7 @@ function recordToJSON(self) {
     return o;
 }
 function recordToString(self) {
-    return "{ " + Object.entries(self).map(([k, v]) => k + " = " + toString(v)).join("\n  ") + " }";
+    return "{ " + Object.entries(self).map(([k, v]) => k + " = " + toStringQuoted(v)).join("\n  ") + " }";
 }
 function recordGetHashCode(self) {
     const hashes = Object.values(self).map((v) => structuralHash(v));

package/Util.js

@@ -404,7 +404,18 @@ export function compareDates(x, y) {
     return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);
 }
 export function comparePrimitives(x, y) {
-    return x === y ? 0 : (x < y ? -1 : 1);
+    if (x === y) {
+        return 0;
+    }
+    if (x < y) {
+        return -1;
+    }
+    if (x > y) {
+        return 1;
+    }
+    // Neither equal nor ordered: at least one operand is NaN.
+    // Match .NET Double.CompareTo: NaN equals NaN and is less than any other value.
+    return Number.isNaN(x) ? (Number.isNaN(y) ? 0 : -1) : 1;
 }
 export function compareArraysWith(x, y, comp) {
     if (x == null) {
@@ -466,7 +477,7 @@ export function compare(x, y) {
         return isArrayLike(y) ? compareArrays(x, y) : -1;
     }
     else if (typeof x !== "object") {
-        return x < y ? -1 : 1;
+        return comparePrimitives(x, y);
     }
     else if (x instanceof Date) {
         return y instanceof Date ? compareDates(x, y) : -1;

package/package.json

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