@fable-org/fable-library-js 2.8.1 → 2.10.0

package/Async.js

@@ -2,8 +2,8 @@ import { OperationCanceledException, Trampoline } from "./AsyncBuilder.js";
 import { CancellationToken } from "./AsyncBuilder.js";
 import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
 import { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
-import { TimeoutException_$ctor } from "./System.js";
-import { Exception } from "./Util.js";
+import { ArgumentException_$ctor_Z384F8060, InvalidOperationException_$ctor_Z721C83C5, TimeoutException_$ctor } from "./System.js";
+import { Exception, ensureErrorOrException } from "./Util.js";
 function emptyContinuation(_x) {
     // NOP
 }
@@ -44,27 +44,43 @@ export function throwIfCancellationRequested(token) {
         throw new Exception("Operation is cancelled");
     }
 }
+// The parent keeps the listener until unlink is called
+function createLinkedToken(parent) {
+    const token = new CancellationToken();
+    const id = parent.addListener(() => token.cancel());
+    return [token, () => { parent.removeListener(id); }];
+}
 export function startChild(computation, ms) {
     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);
+        const timeout = ms == null || ms === -1 ? undefined : ms;
+        const [childToken, unlink] = timeout === undefined
+            ? [ctx.cancelToken, () => { }]
+            : createLinkedToken(ctx.cancelToken);
+        const promise = startAsPromise(computation, childToken);
+        let settled = false;
+        const onSettled = () => { settled = true; unlink(); };
+        // Without a rejection handler an unawaited child's failure is an unhandled rejection
+        promise.then(onSettled, onSettled);
+        // Like .NET, the timeout only runs while the result is awaited, not from the start of the child
+        const awaitResult = () => timeout === undefined || settled ? promise : new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                // .NET doesn't cancel the child when the timeout is 0
+                if (timeout !== 0) {
+                    try {
+                        childToken.cancel();
+                    }
+                    catch (error) {
+                        reject(error);
+                        return;
+                    }
+                }
+                reject(TimeoutException_$ctor());
+            }, timeout);
+            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
-        protectedReturn(awaitPromise(promiseToRun))(ctx);
+        protectedReturn(protectedCont((awaitCtx) => awaitPromise(awaitResult())(awaitCtx)))(ctx);
     });
 }
 export function awaitPromise(p) {
@@ -107,15 +123,179 @@ export function catchAsync(work) {
         });
     });
 }
