@fable-org/fable-library-ts 2.0.0-rc.6 → 2.0.0

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0 - 2026-04-21
+
+### Fixed
+
+* [JS/TS] Fix `ResizeArray` (`System.Collections.Generic.List`) equality to use reference equality instead of structural equality (fixes #3718)
+* [JS/TS] Fix `String.Contains` ignoring `StringComparison` argument (second argument was silently discarded)
+
 ## 2.0.0-rc.6 - 2026-04-07
 
 ### Fixed

package/Seq.ts

@@ -6,9 +6,10 @@ import { class_type, TypeInfo } from "./Reflection.ts";
 import { some, value as value_1, Option } from "./Option.ts";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
 import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.ts";
-import { randomSampleBy as randomSampleBy_1, randomChoicesBy as randomChoicesBy_1, randomChoice as randomChoice_1, randomChoiceWith as randomChoiceWith_1, randomChoiceBy as randomChoiceBy_1, randomShuffleInPlaceBy, chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, item as item_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.ts";
+import { randomSampleBy as randomSampleBy_1, randomChoicesBy as randomChoicesBy_1, randomChoice as randomChoice_1, randomChoiceWith as randomChoiceWith_1, randomChoiceBy as randomChoiceBy_1, randomShuffleInPlaceBy, chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, item as item_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.ts";
 import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.ts";
 import { float64, int32 } from "./Int32.ts";
+import { min as min_1 } from "./Double.ts";
 import { SR_indexOutOfBounds } from "./Global.ts";
 import { nonSeeded } from "./Random.ts";
 
@@ -724,7 +725,14 @@ export function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2)
 }
 
 export function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: Iterable<T1>, ys: Iterable<T2>, state: State): State {
-    return foldBack2_1<T1, T2, State>(folder, toArray<T1>(xs), toArray<T2>(ys), state);
+    const xs_1: MutableArray<T1> = toArray<T1>(xs);
+    const ys_1: MutableArray<T2> = toArray<T2>(ys);
+    const len: int32 = min_1(xs_1.length, ys_1.length) | 0;
+    let acc: State = state;
+    for (let i: int32 = len - 1; i >= 0; i--) {
+        acc = folder(item_1(i, xs_1), item_1(i, ys_1), acc);
+    }
+    return acc;
 }
 
 export function forAll<$a>(predicate: ((arg0: $a) => boolean), xs: Iterable<$a>): boolean {

package/Set.ts

@@ -1,6 +1,6 @@
 
 import { record_type, bool_type, list_type, option_type, class_type, TypeInfo } from "./Reflection.ts";
-import { some, value as value_3, Option } from "./Option.ts";
+import { some, value as value_2, Option } from "./Option.ts";
 import { int32 } from "./Int32.ts";
 import { structuralHash, ISet, toIterator, IDisposable, disposeSafe, getEnumerator, isArrayLike, MutableArray, IEnumerator, IComparer, Exception } from "./Util.ts";
 import { Record } from "./Types.ts";
@@ -8,7 +8,7 @@ import { fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArr
 import { fold as fold_1, fill, setItem } from "./Array.ts";
 import { join } from "./String.ts";
 import { NotSupportedException_$ctor_Z721C83C5 } from "./System.ts";
-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.ts";
+import { skip, truncate, iterateIndexed, exists as exists_1, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from "./Seq.ts";
 import { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from "./MutableSet.ts";
 
 export class SetTreeLeaf$1<T> {
@@ -71,7 +71,7 @@ export function SetTreeModule_countAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, acc_m
     while (true) {
         const t: Option<SetTreeLeaf$1<T>> = t_mut, acc: int32 = acc_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 t_mut = SetTreeNode$1__get_Left<T>(tn);
@@ -98,7 +98,7 @@ export function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r: Option
     let hl: int32;
     const t: Option<SetTreeLeaf$1<T>> = l;
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         hl = ((t2 instanceof SetTreeNode$1) ? ((tn = (t2 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn))) : 1);
     }
     else {
@@ -107,7 +107,7 @@ export function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r: Option
     let hr: int32;
     const t_1: Option<SetTreeLeaf$1<T>> = r;
     if (t_1 != null) {
-        const t2_1: SetTreeLeaf$1<T> = value_3(t_1);
+        const t2_1: SetTreeLeaf$1<T> = value_2(t_1);
         hr = ((t2_1 instanceof SetTreeNode$1) ? ((tn_1 = (t2_1 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn_1))) : 1);
     }
     else {
@@ -127,7 +127,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
     let t1h: int32;
     const t: Option<SetTreeLeaf$1<T>> = t1;
     if (t != null) {
-        const t2_1: SetTreeLeaf$1<T> = value_3(t);
+        const t2_1: SetTreeLeaf$1<T> = value_2(t);
         t1h = ((t2_1 instanceof SetTreeNode$1) ? ((tn = (t2_1 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn))) : 1);
     }
     else {
@@ -136,18 +136,18 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
     let t2h: int32;
     const t_1: Option<SetTreeLeaf$1<T>> = t2;
     if (t_1 != null) {
-        const t2_2: SetTreeLeaf$1<T> = value_3(t_1);
+        const t2_2: SetTreeLeaf$1<T> = value_2(t_1);
         t2h = ((t2_2 instanceof SetTreeNode$1) ? ((tn_1 = (t2_2 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn_1))) : 1);
     }
     else {
         t2h = 0;
     }
     if (t2h > (t1h + 2)) {
-        const matchValue: SetTreeLeaf$1<T> = value_3(t2);
+        const matchValue: SetTreeLeaf$1<T> = value_2(t2);
         if (matchValue instanceof SetTreeNode$1) {
             const t2$0027 = matchValue as SetTreeNode$1<T>;
-            if (((t_2 = SetTreeNode$1__get_Left<T>(t2$0027), (t_2 != null) ? ((t2_3 = value_3(t_2), (t2_3 instanceof SetTreeNode$1) ? ((tn_2 = (t2_3 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn_2))) : 1)) : 0)) > (t1h + 1)) {
-                const matchValue_1: SetTreeLeaf$1<T> = value_3(SetTreeNode$1__get_Left<T>(t2$0027));
+            if (((t_2 = SetTreeNode$1__get_Left<T>(t2$0027), (t_2 != null) ? ((t2_3 = value_2(t_2), (t2_3 instanceof SetTreeNode$1) ? ((tn_2 = (t2_3 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn_2))) : 1)) : 0)) > (t1h + 1)) {
+                const matchValue_1: SetTreeLeaf$1<T> = value_2(SetTreeNode$1__get_Left<T>(t2$0027));
                 if (matchValue_1 instanceof SetTreeNode$1) {
                     const t2l = matchValue_1 as SetTreeNode$1<T>;
                     return SetTreeModule_mk<T>(SetTreeModule_mk<T>(t1, v, SetTreeNode$1__get_Left<T>(t2l)), SetTreeLeaf$1__get_Key<T>(t2l), SetTreeModule_mk<T>(SetTreeNode$1__get_Right<T>(t2l), SetTreeLeaf$1__get_Key<T>(t2$0027), SetTreeNode$1__get_Right<T>(t2$0027)));
@@ -165,11 +165,11 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
         }
     }
     else if (t1h > (t2h + 2)) {
-        const matchValue_2: SetTreeLeaf$1<T> = value_3(t1);
+        const matchValue_2: SetTreeLeaf$1<T> = value_2(t1);
         if (matchValue_2 instanceof SetTreeNode$1) {
             const t1$0027 = matchValue_2 as SetTreeNode$1<T>;
-            if (((t_3 = SetTreeNode$1__get_Right<T>(t1$0027), (t_3 != null) ? ((t2_4 = value_3(t_3), (t2_4 instanceof SetTreeNode$1) ? ((tn_3 = (t2_4 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn_3))) : 1)) : 0)) > (t2h + 1)) {
-                const matchValue_3: SetTreeLeaf$1<T> = value_3(SetTreeNode$1__get_Right<T>(t1$0027));
+            if (((t_3 = SetTreeNode$1__get_Right<T>(t1$0027), (t_3 != null) ? ((t2_4 = value_2(t_3), (t2_4 instanceof SetTreeNode$1) ? ((tn_3 = (t2_4 as SetTreeNode$1<T>), SetTreeNode$1__get_Height<T>(tn_3))) : 1)) : 0)) > (t2h + 1)) {
+                const matchValue_3: SetTreeLeaf$1<T> = value_2(SetTreeNode$1__get_Right<T>(t1$0027));
                 if (matchValue_3 instanceof SetTreeNode$1) {
                     const t1r = matchValue_3 as SetTreeNode$1<T>;
                     return SetTreeModule_mk<T>(SetTreeModule_mk<T>(SetTreeNode$1__get_Left<T>(t1$0027), SetTreeLeaf$1__get_Key<T>(t1$0027), SetTreeNode$1__get_Left<T>(t1r)), SetTreeLeaf$1__get_Key<T>(t1r), SetTreeModule_mk<T>(SetTreeNode$1__get_Right<T>(t1r), v, t2));
@@ -193,7 +193,7 @@ export function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t
 
 export function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
@@ -227,9 +227,9 @@ export function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<Set
 
 export function SetTreeModule_balance<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, k: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
     if (t1 != null) {
-        const t1$0027: SetTreeLeaf$1<T> = value_3(t1);
+        const t1$0027: SetTreeLeaf$1<T> = value_2(t1);
         if (t2 != null) {
-            const t2$0027: SetTreeLeaf$1<T> = value_3(t2);
+            const t2$0027: SetTreeLeaf$1<T> = value_2(t2);
             if (t1$0027 instanceof SetTreeNode$1) {
                 const t1n = t1$0027 as SetTreeNode$1<T>;
                 if (t2$0027 instanceof SetTreeNode$1) {
@@ -263,7 +263,7 @@ export function SetTreeModule_balance<T>(comparer: IComparer<T>, t1: Option<SetT
 
 export function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: T, t: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>] {
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
             const c: int32 = comparer.Compare(pivot, SetTreeLeaf$1__get_Key<T>(tn)) | 0;
@@ -299,7 +299,7 @@ export function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: T, t: Opti
 
 export function SetTreeModule_spliceOutSuccessor<T>(t: Option<SetTreeLeaf$1<T>>): [T, Option<SetTreeLeaf$1<T>>] {
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
             if (SetTreeNode$1__get_Left<T>(tn) == null) {
@@ -321,7 +321,7 @@ export function SetTreeModule_spliceOutSuccessor<T>(t: Option<SetTreeLeaf$1<T>>)
 
 export function SetTreeModule_remove<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
@@ -361,7 +361,7 @@ export function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: T, t_mut
     while (true) {
         const comparer: IComparer<T> = comparer_mut, k: T = k_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             const c: int32 = comparer.Compare(k, SetTreeLeaf$1__get_Key<T>(t2)) | 0;
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
@@ -397,7 +397,7 @@ export function SetTreeModule_iter<T>(f_mut: ((arg0: T) => void), t_mut: Option<
     while (true) {
         const f: ((arg0: T) => void) = f_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 SetTreeModule_iter<T>(f, SetTreeNode$1__get_Left<T>(tn));
@@ -419,7 +419,7 @@ export function SetTreeModule_foldBackOpt<T, $a>(f_mut: any, t_mut: Option<SetTr
     while (true) {
         const f: any = f_mut, t: Option<SetTreeLeaf$1<T>> = t_mut, x: $a = x_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 f_mut = f;
@@ -447,7 +447,7 @@ export function SetTreeModule_foldOpt<$a, T>(f_mut: any, x_mut: $a, t_mut: Optio
     while (true) {
         const f: any = f_mut, x: $a = x_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 f_mut = f;
@@ -475,7 +475,7 @@ export function SetTreeModule_forall<T>(f_mut: ((arg0: T) => boolean), t_mut: Op
     while (true) {
         const f: ((arg0: T) => boolean) = f_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 if (f(SetTreeLeaf$1__get_Key<T>(tn)) && SetTreeModule_forall<T>(f, SetTreeNode$1__get_Left<T>(tn))) {
@@ -503,7 +503,7 @@ export function SetTreeModule_exists<T>(f_mut: ((arg0: T) => boolean), t_mut: Op
     while (true) {
         const f: ((arg0: T) => boolean) = f_mut, t: Option<SetTreeLeaf$1<T>> = t_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 if (f(SetTreeLeaf$1__get_Key<T>(tn)) ? true : SetTreeModule_exists<T>(f, SetTreeNode$1__get_Left<T>(tn))) {
@@ -544,7 +544,7 @@ export function SetTreeModule_filterAux<T>(comparer_mut: IComparer<T>, f_mut: ((
     while (true) {
         const comparer: IComparer<T> = comparer_mut, f: ((arg0: T) => boolean) = f_mut, t: Option<SetTreeLeaf$1<T>> = t_mut, acc: Option<SetTreeLeaf$1<T>> = acc_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 const acc_1: Option<SetTreeLeaf$1<T>> = f(SetTreeLeaf$1__get_Key<T>(tn)) ? SetTreeModule_add<T>(comparer, SetTreeLeaf$1__get_Key<T>(tn), acc) : acc;
@@ -580,7 +580,7 @@ export function SetTreeModule_diffAux<T>(comparer_mut: IComparer<T>, t_mut: Opti
             return acc;
         }
         else if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 comparer_mut = comparer;
@@ -605,9 +605,9 @@ export function SetTreeModule_diff<$a>(comparer: IComparer<$a>, a: Option<SetTre
 
 export function SetTreeModule_union<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>> {
     if (t1 != null) {
-        const t1$0027: SetTreeLeaf$1<T> = value_3(t1);
+        const t1$0027: SetTreeLeaf$1<T> = value_2(t1);
         if (t2 != null) {
-            const t2$0027: SetTreeLeaf$1<T> = value_3(t2);
+            const t2$0027: SetTreeLeaf$1<T> = value_2(t2);
             if (t1$0027 instanceof SetTreeNode$1) {
                 const t1n = t1$0027 as SetTreeNode$1<T>;
                 if (t2$0027 instanceof SetTreeNode$1) {
@@ -643,7 +643,7 @@ export function SetTreeModule_intersectionAux<T>(comparer_mut: IComparer<T>, b_m
     while (true) {
         const comparer: IComparer<T> = comparer_mut, b: Option<SetTreeLeaf$1<T>> = b_mut, t: Option<SetTreeLeaf$1<T>> = t_mut, acc: Option<SetTreeLeaf$1<T>> = acc_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 const acc_1: Option<SetTreeLeaf$1<T>> = SetTreeModule_intersectionAux<T>(comparer, b, SetTreeNode$1__get_Right<T>(tn), acc);
@@ -687,7 +687,7 @@ export function SetTreeModule_partitionAux<T>(comparer_mut: IComparer<T>, f_mut:
         const comparer: IComparer<T> = comparer_mut, f: ((arg0: T) => boolean) = f_mut, t: Option<SetTreeLeaf$1<T>> = t_mut, acc_: Option<SetTreeLeaf$1<T>> = acc__mut, acc__1: Option<SetTreeLeaf$1<T>> = acc__1_mut;
         const acc = [acc_, acc__1] as [Option<SetTreeLeaf$1<T>>, Option<SetTreeLeaf$1<T>>];
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 const acc_1: [Option<SetTreeLeaf$1<T>>, Option<SetTreeLeaf$1<T>>] = SetTreeModule_partitionAux<T>(comparer, f, SetTreeNode$1__get_Right<T>(tn), acc[0], acc[1]);
@@ -719,7 +719,7 @@ export function SetTreeModule_minimumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T
     while (true) {
         const t: Option<SetTreeLeaf$1<T>> = t_mut, n: T = n_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 t_mut = SetTreeNode$1__get_Left<T>(tn);
@@ -739,7 +739,7 @@ export function SetTreeModule_minimumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T
 
 export function SetTreeModule_minimumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>): Option<T> {
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
             return some(SetTreeModule_minimumElementAux<T>(SetTreeNode$1__get_Left<T>(tn), SetTreeLeaf$1__get_Key<T>(tn)));
@@ -758,7 +758,7 @@ export function SetTreeModule_maximumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T
     while (true) {
         const t: Option<SetTreeLeaf$1<T>> = t_mut, n: T = n_mut;
         if (t != null) {
-            const t2: SetTreeLeaf$1<T> = value_3(t);
+            const t2: SetTreeLeaf$1<T> = value_2(t);
             if (t2 instanceof SetTreeNode$1) {
                 const tn = t2 as SetTreeNode$1<T>;
                 t_mut = SetTreeNode$1__get_Right<T>(tn);
@@ -778,7 +778,7 @@ export function SetTreeModule_maximumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T
 
 export function SetTreeModule_maximumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>): Option<T> {
     if (t != null) {
-        const t2: SetTreeLeaf$1<T> = value_3(t);
+        const t2: SetTreeLeaf$1<T> = value_2(t);
         if (t2 instanceof SetTreeNode$1) {
             const tn = t2 as SetTreeNode$1<T>;
             return some(SetTreeModule_maximumElementAux<T>(SetTreeNode$1__get_Right<T>(tn), SetTreeLeaf$1__get_Key<T>(tn)));
@@ -798,7 +798,7 @@ export function SetTreeModule_minimumElement<$a>(s: Option<SetTreeLeaf$1<$a>>):
         throw new Exception("Set contains no elements");
     }
     else {
-        return value_3(matchValue);
+        return value_2(matchValue);
     }
 }
 
@@ -808,7 +808,7 @@ export function SetTreeModule_maximumElement<$a>(s: Option<SetTreeLeaf$1<$a>>):
         throw new Exception("Set contains no elements");
     }
     else {
-        return value_3(matchValue);
+        return value_2(matchValue);
     }
 }
 
@@ -834,7 +834,7 @@ export function SetTreeModule_collapseLHS<T>(stack_mut: FSharpList<Option<SetTre
             const x: Option<SetTreeLeaf$1<T>> = head(stack);
             const rest: FSharpList<Option<SetTreeLeaf$1<T>>> = tail(stack);
             if (x != null) {
-                const x2: SetTreeLeaf$1<T> = value_3(x);
+                const x2: SetTreeLeaf$1<T> = value_2(x);
                 if (x2 instanceof SetTreeNode$1) {
                     const xn = x2 as SetTreeNode$1<T>;
                     stack_mut = ofArrayWithTail([SetTreeNode$1__get_Left<T>(xn), SetTreeLeaf$1_$ctor_2B595<T>(SetTreeLeaf$1__get_Key<T>(xn)), SetTreeNode$1__get_Right<T>(xn)], rest);
@@ -875,7 +875,7 @@ export function SetTreeModule_current<$a>(i: SetTreeModule_SetIterator$1<$a>): $
             return SetTreeModule_alreadyFinished<$a>();
         }
         else if (head(matchValue) != null) {
-            const t: SetTreeLeaf$1<$a> = value_3(head(matchValue));
+            const t: SetTreeLeaf$1<$a> = value_2(head(matchValue));
             return SetTreeLeaf$1__get_Key<$a>(t);
         }
         else {
@@ -892,7 +892,7 @@ export function SetTreeModule_moveNext<T>(i: SetTreeModule_SetIterator$1<T>): bo
         const matchValue: FSharpList<Option<SetTreeLeaf$1<T>>> = i.stack;
         if (!isEmpty_1(matchValue)) {
             if (head(matchValue) != null) {
-                const t: SetTreeLeaf$1<T> = value_3(head(matchValue));
+                const t: SetTreeLeaf$1<T> = value_2(head(matchValue));
                 if (t instanceof SetTreeNode$1) {
                     throw new Exception("Please report error: Set iterator, unexpected stack for moveNext");
                 }
@@ -946,8 +946,8 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
             if (!isEmpty_1(l2)) {
                 if (head(l2) != null) {
                     if (head(l1) != null) {
-                        const x1_3: SetTreeLeaf$1<T> = value_3(head(l1));
-                        const x2_3: SetTreeLeaf$1<T> = value_3(head(l2));
+                        const x1_3: SetTreeLeaf$1<T> = value_2(head(l1));
+                        const x2_3: SetTreeLeaf$1<T> = value_2(head(l2));
                         if (x1_3 instanceof SetTreeNode$1) {
                             const x1n_2 = x1_3 as SetTreeNode$1<T>;
                             if (SetTreeNode$1__get_Left<T>(x1n_2) == null) {
@@ -971,13 +971,13 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                             if (head(l1) != null) {
                                                 matchResult = 0;
                                                 t1_6 = tail(l1);
-                                                x1_4 = value_3(head(l1));
+                                                x1_4 = value_2(head(l1));
                                             }
                                             else if (!isEmpty_1(l2)) {
                                                 if (head(l2) != null) {
                                                     matchResult = 1;
                                                     t2_6 = tail(l2);
-                                                    x2_4 = value_3(head(l2));
+                                                    x2_4 = value_2(head(l2));
                                                 }
                                                 else {
                                                     matchResult = 2;
@@ -991,7 +991,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                             if (head(l2) != null) {
                                                 matchResult = 1;
                                                 t2_6 = tail(l2);
-                                                x2_4 = value_3(head(l2));
+                                                x2_4 = value_2(head(l2));
                                             }
                                             else {
                                                 matchResult = 2;
@@ -1053,13 +1053,13 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                     if (head(l1) != null) {
                                         matchResult_1 = 0;
                                         t1_7 = tail(l1);
-                                        x1_5 = value_3(head(l1));
+                                        x1_5 = value_2(head(l1));
                                     }
                                     else if (!isEmpty_1(l2)) {
                                         if (head(l2) != null) {
                                             matchResult_1 = 1;
                                             t2_7 = tail(l2);
-                                            x2_5 = value_3(head(l2));
+                                            x2_5 = value_2(head(l2));
                                         }
                                         else {
                                             matchResult_1 = 2;
@@ -1073,7 +1073,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                     if (head(l2) != null) {
                                         matchResult_1 = 1;
                                         t2_7 = tail(l2);
-                                        x2_5 = value_3(head(l2));
+                                        x2_5 = value_2(head(l2));
                                     }
                                     else {
                                         matchResult_1 = 2;
@@ -1136,13 +1136,13 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                     if (head(l1) != null) {
                                         matchResult_2 = 0;
                                         t1_8 = tail(l1);
-                                        x1_6 = value_3(head(l1));
+                                        x1_6 = value_2(head(l1));
                                     }
                                     else if (!isEmpty_1(l2)) {
                                         if (head(l2) != null) {
                                             matchResult_2 = 1;
                                             t2_8 = tail(l2);
-                                            x2_6 = value_3(head(l2));
+                                            x2_6 = value_2(head(l2));
                                         }
                                         else {
                                             matchResult_2 = 2;
@@ -1156,7 +1156,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                                     if (head(l2) != null) {
                                         matchResult_2 = 1;
                                         t2_8 = tail(l2);
-                                        x2_6 = value_3(head(l2));
+                                        x2_6 = value_2(head(l2));
                                     }
                                     else {
                                         matchResult_2 = 2;
@@ -1213,19 +1213,19 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                         }
                     }
                     else {
-                        const x2: SetTreeLeaf$1<T> = value_3(head(l2));
+                        const x2: SetTreeLeaf$1<T> = value_2(head(l2));
                         let matchResult_3: int32 = (undefined as any), t1_2: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1: SetTreeLeaf$1<T> = (undefined as any), t2_2: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_1: SetTreeLeaf$1<T> = (undefined as any);
                         if (!isEmpty_1(l1)) {
                             if (head(l1) != null) {
                                 matchResult_3 = 0;
                                 t1_2 = tail(l1);
-                                x1 = value_3(head(l1));
+                                x1 = value_2(head(l1));
                             }
                             else if (!isEmpty_1(l2)) {
                                 if (head(l2) != null) {
                                     matchResult_3 = 1;
                                     t2_2 = tail(l2);
-                                    x2_1 = value_3(head(l2));
+                                    x2_1 = value_2(head(l2));
                                 }
                                 else {
                                     matchResult_3 = 2;
@@ -1239,7 +1239,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                             if (head(l2) != null) {
                                 matchResult_3 = 1;
                                 t2_2 = tail(l2);
-                                x2_1 = value_3(head(l2));
+                                x2_1 = value_2(head(l2));
                             }
                             else {
                                 matchResult_3 = 2;
@@ -1283,19 +1283,19 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                     }
                 }
                 else if (head(l1) != null) {
-                    const x1_1: SetTreeLeaf$1<T> = value_3(head(l1));
+                    const x1_1: SetTreeLeaf$1<T> = value_2(head(l1));
                     let matchResult_4: int32 = (undefined as any), t1_4: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x1_2: SetTreeLeaf$1<T> = (undefined as any), t2_4: FSharpList<Option<SetTreeLeaf$1<T>>> = (undefined as any), x2_2: SetTreeLeaf$1<T> = (undefined as any);
                     if (!isEmpty_1(l1)) {
                         if (head(l1) != null) {
                             matchResult_4 = 0;
                             t1_4 = tail(l1);
-                            x1_2 = value_3(head(l1));
+                            x1_2 = value_2(head(l1));
                         }
                         else if (!isEmpty_1(l2)) {
                             if (head(l2) != null) {
                                 matchResult_4 = 1;
                                 t2_4 = tail(l2);
-                                x2_2 = value_3(head(l2));
+                                x2_2 = value_2(head(l2));
                             }
                             else {
                                 matchResult_4 = 2;
@@ -1309,7 +1309,7 @@ export function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mu
                         if (head(l2) != null) {
                             matchResult_4 = 1;
                             t2_4 = tail(l2);
-                            x2_2 = value_3(head(l2));
+                            x2_2 = value_2(head(l2));
                         }
                         else {
                             matchResult_4 = 2;
@@ -1399,7 +1399,7 @@ export function SetTreeModule_toList<T>(t: Option<SetTreeLeaf$1<T>>): FSharpList
         while (true) {
             const t$0027: Option<SetTreeLeaf$1<T>> = t$0027_mut, acc: FSharpList<T> = acc_mut;
             if (t$0027 != null) {
-                const t2: SetTreeLeaf$1<T> = value_3(t$0027);
+                const t2: SetTreeLeaf$1<T> = value_2(t$0027);
                 if (t2 instanceof SetTreeNode$1) {
                     const tn = t2 as SetTreeNode$1<T>;
                     t$0027_mut = SetTreeNode$1__get_Left<T>(tn);
@@ -1944,12 +1944,44 @@ export function isProperSubsetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean {
 }
 
 export function isProperSupersetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean {
-    const s2_1: Iterable<T> = cache<T>(s2);
-    if (exists_1<T>((arg: T): boolean => !s1.has(arg), s2_1)) {
-        return forAll_1<T>((value_2: T): boolean => s1.has(value_2), s2_1);
+    const s2_1: ISet<T> = newMutableSetWith<T>(s1, s2);
+    if (s1.size > s2_1.size) {
+        return forAll_1<T>((value: T): boolean => s1.has(value), s2_1.values());
     }
     else {
         return false;
     }
 }
 
+export function symmetricExceptWith<T>(s1: ISet<T>, s2: Iterable<T>): void {
+    const s2_1: ISet<T> = newMutableSetWith<T>(s1, s2);
+    iterate_1<T>((x: T): void => {
+        if (s1.has(x)) {
+            s1.delete(x);
+        }
+        else {
+            s1.add(x);
+        }
+    }, s2_1.values());
+}
+
+export function overlaps<T>(s1: ISet<T>, s2: Iterable<T>): boolean {
+    return exists_1<T>((value: T): boolean => s1.has(value), s2);
+}
+
+export function setEquals<T>(s1: ISet<T>, s2: Iterable<T>): boolean {
+    const s2_1: ISet<T> = newMutableSetWith<T>(s1, s2);
+    if (s1.size === s2_1.size) {
+        return forAll_1<T>((value: T): boolean => s2_1.has(value), s1.values());
+    }
+    else {
+        return false;
+    }
+}
+
+export function copyToArray<T>(s1: ISet<T>, target: MutableArray<T>, sourceIndex: int32, targetIndex: int32, count_1: int32): void {
+    iterateIndexed<T>((index: int32, value: T): void => {
+        setItem(target, targetIndex + index, value);
+    }, truncate<T>(count_1, skip<T>(sourceIndex, s1.values())));
+}
+

package/String.ts

@@ -86,6 +86,19 @@ export function endsWith(str: string, pattern: string, ic: boolean | StringCompa
   return false;
 }
 
+export function contains(str: string, pattern: string, ic: boolean | StringComparison) {
+  if (ic === StringComparison.Ordinal) { // fast path
+    return str.includes(pattern);
+  }
+  const len = pattern.length;
+  for (let i = 0; i <= str.length - len; i++) {
+    if (cmp(str.slice(i, i + len), pattern, ic) === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export function indexOfAny(str: string, anyOf: string[], ...args: number[]) {
   if (str == null || str === "") {
     return -1;

package/package.json

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