@fable-org/fable-library-ts 1.0.0-beta-001 → 1.1.0

package/Array.ts

@@ -1,5 +1,6 @@
 import { int32 } from "./Int32.js";
 import { Helpers_allocateArrayFromCons } from "./Native.js";
+import { setItem as setItem_1, item as item_2 } from "./Array.js";
 import { value as value_2, map as map_1, defaultArg, Option, some } from "./Option.js";
 import { min as min_1, max as max_1 } from "./Double.js";
 import { IComparer, equals as equals_1, IDisposable, disposeSafe, IEnumerator, getEnumerator, copyToArray, IEqualityComparer, defaultOf } from "./Util.js";
@@ -19,10 +20,10 @@ export function append<T>(array1: T[], array2: T[], cons?: any): T[] {
     const len2: int32 = array2.length | 0;
     const newArray: T[] = Helpers_allocateArrayFromCons<T>(cons, len1 + len2);
     for (let i = 0; i <= (len1 - 1); i++) {
-        newArray[i] = array1[i];
+        setItem_1(newArray, i, item_2(i, array1));
     }
     for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {
-        newArray[i_1 + len1] = array2[i_1];
+        setItem_1(newArray, i_1 + len1, item_2(i_1, array2));
     }
     return newArray;
 }
@@ -45,7 +46,7 @@ export function last<T>(array: T[]): T {
     if (array.length === 0) {
         throw new Error("The input array was empty\\nParameter name: array");
     }
-    return array[array.length - 1];
+    return item_2(array.length - 1, array);
 }
 
 export function tryLast<T>(array: T[]): Option<T> {
@@ -53,7 +54,7 @@ export function tryLast<T>(array: T[]): Option<T> {
         return void 0;
     }
     else {
-        return some(array[array.length - 1]);
+        return some(item_2(array.length - 1, array));
     }
 }
 
@@ -61,7 +62,7 @@ export function mapIndexed<T, U>(f: ((arg0: int32, arg1: T) => U), source: T[],
     const len: int32 = source.length | 0;
     const target: U[] = Helpers_allocateArrayFromCons<U>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
-        target[i] = f(i, source[i]);
+        setItem_1(target, i, f(i, item_2(i, source)));
     }
     return target;
 }
@@ -70,7 +71,7 @@ export function map<T, U>(f: ((arg0: T) => U), source: T[], cons?: any): U[] {
     const len: int32 = source.length | 0;
     const target: U[] = Helpers_allocateArrayFromCons<U>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
-        target[i] = f(source[i]);
+        setItem_1(target, i, f(item_2(i, source)));
     }
     return target;
 }
@@ -81,7 +82,7 @@ export function mapIndexed2<T1, T2, U>(f: ((arg0: int32, arg1: T1, arg2: T2) =>
     }
     const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
-        result[i] = f(i, source1[i], source2[i]);
+        setItem_1(result, i, f(i, item_2(i, source1), item_2(i, source2)));
     }
     return result;
 }
@@ -92,7 +93,7 @@ export function map2<T1, T2, U>(f: ((arg0: T1, arg1: T2) => U), source1: T1[], s
     }
     const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
-        result[i] = f(source1[i], source2[i]);
+        setItem_1(result, i, f(item_2(i, source1), item_2(i, source2)));
     }
     return result;
 }
@@ -103,7 +104,7 @@ export function mapIndexed3<T1, T2, T3, U>(f: ((arg0: int32, arg1: T1, arg2: T2,
     }
     const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
-        result[i] = f(i, source1[i], source2[i], source3[i]);
+        setItem_1(result, i, f(i, item_2(i, source1), item_2(i, source2), item_2(i, source3)));
     }
     return result;
 }
@@ -114,7 +115,7 @@ export function map3<T1, T2, T3, U>(f: ((arg0: T1, arg1: T2, arg2: T3) => U), so
     }
     const result: U[] = Helpers_allocateArrayFromCons<U>(cons, source1.length);
     for (let i = 0; i <= (source1.length - 1); i++) {
-        result[i] = f(source1[i], source2[i], source3[i]);
+        setItem_1(result, i, f(item_2(i, source1), item_2(i, source2), item_2(i, source3)));
     }
     return result;
 }
