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

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: 2098f64a25e96385306ef19ed8c289f3b6c84db9
+last_commit_released: ce886964cb4521dc4c01c8da089b97c9d9742814
 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.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

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,6 +1,8 @@
 import Decimal from "./lib/big.js";
 import { symbol } from "./Numeric.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 () {
@@ -101,56 +103,21 @@ export const negate = op_UnaryNegation;
 export function toString(x) {
     return x.toString();
 }
-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);
+    const parts = splitNumber(str, style);
+    if (parts === undefined) {
+        return undefined;
     }
-    else if (style & NumberStyles.AllowTrailingSign && /[+-]$/.test(s)) {
-        negative = s[s.length - 1] === "-" ? !negative : negative;
-        s = s.slice(0, -1);
+    let d;
+    try {
+        d = new Decimal(parts.digits);
     }
-    if (!digitsPattern(style).test(s)) {
-        return undefined;
+    catch {
+        // Fable's big.js fork throws for values outside the decimal range
+        throw OverflowException_$ctor_Z721C83C5(OVERFLOW);
     }
-    const d = new Decimal(s.replace(/,/g, ""));
-    if (negative) {
+    if (parts.negative) {
         d.s = -1;
     }
     return d;
@@ -169,9 +136,12 @@ export function tryParse(str, style, defValue) {
     }
 }
 export function parse(str, style = NumberStyles.Number) {
+    if (str == null) {
+        throw ArgumentNullException_$ctor_Z721C83C5("s");
+    }
     const d = parseWithStyle(str, style);
     if (d === undefined) {
-        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.`);
     }
     return d;
 }

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 {