@fable-org/fable-library-ts 2.1.1 → 2.3.0

package/Array.ts

@@ -47,7 +47,7 @@ export function getSubArray<T>(array: MutableArray<T>, start: int32, count: int3
 
 export function last<T>(array: MutableArray<T>): T {
     if (array.length === 0) {
-        throw new Exception("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty (Parameter \'array\')");
     }
     return item_2(array.length - 1, array);
 }
@@ -246,7 +246,7 @@ export function singleton<T>(value: T, cons?: any): MutableArray<T> {
 
 export function initialize<T>(count: int32, initializer: ((arg0: int32) => T), cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Exception("The input must be non-negative\\nParameter name: count");
+        throw new Exception("The input must be non-negative (Parameter \'count\')");
     }
     const result: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, count);
     for (let i = 0; i <= (count - 1); i++) {
@@ -271,7 +271,7 @@ export function pairwise<T>(array: MutableArray<T>): MutableArray<[T, T]> {
 
 export function replicate<T>(count: int32, initial: T, cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Exception("The input must be non-negative\\nParameter name: count");
+        throw new Exception("The input must be non-negative (Parameter \'count\')");
     }
     const result: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, count);
     for (let i = 0; i <= (result.length - 1); i++) {
@@ -313,7 +313,7 @@ export function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), ar
 
 export function skip<T>(count: int32, array: MutableArray<T>, cons?: any): MutableArray<T> {
     if (count > array.length) {
-        throw new Exception("count is greater than array length\\nParameter name: count");
+        throw new Exception("count is greater than array length (Parameter \'count\')");
     }
     if (count === array.length) {
         return Helpers_allocateArrayFromCons<T>(cons, 0);
@@ -340,10 +340,10 @@ export function skipWhile<T>(predicate: ((arg0: T) => boolean), array: MutableAr
 
 export function take<T>(count: int32, array: MutableArray<T>, cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Exception("The input must be non-negative\\nParameter name: count");
+        throw new Exception("The input must be non-negative (Parameter \'count\')");
     }
     if (count > array.length) {
-        throw new Exception("count is greater than array length\\nParameter name: count");
+        throw new Exception("count is greater than array length (Parameter \'count\')");
     }
     if (count === 0) {
         return Helpers_allocateArrayFromCons<T>(cons, 0);
@@ -854,7 +854,7 @@ export function zip3<T, U, V>(array1: MutableArray<T>, array2: MutableArray<U>,
 
 export function chunkBySize<T>(chunkSize: int32, array: MutableArray<T>): MutableArray<MutableArray<T>> {
     if (chunkSize < 1) {
-        throw new Exception("The input must be positive.\\nParameter name: size");
+        throw new Exception("The input must be positive. (Parameter \'size\')");
     }
     const result: MutableArray<T>[] = [];
     if (array.length > 0) {
@@ -871,7 +871,7 @@ export function chunkBySize<T>(chunkSize: int32, array: MutableArray<T>): Mutabl
 
 export function splitAt<T>(index: int32, array: MutableArray<T>): [MutableArray<T>, MutableArray<T>] {
     if ((index < 0) ? true : (index > array.length)) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return [array.slice(0, (0 + index)), array.slice(index)] as [MutableArray<T>, MutableArray<T>];
 }
@@ -984,9 +984,9 @@ export function exactlyOne<T>(array: MutableArray<T>): T {
         case 1:
             return item_2(0, array);
         case 0:
-            throw new Exception("The input sequence was empty\\nParameter name: array");
+            throw new Exception("The input sequence was empty (Parameter \'array\')");
         default:
-            throw new Exception("Input array too long\\nParameter name: array");
+            throw new Exception("Input array too long (Parameter \'array\')");
     }
 }
 
@@ -1001,7 +1001,7 @@ export function tryExactlyOne<T>(array: MutableArray<T>): Option<T> {
 
 export function head<T>(array: MutableArray<T>): T {
     if (array.length === 0) {
-        throw new Exception("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty (Parameter \'array\')");
     }
     else {
         return item_2(0, array);
@@ -1019,14 +1019,14 @@ export function tryHead<T>(array: MutableArray<T>): Option<T> {
 
 export function tail<T>(array: MutableArray<T>): MutableArray<T> {
     if (array.length === 0) {
-        throw new Exception("Not enough elements\\nParameter name: array");
+        throw new Exception("Not enough elements (Parameter \'array\')");
     }
     return array.slice(1);
 }
 
 export function item<T>(index: int32, array: MutableArray<T>): T {
     if ((index < 0) ? true : (index >= array.length)) {
-        throw new Exception("Index was outside the bounds of the array.\\nParameter name: index");
+        throw new Exception("Index was outside the bounds of the array. (Parameter \'index\')");
     }
     else {
         return array[index];
@@ -1035,7 +1035,7 @@ export function item<T>(index: int32, array: MutableArray<T>): T {
 
 export function setItem<T>(array: MutableArray<T>, index: int32, value: T): void {
     if ((index < 0) ? true : (index >= array.length)) {
-        throw new Exception("Index was outside the bounds of the array.\\nParameter name: index");
+        throw new Exception("Index was outside the bounds of the array. (Parameter \'index\')");
     }
     else {
         array[index] = value;
@@ -1196,7 +1196,7 @@ export function min<a>(xs: MutableArray<a>, comparer: IComparer<a>): a {
 
 export function average<T>(array: MutableArray<T>, averager: any): T {
     if (array.length === 0) {
-        throw new Exception("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty (Parameter \'array\')");
     }
     let total: T = averager.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
@@ -1207,7 +1207,7 @@ export function average<T>(array: MutableArray<T>, averager: any): T {
 
 export function averageBy<T, T2>(projection: ((arg0: T) => T2), array: MutableArray<T>, averager: any): T2 {
     if (array.length === 0) {
-        throw new Exception("The input array was empty\\nParameter name: array");
+        throw new Exception("The input array was empty (Parameter \'array\')");
     }
     let total: T2 = averager.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
@@ -1231,7 +1231,7 @@ export function windowed<T>(windowSize: int32, source: MutableArray<T>): Mutable
 
 export function splitInto<T>(chunks: int32, array: MutableArray<T>): MutableArray<MutableArray<T>> {
     if (chunks < 1) {
-        throw new Exception("The input must be positive.\\nParameter name: chunks");
+        throw new Exception("The input must be positive. (Parameter \'chunks\')");
     }
     const result: MutableArray<T>[] = [];
     if (array.length > 0) {
@@ -1275,7 +1275,7 @@ export function transpose<T>(arrays: Iterable<MutableArray<T>>, cons?: any): Mut
 export function insertAt<T>(index: int32, y: T, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     const len: int32 = xs.length | 0;
     if ((index < 0) ? true : (index > len)) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     const target: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len + 1);
     for (let i = 0; i <= (index - 1); i++) {
@@ -1291,7 +1291,7 @@ export function insertAt<T>(index: int32, y: T, xs: MutableArray<T>, cons?: any)
 export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     const len: int32 = xs.length | 0;
     if ((index < 0) ? true : (index > len)) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     const ys_1: MutableArray<T> = Array.from(ys);
     const len2: int32 = ys_1.length | 0;
@@ -1313,7 +1313,7 @@ export function randomShuffleInPlaceBy<T>(randomizer: (() => float64), xs: Mutab
     for (let i: int32 = len - 1; i >= 1; i--) {
         const r: float64 = randomizer();
         if ((r < 0) ? true : (r >= 1)) {
-            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+            throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter \'randomizer\')");
         }
         const j: int32 = ~~(r * (i + 1)) | 0;
         const tmp: T = item_2(i, xs);
@@ -1346,12 +1346,12 @@ export function randomShuffle<T>(xs: MutableArray<T>): MutableArray<T> {
 
 export function randomChoiceBy<T>(randomizer: (() => float64), xs: MutableArray<T>): T {
     if (isEmpty<T>(xs)) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
     }
     const len: int32 = xs.length | 0;
     const r: float64 = randomizer();
     if ((r < 0) ? true : (r >= 1)) {
-        throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter \'randomizer\')");
     }
     return item_2(~~(r * len), xs);
 }
@@ -1366,16 +1366,16 @@ export function randomChoice<T>(xs: MutableArray<T>): T {
 
 export function randomChoicesBy<T>(randomizer: (() => float64), count: int32, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     if (count < 0) {
-        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+        throw new Exception(SR_inputMustBeNonNegative + " (Parameter \'count\')");
     }
     if ((count > 0) && isEmpty<T>(xs)) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
     }
     const len: int32 = xs.length | 0;
     return initialize<T>(count, (_arg: int32): T => {
         const r: float64 = randomizer();
         if ((r < 0) ? true : (r >= 1)) {
-            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+            throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter \'randomizer\')");
         }
         return item_2(~~(r * len), xs);
     }, cons);
@@ -1391,20 +1391,20 @@ export function randomChoices<T>(count: int32, xs: MutableArray<T>, cons?: any):
 
 export function randomSampleBy<T>(randomizer: (() => float64), count: int32, xs: MutableArray<T>): MutableArray<T> {
     if (count < 0) {
-        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+        throw new Exception(SR_inputMustBeNonNegative + " (Parameter \'count\')");
     }
     const arr: MutableArray<T> = copy<T>(xs);
     const len: int32 = arr.length | 0;
     if ((len === 0) && (count > 0)) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
     }
     if (count > len) {
-        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "count");
+        throw new Exception(SR_notEnoughElements + " (Parameter \'count\')");
     }
     for (let i = 0; i <= (count - 1); i++) {
         const r: float64 = randomizer();
         if ((r < 0) ? true : (r >= 1)) {
-            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+            throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter \'randomizer\')");
         }
         const j: int32 = (i + ~~(r * (len - i))) | 0;
         const tmp: T = item_2(i, arr);
@@ -1424,7 +1424,7 @@ export function randomSample<T>(count: int32, xs: MutableArray<T>): MutableArray
 
 export function removeAt<T>(index: int32, xs: MutableArray<T>): MutableArray<T> {
     if ((index < 0) ? true : (index >= xs.length)) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     let i = -1;
     return filter<T>((_arg: T): boolean => {
@@ -1457,7 +1457,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: MutableArray<T>)
     }, xs);
     const status_1: int32 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;
     if (status_1 < 1) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
+        throw new Exception(SR_indexOutOfBounds + ((" (Parameter \'" + ((status_1 < 0) ? "index" : "count")) + "\')"));
     }
     return ys;
 }
@@ -1465,7 +1465,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: MutableArray<T>)
 export function updateAt<T>(index: int32, y: T, xs: MutableArray<T>, cons?: any): MutableArray<T> {
     const len: int32 = xs.length | 0;
     if ((index < 0) ? true : (index >= len)) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     const target: MutableArray<T> = Helpers_allocateArrayFromCons<T>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
@@ -1477,7 +1477,7 @@ export function updateAt<T>(index: int32, y: T, xs: MutableArray<T>, cons?: any)
 export function resize<T>(xs: FSharpRef<MutableArray<T>>, newSize: int32, zero?: Option<T>, cons?: any): void {
     let array: MutableArray<T> = (undefined as any), array_1: MutableArray<T> = (undefined as any), start_2: int32 = (undefined as any), count_2: int32 = (undefined as any);
     if (newSize < 0) {
-        throw new Exception("The input must be non-negative.\\nParameter name: newSize");
+        throw new Exception("The input must be non-negative. (Parameter \'newSize\')");
     }
     const zero_1: T = defaultArg<T>(zero, defaultOf());
     if (Operators_IsNull<any>(xs.contents)) {

package/Async.ts

@@ -2,6 +2,7 @@ import { OperationCanceledException, Trampoline } from "./AsyncBuilder.ts";
 import { Continuation, Continuations } from "./AsyncBuilder.ts";
 import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.ts";
 import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.ts";
+import type { IEvent$2 } from "./Event.ts";
 import { FSharpChoice$2_$union, Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.ts";
 import { TimeoutException_$ctor } from "./System.ts";
 import { Exception } from "./Util.ts";
@@ -86,6 +87,23 @@ export function awaitPromise<T>(p: Promise<T>) {
         ? conts[2] : conts[1])(err)));
 }
 
+export function awaitEvent<Del extends Function, T>(event: IEvent$2<Del, T>, cancelAction?: () => void): Async<T> {
+  return protectedCont((ctx: IAsyncContext<T>) => {
+    let tokenId: number;
+    const handler = ((_sender: unknown, arg: T) => {
+      ctx.cancelToken.removeListener(tokenId);
+      event.RemoveHandler(handler as unknown as Del);
+      ctx.onSuccess(arg);
+    }) as unknown as Del;
+    tokenId = ctx.cancelToken.addListener(() => {
+      event.RemoveHandler(handler);
+      if (cancelAction != null) { cancelAction(); }
+      ctx.onCancel(new OperationCanceledException());
+    });
+    event.AddHandler(handler);
+  });
+}
+
 export function cancellationToken() {
   return protectedCont((ctx: IAsyncContext<CancellationToken>) => ctx.onSuccess(ctx.cancelToken));
 }

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: 15eb83ed36657f75073fb0e1b4cac677e24fc9bb
+last_commit_released: c977d78b39225a51c7bd051a1fe363ed0ccbe201
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,30 @@ 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.3.0 - 2026-06-30
+
+### 🚀 Features
+
+* *(js/ts)* Map task { } to Promise<T> ([97f54d36](https://github.com/fable-compiler/Fable/commit/97f54d3692e5ba881c249b289c20b4fad5ac27e2))
+* *(js/ts/python/beam)* Add support for `Async.AwaitEvent` (#4693) ([71c98179](https://github.com/fable-compiler/Fable/commit/71c981792b6ff99cd417bb2e70a13a9d55ed72cf))
+
+### 🐞 Bug Fixes
+
+* *(js)* Respect StringComparison in String.IndexOf/LastIndexOf (#4681) ([7cb92d52](https://github.com/fable-compiler/Fable/commit/7cb92d522e5dc8dfe51351565504c59a94c2f408))
+* *(js/ts)* Int list is not a union type (#4698) ([ecbecbe7](https://github.com/fable-compiler/Fable/commit/ecbecbe756610fd83a621c005e97eda92bbc332a))
+* *(js/ts)* Pass TypeInfo to getRecordFields to handle None fields in anonymous records (#4704) ([c977d78b](https://github.com/fable-compiler/Fable/commit/c977d78b39225a51c7bd051a1fe363ed0ccbe201))
+* *(ts)* Widen isEnumDefined value parameter to accept any value (#4690) ([0d6498dd](https://github.com/fable-compiler/Fable/commit/0d6498ddf65e0e18918690633da23b04b78479f6))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/c9b3ee2429a4688946c1936e27df730837428070..c977d78b39225a51c7bd051a1fe363ed0ccbe201)</small></strong>
+
+## 2.2.0 - 2026-06-24
+
+### 🚀 Features
+
+* *(all)* Support Exception.InnerException across all targets (#4677) ([c9b3ee24](https://github.com/fable-compiler/Fable/commit/c9b3ee2429a4688946c1936e27df730837428070))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/15eb83ed36657f75073fb0e1b4cac677e24fc9bb..c9b3ee2429a4688946c1936e27df730837428070)</small></strong>
+
 ## 2.1.1 - 2026-06-10
 
 ### 🐞 Bug Fixes

package/List.ts

@@ -243,7 +243,7 @@ export function FSharpList__get_Head<T>(xs: FSharpList<T>): T {
         return xs.head;
     }
     else {
-        throw new Exception((SR_inputWasEmpty + "\\nParameter name: ") + "list");
+        throw new Exception(SR_inputWasEmpty + " (Parameter \'list\')");
     }
 }
 
@@ -253,7 +253,7 @@ export function FSharpList__get_Tail<T>(xs: FSharpList<T>): FSharpList<T> {
         return value_1(matchValue);
     }
     else {
-        throw new Exception((SR_inputWasEmpty + "\\nParameter name: ") + "list");
+        throw new Exception(SR_inputWasEmpty + " (Parameter \'list\')");
     }
 }
 
@@ -274,7 +274,7 @@ export function FSharpList__get_Item_Z524259A4<T>(xs: FSharpList<T>, index: int3
                 }
             }
             else {
-                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
             }
             break;
         }
@@ -1026,7 +1026,7 @@ export function exists2<T1, T2>(f_mut: ((arg0: T1, arg1: T2) => boolean), xs_mut
                     continue exists2;
                 }
             default:
-                throw new Exception((SR_differentLengths + "\\nParameter name: ") + "list2");
+                throw new Exception(SR_differentLengths + " (Parameter \'list2\')");
         }
         break;
     }
@@ -1143,7 +1143,7 @@ export function skip<T>(count_mut: int32, xs_mut: FSharpList<T>): FSharpList<T>
             return xs;
         }
         else if (FSharpList__get_IsEmpty<T>(xs)) {
-            throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "list");
+            throw new Exception(SR_notEnoughElements + " (Parameter \'list\')");
         }
         else {
             count_mut = (count - 1);
@@ -1175,7 +1175,7 @@ export function skipWhile<T>(predicate_mut: ((arg0: T) => boolean), xs_mut: FSha
 
 export function take<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
     if (count < 0) {
-        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+        throw new Exception(SR_inputMustBeNonNegative + " (Parameter \'count\')");
     }
     const loop = (i_mut: int32, acc_mut: FSharpList<T>, xs_1_mut: FSharpList<T>): FSharpList<T> => {
         loop:
@@ -1186,7 +1186,7 @@ export function take<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
                 return acc;
             }
             else if (FSharpList__get_IsEmpty<T>(xs_1)) {
-                throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "list");
+                throw new Exception(SR_notEnoughElements + " (Parameter \'list\')");
             }
             else {
                 i_mut = (i - 1);
@@ -1277,23 +1277,23 @@ export function getSlice<T>(startIndex: Option<int32>, endIndex: Option<int32>,
 
 export function splitAt<T>(index: int32, xs: FSharpList<T>): [FSharpList<T>, FSharpList<T>] {
     if (index < 0) {
-        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "index");
+        throw new Exception(SR_inputMustBeNonNegative + " (Parameter \'index\')");
     }
     if (index > FSharpList__get_Length<T>(xs)) {
-        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "index");
+        throw new Exception(SR_notEnoughElements + " (Parameter \'index\')");
     }
     return [take<T>(index, xs), skip<T>(index, xs)] as [FSharpList<T>, FSharpList<T>];
 }
 
 export function exactlyOne<T>(xs: FSharpList<T>): T {
     if (FSharpList__get_IsEmpty<T>(xs)) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "list");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'list\')");
     }
     else if (FSharpList__get_IsEmpty<T>(FSharpList__get_Tail<T>(xs))) {
         return FSharpList__get_Head<T>(xs);
     }
     else {
-        throw new Exception((SR_inputSequenceTooLong + "\\nParameter name: ") + "list");
+        throw new Exception(SR_inputSequenceTooLong + " (Parameter \'list\')");
     }
 }
 
@@ -1340,7 +1340,7 @@ export function insertAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T
         }
     }, FSharpList_get_Empty<T>(), xs);
     return reverse<T>(isDone ? result : (((i + 1) === index) ? FSharpList_Cons_305B8EAC<T>(y, result) : (() => {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     })()));
 }
 
@@ -1359,7 +1359,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: FSharpList<T>
         }
     }, FSharpList_get_Empty<T>(), xs);
     return reverse<T>(isDone ? result : (((i + 1) === index) ? append<T>(ys_1, result) : (() => {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     })()));
 }
 
@@ -1377,7 +1377,7 @@ export function removeAt<T>(index: int32, xs: FSharpList<T>): FSharpList<T> {
         }
     }, xs);
     if (!isDone) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return ys;
 }
@@ -1406,7 +1406,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: FSharpList<T>):
     }, xs);
     const status_1: int32 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;
     if (status_1 < 1) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
+        throw new Exception(SR_indexOutOfBounds + ((" (Parameter \'" + ((status_1 < 0) ? "index" : "count")) + "\')"));
     }
     return ys;
 }
@@ -1423,7 +1423,7 @@ export function updateAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T
         }
     }, xs);
     if (!isDone) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return ys;
 }

package/Reflection.ts

@@ -171,7 +171,18 @@ export function option_type(generic: TypeInfo): TypeInfo {
 }
 
 export function list_type(generic: TypeInfo): TypeInfo {
-  return new TypeInfo("Microsoft.FSharp.Collections.FSharpList`1", [generic]);
+  const t: TypeInfo = new TypeInfo(
+    "Microsoft.FSharp.Collections.FSharpList`1",
+    [generic],
+    undefined,
+    undefined,
+    undefined,
+    () => [
+      new CaseInfo(t, 0, "Empty"),
+      new CaseInfo(t, 1, "Cons", [["Head", generic], ["Tail", t]])
+    ]
+  );
+  return t;
 }
 
 export function array_type(generic: TypeInfo): TypeInfo {
@@ -389,7 +400,7 @@ export function getEnumName(t: TypeInfo, v: number): string {
   return getEnumCase(t, v)[0];
 }
 
-export function isEnumDefined(t: TypeInfo, v: string | number): boolean {
+export function isEnumDefined(t: TypeInfo, v: any): boolean {
   try {
     const kv = getEnumCase(t, v);
     return kv[0] != null && kv[0] !== "";
@@ -477,8 +488,14 @@ export function getUnionCaseFields(uci: CaseInfo): FieldInfo[] {
 
 // This is used as replacement of `FSharpValue.GetRecordFields`
 // For `FSharpTypes.GetRecordFields` see `getRecordElements`
-// Object.keys returns keys in the order they were added to the object
-export function getRecordFields(v: any): MutableArray<any> {
+// TypeInfo is used when available to enumerate fields by name: anonymous record None fields
+// are omitted from the JS object, so Object.keys alone would miss them.
+// Boxed anonymous record would are still not covered but this is the best we can do for now
+// without adding a __fields__ to every anonymous record being created
+export function getRecordFields(v: any, t: TypeInfo): MutableArray<any> {
+  if (t.fields != null) {
+    return t.fields().map(([key, _]) => v[key]);
+  }
   return Object.keys(v).map((k) => v[k]);
 }
 

package/Seq.ts

@@ -559,14 +559,14 @@ export function exactlyOne<T>(xs: Iterable<T>): T {
         if (e["System.Collections.IEnumerator.MoveNext"]()) {
             const v: T = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
             if (e["System.Collections.IEnumerator.MoveNext"]()) {
-                throw new Exception((SR_inputSequenceTooLong + "\\nParameter name: ") + "source");
+                throw new Exception(SR_inputSequenceTooLong + " (Parameter \'source\')");
             }
             else {
                 return v;
             }
         }
         else {
-            throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+            throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
         }
     }
     finally {
@@ -764,7 +764,7 @@ export function tryHead<T>(xs: Iterable<T>): Option<T> {
 export function head<T>(xs: Iterable<T>): T {
     const matchValue: Option<T> = tryHead<T>(xs);
     if (matchValue == null) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
     }
     else {
         return value_1(matchValue);
@@ -836,7 +836,7 @@ export function tryItem<T>(index: int32, xs: Iterable<T>): Option<T> {
 export function item<T>(index: int32, xs: Iterable<T>): T {
     const matchValue: Option<T> = tryItem<T>(index, xs);
     if (matchValue == null) {
-        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "index");
+        throw new Exception(SR_notEnoughElements + " (Parameter \'index\')");
     }
     else {
         return value_1(matchValue);
@@ -896,7 +896,7 @@ export function tryLast<T>(xs: Iterable<T>): Option<T> {
 export function last<T>(xs: Iterable<T>): T {
     const matchValue: Option<T> = tryLast<T>(xs);
     if (matchValue == null) {
-        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "source");
+        throw new Exception(SR_notEnoughElements + " (Parameter \'source\')");
     }
     else {
         return value_1(matchValue);
@@ -1205,7 +1205,7 @@ export function skip<T>(count: int32, source: Iterable<T>): Iterable<T> {
         try {
             for (let _ = 1; _ <= count; _++) {
                 if (!e["System.Collections.IEnumerator.MoveNext"]()) {
-                    throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "source");
+                    throw new Exception(SR_notEnoughElements + " (Parameter \'source\')");
                 }
             }
             return Enumerator_enumerateThenFinally<T>((): void => {
@@ -1241,7 +1241,7 @@ export function take<T>(count: int32, xs: Iterable<T>): Iterable<T> {
                 return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
             }
             else {
-                throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "source");
+                throw new Exception(SR_notEnoughElements + " (Parameter \'source\')");
             }
         }
         else {
@@ -1351,7 +1351,7 @@ export function average<T>(xs: Iterable<T>, averager: any): T {
         return averager.Add(acc, x);
     }, averager.GetZero(), xs);
     if (count === 0) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
     }
     else {
         return averager.DivideByInt(total, count);
@@ -1365,7 +1365,7 @@ export function averageBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, averager:
         return averager.Add(acc, f(x));
     }, averager.GetZero(), xs);
     if (count === 0) {
-        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        throw new Exception(SR_inputSequenceEmpty + " (Parameter \'source\')");
     }
     else {
         return averager.DivideByInt(total, count);
@@ -1383,7 +1383,7 @@ export function chunkBySize<T>(chunkSize: int32, xs: Iterable<T>): Iterable<Muta
 export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
     let isDone = false;
     if (index < 0) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1395,7 +1395,7 @@ export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
         }
         else {
             if (!isDone) {
-                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
             }
             return undefined;
         }
@@ -1407,7 +1407,7 @@ export function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
 export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>): Iterable<T> {
     let status = -1;
     if (index < 0) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return generateIndexed<[IEnumerator<T>, IEnumerator<T>], T>((): [IEnumerator<T>, IEnumerator<T>] => ([ofSeq<T>(xs), ofSeq<T>(ys)] as [IEnumerator<T>, IEnumerator<T>]), (i: int32, tupledArg: [IEnumerator<T>, IEnumerator<T>]): Option<T> => {
         const e1: IEnumerator<T> = tupledArg[0];
@@ -1434,7 +1434,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>):
             }
             else {
                 if (status < 1) {
-                    throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                    throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
                 }
                 return undefined;
             }
@@ -1451,7 +1451,7 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>):
 export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
     let isDone = false;
     if (index < 0) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1463,7 +1463,7 @@ export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
         }
         else {
             if (!isDone) {
-                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
             }
             return undefined;
         }
@@ -1474,7 +1474,7 @@ export function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T> {
 
 export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): Iterable<T> {
     if (index < 0) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if (i < index) {
@@ -1482,14 +1482,14 @@ export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): It
                 return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
             }
             else {
-                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
             }
         }
         else {
             if (i === index) {
                 for (let _ = 1; _ <= count; _++) {
                     if (!e["System.Collections.IEnumerator.MoveNext"]()) {
-                        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "count");
+                        throw new Exception(SR_indexOutOfBounds + " (Parameter \'count\')");
                     }
                 }
             }
@@ -1503,7 +1503,7 @@ export function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): It
 export function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
     let isDone = false;
     if (index < 0) {
-        throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+        throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
     }
     return generateIndexed<IEnumerator<T>, T>((): IEnumerator<T> => ofSeq<T>(xs), (i: int32, e: IEnumerator<T>): Option<T> => {
         if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
@@ -1515,7 +1515,7 @@ export function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
         }
         else {
             if (!isDone) {
-                throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                throw new Exception(SR_indexOutOfBounds + " (Parameter \'index\')");
             }
             return undefined;
         }

package/String.ts

@@ -99,6 +99,32 @@ export function contains(str: string, pattern: string, ic: boolean | StringCompa
   return false;
 }
 
+export function indexOf(str: string, searchValue: string, comparison: StringComparison, startIndex: number = 0): number {
+  if (comparison === StringComparison.Ordinal) { // fast path
+    return str.indexOf(searchValue, startIndex);
+  }
+  const len = searchValue.length;
+  for (let i = Math.max(startIndex, 0); i <= str.length - len; i++) {
+    if (cmp(str.slice(i, i + len), searchValue, comparison) === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export function lastIndexOf(str: string, searchValue: string, comparison: StringComparison, startIndex: number = str.length - 1): number {
+  if (comparison === StringComparison.Ordinal) { // fast path
+    return str.lastIndexOf(searchValue, startIndex);
+  }
+  const len = searchValue.length;
+  for (let i = Math.min(startIndex, str.length - len); i >= 0; i--) {
+    if (cmp(str.slice(i, i + len), searchValue, comparison) === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 export function indexOfAny(str: string, anyOf: string[], ...args: number[]) {
   if (str == null || str === "") {
     return -1;

package/System.ts

@@ -1,5 +1,5 @@
 
-import { Exception } from "./Util.ts";
+import { defaultOf, Exception } from "./Util.ts";
 import { class_type, TypeInfo } from "./Reflection.ts";
 import { SR_Arg_ArgumentOutOfRangeException, SR_ArgumentNull_Generic, SR_Arg_ArgumentException, SR_Arg_ParamName_Name, SR_Arg_TimeoutException, SR_Arg_StackOverflowException, SR_Arg_RankException, SR_Arg_OverflowException, SR_Arg_OutOfMemoryException, SR_Arg_NullReferenceException, SR_Arg_NotSupportedException, SR_Arg_NotImplementedException, SR_Arg_NotFiniteNumberException, SR_Arg_InvalidOperationException, SR_Arg_IndexOutOfRangeException, SR_Arg_FormatException, SR_Arg_DivideByZero, SR_Arg_ArithmeticException, SR_Arg_ApplicationException, SR_Arg_SystemException } from "./Global.ts";
 import { isNullOrEmpty } from "./String.ts";
@@ -294,8 +294,8 @@ export function TimeoutException_$ctor(): TimeoutException {
 
 export class ArgumentException extends Exception {
     readonly paramName: string;
-    constructor(message: string, paramName: string) {
-        super(isNullOrEmpty(paramName) ? message : (((message + SR_Arg_ParamName_Name) + paramName) + "\')"));
+    constructor(message: string, paramName: string, innerException: Exception) {
+        super(isNullOrEmpty(paramName) ? message : (((message + SR_Arg_ParamName_Name) + paramName) + "\')"), innerException);
         this.paramName = paramName;
     }
 }
@@ -304,16 +304,24 @@ export function ArgumentException_$reflection(): TypeInfo {
     return class_type("System.ArgumentException", undefined, ArgumentException, class_type("System.Exception"));
 }
 
-export function ArgumentException_$ctor_Z384F8060(message: string, paramName: string): ArgumentException {
-    return new ArgumentException(message, paramName);
+export function ArgumentException_$ctor_Z60A2B367(message: string, paramName: string, innerException: Exception): ArgumentException {
+    return new ArgumentException(message, paramName, innerException);
 }
 
 export function ArgumentException_$ctor(): ArgumentException {
-    return ArgumentException_$ctor_Z384F8060(SR_Arg_ArgumentException, "");
+    return ArgumentException_$ctor_Z60A2B367(SR_Arg_ArgumentException, "", defaultOf());
 }
 
 export function ArgumentException_$ctor_Z721C83C5(message: string): ArgumentException {
-    return ArgumentException_$ctor_Z384F8060(message, "");
+    return ArgumentException_$ctor_Z60A2B367(message, "", defaultOf());
+}
+
+export function ArgumentException_$ctor_Z384F8060(message: string, paramName: string): ArgumentException {
+    return ArgumentException_$ctor_Z60A2B367(message, paramName, defaultOf());
+}
+
+export function ArgumentException_$ctor_68CE3CA2(message: string, innerException: Exception): ArgumentException {
+    return ArgumentException_$ctor_Z60A2B367(message, "", innerException);
 }
 
 export function ArgumentException__get_ParamName(_: ArgumentException): string {
@@ -322,7 +330,7 @@ export function ArgumentException__get_ParamName(_: ArgumentException): string {
 
 export class ArgumentNullException extends ArgumentException {
     constructor(paramName: string, message: string) {
-        super(message, paramName);
+        super(message, paramName, defaultOf());
     }
 }
 
@@ -344,7 +352,7 @@ export function ArgumentNullException_$ctor(): ArgumentNullException {
 
 export class ArgumentOutOfRangeException extends ArgumentException {
     constructor(paramName: string, message: string) {
-        super(message, paramName);
+        super(message, paramName, defaultOf());
     }
 }
 

package/Task.ts

@@ -0,0 +1,37 @@
+import { OperationCanceledException } from "./AsyncBuilder.ts";
+
+export class TaskCompletionSource<T> {
+  private _resolve!: (value: T) => void;
+  private _reject!: (reason?: unknown) => void;
+  public task: Promise<T>;
+
+  constructor() {
+    this.task = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  SetResult(value: T): void { this._resolve(value); }
+  SetException(error: unknown): void { this._reject(error); }
+  SetCancelled(): void { this._reject(new OperationCanceledException()); }
+  get_Task(): Promise<T> { return this.task; }
+}
+
+export function fromResult<T>(value: T): Promise<T> {
+  return Promise.resolve(value);
+}
+
+export function zero(): Promise<void> {
+  return Promise.resolve();
+}
+
+// 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>(t: Promise<T>): Promise<T> {
+  return t;
+}
+
+export function getResult<T>(t: Promise<T>): Promise<T> {
+  return t;
+}

package/TaskBuilder.ts

@@ -0,0 +1,85 @@
+import { IDisposable } from "./Util.ts";
+import { zero } from "./Task.ts";
+
+export class TaskBuilder {
+  public Bind<T, U>(computation: Promise<T>, binder: (x: T) => Promise<U>): Promise<U> {
+    return computation.then(binder);
+  }
+
+  public Combine<T>(computation1: Promise<void>, computation2: () => Promise<T>): Promise<T> {
+    return computation1.then(computation2);
+  }
+
+  public Delay<T>(generator: () => Promise<T>): () => Promise<T> {
+    return generator;
+  }
+
+  public For<T>(sequence: Iterable<T>, body: (x: T) => Promise<void>): Promise<void> {
+    const iter = sequence[Symbol.iterator]();
+    let cur = iter.next();
+    return this.While(
+      () => !cur.done,
+      this.Delay(() => {
+        const res = body(cur.value!);
+        cur = iter.next();
+        return res;
+      })
+    );
+  }
+
+  public Return<T>(value?: T): Promise<T | undefined> {
+    return Promise.resolve(value);
+  }
+
+  public ReturnFrom<T>(computation: Promise<T>): Promise<T> {
+    return computation;
+  }
+
+  public TryFinally<T>(computation: () => Promise<T>, compensation: () => void): Promise<T> {
+    try {
+      return computation().finally(compensation);
+    } catch (e) {
+      compensation();
+      return Promise.reject(e);
+    }
+  }
+
+  public TryWith<T>(computation: () => Promise<T>, catchHandler: (e: unknown) => Promise<T>): Promise<T> {
+    try {
+      return computation().catch(catchHandler);
+    } catch (e) {
+      try {
+        return catchHandler(e);
+      } catch (e2) {
+        return Promise.reject(e2);
+      }
+    }
+  }
+
+  public Using<T extends IDisposable, U>(resource: T, binder: (x: T) => Promise<U>): Promise<U> {
+    return this.TryFinally(() => binder(resource), () => resource.Dispose());
+  }
+
+  public While(guard: () => boolean, computation: () => Promise<void>): Promise<void> {
+    return (async () => {
+      while (guard()) {
+        await computation();
+      }
+    })();
+  }
+
+  public Zero(): Promise<void> {
+    return zero();
+  }
+
+  public Run<T>(computation: () => Promise<T>): Promise<T> {
+    try {
+      return computation();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+}
+
+export const singleton = new TaskBuilder();
+export function task(): TaskBuilder { return singleton; }

package/Util.ts

@@ -80,9 +80,15 @@ export interface ICollection<T> extends IEnumerable<T> {
 export class Exception {
   public message: string;
   public stack?: string;
+  // Typed non-nullable to match how Fable models .NET reference types: nullability
+  // annotations are erased, so consumers (and `get_InnerException`) see `Exception`.
+  // At runtime this is `undefined` when no inner exception was provided, just like
+  // a `defaultOf()` value, which is fine for code that reads `.InnerException`.
+  public innerException!: Exception;
 
-  constructor(msg?: string) {
+  constructor(msg?: string, innerException?: Exception) {
     this.message = msg ?? "";
+    this.innerException = innerException as Exception;
   }
 
   toString() {

package/package.json

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