@fable-org/fable-library-js 2.9.0 → 2.11.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 { InvalidOperationException_$ctor_Z721C83C5, 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) {
@@ -154,9 +170,132 @@ export function fromContinuations(f) {
 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) {
@@ -216,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/BigInt.js

@@ -1,5 +1,7 @@
+import { FSharpRef } from "./Types.js";
 import { fromParts, truncate } from "./Decimal.js";
 import { Exception, bigintHash } from "./Util.js";
+import { ArgumentNullException_$ctor_Z721C83C5, FormatException_$ctor_Z721C83C5 } from "./System.js";
 const isBigEndian = false;
 BigInt.prototype.toJSON = function () {
     return `${this.toString()}`;
@@ -151,17 +153,27 @@ export function toChar(x) {
     return String.fromCharCode(toUInt16(x));
 }
 export function toString(x) { return x.toString(); }
+// .NET's Integer style: white space, a sign and decimal digits, then NULs
+const integerRegex = /^[\t-\r ]*([+-]?\d+)[\t-\r ]*\0*$/;
 export function tryParse(s, res) {
-    try {
-        res.contents = BigInt(s);
+    const m = s == null ? null : integerRegex.exec(s);
+    if (m != null) {
+        res.contents = BigInt(m[1]);
         return true;
     }
-    catch (err) {
-        return false;
-    }
+    return false;
 }
 export function parse(s) {
-    return BigInt(s);
+    const res = new FSharpRef(zero);
+    if (tryParse(s, res)) {
+        return res.contents;
+    }
+    else if (s == null) {
+        throw ArgumentNullException_$ctor_Z721C83C5("value");
+    }
+    else {
+        throw FormatException_$ctor_Z721C83C5("The value could not be parsed.");
+    }
 }
 export function pow(x, n) {
     return x ** BigInt(n);

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: e33c57870454fea189a3eb33519f583a5003f8c3
+last_commit_released: ce886964cb4521dc4c01c8da089b97c9d9742814
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,57 @@ 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.11.0 - 2026-10-29
+
+### 🚀 Features
+
+* *(js/ts/python/dart/beam)* Support System.Array.BinarySearch and ResizeArray.BinarySearch (#5172) ([d332e7d4](https://github.com/fable-compiler/Fable/commit/d332e7d42c889f172bb9501f505292abf519752f))
+
+### 🐞 Bug Fixes
+
+* *(all)* Accept RegexOptions.NonBacktracking (#5178) ([a61ec8a1](https://github.com/fable-compiler/Fable/commit/a61ec8a1583830599a7ffb2dfb4d093e99902d4f))
+* *(js/ts)* Format DateTimeOffset in its own offset (#5171) ([04ddbd20](https://github.com/fable-compiler/Fable/commit/04ddbd2027e03f4cf7b0b22fe886fdabadf26d93))
+* *(js/ts)* Support %o in sprintf and interpolated strings (#5175) ([e13e7b0f](https://github.com/fable-compiler/Fable/commit/e13e7b0fdc16d26793833c77a11d242ccc61109b))
+* *(js/ts)* Parse numbers like .NET and raise its exception types (#5200) ([82e606e9](https://github.com/fable-compiler/Fable/commit/82e606e9f8567d9bdad743df1b5de6abbdda89b0))
+* *(js/ts)* Honor NumberStyles when parsing floats (#5217) ([82b935f3](https://github.com/fable-compiler/Fable/commit/82b935f3859b36923e5e0eb26771f860eadbe525))
+* *(js/ts/python/dart/beam)* Raise typed exceptions from invalidArg and invalidOp ([60f2f5b9](https://github.com/fable-compiler/Fable/commit/60f2f5b9fa0e6a26af0f3b4f3cddc2496f075ba3))
+* *(js/ts/python/dart/beam)* Align collection exception types with FSharp.Core (#5153) ([7d7ceb33](https://github.com/fable-compiler/Fable/commit/7d7ceb33afd85a25bf06dc703e9d4a471cbc3292))
+* *(js/ts/python/dart/beam)* Add FSharp.Core's argument checks to collection functions (#5154) ([5185e654](https://github.com/fable-compiler/Fable/commit/5185e6547416384fe85fcb0b0c1cf267708879db))
+
+### ⚡ Performance Improvements
+
+* *(js/ts)* Standard library combine numeric hash from snapshot of object instead of mapping (#5151) ([44495104](https://github.com/fable-compiler/Fable/commit/44495104b5c7ac65bfcea184d1305fd29f1db9b4))
+* *(js/ts)* Standard library remove .map result array from record hash using snapshot (#5150) ([0ceb5e9e](https://github.com/fable-compiler/Fable/commit/0ceb5e9ec5b470d00295a5cea9ead1c621c7858e))
+* *(js/ts)* Standard library one pass List.append builder (#5148) ([2ed9d6dd](https://github.com/fable-compiler/Fable/commit/2ed9d6dd0a372e5bcf53dfe24d786bf9b9256fd3))
+* *(js/ts)* List node as a class with a shared empty node (#5185) ([187f8985](https://github.com/fable-compiler/Fable/commit/187f89852413186b52d4ecdde55e1be7cf736785))
+* *(js/ts)* Check array bounds only on undefined reads (#5188) ([435fc0bb](https://github.com/fable-compiler/Fable/commit/435fc0bb008ff2ab7c14a08c7218be94f4735029))
+* *(js/ts)* Closure-free ref cells and out-arg value cells (#5189) ([91bca925](https://github.com/fable-compiler/Fable/commit/91bca925757356191c7e6e7a71cb3e8a1bc8d52d))
+* *(js/ts)* Keep the curried original on its adapter (#5191) ([bfb4a2a4](https://github.com/fable-compiler/Fable/commit/bfb4a2a4e3bb1b5bd4491955a1e1cb90c14050b6))
+* *(js/ts)* Walk arrays by index when enumerated as seq (#5192) ([d88621c3](https://github.com/fable-compiler/Fable/commit/d88621c3b9d6ce48a72dc09b86a6805f612ac185))
+* *(js/ts)* Hash unions without allocating (#5195) ([2b66a5d2](https://github.com/fable-compiler/Fable/commit/2b66a5d2184f3a35f0d73fb397ab902e300ac4bd))
+* *(js/ts)* Probe dictionary buckets without allocating (#5196) ([9517eafd](https://github.com/fable-compiler/Fable/commit/9517eafd93aa7b84061662a421b7a39a7269318b))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/2098f64a25e96385306ef19ed8c289f3b6c84db9..ce886964cb4521dc4c01c8da089b97c9d9742814)</small></strong>
+
+## 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

package/Date.js

@@ -376,7 +376,7 @@ function dateToISOStringWithOffset(dateWithOffset, offset) {
     return str.substring(0, str.length - 1) + dateOffsetToString(offset);
 }
 function dateToStringWithOffset(date, format) {
-    const d = new Date(date.getTime() + (date.offset ?? 0));
+    const d = DateTime(date.getTime() + (date.offset ?? 0), DateTimeKind.Utc);
     if (typeof format !== "string") {
         return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString((date.offset ?? 0));
     }

package/Decimal.js

@@ -1,11 +1,20 @@
 import Decimal from "./lib/big.js";
 import { symbol } from "./Numeric.js";
-import { FSharpRef } from "./Types.js";
 import { Exception, combineHashCodes } from "./Util.js";
+import { NumberStyles, splitNumber } from "./NumberStyles.js";
+import { ArgumentNullException_$ctor_Z721C83C5, FormatException_$ctor_Z721C83C5, OverflowException_$ctor_Z721C83C5 } from "./System.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 +46,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 +103,47 @@ export const negate = op_UnaryNegation;
 export function toString(x) {
     return x.toString();
 }
-export function tryParse(str, defValue) {
+// Returns undefined when the string does not have the format allowed by the style
+function parseWithStyle(str, style) {
+    const parts = splitNumber(str, style);
+    if (parts === undefined) {
+        return undefined;
+    }
+    let d;
+    try {
+        d = new Decimal(parts.digits);
+    }
+    catch {
+        // Fable's big.js fork throws for values outside the decimal range
+        throw OverflowException_$ctor_Z721C83C5(OVERFLOW);
+    }
+    if (parts.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;
+export function parse(str, style = NumberStyles.Number) {
+    if (str == null) {
+        throw ArgumentNullException_$ctor_Z721C83C5("s");
     }
-    else {
-        throw new Exception(`The input string ${str} was not in a correct format.`);
+    const d = parseWithStyle(str, style);
+    if (d === undefined) {
+        throw FormatException_$ctor_Z721C83C5(`The input string '${str}' was not in a correct format.`);
     }
+    return d;
 }
 export function toNumber(x) {
     return +x;
@@ -182,6 +215,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/Double.js

@@ -1,25 +1,40 @@
 import { FSharpRef } from "./Types.js";
-import { Exception } from "./Util.js";
-export function tryParse(str, defValue) {
-    // TODO: test if value is valid and in range
-    if (str != null && /\S/.test(str)) {
-        const v = +str.replace("_", "");
-        if (!Number.isNaN(v)) {
-            defValue.contents = v;
+import { ArgumentNullException_$ctor_Z721C83C5, FormatException_$ctor_Z721C83C5 } from "./System.js";
+import { NumberStyles, splitNumber } from "./NumberStyles.js";
+// .NET's NaN and infinity symbols, ignoring case, allowing a sign and trimmed like String.Trim
+const symbolRegex = /^[\t-\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]*(?:[+-]?nan|([+-]?)infinity)[\t-\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]*$/i;
+const defaultStyle = NumberStyles.Float | NumberStyles.AllowThousands;
+export function tryParse(str, style, defValue) {
+    if (str != null) {
+        const parts = splitNumber(str, style);
+        if (parts !== undefined) {
+            const value = Number.parseFloat(parts.digits);
+            defValue.contents = parts.negative ? -value : value;
+            return true;
+        }
+        const symbol = symbolRegex.exec(str);
+        if (symbol != null) {
+            defValue.contents = symbol[1] == null ? NaN : symbol[1] === "-" ? -Infinity : Infinity;
             return true;
         }
     }
     return false;
 }
-export function parse(str) {
+export function parse(str, style = defaultStyle) {
     const defValue = new FSharpRef(0);
-    if (tryParse(str, defValue)) {
+    if (tryParse(str, style, defValue)) {
         return defValue.contents;
     }
+    else if (str == null) {
+        throw ArgumentNullException_$ctor_Z721C83C5("s");
+    }
     else {
-        throw new Exception(`The input string ${str} was not in a correct format.`);
+        throw FormatException_$ctor_Z721C83C5(`The input string '${str}' was not in a correct format.`);
     }
 }
+export function parseIgnoringUnderscores(str) {
+    return parse(str == null ? str : str.replace(/_/g, ""), NumberStyles.Float);
+}
 // JS Number.isFinite function evals false for NaN
 export function isPositiveInfinity(x) {
     return x === Number.POSITIVE_INFINITY;

package/FSharp.Core.js

@@ -1,7 +1,7 @@
 import { disposeSafe, defaultOf, Exception, structuralHash, equals } from "./Util.js";
 import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
 import { nonNullValue } from "./Option.js";
-import { NullReferenceException_$ctor, ArgumentNullException_$ctor_Z721C83C5 } from "./System.js";
+import { NullReferenceException_$ctor, InvalidOperationException_$ctor_Z721C83C5, ArgumentException_$ctor_Z384F8060, ArgumentNullException_$ctor_Z721C83C5 } from "./System.js";
 import { FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
 import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
 export const LanguagePrimitives_GenericEqualityComparer = {
@@ -41,6 +41,12 @@ export function Operators_FailurePattern(exn) {
 export function Operators_NullArg(argumentName) {
     throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
 }
+export function Operators_InvalidArg(argumentName, message) {
+    throw ArgumentException_$ctor_Z384F8060(message, argumentName);
+}
+export function Operators_InvalidOp(message) {
+    throw InvalidOperationException_$ctor_Z721C83C5(message);
+}
 export function Operators_Using(resource, action) {
     try {
         return action(resource);

package/Global.js

@@ -1,5 +1,5 @@
 export const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
-export const SR_inputWasEmpty = "Collection was empty.";
+export const SR_inputWasEmpty = "The input list was empty.";
 export const SR_inputMustBeNonNegative = "The input must be non-negative.";
 export const SR_inputSequenceEmpty = "The input sequence was empty.";
 export const SR_inputSequenceTooLong = "The input sequence contains more than one element.";

package/Int32.js

@@ -1,4 +1,5 @@
 import { Exception } from "./Util.js";
+import { ArgumentNullException_$ctor_Z721C83C5, FormatException_$ctor_Z721C83C5, OverflowException_$ctor_Z721C83C5 } from "./System.js";
 export const NumberStyles = {
     // None: 0x00000000,
     // AllowLeadingWhite: 0x00000001,
@@ -87,7 +88,14 @@ export function isValid(str, style, radix) {
     }
     return null;
 }
+export function parseOverflow(unsigned, bitsize) {
+    const type = bitsize === 8 ? (unsigned ? "an unsigned byte" : "a signed byte") : (unsigned ? "a UInt" : "an Int") + bitsize;
+    return OverflowException_$ctor_Z721C83C5(`Value was either too large or too small for ${type}.`);
+}
 export function parse(str, style, unsigned, bitsize, radix) {
+    if (str == null) {
+        throw ArgumentNullException_$ctor_Z721C83C5("s");
+    }
     const res = isValid(str, style, radix);
     if (res != null) {
         let v = Number.parseInt(res.sign + res.digits, res.radix);
@@ -100,9 +108,10 @@ export function parse(str, style, unsigned, bitsize, radix) {
             if (v >= min && v <= max) {
                 return v;
             }
+            throw parseOverflow(unsigned, bitsize);
         }
     }
-    throw new Exception(`The input string ${str} was not in a correct format.`);
+    throw FormatException_$ctor_Z721C83C5(`The input string '${str}' was not in a correct format.`);
 }
 export function tryParse(str, style, unsigned, bitsize, defValue) {
     try {