@fable-org/fable-library-js 1.0.0 → 1.2.0

package/Date.js

@@ -9,6 +9,342 @@
  */
 import { toInt64, toFloat64 } from "./BigInt.js";
 import { compareDates, dateOffset, padWithZeros } from "./Util.js";
+const shortDays = [
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+];
+const longDays = [
+    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+];
+const shortMonths = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+];
+const longMonths = [
+    "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
+];
+function parseRepeatToken(format, pos, patternChar) {
+    let tokenLength = 0;
+    let internalPos = pos;
+    while (internalPos < format.length && format[internalPos] === patternChar) {
+        internalPos++;
+        tokenLength++;
+    }
+    return tokenLength;
+}
+function parseNextChar(format, pos) {
+    if (pos >= format.length - 1) {
+        return -1;
+    }
+    return format.charCodeAt(pos + 1);
+}
+function parseQuotedString(format, pos) {
+    let beginPos = pos;
+    // Get the character used to quote the string
+    const quoteChar = format[pos];
+    let result = "";
+    let foundQuote = false;
+    while (pos < format.length) {
+        pos++;
+        const currentChar = format[pos];
+        if (currentChar === quoteChar) {
+            foundQuote = true;
+            break;
+        }
+        else if (currentChar === "\\") {
+            if (pos < format.length) {
+                pos++;
+                result += format[pos];
+            }
+            else {
+                // This means that '\' is the last character in the string.
+                throw new Error("Invalid string format");
+            }
+        }
+        else {
+            result += currentChar;
+        }
+    }
+    if (!foundQuote) {
+        // We could not find the matching quote
+        throw new Error(`Invalid string format could not find matching quote for ${quoteChar}`);
+    }
+    return [result, pos - beginPos + 1];
+}
+function dateToStringWithCustomFormat(date, format, utc) {
+    let cursorPos = 0;
+    let tokenLength = 0;
+    let result = "";
+    const localizedDate = utc ? DateTime(date.getTime(), 1 /* DateKind.UTC */) : date;
+    while (cursorPos < format.length) {
+        const token = format[cursorPos];
+        switch (token) {
+            case "d":
+                tokenLength = parseRepeatToken(format, cursorPos, "d");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getDate();
+                        break;
+                    case 2:
+                        result += padWithZeros(localizedDate.getDate(), 2);
+                        break;
+                    case 3:
+                        result += shortDays[dayOfWeek(localizedDate)];
+                        break;
+                    case 4:
+                        result += longDays[dayOfWeek(localizedDate)];
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "f":
+                tokenLength = parseRepeatToken(format, cursorPos, "f");
+                cursorPos += tokenLength;
+                if (tokenLength <= 3) {
+                    const precision = 10 ** (3 - tokenLength);
+                    result += padWithZeros(Math.floor(millisecond(localizedDate) / precision), tokenLength);
+                }
+                else if (tokenLength <= 7) {
+                    // JavaScript Date only support precision to the millisecond
+                    // so we fill the rest of the precision with 0 as if the date didn't have
+                    // milliseconds provided to it.
+                    // This is to have the same behavior as .NET when doing:
+                    // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
+                    result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
+                }
+                break;
+            case "F":
+                tokenLength = parseRepeatToken(format, cursorPos, "F");
+                cursorPos += tokenLength;
+                if (tokenLength <= 3) {
+                    const precision = 10 ** (3 - tokenLength);
+                    const value = Math.floor(millisecond(localizedDate) / precision);
+                    if (value != 0) {
+                        result += padWithZeros(value, tokenLength);
+                    }
+                }
+                else if (tokenLength <= 7) {
+                    // JavaScript Date only support precision to the millisecond
+                    // so we can't go beyond that.
+                    // We also need to pad start with 0 if the value is not 0
+                    const value = millisecond(localizedDate);
+                    if (value != 0) {
+                        result += padWithZeros(value, 3);
+                    }
+                }
+                break;
+            case "g":
+                tokenLength = parseRepeatToken(format, cursorPos, "g");
+                cursorPos += tokenLength;
+                if (tokenLength <= 2) {
+                    result += "A.D.";
+                }
+                break;
+            case "h":
+                tokenLength = parseRepeatToken(format, cursorPos, "h");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += hour(localizedDate) % 12;
+                        break;
+                    case 2:
+                        result += padWithZeros(hour(localizedDate) % 12, 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "H":
+                tokenLength = parseRepeatToken(format, cursorPos, "H");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += hour(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(hour(localizedDate), 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "K":
+                tokenLength = parseRepeatToken(format, cursorPos, "K");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        switch (kind(localizedDate)) {
+                            case 1 /* DateKind.UTC */:
+                                result += "Z";
+                                break;
+                            case 2 /* DateKind.Local */:
+                                result += dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
+                                break;
+                            case 0 /* DateKind.Unspecified */:
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "m":
+                tokenLength = parseRepeatToken(format, cursorPos, "m");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += minute(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(minute(localizedDate), 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "M":
+                tokenLength = parseRepeatToken(format, cursorPos, "M");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += month(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(month(localizedDate), 2);
+                        break;
+                    case 3:
+                        result += shortMonths[month(localizedDate) - 1];
+                        break;
+                    case 4:
+                        result += longMonths[month(localizedDate) - 1];
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "s":
+                tokenLength = parseRepeatToken(format, cursorPos, "s");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += second(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(second(localizedDate), 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "t":
+                tokenLength = parseRepeatToken(format, cursorPos, "t");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getHours() < 12 ? "A" : "P";
+                        break;
+                    case 2:
+                        result += localizedDate.getHours() < 12 ? "AM" : "PM";
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "y":
+                tokenLength = parseRepeatToken(format, cursorPos, "y");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getFullYear() % 100;
+                        break;
+                    case 2:
+                        result += padWithZeros(localizedDate.getFullYear() % 100, 2);
+                        break;
+                    case 3:
+                        result += padWithZeros(localizedDate.getFullYear(), 3);
+                        break;
+                    case 4:
+                        result += padWithZeros(localizedDate.getFullYear(), 4);
+                        break;
+                    case 5:
+                        result += padWithZeros(localizedDate.getFullYear(), 5);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "z":
+                tokenLength = parseRepeatToken(format, cursorPos, "z");
+                cursorPos += tokenLength;
+                let utcOffsetText = "";
+                switch (kind(localizedDate)) {
+                    case 1 /* DateKind.UTC */:
+                        utcOffsetText = "+00:00";
+                        break;
+                    case 2 /* DateKind.Local */:
+                        utcOffsetText = dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
+                        break;
+                    case 0 /* DateKind.Unspecified */:
+                        utcOffsetText = dateOffsetToString(toLocalTime(localizedDate).getTimezoneOffset() * -60000);
+                        break;
+                }
+                const sign = utcOffsetText[0] === "-" ? "-" : "+";
+                const hours = parseInt(utcOffsetText.substring(1, 3), 10);
+                const minutes = parseInt(utcOffsetText.substring(4, 6), 10);
+                switch (tokenLength) {
+                    case 1:
+                        result += `${sign}${hours}`;
+                        break;
+                    case 2:
+                        result += `${sign}${padWithZeros(hours, 2)}`;
+                        break;
+                    default:
+                        result += `${sign}${padWithZeros(hours, 2)}:${padWithZeros(minutes, 2)}`;
+                        break;
+                }
+                break;
+            case ":":
+                result += ":";
+                cursorPos++;
+                break;
+            case "/":
+                result += "/";
+                cursorPos++;
+                break;
+            case "'":
+            case '"':
+                const [quotedString, quotedStringLenght] = parseQuotedString(format, cursorPos);
+                result += quotedString;
+                cursorPos += quotedStringLenght;
+                break;
+            case "%":
+                const nextChar = parseNextChar(format, cursorPos);
+                if (nextChar >= 0 && nextChar !== "%".charCodeAt(0)) {
+                    cursorPos += 2;
+                    result += dateToStringWithCustomFormat(localizedDate, String.fromCharCode(nextChar), utc);
+                }
+                else {
+                    throw new Error("Invalid format string");
+                }
+                break;
+            case "\\":
+                const nextChar2 = parseNextChar(format, cursorPos);
+                if (nextChar2 >= 0) {
+                    cursorPos += 2;
+                    result += String.fromCharCode(nextChar2);
+                }
+                else {
+                    throw new Error("Invalid format string");
+                }
+                break;
+            default:
+                cursorPos++;
+                result += token;
+                break;
+        }
+    }
+    return result;
+}
 export function kind(value) {
     return value.kind || 0;
 }
@@ -54,45 +390,6 @@ function dateToISOStringWithOffset(dateWithOffset, offset) {
     const str = dateWithOffset.toISOString();
     return str.substring(0, str.length - 1) + dateOffsetToString(offset);
 }
-function dateToStringWithCustomFormat(date, format, utc) {
-    return format.replace(/(\w)\1*/g, (match) => {
-        let rep = Number.NaN;
-        switch (match.substring(0, 1)) {
-            case "y":
-                const y = utc ? date.getUTCFullYear() : date.getFullYear();
-                rep = match.length < 4 ? y % 100 : y;
-                break;
-            case "M":
-                rep = (utc ? date.getUTCMonth() : date.getMonth()) + 1;
-                break;
-            case "d":
-                rep = utc ? date.getUTCDate() : date.getDate();
-                break;
-            case "H":
-                rep = utc ? date.getUTCHours() : date.getHours();
-                break;
-            case "h":
-                const h = utc ? date.getUTCHours() : date.getHours();
-                rep = h > 12 ? h % 12 : h;
-                break;
-            case "m":
-                rep = utc ? date.getUTCMinutes() : date.getMinutes();
-                break;
-            case "s":
-                rep = utc ? date.getUTCSeconds() : date.getSeconds();
-                break;
-            case "f":
-                rep = utc ? date.getUTCMilliseconds() : date.getMilliseconds();
-                break;
-        }
-        if (Number.isNaN(rep)) {
-            return match;
-        }
-        else {
-            return padWithZeros(rep, match.length);
-        }
-    });
-}
 function dateToStringWithOffset(date, format) {
     const d = new Date(date.getTime() + (date.offset ?? 0));
     if (typeof format !== "string") {

package/List.js

@@ -4,7 +4,7 @@ import { disposeSafe, isArrayLike, defaultOf, toIterator, getEnumerator, compare
 import { Record } from "./Types.js";
 import { class_type, record_type, option_type } 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 extends Record {
     constructor(head, tail) {
         super();
@@ -345,7 +345,7 @@ export function toArray(xs) {
         loop: while (true) {
             const i = i_mut, xs_1 = xs_1_mut;
             if (!FSharpList__get_IsEmpty(xs_1)) {
-                res[i] = FSharpList__get_Head(xs_1);
+                setItem(res, i, FSharpList__get_Head(xs_1));
                 i_mut = (i + 1);
                 xs_1_mut = FSharpList__get_Tail(xs_1);
                 continue loop;
@@ -454,7 +454,7 @@ export function toSeq(xs) {
 export function ofArrayWithTail(xs, tail_1) {
     let res = tail_1;
     for (let i = xs.length - 1; i >= 0; i--) {
-        res = FSharpList_Cons_305B8EAC(xs[i], res);
+        res = FSharpList_Cons_305B8EAC(item_1(i, xs), res);
     }
     return res;
 }

package/Map.js

@@ -2,7 +2,7 @@ import { record_type, bool_type, list_type, option_type, class_type } from "./Re
 import { some, value as value_1 } from "./Option.js";
 import { structuralHash, compare, toIterator, equals, disposeSafe, getEnumerator, isArrayLike } 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 { 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";
@@ -750,7 +750,7 @@ export function MapTreeModule_toList(m) {
 export function MapTreeModule_copyToArray(m, arr, i) {
     let j = i;
     MapTreeModule_iter((x, y) => {
-        arr[j] = [x, y];
+        setItem(arr, j, [x, y]);
         j = ((j + 1) | 0);
     }, m);
 }
@@ -782,7 +782,7 @@ export function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {
 export function MapTreeModule_ofArray(comparer, arr) {
     let res = MapTreeModule_empty();
     for (let idx = 0; idx <= (arr.length - 1); idx++) {
-        const forLoopVar = arr[idx];
+        const forLoopVar = item(idx, arr);
         res = MapTreeModule_add(comparer, forLoopVar[0], forLoopVar[1], res);
     }
     return res;

package/MutableMap.js

@@ -1,6 +1,7 @@
 import { disposeSafe, defaultOf, equals, toIterator, getEnumerator } from "./Util.js";
 import { iterate, map, delay, toArray, iterateIndexed, concat } from "./Seq.js";
 import { value as value_1 } from "./Option.js";
+import { setItem } from "./Array.js";
 import { FSharpRef } from "./Types.js";
 import { class_type } from "./Reflection.js";
 import { getItemFromDict, tryGetValue } from "./MapUtil.js";
@@ -75,7 +76,7 @@ export class Dictionary {
     "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array, arrayIndex) {
         const this$ = this;
         iterateIndexed((i, e) => {
-            array[arrayIndex + i] = e;
+            setItem(array, arrayIndex + i, e);
         }, this$);
     }
     "System.Collections.Generic.ICollection`1.get_Count"() {

package/MutableSet.js

@@ -1,5 +1,6 @@
 import { disposeSafe, defaultOf, toIterator, getEnumerator } from "./Util.js";
 import { iterate, map, iterateIndexed, concat } from "./Seq.js";
+import { setItem } from "./Array.js";
 import { some } from "./Option.js";
 import { FSharpRef } from "./Types.js";
 import { class_type } from "./Reflection.js";
@@ -55,7 +56,7 @@ export class HashSet {
     "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array, arrayIndex) {
         const this$ = this;
         iterateIndexed((i, e) => {
-            array[arrayIndex + i] = e;
+            setItem(array, arrayIndex + i, e);
         }, this$);
     }
     "System.Collections.Generic.ICollection`1.get_Count"() {

package/Random.js

@@ -1,6 +1,6 @@
 import { class_type } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32, toFloat64, compare, fromInt32, toInt64 } from "./BigInt.js";
-import { fill } from "./Array.js";
+import { item, fill, setItem } from "./Array.js";
 function Native_random() {
     return Math.random();
 }
@@ -73,13 +73,13 @@ export class Seeded {
             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);
                 }
             }
         }
@@ -115,7 +115,7 @@ export class Seeded {
             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);
         }
     }
 }
@@ -137,7 +137,7 @@ function Seeded__InternalSample(_) {
     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.js

@@ -3,7 +3,7 @@ import { some, value as value_3 } from "./Option.js";
 import { structuralHash, toIterator, disposeSafe, getEnumerator, isArrayLike } 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";
@@ -1337,7 +1337,7 @@ export function SetTreeModule_toList(t) {
 export function SetTreeModule_copyToArray(s, arr, i) {
     let j = i;
     SetTreeModule_iter((x) => {
-        arr[j] = x;
+        setItem(arr, j, x);
         j = ((j + 1) | 0);
     }, s);
 }

package/String.d.ts

@@ -38,6 +38,7 @@ export declare function trimStart(str: string, ...chars: string[]): any;
 export declare function trimEnd(str: string, ...chars: string[]): any;
 export declare function filter(pred: (char: string) => boolean, x: string): string;
 export declare function substring(str: string, startIndex: number, length?: number): string;
+export declare function toCharArray2(str: string, startIndex: number, length: number): string[];
 interface FormattableString {
     strs: TemplateStringsArray;
     args: any[];

package/String.js

@@ -527,6 +527,9 @@ export function substring(str, startIndex, length) {
     }
     return length != null ? str.substr(startIndex, length) : str.substr(startIndex);
 }
+export function toCharArray2(str, startIndex, length) {
+    return substring(str, startIndex, length).split("");
+}
 export function fmt(strs, ...args) {
     return ({ strs, args });
 }

package/System.Collections.Generic.js

@@ -1,7 +1,7 @@
 import { disposeSafe, defaultOf, toIterator, getEnumerator, structuralHash, equals as equals_1, compare } from "./Util.js";
 import { class_type } 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";
 export class Comparer$1 {
     constructor(comparison) {
@@ -68,7 +68,7 @@ export class Stack$1 {
         const _ = this;
         return getEnumerator(delay(() => {
             let index = _.count - 1;
-            return enumerateWhile(() => (index >= 0), delay(() => append(singleton(_.contents[index]), delay(() => {
+            return enumerateWhile(() => (index >= 0), delay(() => append(singleton(item_1(index, _.contents)), delay(() => {
                 index = ((index - 1) | 0);
                 return empty();
             }))));
@@ -111,16 +111,16 @@ export function Stack$1__get_Count(_) {
 }
 export function Stack$1__Pop(_) {
     _.count = ((_.count - 1) | 0);
-    return _.contents[_.count];
+    return item_1(_.count, _.contents);
 }
 export function Stack$1__Peek(_) {
-    return _.contents[_.count - 1];
+    return item_1(_.count - 1, _.contents);
 }
 export function Stack$1__Contains_2B595(_, x) {
     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 {
@@ -162,7 +162,7 @@ export function Stack$1__TrimExcess(this$) {
     }
 }
 export function Stack$1__ToArray(_) {
-    return initialize(_.count, (i) => _.contents[(_.count - 1) - i]);
+    return initialize(_.count, (i) => item_1((_.count - 1) - i, _.contents));
 }
 export class Queue$1 {
     constructor(initialContents, initialCount) {
@@ -217,7 +217,7 @@ export function Queue$1__Dequeue(_) {
     if (_.count === 0) {
         throw new Error("Queue is empty");
     }
-    const value = _.contents[_.head];
+    const value = item_1(_.head, _.contents);
     _.head = (((_.head + 1) % Queue$1__size(_)) | 0);
     _.count = ((_.count - 1) | 0);
     return value;
@@ -226,7 +226,7 @@ export function Queue$1__Peek(_) {
     if (_.count === 0) {
         throw new Error("Queue is empty");
     }
-    return _.contents[_.head];
+    return item_1(_.head, _.contents);
 }
 export function Queue$1__TryDequeue_1F3DB691(this$, result) {
     if (this$.count === 0) {
@@ -250,7 +250,7 @@ export function Queue$1__Contains_2B595(_, x) {
     let found = false;
     let i = 0;
     while ((i < _.count) && !found) {
-        if (equals_1(x, _.contents[Queue$1__toIndex_Z524259A4(_, i)])) {
+        if (equals_1(x, item_1(Queue$1__toIndex_Z524259A4(_, i), _.contents))) {
             found = true;
         }
         else {
@@ -279,7 +279,7 @@ export function Queue$1__CopyTo_Z3B4C077E(_, target, start) {
     try {
         while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
             const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            target[i] = item;
+            setItem(target, i, item);
             i = ((i + 1) | 0);
         }
     }
@@ -309,7 +309,7 @@ export function Queue$1__ensure_Z524259A4(this$, requiredSize) {
 export function Queue$1__toSeq(this$) {
     return delay(() => {
         let i = 0;
-        return enumerateWhile(() => (i < this$.count), delay(() => append(singleton(this$.contents[Queue$1__toIndex_Z524259A4(this$, i)]), delay(() => {
+        return enumerateWhile(() => (i < this$.count), delay(() => append(singleton(item_1(Queue$1__toIndex_Z524259A4(this$, i), this$.contents)), delay(() => {
             i = ((i + 1) | 0);
             return empty();
         }))));

package/System.Text.d.ts

@@ -20,11 +20,19 @@ export declare function StringBuilder__Append_4E60E31B(x: StringBuilder, o: any)
 export declare function StringBuilder__Append_Z372E4D23(x: StringBuilder, cs: string[]): StringBuilder;
 export declare function StringBuilder__Append_43A65C09(x: StringBuilder, s: StringBuilder): StringBuilder;
 export declare function StringBuilder__AppendFormat_433E080(x: StringBuilder, fmt: string, o: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z3B30EC65(x: StringBuilder, fmt: string, o1: any, o2: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_10D165E0(x: StringBuilder, fmt: string, o1: any, o2: any, o3: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z17053F5(x: StringBuilder, fmt: string, arr: any[]): StringBuilder;
 export declare function StringBuilder__AppendFormat_Z696D8D1B(x: StringBuilder, provider: any, fmt: string, o: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_26802C9E(x: StringBuilder, provider: any, fmt: string, o1: any, o2: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z471ADCBB(x: StringBuilder, provider: any, fmt: string, o1: any, o2: any, o3: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_6C2E3E6E(x: StringBuilder, provider: any, fmt: string, arr: any[]): StringBuilder;
 export declare function StringBuilder__AppendLine(x: StringBuilder): StringBuilder;
 export declare function StringBuilder__AppendLine_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
+export declare function StringBuilder__Clear(x: StringBuilder): StringBuilder;
+export declare function StringBuilder__get_Chars_Z524259A4(x: StringBuilder, index: int32): string;
+export declare function StringBuilder__set_Chars_413E0D0A(x: StringBuilder, index: int32, value: string): void;
 export declare function StringBuilder__Replace_Z766F94C0(x: StringBuilder, oldValue: string, newValue: string): StringBuilder;
 export declare function StringBuilder__Replace_Z384F8060(x: StringBuilder, oldValue: string, newValue: string): StringBuilder;
 export declare function StringBuilder__get_Length(x: StringBuilder): int32;
 export declare function StringBuilder__ToString_Z37302880(x: StringBuilder, firstIndex: int32, length: int32): string;
-export declare function StringBuilder__Clear(x: StringBuilder): StringBuilder;