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

package/Date.ts

@@ -15,6 +15,360 @@ import { compareDates, DateKind, dateOffset, IDateTime, IDateTimeOffset, padWith
 export type OffsetInMinutes = number;
 export type Offset = "Z" | OffsetInMinutes | null;
 
+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: string, pos: number, patternChar: string) {
+  let tokenLength = 0;
+  let internalPos = pos;
+  while (internalPos < format.length && format[internalPos] === patternChar) {
+    internalPos++;
+    tokenLength++;
+  }
+
+  return tokenLength;
+}
+
+function parseNextChar(format: string, pos: number) {
+  if (pos >= format.length - 1) {
+    return -1
+  }
+
+  return format.charCodeAt(pos + 1);
+}
+
+function parseQuotedString(format: string, pos: number) : [string, number] {
+  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: Date, format: string, utc: boolean) {
+  let cursorPos = 0;
+  let tokenLength = 0;
+  let result = "";
+  const localizedDate = utc ? DateTime(date.getTime(), 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 DateKind.UTC:
+                result += "Z";
+                break;
+              case DateKind.Local:
+                result += dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
+                break;
+              case 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 DateKind.UTC:
+            utcOffsetText = "+00:00";
+            break;
+          case DateKind.Local:
+            utcOffsetText = dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
+            break;
+          case 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: IDateTime): number {
   return value.kind || 0;
 }
@@ -66,31 +420,6 @@ function dateToISOStringWithOffset(dateWithOffset: Date, offset: number) {
   return str.substring(0, str.length - 1) + dateOffsetToString(offset);
 }
 
-function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean) {
-  return format.replace(/(\w)\1*/g, (match: string) => {
-    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: IDateTimeOffset, format?: string) {
   const d = new Date(date.getTime() + (date.offset ?? 0));
   if (typeof format !== "string") {

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>();
         }))));