@nfdi4plants/arctrl 1.1.0 → 1.2.0

package/fable_modules/fable-library-js.4.13.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 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
+
+* Separate `Result` from `Choice`
+* Released as part of Fable 4.12.0

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.13.0}/Choice.d.ts

@@ -1,23 +1,6 @@
 import { Union } from "./Types.js";
 import { TypeInfo } from "./Reflection.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 type FSharpChoice$2_$union<T1, T2> = FSharpChoice$2<T1, T2, 0> | FSharpChoice$2<T1, T2, 1>;
 export type FSharpChoice$2_$cases<T1, T2> = {
     0: ["Choice1Of2", [T1]];

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.13.0}/Choice.js

@@ -1,49 +1,6 @@
 import { Union } from "./Types.js";
 import { union_type } from "./Reflection.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 FSharpChoice$2_Choice1Of2(Item) {
     return new FSharpChoice$2(0, [Item]);
 }

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.13.0}/Date.js

@@ -200,11 +200,12 @@ export function parseRaw(input) {
             let timeInSeconds = 0;
             if (m[2] != null) {
                 const timeParts = m[2].split(":");
+                const hourPart = parseInt(timeParts[0], 10);
                 timeInSeconds =
-                    parseInt(timeParts[0], 10) * 3600 +
+                    hourPart * 3600 +
                         parseInt(timeParts[1] || "0", 10) * 60 +
                         parseFloat(timeParts[2] || "0");
-                if (m[3] != null && m[3].toUpperCase() === "PM") {
+                if (m[3] != null && m[3].toUpperCase() === "PM" && hourPart < 12) {
                     timeInSeconds += 720;
                 }
             }

package/fable_modules/fable-library-js.4.13.0/FSharp.Core.CompilerServices.d.ts

@@ -0,0 +1,12 @@
+import { TypeInfo } from "./Reflection.js";
+import { FSharpList } from "./List.js";
+export declare class ListCollector$1<T> {
+    readonly collector: T[];
+    constructor();
+}
+export declare function ListCollector$1_$reflection(gen0: TypeInfo): TypeInfo;
+export declare function ListCollector$1_$ctor<T>(): ListCollector$1<T>;
+export declare function ListCollector$1__Add_2B595<T>(this$: ListCollector$1<T>, value: T): void;
+export declare function ListCollector$1__AddMany_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): void;
+export declare function ListCollector$1__AddManyAndClose_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): FSharpList<T>;
+export declare function ListCollector$1__Close<T>(this$: ListCollector$1<T>): FSharpList<T>;

package/fable_modules/fable-library-js.4.13.0/FSharp.Core.CompilerServices.js

@@ -0,0 +1,27 @@
+import { class_type } from "./Reflection.js";
+import { addRangeInPlace } from "./Array.js";
+import { toList } from "./Seq.js";
+export class ListCollector$1 {
+    constructor() {
+        this.collector = [];
+    }
+}
+export function ListCollector$1_$reflection(gen0) {
+    return class_type("Microsoft.FSharp.Core.CompilerServices.ListCollector`1", [gen0], ListCollector$1);
+}
+export function ListCollector$1_$ctor() {
+    return new ListCollector$1();
+}
+export function ListCollector$1__Add_2B595(this$, value) {
+    void (this$.collector.push(value));
+}
+export function ListCollector$1__AddMany_BB573A(this$, values) {
+    addRangeInPlace(values, this$.collector);
+}
+export function ListCollector$1__AddManyAndClose_BB573A(this$, values) {
+    addRangeInPlace(values, this$.collector);
+    return toList(this$.collector);
+}
+export function ListCollector$1__Close(this$) {
+    return toList(this$.collector);
+}

package/fable_modules/{fable-library.4.5.0 → fable-library-js.4.13.0}/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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.13.0}/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/fable_modules/{fable-library.4.5.0 → fable-library-js.4.13.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.13.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.13.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.13.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.13.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.13.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.13.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.13.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.13.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;