@@ -128,8 +129,8 @@ export function mapFold<T, State, Result>(mapping: ((arg0: State, arg1: T) => [R
         let acc: State = state;
         const res: Result[] = Helpers_allocateArrayFromCons<Result>(cons, matchValue);
         for (let i = 0; i <= (array.length - 1); i++) {
-            const patternInput: [Result, State] = mapping(acc, array[i]);
-            res[i] = patternInput[0];
+            const patternInput: [Result, State] = mapping(acc, item_2(i, array));
+            setItem_1(res, i, patternInput[0]);
             acc = patternInput[1];
         }
         return [res, acc] as [Result[], State];
@@ -145,8 +146,8 @@ export function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) =
         let acc: State = state;
         const res: Result[] = Helpers_allocateArrayFromCons<Result>(cons, matchValue);
         for (let i: int32 = array.length - 1; i >= 0; i--) {
-            const patternInput: [Result, State] = mapping(array[i], acc);
-            res[i] = patternInput[0];
+            const patternInput: [Result, State] = mapping(item_2(i, array), acc);
+            setItem_1(res, i, patternInput[0]);
             acc = patternInput[1];
         }
         return [res, acc] as [Result[], State];
@@ -157,7 +158,7 @@ export function indexed<T>(source: T[]): [int32, T][] {
     const len: int32 = source.length | 0;
     const target: [int32, T][] = new Array(len);
     for (let i = 0; i <= (len - 1); i++) {
-        target[i] = ([i, source[i]] as [int32, T]);
+        setItem_1(target, i, [i, item_2(i, source)] as [int32, T]);
     }
     return target;
 }
@@ -174,19 +175,19 @@ export function concat<T>(arrays: Iterable<T[]>, cons?: any): T[] {
         case 0:
             return Helpers_allocateArrayFromCons<T>(cons, 0);
         case 1:
-            return arrays_1[0];
+            return item_2(0, arrays_1);
         default: {
             let totalIdx = 0;
             let totalLength = 0;
             for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {
-                const arr_1: T[] = arrays_1[idx];
+                const arr_1: T[] = item_2(idx, arrays_1);
                 totalLength = ((totalLength + arr_1.length) | 0);
             }
             const result: T[] = Helpers_allocateArrayFromCons<T>(cons, totalLength);
             for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {
-                const arr_2: T[] = arrays_1[idx_1];
+                const arr_2: T[] = item_2(idx_1, arrays_1);
                 for (let j = 0; j <= (arr_2.length - 1); j++) {
-                    result[totalIdx] = arr_2[j];
+                    setItem_1(result, totalIdx, item_2(j, arr_2));
                     totalIdx = ((totalIdx + 1) | 0);
                 }
             }
@@ -213,7 +214,7 @@ export function indexOf<T>(array: T[], item_1: T, start: Option<int32>, count: O
             if (i >= end$0027) {
                 return -1;
             }
-            else if (eq.Equals(item_1, array[i])) {
+            else if (eq.Equals(item_1, item_2(i, array))) {
                 return i | 0;
             }
             else {
@@ -236,7 +237,7 @@ export function empty<$a>(cons: any): $a[] {
 
 export function singleton<T>(value: T, cons?: any): T[] {
     const ar: T[] = Helpers_allocateArrayFromCons<T>(cons, 1);
-    ar[0] = value;
+    setItem_1(ar, 0, value);
     return ar;
 }
 
@@ -246,7 +247,7 @@ export function initialize<T>(count: int32, initializer: ((arg0: int32) => T), c
     }
     const result: T[] = Helpers_allocateArrayFromCons<T>(cons, count);
     for (let i = 0; i <= (count - 1); i++) {
-        result[i] = initializer(i);
+        setItem_1(result, i, initializer(i));
     }
     return result;
 }
@@ -259,7 +260,7 @@ export function pairwise<T>(array: T[]): [T, T][] {
         const count: int32 = (array.length - 1) | 0;
         const result: [T, T][] = new Array(count);
         for (let i = 0; i <= (count - 1); i++) {
-            result[i] = ([array[i], array[i + 1]] as [T, T]);
+            setItem_1(result, i, [item_2(i, array), item_2(i + 1, array)] as [T, T]);
         }
         return result;
     }
@@ -271,7 +272,7 @@ export function replicate<T>(count: int32, initial: T, cons?: any): T[] {
     }
     const result: T[] = Helpers_allocateArrayFromCons<T>(cons, count);
     for (let i = 0; i <= (result.length - 1); i++) {
-        result[i] = initial;
+        setItem_1(result, i, initial);
     }
     return result;
 }
@@ -291,18 +292,18 @@ export function reverse<T>(array: T[]): T[] {
 
 export function scan<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: T[], cons?: any): State[] {
     const res: State[] = Helpers_allocateArrayFromCons<State>(cons, array.length + 1);
-    res[0] = state;
+    setItem_1(res, 0, state);
     for (let i = 0; i <= (array.length - 1); i++) {
-        res[i + 1] = folder(res[i], array[i]);
+        setItem_1(res, i + 1, folder(item_2(i, res), item_2(i, array)));
     }
     return res;
 }
 
 export function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: T[], state: State, cons?: any): State[] {
     const res: State[] = Helpers_allocateArrayFromCons<State>(cons, array.length + 1);
-    res[array.length] = state;
+    setItem_1(res, array.length, state);
     for (let i: int32 = array.length - 1; i >= 0; i--) {
-        res[i] = folder(array[i], res[i + 1]);
+        setItem_1(res, i, folder(item_2(i, array), item_2(i + 1, res)));
     }
     return res;
 }
@@ -322,7 +323,7 @@ export function skip<T>(count: int32, array: T[], cons?: any): T[] {
 
 export function skipWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons?: any): T[] {
     let count = 0;
-    while ((count < array.length) && predicate(array[count])) {
+    while ((count < array.length) && predicate(item_2(count, array))) {
         count = ((count + 1) | 0);
     }
     if (count === array.length) {
@@ -351,7 +352,7 @@ export function take<T>(count: int32, array: T[], cons?: any): T[] {
 
 export function takeWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons?: any): T[] {
     let count = 0;
-    while ((count < array.length) && predicate(array[count])) {
+    while ((count < array.length) && predicate(item_2(count, array))) {
         count = ((count + 1) | 0);
     }
     if (count === 0) {
@@ -427,12 +428,12 @@ export function partition<T>(f: ((arg0: T) => boolean), source: T[], cons?: any)
     let iTrue = 0;
     let iFalse = 0;
     for (let i = 0; i <= (len - 1); i++) {
-        if (f(source[i])) {
-            res1[iTrue] = source[i];
+        if (f(item_2(i, source))) {
+            setItem_1(res1, iTrue, item_2(i, source));
             iTrue = ((iTrue + 1) | 0);
         }
         else {
-            res2[iFalse] = source[i];
+            setItem_1(res2, iFalse, item_2(i, source));
             iFalse = ((iFalse + 1) | 0);
         }
     }
@@ -483,7 +484,7 @@ export function pick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]):
                 return indexNotFound<$b>();
             }
             else {
-                const matchValue: Option<$b> = chooser(array[i]);
+                const matchValue: Option<$b> = chooser(item_2(i, array));
                 if (matchValue != null) {
                     return value_2(matchValue);
                 }
@@ -507,7 +508,7 @@ export function tryPick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]
                 return void 0;
             }
             else {
-                const matchValue: Option<$b> = chooser(array[i]);
+                const matchValue: Option<$b> = chooser(item_2(i, array));
                 if (matchValue == null) {
                     i_mut = (i + 1);
                     continue loop;
@@ -530,8 +531,8 @@ export function findBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $
             if (i < 0) {
                 return indexNotFound<$a>();
             }
-            else if (predicate(array[i])) {
-                return array[i];
+            else if (predicate(item_2(i, array))) {
+                return item_2(i, array);
             }
             else {
                 i_mut = (i - 1);
@@ -551,8 +552,8 @@ export function tryFindBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[])
             if (i < 0) {
                 return void 0;
             }
-            else if (predicate(array[i])) {
-                return some(array[i]);
+            else if (predicate(item_2(i, array))) {
+                return some(item_2(i, array));
             }
             else {
                 i_mut = (i - 1);
@@ -572,7 +573,7 @@ export function findLastIndex<$a>(predicate: ((arg0: $a) => boolean), array: $a[
             if (i < 0) {
                 return -1;
             }
-            else if (predicate(array[i])) {
+            else if (predicate(item_2(i, array))) {
                 return i | 0;
             }
             else {
@@ -594,7 +595,7 @@ export function findIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[
                 indexNotFound<void>();
                 return -1;
             }
-            else if (predicate(array[i])) {
+            else if (predicate(item_2(i, array))) {
                 return i | 0;
             }
             else {
@@ -615,7 +616,7 @@ export function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array:
             if (i < 0) {
                 return void 0;
             }
-            else if (predicate(array[i])) {
+            else if (predicate(item_2(i, array))) {
                 return i;
             }
             else {
@@ -631,7 +632,7 @@ export function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array:
 export function choose<T, U>(chooser: ((arg0: T) => Option<U>), array: T[], cons?: any): U[] {
     const res: U[] = [];
     for (let i = 0; i <= (array.length - 1); i++) {
-        const matchValue: Option<U> = chooser(array[i]);
+        const matchValue: Option<U> = chooser(item_2(i, array));
         if (matchValue != null) {
             const y: U = value_2(matchValue);
             res.push(y);
@@ -656,13 +657,13 @@ export function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state:
 
 export function iterate<T>(action: ((arg0: T) => void), array: T[]): void {
     for (let i = 0; i <= (array.length - 1); i++) {
-        action(array[i]);
+        action(item_2(i, array));
     }
 }
 
 export function iterateIndexed<T>(action: ((arg0: int32, arg1: T) => void), array: T[]): void {
     for (let i = 0; i <= (array.length - 1); i++) {
-        action(i, array[i]);
+        action(i, item_2(i, array));
     }
 }
 
@@ -671,7 +672,7 @@ export function iterate2<T1, T2>(action: ((arg0: T1, arg1: T2) => void), array1:
         differentLengths<void>();
     }
     for (let i = 0; i <= (array1.length - 1); i++) {
-        action(array1[i], array2[i]);
+        action(item_2(i, array1), item_2(i, array2));
     }
 }
 
@@ -680,7 +681,7 @@ export function iterateIndexed2<T1, T2>(action: ((arg0: int32, arg1: T1, arg2: T
         differentLengths<void>();
     }
     for (let i = 0; i <= (array1.length - 1); i++) {
-        action(i, array1[i], array2[i]);
+        action(i, item_2(i, array1), item_2(i, array2));
     }
 }
 
@@ -701,8 +702,8 @@ export function permute<T>(f: ((arg0: int32) => int32), array: T[]): T[] {
         if ((j < 0) ? true : (j >= size)) {
             throw new Error("Not a valid permutation");
         }
-        res[j] = x;
-        checkFlags[j] = 1;
+        setItem_1(res, j, x);
+        setItem_1(checkFlags, j, 1);
     }, array);
     if (!(checkFlags.every((y: int32): boolean => (1 === y)))) {
         throw new Error("Not a valid permutation");
@@ -715,7 +716,7 @@ export function setSlice<T>(target: T[], lower: Option<int32>, upper: Option<int
     const upper_1: int32 = defaultArg<int32>(upper, -1) | 0;
     const length: int32 = (((upper_1 >= 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;
     for (let i = 0; i <= length; i++) {
-        target[i + lower_1] = source[i];
+        setItem_1(target, i + lower_1, item_2(i, source));
     }
 }
 
@@ -764,7 +765,7 @@ export function allPairs<T1, T2>(xs: T1[], ys: T2[]): [T1, T2][] {
     const res: [T1, T2][] = new Array(len1 * len2);
     for (let i = 0; i <= (xs.length - 1); i++) {
         for (let j = 0; j <= (ys.length - 1); j++) {
-            res[(i * len2) + j] = ([xs[i], ys[j]] as [T1, T2]);
+            setItem_1(res, (i * len2) + j, [item_2(i, xs), item_2(j, ys)] as [T1, T2]);
         }
     }
     return res;
@@ -796,8 +797,8 @@ export function unzip<$a, $b>(array: [$a, $b][]): [$a[], $b[]] {
     const res1: $a[] = new Array(len);
     const res2: $b[] = new Array(len);
     iterateIndexed<[$a, $b]>((i: int32, tupledArg: [$a, $b]): void => {
-        res1[i] = tupledArg[0];
-        res2[i] = tupledArg[1];
+        setItem_1(res1, i, tupledArg[0]);
+        setItem_1(res2, i, tupledArg[1]);
     }, array);
     return [res1, res2] as [$a[], $b[]];
 }
@@ -808,9 +809,9 @@ export function unzip3<$a, $b, $c>(array: [$a, $b, $c][]): [$a[], $b[], $c[]] {
     const res2: $b[] = new Array(len);
     const res3: $c[] = new Array(len);
     iterateIndexed<[$a, $b, $c]>((i: int32, tupledArg: [$a, $b, $c]): void => {
-        res1[i] = tupledArg[0];
-        res2[i] = tupledArg[1];
-        res3[i] = tupledArg[2];
+        setItem_1(res1, i, tupledArg[0]);
+        setItem_1(res2, i, tupledArg[1]);
+        setItem_1(res3, i, tupledArg[2]);
     }, array);
     return [res1, res2, res3] as [$a[], $b[], $c[]];
 }
@@ -821,7 +822,7 @@ export function zip<T, U>(array1: T[], array2: U[]): [T, U][] {
     }
     const result: [T, U][] = new Array(array1.length);
     for (let i = 0; i <= (array1.length - 1); i++) {
-        result[i] = ([array1[i], array2[i]] as [T, U]);
+        setItem_1(result, i, [item_2(i, array1), item_2(i, array2)] as [T, U]);
     }
     return result;
 }
@@ -832,7 +833,7 @@ export function zip3<T, U, V>(array1: T[], array2: U[], array3: V[]): [T, U, V][
     }
     const result: [T, U, V][] = new Array(array1.length);
     for (let i = 0; i <= (array1.length - 1); i++) {
-        result[i] = ([array1[i], array2[i], array3[i]] as [T, U, V]);
+        setItem_1(result, i, [item_2(i, array1), item_2(i, array2), item_2(i, array3)] as [T, U, V]);
     }
     return result;
 }
@@ -882,7 +883,7 @@ export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1:
         let i = 0;
         let res = 0;
         while ((res === 0) && (i < len)) {
-            res = (comparer(source1[i], source2[i]) | 0);
+            res = (comparer(item_2(i, source1), item_2(i, source2)) | 0);
             i = ((i + 1) | 0);
         }
         if (res !== 0) {
@@ -925,7 +926,7 @@ export function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T
             let i = 0;
             let res = 0;
             while ((res === 0) && (i < len1)) {
-                res = (comparer(source1[i], source2[i]) | 0);
+                res = (comparer(item_2(i, source1), item_2(i, source2)) | 0);
                 i = ((i + 1) | 0);
             }
             return res | 0;
@@ -958,7 +959,7 @@ export function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), array1: T
         }
         else {
             while ((i < length1) && result) {
-                result = equals(array1[i], array2[i]);
+                result = equals(item_2(i, array1), item_2(i, array2));
                 i = ((i + 1) | 0);
             }
             return result;
@@ -969,7 +970,7 @@ export function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), array1: T
 export function exactlyOne<T>(array: T[]): T {
     switch (array.length) {
         case 1:
-            return array[0];
+            return item_2(0, array);
         case 0:
             throw new Error("The input sequence was empty\\nParameter name: array");
         default:
@@ -979,7 +980,7 @@ export function exactlyOne<T>(array: T[]): T {
 
 export function tryExactlyOne<T>(array: T[]): Option<T> {
     if (array.length === 1) {
-        return some(array[0]);
+        return some(item_2(0, array));
     }
     else {
         return void 0;
@@ -991,7 +992,7 @@ export function head<T>(array: T[]): T {
         throw new Error("The input array was empty\\nParameter name: array");
     }
     else {
-        return array[0];
+        return item_2(0, array);
     }
 }
 
@@ -1000,7 +1001,7 @@ export function tryHead<T>(array: T[]): Option<T> {
         return void 0;
     }
     else {
-        return some(array[0]);
+        return some(item_2(0, array));
     }
 }
 
@@ -1011,8 +1012,22 @@ export function tail<T>(array: T[]): T[] {
     return array.slice(1);
 }
 
-export function item<$a>(index: int32, array: $a[]): $a {
-    return array[index];
+export function item<T>(index: int32, array: T[]): T {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        return array[index];
+    }
+}
+
+export function setItem<T>(array: T[], index: int32, value: T): void {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        array[index] = value;
+    }
 }
 
 export function tryItem<T>(index: int32, array: T[]): Option<T> {
@@ -1038,7 +1053,7 @@ export function foldIndexed2<$a, $b, $c>(folder: ((arg0: int32, arg1: $a, arg2:
         throw new Error("Arrays have different lengths");
     }
     for (let i = 0; i <= (array1.length - 1); i++) {
-        acc = folder(i, acc, array1[i], array2[i]);
+        acc = folder(i, acc, item_2(i, array1), item_2(i, array2));
     }
     return acc;
 }
@@ -1054,7 +1069,7 @@ export function foldBackIndexed2<T1, T2, State>(folder: ((arg0: int32, arg1: T1,
     }
     const size: int32 = array1.length | 0;
     for (let i = 1; i <= size; i++) {
-        acc = folder(i - 1, array1[size - i], array2[size - i], acc);
+        acc = folder(i - 1, item_2(size - i, array1), item_2(size - i, array2), acc);
     }
     return acc;
 }
@@ -1090,7 +1105,7 @@ export function existsOffset<T>(predicate_mut: ((arg0: T) => boolean), array_mut
         if (index === array.length) {
             return false;
         }
-        else if (predicate(array[index])) {
+        else if (predicate(item_2(index, array))) {
             return true;
         }
         else {
@@ -1114,7 +1129,7 @@ export function existsOffset2<$a, $b>(predicate_mut: ((arg0: $a, arg1: $b) => bo
         if (index === array1.length) {
             return false;
         }
-        else if (predicate(array1[index], array2[index])) {
+        else if (predicate(item_2(index, array1), item_2(index, array2))) {
             return true;
         }
         else {
@@ -1138,7 +1153,7 @@ export function exists2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), ar
 export function sum<T>(array: T[], adder: any): T {
     let acc: T = adder.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
-        acc = adder.Add(acc, array[i]);
+        acc = adder.Add(acc, item_2(i, array));
     }
     return acc;
 }
@@ -1146,7 +1161,7 @@ export function sum<T>(array: T[], adder: any): T {
 export function sumBy<T, T2>(projection: ((arg0: T) => T2), array: T[], adder: any): T2 {
     let acc: T2 = adder.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
-        acc = adder.Add(acc, projection(array[i]));
+        acc = adder.Add(acc, projection(item_2(i, array)));
     }
     return acc;
 }
@@ -1173,7 +1188,7 @@ export function average<T>(array: T[], averager: any): T {
     }
     let total: T = averager.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
-        total = averager.Add(total, array[i]);
+        total = averager.Add(total, item_2(i, array));
     }
     return averager.DivideByInt(total, array.length);
 }
@@ -1184,7 +1199,7 @@ export function averageBy<T, T2>(projection: ((arg0: T) => T2), array: T[], aver
     }
     let total: T2 = averager.GetZero();
     for (let i = 0; i <= (array.length - 1); i++) {
-        total = averager.Add(total, projection(array[i]));
+        total = averager.Add(total, projection(item_2(i, array)));
     }
     return averager.DivideByInt(total, array.length);
 }
@@ -1197,7 +1212,7 @@ export function windowed<T>(windowSize: int32, source: T[]): T[][] {
     const len: int32 = max_1(0, (source.length - windowSize) + 1) | 0;
     res = (new Array(len));
     for (let i: int32 = windowSize; i <= source.length; i++) {
-        res[i - windowSize] = source.slice(i - windowSize, (i - 1) + 1);
+        setItem_1(res, i - windowSize, source.slice(i - windowSize, (i - 1) + 1));
     }
     return res;
 }
@@ -1232,16 +1247,16 @@ export function transpose<T>(arrays: Iterable<T[]>, cons?: any): T[][] {
         return new Array(0);
     }
     else {
-        const firstArray: T[] = arrays_1[0];
+        const firstArray: T[] = item_2(0, arrays_1);
         const lenInner: int32 = firstArray.length | 0;
         if (!forAll<T[]>((a: T[]): boolean => (a.length === lenInner), arrays_1)) {
             differentLengths<void>();
         }
         const result: T[][] = new Array(lenInner);
         for (let i = 0; i <= (lenInner - 1); i++) {
-            result[i] = Helpers_allocateArrayFromCons<T>(cons, len);
+            setItem_1(result, i, Helpers_allocateArrayFromCons<T>(cons, len));
             for (let j = 0; j <= (len - 1); j++) {
-                result[i][j] = arrays_1[j][i];
+                item_2(i, result)[j] = item_2(i, item_2(j, arrays_1));
             }
         }
         return result;
@@ -1255,11 +1270,11 @@ export function insertAt<T>(index: int32, y: T, xs: T[], cons?: any): T[] {
     }
     const target: T[] = Helpers_allocateArrayFromCons<T>(cons, len + 1);
     for (let i = 0; i <= (index - 1); i++) {
-        target[i] = xs[i];
+        setItem_1(target, i, item_2(i, xs));
     }
-    target[index] = y;
+    setItem_1(target, index, y);
     for (let i_1: int32 = index; i_1 <= (len - 1); i_1++) {
-        target[i_1 + 1] = xs[i_1];
+        setItem_1(target, i_1 + 1, item_2(i_1, xs));
     }
     return target;
 }
@@ -1273,13 +1288,13 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: T[], cons?: a
     const len2: int32 = ys_1.length | 0;
     const target: T[] = Helpers_allocateArrayFromCons<T>(cons, len + len2);
     for (let i = 0; i <= (index - 1); i++) {
-        target[i] = xs[i];
+        setItem_1(target, i, item_2(i, xs));
     }
     for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {
-        target[index + i_1] = ys_1[i_1];
+        setItem_1(target, index + i_1, item_2(i_1, ys_1));
     }
     for (let i_2: int32 = index; i_2 <= (len - 1); i_2++) {
-        target[i_2 + len2] = xs[i_2];
+        setItem_1(target, i_2 + len2, item_2(i_2, xs));
     }
     return target;
 }
@@ -1331,7 +1346,7 @@ export function updateAt<T>(index: int32, y: T, xs: T[], cons?: any): T[] {
     }
     const target: T[] = Helpers_allocateArrayFromCons<T>(cons, len);
     for (let i = 0; i <= (len - 1); i++) {
-        target[i] = ((i === index) ? y : xs[i]);
+        setItem_1(target, i, (i === index) ? y : item_2(i, xs));
     }
     return target;
 }

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 1.1.0 - 2024-02-20
+
+### Added
+
+#### JavaScript
+
+* [GH-3759](https://github.com/fable-compiler/Fable/issues/3759) Add `StringBuilder.Chars` (by @MangelMaxime)
+* Add `StringBuilder.AppendFormat` (by @ncave)
+* [GH-3748](https://github.com/fable-compiler/Fable/pull/3748) Add `Array.getItem` and `Array.setItem` (by @MangelMaxime)
+
+## 1.0.0 - 2024-02-13
+
+* Release stable version
+
 ## 1.0.0-beta-001 - 2024-02-12
 
 ### Changed

package/List.ts

@@ -5,7 +5,7 @@ import { int32 } from "./Int32.js";
 import { Record } from "./Types.js";
 import { class_type, record_type, option_type, TypeInfo } from "./Reflection.js";
 import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.js";
-import { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, fill } from "./Array.js";
+import { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.js";
 
 export class FSharpList<T> extends Record implements Iterable<T> {
     readonly head: T;
@@ -384,7 +384,7 @@ export function toArray<T>(xs: FSharpList<T>): T[] {
         while (true) {
             const i: int32 = i_mut, xs_1: FSharpList<T> = xs_1_mut;
             if (!FSharpList__get_IsEmpty<T>(xs_1)) {
-                res[i] = FSharpList__get_Head<T>(xs_1);
+                setItem(res, i, FSharpList__get_Head<T>(xs_1));
                 i_mut = (i + 1);
                 xs_1_mut = FSharpList__get_Tail<T>(xs_1);
                 continue loop;
@@ -508,7 +508,7 @@ export function toSeq<T>(xs: FSharpList<T>): Iterable<T> {
 export function ofArrayWithTail<T>(xs: T[], tail_1: FSharpList<T>): FSharpList<T> {
     let res: FSharpList<T> = tail_1;
     for (let i: int32 = xs.length - 1; i >= 0; i--) {
-        res = FSharpList_Cons_305B8EAC<T>(xs[i], res);
+        res = FSharpList_Cons_305B8EAC<T>(item_1(i, xs), res);
     }
     return res;
 }

package/Map.ts

@@ -3,7 +3,7 @@ import { some, value as value_1, Option } from "./Option.js";
 import { int32 } from "./Int32.js";
 import { structuralHash, IMap, compare, toIterator, equals, IDisposable, disposeSafe, getEnumerator, isArrayLike, IEnumerator, IComparer } from "./Util.js";
 import { singleton, ofArrayWithTail, head, tail, isEmpty as isEmpty_1, fold as fold_1, empty as empty_1, FSharpList, cons } from "./List.js";
-import { map as map_2, fill } from "./Array.js";
+import { map as map_2, item, fill, setItem } from "./Array.js";
 import { FSharpRef, Record } from "./Types.js";
 import { tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, map as map_1, unfold } from "./Seq.js";
 import { format, join } from "./String.js";
@@ -817,7 +817,7 @@ export function MapTreeModule_toList<Key, Value>(m: Option<MapTreeLeaf$2<Key, Va
 export function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>, arr: [$a, $b][], i: int32): void {
     let j: int32 = i;
     MapTreeModule_iter<$a, $b>((x: $a, y: $b): void => {
-        arr[j] = ([x, y] as [$a, $b]);
+        setItem(arr, j, [x, y] as [$a, $b]);
         j = ((j + 1) | 0);
     }, m);
 }
@@ -854,7 +854,7 @@ export function MapTreeModule_mkFromEnumerator<$a, $b>(comparer_mut: IComparer<$
 export function MapTreeModule_ofArray<Key, Value>(comparer: IComparer<Key>, arr: [Key, Value][]): Option<MapTreeLeaf$2<Key, Value>> {
     let res: Option<MapTreeLeaf$2<Key, Value>> = MapTreeModule_empty<Key, Value>();
     for (let idx = 0; idx <= (arr.length - 1); idx++) {
-        const forLoopVar: [Key, Value] = arr[idx];
+        const forLoopVar: [Key, Value] = item(idx, arr);
         res = MapTreeModule_add<Key, Value>(comparer, forLoopVar[0], forLoopVar[1], res);
     }
     return res;

package/MutableMap.ts

@@ -2,6 +2,7 @@ import { IEqualityComparer, IDisposable, disposeSafe, defaultOf, IMap, equals, t
 import { iterate, map, delay, toArray, iterateIndexed, concat } from "./Seq.js";
 import { value as value_1, Option } from "./Option.js";
 import { int32 } from "./Int32.js";
+import { setItem } from "./Array.js";
 import { FSharpRef } from "./Types.js";
 import { class_type, TypeInfo } from "./Reflection.js";
 import { getItemFromDict, tryGetValue } from "./MapUtil.js";
@@ -80,7 +81,7 @@ export class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key,
     "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: [Key, Value][], arrayIndex: int32): void {
         const this$: Dictionary<Key, Value> = this;
         iterateIndexed<[Key, Value]>((i: int32, e: [Key, Value]): void => {
-            array[arrayIndex + i] = e;
+            setItem(array, arrayIndex + i, e);
         }, this$);
     }
     "System.Collections.Generic.ICollection`1.get_Count"(): int32 {

package/MutableSet.ts

@@ -1,5 +1,6 @@
 import { IMap, IEqualityComparer, IDisposable, disposeSafe, defaultOf, ISet, toIterator, IEnumerator, getEnumerator } from "./Util.js";
 import { iterate, map, iterateIndexed, concat } from "./Seq.js";
+import { setItem } from "./Array.js";
 import { int32 } from "./Int32.js";
 import { some, Option } from "./Option.js";
 import { FSharpRef } from "./Types.js";
@@ -60,7 +61,7 @@ export class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
     "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: T[], arrayIndex: int32): void {
         const this$: HashSet<T> = this;
         iterateIndexed<T>((i: int32, e: T): void => {
-            array[arrayIndex + i] = e;
+            setItem(array, arrayIndex + i, e);
         }, this$);
     }
     "System.Collections.Generic.ICollection`1.get_Count"(): int32 {

package/Random.ts

@@ -1,7 +1,7 @@
 import { uint8, int32, float64 } from "./Int32.js";
 import { class_type, TypeInfo } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32, toFloat64, compare, int64, fromInt32, toInt64 } from "./BigInt.js";
-import { fill } from "./Array.js";
+import { item, fill, setItem } from "./Array.js";
 
 function Native_random(): float64 {
     return Math.random();
@@ -91,13 +91,13 @@ export class Seeded implements IRandom {
             if (mk < 0) {
                 mk = ((mk + this.MBIG) | 0);
             }
-            mj = (this.seedArray[ii] | 0);
+            mj = (item(ii, this.seedArray) | 0);
         }
         for (let k = 1; k <= 4; k++) {
             for (let i_1 = 1; i_1 <= 55; i_1++) {
-                this.seedArray[i_1] = ((this.seedArray[i_1] - this.seedArray[1 + ((i_1 + 30) % 55)]) | 0);
-                if (this.seedArray[i_1] < 0) {
-                    this.seedArray[i_1] = ((this.seedArray[i_1] + this.MBIG) | 0);
+                this.seedArray[i_1] = ((item(i_1, this.seedArray) - item(1 + ((i_1 + 30) % 55), this.seedArray)) | 0);
+                if (item(i_1, this.seedArray) < 0) {
+                    this.seedArray[i_1] = ((item(i_1, this.seedArray) + this.MBIG) | 0);
                 }
             }
         }
@@ -133,7 +133,7 @@ export class Seeded implements IRandom {
             throw new Error("buffer");
         }
         for (let i = 0; i <= (buffer.length - 1); i++) {
-            buffer[i] = ((Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);
+            setItem(buffer, i, (Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);
         }
     }
 }
@@ -158,7 +158,7 @@ function Seeded__InternalSample(_: Seeded): int32 {
     if (locINextp >= 56) {
         locINextp = 1;
     }
-    retVal = ((_.seedArray[locINext] - _.seedArray[locINextp]) | 0);
+    retVal = ((item(locINext, _.seedArray) - item(locINextp, _.seedArray)) | 0);
     if (retVal === _.MBIG) {
         retVal = ((retVal - 1) | 0);
     }

package/Set.ts

@@ -4,7 +4,7 @@ import { int32 } from "./Int32.js";
 import { structuralHash, ISet, toIterator, IDisposable, disposeSafe, getEnumerator, isArrayLike, IEnumerator, IComparer } from "./Util.js";
 import { toString, Record } from "./Types.js";
 import { fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1, FSharpList } from "./List.js";
-import { fold as fold_1, fill } from "./Array.js";
+import { fold as fold_1, fill, setItem } from "./Array.js";
 import { join } from "./String.js";
 import { exists as exists_1, cache, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from "./Seq.js";
 import { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from "./MutableSet.js";
@@ -1420,7 +1420,7 @@ export function SetTreeModule_toList<T>(t: Option<SetTreeLeaf$1<T>>): FSharpList
 export function SetTreeModule_copyToArray<$a>(s: Option<SetTreeLeaf$1<$a>>, arr: $a[], i: int32): void {
     let j: int32 = i;
     SetTreeModule_iter<$a>((x: $a): void => {
-        arr[j] = x;
+        setItem(arr, j, x);
         j = ((j + 1) | 0);
     }, s);
 }

package/String.ts

@@ -568,6 +568,10 @@ export function substring(str: string, startIndex: number, length?: number) {
   return length != null ? str.substr(startIndex, length) : str.substr(startIndex);
 }
 
+export function toCharArray2(str: string, startIndex: number, length: number) {
+  return substring(str, startIndex, length).split("")
+}
+
 interface FormattableString {
   strs: TemplateStringsArray,
   args: any[],

package/System.Collections.Generic.ts

@@ -2,7 +2,7 @@ import { int32 } from "./Int32.js";
 import { IDisposable, disposeSafe, defaultOf, toIterator, IEnumerator, getEnumerator, structuralHash, equals as equals_1, IEqualityComparer, compare, IComparer } from "./Util.js";
 import { class_type, TypeInfo } from "./Reflection.js";
 import { toArray, empty, singleton, append, enumerateWhile, delay } from "./Seq.js";
-import { initialize, copyTo, fill } from "./Array.js";
+import { setItem, initialize, copyTo, fill, item as item_1 } from "./Array.js";
 import { max } from "./Double.js";
 import { FSharpRef } from "./Types.js";
 
@@ -89,7 +89,7 @@ export class Stack$1<T> implements Iterable<T> {
         const _: Stack$1<T> = this;
         return getEnumerator(delay<T>((): Iterable<T> => {
             let index: int32 = _.count - 1;
-            return enumerateWhile<T>((): boolean => (index >= 0), delay<T>((): Iterable<T> => append<T>(singleton<T>(_.contents[index]), delay<T>((): Iterable<T> => {
+            return enumerateWhile<T>((): boolean => (index >= 0), delay<T>((): Iterable<T> => append<T>(singleton<T>(item_1(index, _.contents)), delay<T>((): Iterable<T> => {
                 index = ((index - 1) | 0);
                 return empty<T>();
             }))));
@@ -140,18 +140,18 @@ export function Stack$1__get_Count<T>(_: Stack$1<T>): int32 {
 
 export function Stack$1__Pop<T>(_: Stack$1<T>): T {
     _.count = ((_.count - 1) | 0);
-    return _.contents[_.count];
+    return item_1(_.count, _.contents);
 }
 
 export function Stack$1__Peek<T>(_: Stack$1<T>): T {
-    return _.contents[_.count - 1];
+    return item_1(_.count - 1, _.contents);
 }
 
 export function Stack$1__Contains_2B595<T>(_: Stack$1<T>, x: T): boolean {
     let found = false;
     let i = 0;
     while ((i < _.count) && !found) {
-        if (equals_1(x, _.contents[i])) {
+        if (equals_1(x, item_1(i, _.contents))) {
             found = true;
         }
         else {
@@ -199,7 +199,7 @@ export function Stack$1__TrimExcess<T>(this$: Stack$1<T>): void {
 }
 
 export function Stack$1__ToArray<T>(_: Stack$1<T>): T[] {
-    return initialize<T>(_.count, (i: int32): T => _.contents[(_.count - 1) - i]);
+    return initialize<T>(_.count, (i: int32): T => item_1((_.count - 1) - i, _.contents));
 }
 
 export class Queue$1<T> implements Iterable<T> {
@@ -267,7 +267,7 @@ export function Queue$1__Dequeue<T>(_: Queue$1<T>): T {
     if (_.count === 0) {
         throw new Error("Queue is empty");
     }
-    const value: T = _.contents[_.head];
+    const value: T = item_1(_.head, _.contents);
     _.head = (((_.head + 1) % Queue$1__size<T>(_)) | 0);
     _.count = ((_.count - 1) | 0);
     return value;
@@ -277,7 +277,7 @@ export function Queue$1__Peek<T>(_: Queue$1<T>): T {
     if (_.count === 0) {
         throw new Error("Queue is empty");
     }
-    return _.contents[_.head];
+    return item_1(_.head, _.contents);
 }
 
 export function Queue$1__TryDequeue_1F3DB691<T>(this$: Queue$1<T>, result: FSharpRef<T>): boolean {
@@ -304,7 +304,7 @@ export function Queue$1__Contains_2B595<T>(_: Queue$1<T>, x: T): boolean {
     let found = false;
     let i = 0;
     while ((i < _.count) && !found) {
-        if (equals_1(x, _.contents[Queue$1__toIndex_Z524259A4<T>(_, i)])) {
+        if (equals_1(x, item_1(Queue$1__toIndex_Z524259A4<T>(_, i), _.contents))) {
             found = true;
         }
         else {
@@ -337,7 +337,7 @@ export function Queue$1__CopyTo_Z3B4C077E<T>(_: Queue$1<T>, target: T[], start:
     try {
         while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
             const item: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            target[i] = item;
+            setItem(target, i, item);
             i = ((i + 1) | 0);
         }
     }
@@ -371,7 +371,7 @@ export function Queue$1__ensure_Z524259A4<T>(this$: Queue$1<T>, requiredSize: in
 export function Queue$1__toSeq<T>(this$: Queue$1<T>): Iterable<T> {
     return delay<T>((): Iterable<T> => {
         let i = 0;
-        return enumerateWhile<T>((): boolean => (i < this$.count), delay<T>((): Iterable<T> => append<T>(singleton<T>(this$.contents[Queue$1__toIndex_Z524259A4<T>(this$, i)]), delay<T>((): Iterable<T> => {
+        return enumerateWhile<T>((): boolean => (i < this$.count), delay<T>((): Iterable<T> => append<T>(singleton<T>(item_1(Queue$1__toIndex_Z524259A4<T>(this$, i), this$.contents)), delay<T>((): Iterable<T> => {
             i = ((i + 1) | 0);
             return empty<T>();
         }))));

package/System.Text.ts

@@ -88,11 +88,41 @@ export function StringBuilder__AppendFormat_433E080(x: StringBuilder, fmt: strin
     return x;
 }
 
+export function StringBuilder__AppendFormat_Z3B30EC65(x: StringBuilder, fmt: string, o1: any, o2: any): StringBuilder {
+    void (x.buf.push(format(fmt, o1, o2)));
+    return x;
+}
+
+export function StringBuilder__AppendFormat_10D165E0(x: StringBuilder, fmt: string, o1: any, o2: any, o3: any): StringBuilder {
+    void (x.buf.push(format(fmt, o1, o2, o3)));
+    return x;
+}
+
+export function StringBuilder__AppendFormat_Z17053F5(x: StringBuilder, fmt: string, arr: any[]): StringBuilder {
+    void (x.buf.push(format(fmt, ...arr)));
+    return x;
+}
+
 export function StringBuilder__AppendFormat_Z696D8D1B(x: StringBuilder, provider: any, fmt: string, o: any): StringBuilder {
     void (x.buf.push(format(provider, fmt, o)));
     return x;
 }
 
+export function StringBuilder__AppendFormat_26802C9E(x: StringBuilder, provider: any, fmt: string, o1: any, o2: any): StringBuilder {
+    void (x.buf.push(format(provider, fmt, o1, o2)));
+    return x;
+}
+
+export function StringBuilder__AppendFormat_Z471ADCBB(x: StringBuilder, provider: any, fmt: string, o1: any, o2: any, o3: any): StringBuilder {
+    void (x.buf.push(format(provider, fmt, o1, o2, o3)));
+    return x;
+}
+
+export function StringBuilder__AppendFormat_6C2E3E6E(x: StringBuilder, provider: any, fmt: string, arr: any[]): StringBuilder {
+    void (x.buf.push(format(provider, fmt, ...arr)));
+    return x;
+}
+
 export function StringBuilder__AppendLine(x: StringBuilder): StringBuilder {
     void (x.buf.push("\n"));
     return x;
@@ -104,6 +134,43 @@ export function StringBuilder__AppendLine_Z721C83C5(x: StringBuilder, s: string)
     return x;
 }
 
+export function StringBuilder__Clear(x: StringBuilder): StringBuilder {
+    clear(x.buf);
+    return x;
+}
+
+export function StringBuilder__get_Chars_Z524259A4(x: StringBuilder, index: int32): string {
+    let len = 0;
+    let i = -1;
+    while (((i + 1) < x.buf.length) && (len < index)) {
+        i = ((i + 1) | 0);
+        len = ((len + x.buf[i].length) | 0);
+    }
+    if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
+        throw new Error("Index was outside the bounds of the array");
+    }
+    else {
+        const pos: int32 = ((len - index) - 1) | 0;
+        return x.buf[i][pos];
+    }
+}
+
+export function StringBuilder__set_Chars_413E0D0A(x: StringBuilder, index: int32, value: string): void {
+    let len = 0;
+    let i = -1;
+    while (((i + 1) < x.buf.length) && (len < index)) {
+        i = ((i + 1) | 0);
+        len = ((len + x.buf[i].length) | 0);
+    }
+    if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
+        throw new Error("Index was outside the bounds of the array");
+    }
+    else {
+        const pos: int32 = ((len - index) - 1) | 0;
+        x.buf[i] = ((x.buf[i].slice(0, (pos - 1) + 1) + value) + x.buf[i].slice(pos + 1, x.buf[i].length));
+    }
+}
+
 export function StringBuilder__Replace_Z766F94C0(x: StringBuilder, oldValue: string, newValue: string): StringBuilder {
     for (let i: int32 = x.buf.length - 1; i >= 0; i--) {
         x.buf[i] = replace(x.buf[i], oldValue, newValue);
@@ -112,10 +179,8 @@ export function StringBuilder__Replace_Z766F94C0(x: StringBuilder, oldValue: str
 }
 
 export function StringBuilder__Replace_Z384F8060(x: StringBuilder, oldValue: string, newValue: string): StringBuilder {
-    for (let i: int32 = x.buf.length - 1; i >= 0; i--) {
-        x.buf[i] = replace(x.buf[i], oldValue, newValue);
-    }
-    return x;
+    const str: string = replace(toString(x), oldValue, newValue);
+    return StringBuilder__Append_Z721C83C5(StringBuilder__Clear(x), str);
 }
 
 export function StringBuilder__get_Length(x: StringBuilder): int32 {
@@ -130,8 +195,3 @@ export function StringBuilder__ToString_Z37302880(x: StringBuilder, firstIndex:
     return substring(toString(x), firstIndex, length);
 }
 
-export function StringBuilder__Clear(x: StringBuilder): StringBuilder {
-    clear(x.buf);
-    return x;
-}
-

package/package.json

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