@nfdi4plants/arctrl 1.1.0 → 2.0.0-alpha.1

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/MapUtil.js

@@ -96,6 +96,13 @@ export function addToSet(v, set) {
     set.add(v);
     return true;
 }
+export function tryAddToDict(dict, k, v) {
+    if (dict.has(k)) {
+        return false;
+    }
+    dict.set(k, v);
+    return true;
+}
 export function addToDict(dict, k, v) {
     if (dict.has(k)) {
         throw new Error("An item with the same key has already been added. Key: " + k);
@@ -110,3 +117,11 @@ export function getItemFromDict(map, key) {
         throw new Error(`The given key '${key}' was not present in the dictionary.`);
     }
 }
+export function getItemFromDictOrCreate(map, key, createValue) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    const value = createValue(key);
+    map.set(key, value);
+    return value;
+}

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/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/fable_modules/fable-library-js.4.16.0/Result.d.ts

@@ -0,0 +1,37 @@
+import { Union } from "./Types.js";
+import { TypeInfo } from "./Reflection.js";
+import { int32 } from "./Int32.js";
+import { FSharpList } from "./List.js";
+import { Option } from "./Option.js";
+export type FSharpResult$2_$union<T, TError> = FSharpResult$2<T, TError, 0> | FSharpResult$2<T, TError, 1>;
+export type FSharpResult$2_$cases<T, TError> = {
+    0: ["Ok", [T]];
+    1: ["Error", [TError]];
+};
+export declare function FSharpResult$2_Ok<T, TError>(ResultValue: T): FSharpResult$2<T, TError, 0>;
+export declare function FSharpResult$2_Error<T, TError>(ErrorValue: TError): FSharpResult$2<T, TError, 1>;
+export declare class FSharpResult$2<T, TError, Tag extends keyof FSharpResult$2_$cases<T, TError>> extends Union<Tag, FSharpResult$2_$cases<T, TError>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpResult$2_$cases<T, TError>[Tag][1];
+    constructor(tag: Tag, fields: FSharpResult$2_$cases<T, TError>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpResult$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
+export declare function Result_Map<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
+export declare function Result_MapError<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<c, a>): FSharpResult$2_$union<c, b>;
+export declare function Result_Bind<a, b, c>(binder: ((arg0: a) => FSharpResult$2_$union<b, c>), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
+export declare function Result_IsOk<a, b>(result: FSharpResult$2_$union<a, b>): boolean;
+export declare function Result_IsError<a, b>(result: FSharpResult$2_$union<a, b>): boolean;
+export declare function Result_Contains<a, b>(value: a, result: FSharpResult$2_$union<a, b>): boolean;
+export declare function Result_Count<a, b>(result: FSharpResult$2_$union<a, b>): int32;
+export declare function Result_DefaultValue<a, b>(defaultValue: a, result: FSharpResult$2_$union<a, b>): a;
+export declare function Result_DefaultWith<b, a>(defThunk: ((arg0: b) => a), result: FSharpResult$2_$union<a, b>): a;
+export declare function Result_Exists<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean;
+export declare function Result_Fold<a, b, s>(folder: ((arg0: s, arg1: a) => s), state: s, result: FSharpResult$2_$union<a, b>): s;
+export declare function Result_FoldBack<a, b, s>(folder: ((arg0: a, arg1: s) => s), result: FSharpResult$2_$union<a, b>, state: s): s;
+export declare function Result_ForAll<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean;
+export declare function Result_Iterate<a, b>(action: ((arg0: a) => void), result: FSharpResult$2_$union<a, b>): void;
+export declare function Result_ToArray<a, b>(result: FSharpResult$2_$union<a, b>): a[];
+export declare function Result_ToList<a, b>(result: FSharpResult$2_$union<a, b>): FSharpList<a>;
+export declare function Result_ToOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a>;
+export declare function Result_ToValueOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a>;

package/fable_modules/fable-library-js.4.16.0/Result.js

@@ -0,0 +1,165 @@
+import { Union } from "./Types.js";
+import { union_type } from "./Reflection.js";
+import { equals } from "./Util.js";
+import { empty, singleton } from "./List.js";
+import { some } from "./Option.js";
+export function FSharpResult$2_Ok(ResultValue) {
+    return new FSharpResult$2(0, [ResultValue]);
+}
+export function FSharpResult$2_Error(ErrorValue) {
+    return new FSharpResult$2(1, [ErrorValue]);
+}
+export class FSharpResult$2 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Ok", "Error"];
+    }
+}
+export function FSharpResult$2_$reflection(gen0, gen1) {
+    return union_type("FSharp.Core.FSharpResult`2", [gen0, gen1], FSharpResult$2, () => [[["ResultValue", gen0]], [["ErrorValue", gen1]]]);
+}
+export function Result_Map(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(mapping(result.fields[0]));
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+export function Result_MapError(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(mapping(result.fields[0]));
+    }
+}
+export function Result_Bind(binder, result) {
+    if (result.tag === /* Ok */ 0) {
+        return binder(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+export function Result_IsOk(result) {
+    if (result.tag === /* Ok */ 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Result_IsError(result) {
+    if (result.tag === /* Ok */ 0) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function Result_Contains(value, result) {
+    if (result.tag === /* Ok */ 0) {
+        return equals(result.fields[0], value);
+    }
+    else {
+        return false;
+    }
+}
+export function Result_Count(result) {
+    if (result.tag === /* Ok */ 0) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+export function Result_DefaultValue(defaultValue, result) {
+    if (result.tag === /* Ok */ 0) {
+        return result.fields[0];
+    }
+    else {
+        return defaultValue;
+    }
+}
+export function Result_DefaultWith(defThunk, result) {
+    if (result.tag === /* Ok */ 0) {
+        return result.fields[0];
+    }
+    else {
+        return defThunk(result.fields[0]);
+    }
+}
+export function Result_Exists(predicate, result) {
+    if (result.tag === /* Ok */ 0) {
+        return predicate(result.fields[0]);
+    }
+    else {
+        return false;
+    }
+}
+export function Result_Fold(folder, state, result) {
+    if (result.tag === /* Ok */ 0) {
+        return folder(state, result.fields[0]);
+    }
+    else {
+        return state;
+    }
+}
+export function Result_FoldBack(folder, result, state) {
+    if (result.tag === /* Ok */ 0) {
+        return folder(result.fields[0], state);
+    }
+    else {
+        return state;
+    }
+}
+export function Result_ForAll(predicate, result) {
+    if (result.tag === /* Ok */ 0) {
+        return predicate(result.fields[0]);
+    }
+    else {
+        return true;
+    }
+}
+export function Result_Iterate(action, result) {
+    if (result.tag === /* Ok */ 0) {
+        action(result.fields[0]);
+    }
+}
+export function Result_ToArray(result) {
+    if (result.tag === /* Ok */ 0) {
+        return [result.fields[0]];
+    }
+    else {
+        return [];
+    }
+}
+export function Result_ToList(result) {
+    if (result.tag === /* Ok */ 0) {
+        return singleton(result.fields[0]);
+    }
+    else {
+        return empty();
+    }
+}
+export function Result_ToOption(result) {
+    if (result.tag === /* Ok */ 0) {
+        return some(result.fields[0]);
+    }
+    else {
+        return void 0;
+    }
+}
+export function Result_ToValueOption(result) {
+    if (result.tag === /* Ok */ 0) {
+        return some(result.fields[0]);
+    }
+    else {
+        return void 0;
+    }
+}

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/String.js

@@ -78,11 +78,11 @@ export function indexOfAny(str, anyOf, ...args) {
     if (startIndex + length > str.length) {
         throw new Error("Invalid startIndex and length");
     }
-    str = str.substring(startIndex, startIndex + length);
-    for (const c of anyOf) {
-        const index = str.indexOf(c);
-        if (index > -1) {
-            return index + startIndex;
+    const endIndex = startIndex + length;
+    const anyOfAsStr = "".concat.apply("", anyOf);
+    for (let i = startIndex; i < endIndex; i++) {
+        if (anyOfAsStr.indexOf(str[i]) > -1) {
+            return i;
         }
     }
     return -1;
@@ -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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/System.Collections.Generic.d.ts

@@ -1,22 +1,30 @@
-import { IEnumerator, IEqualityComparer, IComparer } from "./Util.js";
 import { int32 } from "./Int32.js";
+import { IEnumerator, IEqualityComparer, IComparer } from "./Util.js";
 import { TypeInfo } from "./Reflection.js";
 import { FSharpRef } from "./Types.js";
 export declare class Comparer$1<T> implements IComparer<T> {
-    constructor();
+    readonly comparison: ((arg0: T, arg1: T) => int32);
+    constructor(comparison: ((arg0: T, arg1: T) => int32));
     Compare(x: T, y: T): int32;
 }
 export declare function Comparer$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Comparer$1_$ctor<T>(): Comparer$1<T>;
-export declare function Comparer$1_get_Default<T>(): IComparer<T>;
+export declare function Comparer$1_$ctor_47C913C<T>(comparison: ((arg0: T, arg1: T) => int32)): Comparer$1<T>;
+export declare function Comparer$1_get_Default<T>(): Comparer$1<T>;
+export declare function Comparer$1_Create_47C913C<T>(comparison: ((arg0: T, arg1: T) => int32)): Comparer$1<T>;
+export declare function Comparer$1__Compare_5BDDA0<T>(_: Comparer$1<T>, x: T, y: T): int32;
 export declare class EqualityComparer$1<T> implements IEqualityComparer<T> {
-    constructor();
+    readonly getHashCode: ((arg0: T) => int32);
+    readonly equals: ((arg0: T, arg1: T) => boolean);
+    constructor(equals: ((arg0: T, arg1: T) => boolean), getHashCode: ((arg0: T) => int32));
     Equals(x: T, y: T): boolean;
     GetHashCode(x: T): int32;
 }
 export declare function EqualityComparer$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function EqualityComparer$1_$ctor<T>(): EqualityComparer$1<T>;
-export declare function EqualityComparer$1_get_Default<T>(): IEqualityComparer<T>;
+export declare function EqualityComparer$1_$ctor_Z6EE254AB<T>(equals: ((arg0: T, arg1: T) => boolean), getHashCode: ((arg0: T) => int32)): EqualityComparer$1<T>;
+export declare function EqualityComparer$1_get_Default<T>(): EqualityComparer$1<T>;
+export declare function EqualityComparer$1_Create_Z6EE254AB<T>(equals: ((arg0: T, arg1: T) => boolean), getHashCode: ((arg0: T) => int32)): EqualityComparer$1<T>;
+export declare function EqualityComparer$1__Equals_5BDDA0<T>(_: EqualityComparer$1<T>, x: T, y: T): boolean;
+export declare function EqualityComparer$1__GetHashCode_2B595<T>(_: EqualityComparer$1<T>, x: T): int32;
 export declare class Stack$1<T> implements Iterable<T> {
     contents: T[];
     count: int32;

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/System.Collections.Generic.js

@@ -1,53 +1,63 @@
-import { disposeSafe, defaultOf, toIterator, getEnumerator, structuralHash, equals, compare } from "./Util.js";
+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() {
+    constructor(comparison) {
+        this.comparison = comparison;
     }
     Compare(x, y) {
-        return compare(x, y);
+        const _ = this;
+        return _.comparison(x, y) | 0;
     }
 }
 export function Comparer$1_$reflection(gen0) {
     return class_type("System.Collections.Generic.Comparer`1", [gen0], Comparer$1);
 }
-export function Comparer$1_$ctor() {
-    return new Comparer$1();
+export function Comparer$1_$ctor_47C913C(comparison) {
+    return new Comparer$1(comparison);
 }
 export function Comparer$1_get_Default() {
-    return {
-        Compare(x, y) {
-            return compare(x, y);
-        },
-    };
+    return Comparer$1_$ctor_47C913C(compare);
+}
+export function Comparer$1_Create_47C913C(comparison) {
+    return Comparer$1_$ctor_47C913C(comparison);
+}
+export function Comparer$1__Compare_5BDDA0(_, x, y) {
+    return _.comparison(x, y);
 }
 export class EqualityComparer$1 {
-    constructor() {
+    constructor(equals, getHashCode) {
+        this.equals = equals;
+        this.getHashCode = getHashCode;
     }
     Equals(x, y) {
-        return equals(x, y);
+        const _ = this;
+        return _.equals(x, y);
     }
     GetHashCode(x) {
-        return structuralHash(x);
+        const _ = this;
+        return _.getHashCode(x) | 0;
     }
 }
 export function EqualityComparer$1_$reflection(gen0) {
     return class_type("System.Collections.Generic.EqualityComparer`1", [gen0], EqualityComparer$1);
 }
-export function EqualityComparer$1_$ctor() {
-    return new EqualityComparer$1();
+export function EqualityComparer$1_$ctor_Z6EE254AB(equals, getHashCode) {
+    return new EqualityComparer$1(equals, getHashCode);
 }
 export function EqualityComparer$1_get_Default() {
-    return {
-        Equals(x, y) {
-            return equals(x, y);
-        },
-        GetHashCode(x_1) {
-            return structuralHash(x_1);
-        },
-    };
+    return EqualityComparer$1_$ctor_Z6EE254AB(equals_1, structuralHash);
+}
+export function EqualityComparer$1_Create_Z6EE254AB(equals, getHashCode) {
+    return EqualityComparer$1_$ctor_Z6EE254AB(equals, getHashCode);
+}
+export function EqualityComparer$1__Equals_5BDDA0(_, x, y) {
+    return _.equals(x, y);
+}
+export function EqualityComparer$1__GetHashCode_2B595(_, x) {
+    return _.getHashCode(x);
 }
 export class Stack$1 {
     constructor(initialContents, initialCount) {
@@ -58,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();
             }))));
@@ -101,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(x, _.contents[i])) {
+        if (equals_1(x, item_1(i, _.contents))) {
             found = true;
         }
         else {
@@ -152,14 +162,14 @@ 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) {
         this.contents = initialContents;
         this.count = (initialCount | 0);
         this.head = 0;
-        this.tail = (initialCount | 0);
+        this.tail = (((initialCount === this.contents.length) ? 0 : initialCount) | 0);
     }
     GetEnumerator() {
         const _ = this;
@@ -207,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;
@@ -216,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) {
@@ -240,7 +250,7 @@ export function Queue$1__Contains_2B595(_, x) {
     let found = false;
     let i = 0;
     while ((i < _.count) && !found) {
-        if (equals(x, _.contents[Queue$1__toIndex_Z524259A4(_, i)])) {
+        if (equals_1(x, item_1(Queue$1__toIndex_Z524259A4(_, i), _.contents))) {
             found = true;
         }
         else {
@@ -269,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);
         }
     }
@@ -293,13 +303,13 @@ export function Queue$1__ensure_Z524259A4(this$, requiredSize) {
         copyTo(this$.contents, 0, newBuffer, Queue$1__size(this$) - this$.head, this$.tail);
     }
     this$.head = 0;
-    this$.tail = (this$.count | 0);
     this$.contents = newBuffer;
+    this$.tail = (((this$.count === Queue$1__size(this$)) ? 0 : this$.count) | 0);
 }
 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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.16.0}/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;