@fable-org/fable-library-js 2.3.0 → 2.4.1

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/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: c977d78b39225a51c7bd051a1fe363ed0ccbe201
+last_commit_released: d6ae6bd3790b57b31941a118cdffaeb6a59155c3
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,34 @@ 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.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
+
+* *(js/ts)* Add `System.IO.Path` and `System.IO.File` API support ([ec99fac5](https://github.com/fable-compiler/Fable/commit/ec99fac5fd7a9428ee54f66f878ef4edad0904cb))
+* *(js/ts/python)* Add Environment and Console.Error support ([6e082f95](https://github.com/fable-compiler/Fable/commit/6e082f955140676da3388a43b55378ea4ad20f1c))
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* DateTime.ToString() and %A are now consistent across all DateTimeKind values (#4714) ([de98b0e4](https://github.com/fable-compiler/Fable/commit/de98b0e466c8824b0ba8b941d20efae70d232abb))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/c977d78b39225a51c7bd051a1fe363ed0ccbe201..7f915f1dd66b9a5fbbd56f858b07d39b98519b65)</small></strong>
+
 ## 2.3.0 - 2026-06-30
 
 ### 🚀 Features

package/Date.js

@@ -478,7 +478,7 @@ function dateToString_Y(date) {
 function dateToStringWithKind(date, format) {
     const utc = date.kind === DateTimeKind.Utc;
     if (typeof format !== "string") {
-        return utc ? date.toUTCString() : date.toLocaleString();
+        return dateToString_d(date) + " " + dateToString_T(date);
     }
     else if (format.length === 1) {
         switch (format) {

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

@@ -0,0 +1,3 @@
+export function getEnvironmentVariable(name) {
+    return process.env[name];
+}

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

@@ -0,0 +1,27 @@
+// This library doesn't depend on @types/node (to stay browser-compatible),
+// so this Node.js built-in import can't be type-checked; the exported
+// functions below still declare their own types for callers to rely on.
+// @ts-ignore
+import { readFileSync, writeFileSync } from "node:fs";
+// byte[] is represented as a plain JS/TS array of numbers, not a typed array
+// (see e.g. BitConverter.ts), so convert the Buffer returned by readFileSync.
+export function readAllBytes(path) {
+    return Array.from(readFileSync(path));
+}
+export function readAllLines(path) {
+    const lines = readFileSync(path, "utf8").split(/\r\n|\r|\n/);
+    if (lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines;
+}
+export function readAllText(path) {
+    return readFileSync(path, "utf8");
+}
+export function writeAllBytes(path, bytes) {
+    // Convert back from the plain array representation to a typed array Node's fs accepts.
+    writeFileSync(path, Uint8Array.from(bytes));
+}
+export function writeAllLines(path, lines) {
+    writeFileSync(path, lines.join("\n"));
+}

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

@@ -0,0 +1,31 @@
+// This library doesn't depend on @types/node (to stay browser-compatible),
+// so these Node.js built-in imports can't be type-checked; the exported
+// functions below still declare their own types for callers to rely on.
+// @ts-ignore
+import { basename, extname, join } from "node:path";
+// @ts-ignore
+import { tmpdir } from "node:os";
+// @ts-ignore
+import { writeFileSync } from "node:fs";
+// Mirrors the format of .NET's Path.GetRandomFileName(): 8 random hex chars,
+// a dot, then 3 more random hex chars.
+export function getRandomFileName() {
+    const nameBytes = new Uint8Array(4);
+    crypto.getRandomValues(nameBytes);
+    const name = Array.from(nameBytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    const extBytes = new Uint8Array(2);
+    crypto.getRandomValues(extBytes);
+    const ext = Array.from(extBytes, (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 3);
+    return `${name}.${ext}`;
+}
+export function getFileNameWithoutExtension(path) {
+    return basename(path, extname(path));
+}
+export function hasExtension(path) {
+    return extname(path) !== "";
+}
+export function getTempFileName() {
+    const path = join(tmpdir(), getRandomFileName());
+    writeFileSync(path, "");
+    return path;
+}

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