+export function tryCancelled(computation, compensation) {
+    return (ctx) => {
+        // invariant: install the handler without adding a cancellation checkpoint, including for nested handlers
+        computation({
+            ...ctx,
+            onCancel: (error) => {
+                // decision: preserve the original cancellation even when compensation throws, matching .NET
+                try {
+                    compensation(error);
+                }
+                catch { /* Cancellation takes precedence. */ }
+                if (ctx.trampoline.incrementAndCheck()) {
+                    ctx.trampoline.hijack(() => ctx.onCancel(error));
+                }
+                else {
+                    ctx.onCancel(error);
+                }
+            },
+        });
+    };
+}
 export function fromContinuations(f) {
-    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+    return (ctx) => {
+        let settled = false;
+        const claim = () => {
+            if (settled) {
+                throw InvalidOperationException_$ctor_Z721C83C5("A continuation was invoked more than once");
+            }
+            settled = true;
+        };
+        const success = (x) => { claim(); ctx.onSuccess(x); };
+        const error = (x) => { claim(); ctx.onError(x); };
+        const cancelled = (x) => { claim(); ctx.onCancel(x); };
+        protectedCont(() => f([success, error, cancelled]))({
+            onSuccess: success,
+            onError: (x) => { if (settled) {
+                throw x;
+            } error(x); },
+            onCancel: cancelled,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    };
 }
 export function ignore(computation) {
     return protectedBind(computation, (_x) => protectedReturn(void 0));
 }
-export function parallel(computations) {
-    // 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 parallel(computations, maxDegreeOfParallelism) {
+    if (maxDegreeOfParallelism != null && maxDegreeOfParallelism < 1) {
+        throw ArgumentException_$ctor_Z384F8060(`maxDegreeOfParallelism must be positive, was ${maxDegreeOfParallelism}`, "maxDegreeOfParallelism");
+    }
+    return protectedCont((ctx) => awaitPromise(runParallel(Array.from(computations), maxDegreeOfParallelism, ctx.cancelToken))(ctx));
+}
+function runParallel(computations, limit, parentToken) {
+    return new Promise((resolve, reject) => {
+        const count = computations.length;
+        const results = new Array(count);
+        const [token, unlink] = createLinkedToken(parentToken);
+        let next = 0;
+        let running = 0;
+        let failed = false;
+        let failure;
+        const startNext = () => {
+            const i = next++;
+            running++;
+            startAsPromise(computations[i], token)
+                .then((x) => { results[i] = x; }, (err) => {
+                if (!failed) {
+                    failed = true;
+                    failure = err;
+                    try {
+                        token.cancel();
+                    }
+                    catch (error) {
+                        failure = error;
+                    }
+                }
+            })
+                .then(() => {
+                running--;
+                if (!failed && next < count) {
+                    startNext();
+                }
+                else if (running === 0) {
+                    unlink();
+                    if (failed) {
+                        reject(failure);
+                    }
+                    else {
+                        resolve(results);
+                    }
+                }
+            });
+        };
+        if (count === 0) {
+            unlink();
+            resolve(results);
+        }
+        const initial = Math.min(limit ?? count, count);
+        while (next < initial) {
+            startNext();
+        }
+    });
+}
+export function choice(computations) {
+    return protectedCont((ctx) => {
+        const works = Array.from(computations);
+        let remaining = works.length;
+        if (remaining === 0) {
+            ctx.onSuccess(undefined);
+            return;
+        }
+        const [token, unlink] = createLinkedToken(ctx.cancelToken);
+        let done = false;
+        const finish = (report) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            unlink();
+            try {
+                token.cancel();
+            }
+            catch (error) {
+                ctx.onError(ensureErrorOrException(error));
+                return;
+            }
+            report();
+        };
+        for (const work of works) {
+            startWithContinuations(work, (x) => {
+                if (x != null) {
+                    finish(() => ctx.onSuccess(x));
+                }
+                else if (--remaining === 0) {
+                    finish(() => ctx.onSuccess(undefined));
+                }
+            }, (err) => finish(() => ctx.onError(err)), (err) => finish(() => ctx.onCancel(err)), token);
+            if (done) {
+                break;
+            }
+        }
+    });
+}
+export function onCancel(interruption) {
+    return protectedCont((ctx) => {
+        const token = ctx.cancelToken;
+        let interrupted = false;
+        const interrupt = () => {
+            if (!interrupted) {
+                interrupted = true;
+                try {
+                    interruption();
+                }
+                catch { /* Ignored, like .NET Async.OnCancel */ }
+            }
+        };
+        const id = token.addListener(interrupt);
+        let disposed = false;
+        ctx.onSuccess({
+            Dispose() {
+                if (disposed) {
+                    return;
+                }
+                disposed = true;
+                token.removeListener(id);
+                // With use! Dispose runs inside cancel() before this listener gets its turn
+                if (token.isCancelled) {
+                    interrupt();
+                }
+            },
+        });
+    });
 }
 export function sequential(computations) {
     function _sequential(computations, cancelToken) {
@@ -175,3 +355,9 @@ export function startWithContinuations(computation, continuation, exceptionConti
 export function startAsPromise(computation, cancellationToken) {
     return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
 }
+export function startAsTask(computation, _taskCreationOptions, cancellationToken) {
+    return startAsPromise(computation, cancellationToken);
+}
+export function startImmediateAsTask(computation, cancellationToken) {
+    return startAsPromise(computation, cancellationToken);
+}

package/AsyncBuilder.js

@@ -174,9 +174,15 @@ export class AsyncBuilder {
         return computation;
     }
     TryFinally(computation, compensation) {
-        return protectedCont((ctx) => {
-            computation({
+        // The cancellation check in protectedCont must see the cleanup continuations
+        return (ctx) => {
+            let settled = false;
+            protectedCont(computation)({
                 onSuccess: (x) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
                     try {
                         compensation();
                     }
@@ -187,6 +193,10 @@ export class AsyncBuilder {
                     ctx.onSuccess(x);
                 },
                 onError: (x) => {
+                    if (settled) {
+                        throw x;
+                    }
+                    settled = true;
                     try {
                         compensation();
                     }
@@ -197,6 +207,10 @@ export class AsyncBuilder {
                     ctx.onError(x);
                 },
                 onCancel: (x) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
                     // decision: cancellation remains terminal when compensation throws, matching .NET Async.TryFinally
                     try {
                         compensation();
@@ -207,7 +221,7 @@ export class AsyncBuilder {
                 cancelToken: ctx.cancelToken,
                 trampoline: ctx.trampoline,
             });
-        });
+        };
     }
     TryWith(computation, catchHandler) {
         return protectedCont((ctx) => {
@@ -232,7 +246,8 @@ export class AsyncBuilder {
         });
     }
     Using(resource, binder) {
-        return this.TryFinally(binder(resource), () => resource.Dispose());
+        // Without Delay the binder runs before TryFinally installs Dispose
+        return this.TryFinally(this.Delay(() => binder(resource)), () => resource.Dispose());
     }
     While(guard, computation) {
         if (guard()) {

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: 148f989e1b37b3f6560c3dda615b6a3a8efffcb8
+last_commit_released: 2098f64a25e96385306ef19ed8c289f3b6c84db9
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,38 @@ 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.10.0 - 2026-10-22
+
+### 🚀 Features
+
+* *(js/ts)* Support System.Diagnostics.Stopwatch (#5100) ([eb68225f](https://github.com/fable-compiler/Fable/commit/eb68225ff74d1b455765d99998faa6fd3be32383))
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Round decimals below 0.1 correctly ([fca4c408](https://github.com/fable-compiler/Fable/commit/fca4c408a64e33c58293f12869975e5b61bcb96a))
+* *(js/ts)* Keep decimal zero scale without leading zeros ([3076b45a](https://github.com/fable-compiler/Fable/commit/3076b45acacf39b8c99ec57025560ad355ab74db))
+* *(js/ts)* Hash decimals by value in collections ([32a69e0d](https://github.com/fable-compiler/Fable/commit/32a69e0d00f567c9a838307e9ed51b3b1d519473))
+* *(js/ts)* Keep .NET decimal scale through arithmetic (#5126) ([bdf0a6c8](https://github.com/fable-compiler/Fable/commit/bdf0a6c8cb56151a5431b5e3703f7ee165b26dba))
+* *(js/ts)* Accept decimal integers up to 2^96 ([c9feb339](https://github.com/fable-compiler/Fable/commit/c9feb339fb8a4e98bebf17b3facdc42ecd22d628))
+* *(js/ts)* Align decimal conversion, parsing and G format ([6430cdac](https://github.com/fable-compiler/Fable/commit/6430cdacec34e6327434af649eb0c9427d65608c))
+* *(js/ts)* Add missing Async and Task members, cancel timed-out StartChild, bind Async in task { } (#5097) ([d063630d](https://github.com/fable-compiler/Fable/commit/d063630d58d62db21603d45a6bf54b172378c66e))
+* *(js/ts)* Respect maxDegreeOfParallelism and cancel on failure in Async.Parallel (#5098) ([5de3271d](https://github.com/fable-compiler/Fable/commit/5de3271d8b47f1752c4e74c010e4314cf40bbcbe))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/e33c57870454fea189a3eb33519f583a5003f8c3..2098f64a25e96385306ef19ed8c289f3b6c84db9)</small></strong>
+
+## 2.9.0 - 2026-10-16
+
+### 🚀 Features
+
+* *(js/ts/python/beam)* Support Async.TryCancelled (#5083) ([1643297d](https://github.com/fable-compiler/Fable/commit/1643297d9297fef536c8d10091d5b0d1fad77af7))
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Avoid full array copy in Encoding.GetString (#5069) ([e6b72ec7](https://github.com/fable-compiler/Fable/commit/e6b72ec73be454bd3b3233167542a65fc6553c8a))
+* *(js/ts/python)* Preserve cancelled cleanup and generic unit callbacks (#5062) ([5dd6b497](https://github.com/fable-compiler/Fable/commit/5dd6b4979e79c8f7c4632cbfb5254d6cf0d2e8d2))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/148f989e1b37b3f6560c3dda615b6a3a8efffcb8..e33c57870454fea189a3eb33519f583a5003f8c3)</small></strong>
+
 ## 2.8.1 - 2026-10-12
 
 ### 🐞 Bug Fixes

package/Decimal.js

@@ -1,11 +1,18 @@
 import Decimal from "./lib/big.js";
 import { symbol } from "./Numeric.js";
-import { FSharpRef } from "./Types.js";
 import { Exception, combineHashCodes } from "./Util.js";
 import { fromDecimal } from "./BigInt.js";
 import * as bigInt from "./BigInt.js";
 Decimal.prototype.GetHashCode = function () {
-    return combineHashCodes([this.s, this.e].concat(this.c));
+    const digits = this.c;
+    if (digits[0] === 0) {
+        return combineHashCodes([1, 0, 0]);
+    }
+    let end = digits.length;
+    while (digits[end - 1] === 0) {
+        end--;
+    }
+    return combineHashCodes([this.s, this.e].concat(digits.slice(0, end)));
 };
 Decimal.prototype.Equals = function (x) {
     return !this.cmp(x);
@@ -37,7 +44,7 @@ export function equals(x, y) {
 }
 export function abs(x) { return x.abs(); }
 export function sign(x) { return x.lt(get_Zero) ? -1 : x.gt(get_Zero) ? 1 : 0; }
-export function max(x, y) { return x.gt(y) ? x : y; }
+export function max(x, y) { return x.lt(y) ? y : x; }
 export function min(x, y) { return x.lt(y) ? x : y; }
 export function maxMagnitude(x, y) { return abs(x).gt(abs(y)) ? x : y; }
 export function minMagnitude(x, y) { return abs(x).lt(abs(y)) ? x : y; }
@@ -94,23 +101,79 @@ export const negate = op_UnaryNegation;
 export function toString(x) {
     return x.toString();
 }
-export function tryParse(str, defValue) {
+const NumberStyles = {
+    AllowLeadingWhite: 1,
+    AllowTrailingWhite: 2,
+    AllowLeadingSign: 4,
+    AllowTrailingSign: 8,
+    AllowParentheses: 16,
+    AllowDecimalPoint: 32,
+    AllowThousands: 64,
+    AllowExponent: 128,
+    AllowHexSpecifier: 512,
+    Number: 111,
+};
+// The digits of a decimal string once whitespace, sign and parentheses are stripped
+function digitsPattern(style) {
+    const integral = style & NumberStyles.AllowThousands ? "\\d+(?:,\\d+)*" : "\\d+";
+    const point = style & NumberStyles.AllowDecimalPoint ? "(?:\\.\\d*)?" : "";
+    const leadingPoint = style & NumberStyles.AllowDecimalPoint ? "|\\.\\d+" : "";
+    const exponent = style & NumberStyles.AllowExponent ? "(?:[eE][+-]?\\d+)?" : "";
+    return new RegExp(`^(?:${integral}${point}${leadingPoint})${exponent}$`);
+}
+// Returns undefined when the string does not have the format allowed by the style
+function parseWithStyle(str, style) {
+    if (style & NumberStyles.AllowHexSpecifier) {
+        throw new Exception("The number style AllowHexSpecifier is not supported on floating point data types.");
+    }
+    let s = str;
+    if (style & NumberStyles.AllowLeadingWhite) {
+        s = s.replace(/^\s+/, "");
+    }
+    if (style & NumberStyles.AllowTrailingWhite) {
+        s = s.replace(/\s+$/, "");
+    }
+    let negative = false;
+    if (style & NumberStyles.AllowParentheses && s.startsWith("(") && s.endsWith(")")) {
+        s = s.slice(1, -1);
+        negative = true;
+    }
+    if (style & NumberStyles.AllowLeadingSign && /^[+-]/.test(s)) {
+        negative = s[0] === "-" ? !negative : negative;
+        s = s.slice(1);
+    }
+    else if (style & NumberStyles.AllowTrailingSign && /[+-]$/.test(s)) {
+        negative = s[s.length - 1] === "-" ? !negative : negative;
+        s = s.slice(0, -1);
+    }
+    if (!digitsPattern(style).test(s)) {
+        return undefined;
+    }
+    const d = new Decimal(s.replace(/,/g, ""));
+    if (negative) {
+        d.s = -1;
+    }
+    return d;
+}
+export function tryParse(str, style, defValue) {
     try {
-        defValue.contents = new Decimal(str.trim());
+        const d = parseWithStyle(str, style);
+        if (d === undefined) {
+            return false;
+        }
+        defValue.contents = d;
         return true;
     }
     catch {
         return false;
     }
 }
-export function parse(str) {
-    const defValue = new FSharpRef(get_Zero);
-    if (tryParse(str, defValue)) {
-        return defValue.contents;
-    }
-    else {
+export function parse(str, style = NumberStyles.Number) {
+    const d = parseWithStyle(str, style);
+    if (d === undefined) {
         throw new Exception(`The input string ${str} was not in a correct format.`);
     }
+    return d;
 }
 export function toNumber(x) {
     return +x;
@@ -182,6 +245,32 @@ function getInt32Bits(hexDigits, offset) {
     }
     return bits;
 }
+const OVERFLOW = "Value was either too large or too small for a Decimal.";
+// The first double outside the decimal range
+const MAX_DOUBLE = 2 ** 96;
+function fromFloat(n, significantDigits) {
+    if (!isFinite(n) || Math.abs(n) >= MAX_DOUBLE) {
+        throw new Exception(OVERFLOW);
+    }
+    const exact = Math.abs(n) >= 1e21 ? BigInt(n).toString() : n.toFixed(100);
+    const d = new Decimal(exact).prec(significantDigits, 2);
+    const digits = d.c;
+    let end = digits.length;
+    while (end > 1 && digits[end - 1] === 0) {
+        end--;
+    }
+    d.c = digits.slice(0, end);
+    if (d.c[0] === 0) {
+        d.e = 0;
+    }
+    return d;
+}
+export function fromFloat64(n) {
+    return fromFloat(n, 15);
+}
+export function fromFloat32(n) {
+    return fromFloat(n, 7);
+}
 export function fromIntArray(bits) {
     return fromInts(bits[0], bits[1], bits[2], bits[3]);
 }

package/Encoding.js

@@ -90,6 +90,27 @@ function utf8_decode(bytes) {
     }
     return chars.join("");
 }
+function toUint8Array(bytes, index, count) {
+    if (ArrayBuffer.isView(bytes)) {
+        const buffer = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        if (index != null && count != null) {
+            return buffer.subarray(index, index + count);
+        }
+        else if (index != null) {
+            return buffer.subarray(index);
+        }
+        return buffer;
+    }
+    else {
+        if (index != null && count != null) {
+            return Uint8Array.from(Array.prototype.slice.call(bytes, index, index + count));
+        }
+        else if (index != null) {
+            return Uint8Array.from(Array.prototype.slice.call(bytes, index));
+        }
+        return Uint8Array.from(bytes);
+    }
+}
 class UTF16LE {
     getBytes(str, index, count) {
         str = Array.isArray(str) ? str.join("") : str;
@@ -111,14 +132,7 @@ class UTF16LE {
         }
     }
     getString(bytes, index, count) {
-        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
-        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-        if (index != null && count != null) {
-            buffer = buffer.subarray(index, index + count);
-        }
-        else if (index != null) {
-            buffer = buffer.subarray(index);
-        }
+        const buffer = toUint8Array(bytes, index, count);
         // Allow to compile for Browser environment without @types/node being installed
         // See https://github.com/fable-compiler/Fable/issues/4368
         const g = globalThis;
@@ -157,14 +171,7 @@ class UTF8 {
         }
     }
     getString(bytes, index, count) {
-        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
-        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-        if (index != null && count != null) {
-            buffer = buffer.subarray(index, index + count);
-        }
-        else if (index != null) {
-            buffer = buffer.subarray(index);
-        }
+        const buffer = toUint8Array(bytes, index, count);
         // Allow to compile for Browser environment without @types/node being installed
         // See https://github.com/fable-compiler/Fable/issues/4368
         const g = globalThis;

package/MailboxProcessor.js

@@ -96,6 +96,10 @@ export function postAndAsyncReply($this, buildMessage) {
     }
     const reply = {
         reply: (res) => {
+            // .NET AsyncReplyChannel.Reply ignores a second reply
+            if (replied) {
+                return;
+            }
             result = res;
             replied = true;
             checkCompletion();

package/Stopwatch.js

@@ -0,0 +1,65 @@
+// Timestamps are in microseconds, the resolution performance.now() can offer
+const ticksPerMillisecond = 1000;
+export class Stopwatch {
+    constructor() {
+        // Milliseconds measured before the last Start
+        this.elapsed = 0;
+        // performance.now() at the last Start, while running
+        this.startedAt = undefined;
+    }
+}
+export function create() {
+    return new Stopwatch();
+}
+export function startNew() {
+    const sw = new Stopwatch();
+    start(sw);
+    return sw;
+}
+export function start(sw) {
+    if (sw.startedAt === undefined) {
+        sw.startedAt = performance.now();
+    }
+}
+export function stop(sw) {
+    if (sw.startedAt !== undefined) {
+        sw.elapsed += performance.now() - sw.startedAt;
+        sw.startedAt = undefined;
+    }
+}
+export function reset(sw) {
+    sw.elapsed = 0;
+    sw.startedAt = undefined;
+}
+export function restart(sw) {
+    sw.elapsed = 0;
+    sw.startedAt = performance.now();
+}
+export function isRunning(sw) {
+    return sw.startedAt !== undefined;
+}
+function rawElapsedMilliseconds(sw) {
+    return sw.elapsed + (sw.startedAt === undefined ? 0 : performance.now() - sw.startedAt);
+}
+// In units of Frequency, like .NET (not TimeSpan ticks)
+export function elapsedTicks(sw) {
+    return BigInt(Math.trunc(rawElapsedMilliseconds(sw) * ticksPerMillisecond));
+}
+export function elapsedMilliseconds(sw) {
+    return elapsedTicks(sw) / BigInt(ticksPerMillisecond);
+}
+export function elapsedTotalMilliseconds(sw) {
+    return Number(elapsedTicks(sw)) / ticksPerMillisecond;
+}
+export function frequency() {
+    return BigInt(ticksPerMillisecond * 1000);
+}
+export function isHighResolution() {
+    return true;
+}
+export function getTimestamp() {
+    return BigInt(Math.trunc(performance.now() * ticksPerMillisecond));
+}
+export function getElapsedTotalMilliseconds(startingTimestamp, endingTimestamp) {
+    return Number((endingTimestamp ?? getTimestamp()) - startingTimestamp) / ticksPerMillisecond;
+}

package/String.js

@@ -426,6 +426,10 @@ export function format(str, ...args) {
                     break;
                 case "g":
                 case "G": {
+                    if (precision == null && typeof rep !== "number" && typeof rep !== "bigint") {
+                        rep = String(rep);
+                        break;
+                    }
                     rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);
                     // Handle exponential notation: only trim trailing zeros from mantissa, not from exponent.
                     // .NET G format guarantees an exponent of at least 2 digits with an explicit sign (e.g. "E-07").

package/Task.js

@@ -17,6 +17,28 @@ export function fromResult(value) {
 export function zero() {
     return Promise.resolve();
 }
+// Like .NET, -1 waits until the token is cancelled
+export function delay(millisecondsDelay, cancellationToken) {
+    return new Promise((resolve, reject) => {
+        if (cancellationToken?.isCancelled) {
+            reject(new OperationCanceledException());
+            return;
+        }
+        let tokenId;
+        const timeoutId = millisecondsDelay === -1 ? undefined : setTimeout(() => {
+            if (tokenId !== undefined) {
+                cancellationToken.removeListener(tokenId);
+            }
+            resolve();
+        }, millisecondsDelay);
+        if (cancellationToken != null) {
+            tokenId = cancellationToken.addListener(() => {
+                clearTimeout(timeoutId);
+                reject(new OperationCanceledException());
+            });
+        }
+    });
+}
 // Task<T> = Promise<T> in JS/TS. GetAwaiter/GetResult return the Promise itself;
 // callers should use Async.AwaitTask to extract the value in an async context.
 export function getAwaiter(t) {

package/big.d.ts

@@ -202,6 +202,7 @@ export interface Big extends CustomNumeric {
      * @throws `!Big.RM!` if rm is invalid.
      */
     round(dp?: number, rm?: RoundingMode): Big;
+    prec(sd: number, rm?: RoundingMode): Big;
     /**
      * Returns a Big number whose value is the square root of this Big number.
      *

package/lib/big.js

@@ -67,7 +67,6 @@ function _Big_() {
             x.s = n.s;
             x.e = n.e;
             x.c = n.c.slice();
-            normalize(x);
         }
         else {
             if (typeof n !== 'string') {
@@ -91,14 +90,6 @@ function _Big_() {
     Big.strict = STRICT;
     return Big;
 }
-function normalize(x) {
-    // x = round(x, DP, 0);
-    if (x.c.length > 1 && !x.c[0]) {
-        let i = x.c.findIndex(x => x);
-        x.c = x.c.slice(i);
-        x.e = x.e - i;
-    }
-}
 /*
  * Parse the number or string value passed to a Big constructor.
  *
@@ -128,15 +119,13 @@ function parse(x, n) {
         e = n.length;
     }
     nl = n.length;
-    // Determine leading zeros before decimal point.
-    for (i = 0; i < e && i < nl && n.charAt(i) == '0';)
+    // Determine leading zeros.
+    for (i = 0; i < nl && n.charAt(i) == '0';)
         ++i;
-    // original version (ignores decimal point).
-    // // Determine leading zeros.
-    // for (i = 0; i < nl && n.charAt(i) == '0';) ++i;
     if (i == nl) {
-        // Zero.
-        x.c = [x.e = 0];
+        // Zero, keeping the scale: 0.00 is c = [0], e = -2.
+        x.c = [0];
+        x.e = nl > e ? e - nl : 0;
     }
     else {
         x.e = e - i - 1;
@@ -150,8 +139,7 @@ function parse(x, n) {
         // // Convert string to array of digits without leading/trailing zeros.
         // for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
     }
-    x = round(x, Big.DP + 1, Big.RM);
-    return x;
+    return fit(x);
 }
 /*
  * Round Big x to a maximum of sd significant digits using rounding mode rm.
@@ -171,17 +159,11 @@ function round(x, sd, rm, more) {
     if (sd < 1) {
         more =
             rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 ||
-                rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));
+                rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc.some((d, i) => i > 0 && d))));
         xc.length = 1;
-        if (more) {
-            // 1, 0.1, 0.01, 0.001, 0.0001 etc.
-            x.e = x.e - sd + 1;
-            xc[0] = 1;
-        }
-        else {
-            // Zero.
-            xc[0] = x.e = 0;
-        }
+        // 1, 0.1, 0.01, 0.001, 0.0001 etc., or zero at the same place.
+        x.e = x.e - sd + 1;
+        xc[0] = more ? 1 : 0;
     }
     else if (sd < xc.length) {
         // xc[sd] is the digit after the digit that may be rounded up.
@@ -189,7 +171,7 @@ function round(x, sd, rm, more) {
         more =
             rm === 1 && xc[sd] >= 5 ||
                 rm === 2 && (xc[sd] > 5 || xc[sd] === 5 &&
-                    (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) ||
+                    (more || xc.some((d, i) => i > sd && d) || xc[sd - 1] & 1)) ||
                 rm === 3 && (more || !isZero);
         // Remove any digits after the required precision.
         xc.length = sd--;
@@ -204,14 +186,59 @@ function round(x, sd, rm, more) {
                 }
             }
         }
-        // Remove trailing zeros.
-        for (sd = xc.length; !xc[--sd];)
-            xc.pop();
     }
     return x;
 }
-function hasNonzeroDigit(x) {
-    return x.c.some(d => d !== 0);
+// Largest System.Decimal mantissa, 2^96 - 1.
+var MAX_MANTISSA = '79228162514264337593543950335'.split('').map(Number), OVERFLOW = 'Value was either too large or too small for a Decimal.';
+/*
+ * Return the number of decimal places of Big x.
+ */
+function scaleOf(x) {
+    return x.c.length - x.e - 1;
+}
+/*
+ * Pad Big x with trailing zeros up to dp decimal places.
+ */
+function padScale(x, dp) {
+    if (!x.c[0]) {
+        x.e = Math.min(x.e, -dp);
+    }
+    else {
+        for (; scaleOf(x) < dp;)
+            x.c.push(0);
+    }
+    return x;
+}
+/*
+ * Return true if the digits c, padded with zeros to the length of MAX_MANTISSA, exceed it.
+ */
+function exceedsMax(c) {
+    for (var i = 0; i < MAX_MANTISSA.length; i++) {
+        var d = i < c.length ? c[i] : 0;
+        if (d !== MAX_MANTISSA[i])
+            return d > MAX_MANTISSA[i];
+    }
+    return false;
+}
+/*
+ * Round Big x half to even so that it fits a System.Decimal: at most Big.DP decimal places
+ * and a mantissa no larger than MAX_MANTISSA. Throws when no decimal place is left to drop.
+ */
+function fit(x) {
+    var scale = scaleOf(x), dp = Math.min(scale, Big.DP, Big.DP - x.e);
+    if (x.e > Big.DP)
+        throw Error(OVERFLOW);
+    if (dp < scale)
+        round(x, x.e + 1 + dp, 2);
+    if (x.e > Big.DP)
+        throw Error(OVERFLOW);
+    // Both the value and the mantissa itself must not exceed MAX_MANTISSA.
+    if (x.e === Big.DP && exceedsMax(x.c))
+        throw Error(OVERFLOW);
+    if (x.c.length === MAX_MANTISSA.length && exceedsMax(x.c))
+        round(x, x.c.length - 1, 2);
+    return x;
 }
 /*
  * Return a string representing the value of Big x in normal or exponential notation.
@@ -221,6 +248,8 @@ function stringify(x, doExponential, isNonzero) {
     var e = x.e, s = x.c.join(''), n = s.length;
     // Exponential notation?
     if (doExponential) {
+        if (!x.c[0])
+            e = 0;
         s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;
         // Normal notation.
     }
@@ -292,20 +321,31 @@ P.cmp = function (y) {
  * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
  */
 P.div = function (y) {
-    var Big = this.constructor, x = new Big(this), y = new Big(y), a = x.c, // dividend
-    b = y.c, // divisor
-    k = x.s == y.s ? 1 : -1, dp = Big.DP;
+    var Big = this.constructor, dp = Big.DP;
     if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
         throw Error(INVALID_DP);
     }
+    return divide(new Big(this), new Big(y), dp, 2);
+};
+/*
+ * Return Big x divided by Big y to dp decimal places using rounding mode rm.
+ * Both are modified.
+ */
+function divide(x, y, dp, rm) {
+    var a = x.c, // dividend
+    b = y.c, // divisor
+    k = x.s == y.s ? 1 : -1;
     // Divisor is zero?
     if (!b[0]) {
         throw Error(DIV_BY_ZERO);
     }
+    // Scale of the exact quotient is at least the scale of x less the scale of y.
+    var minScale = Math.max(0, scaleOf(x) - scaleOf(y));
     // Dividend is 0? Return +-0.
     if (!a[0]) {
         y.s = k;
-        y.c = [y.e = 0];
+        y.c = [0];
+        y.e = -minScale;
         return y;
     }
     var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), // remainder
@@ -369,11 +409,20 @@ P.div = function (y) {
         q.e--;
         p--;
     }
+    var exact = r[0] === UNDEFINED;
     // Round?
     if (qi > p)
-        round(q, p, Big.RM, r[0] !== UNDEFINED);
+        round(q, p, rm, !exact);
+    fit(q);
+    if (!q.c[0]) {
+        q.e = 0;
+    }
+    else if (exact) {
+        for (; scaleOf(q) > minScale && !q.c[q.c.length - 1];)
+            q.c.pop();
+    }
     return q;
-};
+}
 /*
  * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
  */
@@ -420,6 +469,7 @@ P.minus = P.sub = function (y) {
     var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;
     // Either zero?
     if (!xc[0] || !yc[0]) {
+        var dp = Math.max(scaleOf(x), scaleOf(y));
         if (yc[0]) {
             y.s = -b;
         }
@@ -429,7 +479,7 @@ P.minus = P.sub = function (y) {
         else {
             y.s = 1;
         }
-        return y;
+        return padScale(y, dp);
     }
     // Determine which is the bigger number. Prepend zeros to equalise exponents.
     if (a = xe - ye) {
@@ -480,9 +530,8 @@ P.minus = P.sub = function (y) {
         }
         xc[j] -= yc[j];
     }
-    // Remove trailing zeros.
-    for (; xc[--b] === 0;)
-        xc.pop();
+    // The result keeps the larger scale.
+    var dp = xc.length - ye - 1;
     // Remove leading zeros and adjust exponent accordingly.
     for (; xc[0] === 0;) {
         xc.shift();
@@ -492,11 +541,12 @@ P.minus = P.sub = function (y) {
         // n - n = +0
         y.s = 1;
         // Result must be zero.
-        xc = [ye = 0];
+        xc = [0];
+        ye = -dp;
     }
     y.c = xc;
     y.e = ye;
-    return y;
+    return fit(y);
 };
 /*
  * Return a new Big whose value is the value of this Big modulo the value of Big y.
@@ -512,12 +562,7 @@ P.mod = function (y) {
     y.s = b;
     if (ygtx)
         return new Big(x);
-    a = Big.DP;
-    b = Big.RM;
-    Big.DP = Big.RM = 0;
-    x = x.div(y);
-    Big.DP = a;
-    Big.RM = b;
+    x = divide(x, new Big(y), 0, 0);
     return this.minus(x.times(y));
 };
 /*
@@ -533,6 +578,7 @@ P.plus = P.add = function (y) {
     var xe = x.e, xc = x.c, ye = y.e, yc = y.c;
     // Either zero?
     if (!xc[0] || !yc[0]) {
+        var dp = Math.max(scaleOf(x), scaleOf(y));
         if (!yc[0]) {
             if (xc[0]) {
                 y = new Big(x);
@@ -541,7 +587,7 @@ P.plus = P.add = function (y) {
                 y.s = x.s;
             }
         }
-        return y;
+        return padScale(y, dp);
     }
     xc = xc.slice();
     // Prepend zeros to equalise exponents.
@@ -575,12 +621,9 @@ P.plus = P.add = function (y) {
         xc.unshift(k);
         ++ye;
     }
-    // Remove trailing zeros.
-    for (e = xc.length; xc[--e] === 0;)
-        xc.pop();
     y.c = xc;
     y.e = ye;
-    return y;
+    return fit(y);
 };
 /*
  * Return a Big whose value is the value of this Big raised to the power n.
@@ -681,7 +724,9 @@ P.times = P.mul = function (y) {
     y.s = x.s == y.s ? 1 : -1;
     // Return signed 0 if either 0.
     if (!xc[0] || !yc[0]) {
-        y.c = [y.e = 0];
+        var dp = scaleOf(x) + scaleOf(y);
+        y.c = [0];
+        y.e = -dp;
         return y;
     }
     // Initialise exponent of result as x.e + y.e.
@@ -717,11 +762,8 @@ P.times = P.mul = function (y) {
         ++y.e;
     else
         c.shift();
-    // Remove trailing zeros.
-    for (i = c.length; !c[--i];)
-        c.pop();
     y.c = c;
-    return y;
+    return fit(y);
 };
 /*
  * Return a string representing the value of this Big in exponential notation rounded to dp fixed
@@ -731,7 +773,7 @@ P.times = P.mul = function (y) {
  * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
  */
 P.toExponential = function (dp, rm) {
-    var x = this, n = hasNonzeroDigit(x);
+    var x = this, n = x.c[0];
     if (dp !== UNDEFINED) {
         if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
             throw Error(INVALID_DP);
@@ -740,7 +782,7 @@ P.toExponential = function (dp, rm) {
         for (; x.c.length < dp;)
             x.c.push(0);
     }
-    return stringify(x, true, n);
+    return stringify(x, true, !!n);
 };
 /*
  * Return a string representing the value of this Big in normal notation rounded to dp fixed
@@ -758,13 +800,12 @@ P.toFixed = function (dp, rm) {
         if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
             throw Error(INVALID_DP);
         }
-        x = new x.constructor(x);
-        x = round(x, dp + x.e + 1, rm);
+        x = round(new x.constructor(x), dp + x.e + 1, rm);
         // x.e may have changed if the value is rounded up.
         for (dp = dp + x.e + 1; x.c.length < dp;)
             x.c.push(0);
     }
-    return stringify(x, false, hasNonzeroDigit(x));
+    return stringify(x, false, !!x.c[0]);
 };
 /*
  * Return a string representing the value of this Big.
@@ -774,7 +815,7 @@ P.toFixed = function (dp, rm) {
  */
 P.toJSON = P.toString = function () {
     var x = this, Big = x.constructor;
-    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, hasNonzeroDigit(x));
+    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);
 };
 /*
  * Return the value of this Big as a primitve number.
@@ -796,16 +837,18 @@ P.toNumber = function () {
  * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
  */
 P.toPrecision = function (sd, rm) {
-    var x = this, Big = x.constructor, n = hasNonzeroDigit(x);
+    var x = this, Big = x.constructor, n = x.c[0];
     if (sd !== UNDEFINED) {
         if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
             throw Error(INVALID + 'precision');
         }
         x = round(new Big(x), sd, rm);
+        if (!x.c[0])
+            x.e = 0;
         for (; x.c.length < sd;)
             x.c.push(0);
     }
-    return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, n);
+    return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);
 };
 /*
  * Return a string representing the value of this Big.

package/package.json

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