@fable-org/fable-library-js 2.0.0-beta.3 → 2.0.0-beta.5

package/Seq.d.ts

@@ -1,165 +0,0 @@
-import { IComparer, IEqualityComparer, IDisposable, IEnumerator } from "./Util.js";
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-import { FSharpList } from "./List.js";
-import { int32 } from "./Int32.js";
-export declare const SR_enumerationAlreadyFinished = "Enumeration already finished.";
-export declare const SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
-export declare const SR_inputSequenceEmpty = "The input sequence was empty.";
-export declare const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
-export declare const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
-export declare const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
-export declare const SR_resetNotSupported = "Reset is not supported on this enumerator.";
-export declare function Enumerator_noReset<$a>(): $a;
-export declare function Enumerator_notStarted<$a>(): $a;
-export declare function Enumerator_alreadyFinished<$a>(): $a;
-export declare class Enumerator_Seq<T> implements Iterable<T> {
-    readonly f: (() => IEnumerator<T>);
-    constructor(f: (() => IEnumerator<T>));
-    toString(): string;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function Enumerator_Seq_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Enumerator_Seq_$ctor_673A07F2<T>(f: (() => IEnumerator<T>)): Enumerator_Seq<T>;
-export declare class Enumerator_FromFunctions$1<T> implements IEnumerator<T>, IDisposable {
-    readonly next: (() => boolean);
-    readonly dispose: (() => void);
-    readonly current: (() => T);
-    constructor(current: (() => T), next: (() => boolean), dispose: (() => void));
-    "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
-    "System.Collections.IEnumerator.get_Current"(): any;
-    "System.Collections.IEnumerator.MoveNext"(): boolean;
-    "System.Collections.IEnumerator.Reset"(): void;
-    Dispose(): void;
-}
-export declare function Enumerator_FromFunctions$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Enumerator_FromFunctions$1_$ctor_58C54629<T>(current: (() => T), next: (() => boolean), dispose: (() => void)): Enumerator_FromFunctions$1<T>;
-export declare function Enumerator_cast<T>(e: IEnumerator<T>): IEnumerator<T>;
-export declare function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>): IEnumerator<T>;
-export declare function Enumerator_enumerateThenFinally<T>(f: (() => void), e: IEnumerator<T>): IEnumerator<T>;
-export declare function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((arg0: T) => Option<U>), closef: ((arg0: T) => void)): IEnumerator<U>;
-export declare function Enumerator_unfold<State, T>(f: ((arg0: State) => Option<[T, State]>), state: State): IEnumerator<T>;
-export declare function indexNotFound<$a>(): $a;
-export declare function checkNonNull<$a>(argName: string, arg: $a): void;
-export declare function mkSeq<T>(f: (() => IEnumerator<T>)): Iterable<T>;
-export declare function ofSeq<T>(xs: Iterable<T>): IEnumerator<T>;
-export declare function delay<T>(generator: (() => Iterable<T>)): Iterable<T>;
-export declare function concat<Collection extends Iterable<T>, T>(sources: Iterable<Collection>): Iterable<T>;
-export declare function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>), state: State): Iterable<T>;
-export declare function empty<T>(): Iterable<T>;
-export declare function singleton<T>(x: T): Iterable<T>;
-export declare function ofArray<T>(arr: T[]): Iterable<T>;
-export declare function toArray<T>(xs: Iterable<T>): T[];
-export declare function ofList<T>(xs: FSharpList<T>): Iterable<T>;
-export declare function toList<T>(xs: Iterable<T>): FSharpList<T>;
-export declare function generate<$a, $b>(create: (() => $a), compute: ((arg0: $a) => Option<$b>), dispose: ((arg0: $a) => void)): Iterable<$b>;
-export declare function generateIndexed<$a, $b>(create: (() => $a), compute: ((arg0: int32, arg1: $a) => Option<$b>), dispose: ((arg0: $a) => void)): Iterable<$b>;
-export declare function append<T>(xs: Iterable<T>, ys: Iterable<T>): Iterable<T>;
-export declare function cast<T>(xs: Iterable<T>): Iterable<T>;
-export declare function choose<T, U>(chooser: ((arg0: T) => Option<U>), xs: Iterable<T>): Iterable<U>;
-export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>, ys: Iterable<T>): int32;
-export declare function contains<T>(value: T, xs: Iterable<T>, comparer: IEqualityComparer<T>): boolean;
-export declare function enumerateFromFunctions<$a, $b>(create: (() => $a), moveNext: ((arg0: $a) => boolean), current: ((arg0: $a) => $b)): Iterable<$b>;
-export declare function enumerateThenFinally<T>(source: Iterable<T>, compensation: (() => void)): Iterable<T>;
-export declare function enumerateUsing<T extends IDisposable, $a extends Iterable<U>, U>(resource: T, source: ((arg0: T) => $a)): Iterable<U>;
-export declare function enumerateWhile<T>(guard: (() => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function filter<T>(f: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function exists<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): boolean;
-export declare function exists2<T1, T2>(predicate: ((arg0: T1, arg1: T2) => boolean), xs: Iterable<T1>, ys: Iterable<T2>): boolean;
-export declare function exactlyOne<T>(xs: Iterable<T>): T;
-export declare function tryExactlyOne<T>(xs: Iterable<T>): Option<T>;
-export declare function tryFind<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T>;
-export declare function find<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): T;
-export declare function tryFindBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T>;
-export declare function findBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): T;
-export declare function tryFindIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<int32>;
-export declare function findIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): int32;
-export declare function tryFindIndexBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<int32>;
-export declare function findIndexBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): int32;
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, xs: Iterable<T>): State;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: any) => any), xs: Iterable<T>, state: any): any;
-export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, xs: Iterable<T1>, ys: Iterable<T2>): State;
-export declare function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: Iterable<T1>, ys: Iterable<T2>, state: State): State;
-export declare function forAll<$a>(predicate: ((arg0: $a) => boolean), xs: Iterable<$a>): boolean;
-export declare function forAll2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), xs: Iterable<$a>, ys: Iterable<$b>): boolean;
-export declare function tryHead<T>(xs: Iterable<T>): Option<T>;
-export declare function head<T>(xs: Iterable<T>): T;
-export declare function initialize<$a>(count: int32, f: ((arg0: int32) => $a)): Iterable<$a>;
-export declare function initializeInfinite<$a>(f: ((arg0: int32) => $a)): Iterable<$a>;
-export declare function isEmpty<T>(xs: Iterable<T>): boolean;
-export declare function tryItem<T>(index: int32, xs: Iterable<T>): Option<T>;
-export declare function item<T>(index: int32, xs: Iterable<T>): T;
-export declare function iterate<$a>(action: ((arg0: $a) => void), xs: Iterable<$a>): void;
-export declare function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void;
-export declare function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: Iterable<$a>): void;
-export declare function iterateIndexed2<$a, $b>(action: ((arg0: int32, arg1: $a, arg2: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void;
-export declare function tryLast<T>(xs: Iterable<T>): Option<T>;
-export declare function last<T>(xs: Iterable<T>): T;
-export declare function length<T>(xs: Iterable<T>): int32;
-export declare function map<T, U>(mapping: ((arg0: T) => U), xs: Iterable<T>): Iterable<U>;
-export declare function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: Iterable<T>): Iterable<U>;
-export declare function indexed<T>(xs: Iterable<T>): Iterable<[int32, T]>;
-export declare function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: Iterable<T1>, ys: Iterable<T2>): Iterable<U>;
-export declare function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T2) => U), xs: Iterable<T1>, ys: Iterable<T2>): Iterable<U>;
-export declare function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) => U), xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Iterable<U>;
-export declare function readOnly<T>(xs: Iterable<T>): Iterable<T>;
-export declare class CachedSeq$1<T> implements Iterable<T>, IDisposable {
-    readonly res: Iterable<T>;
-    readonly cleanup: (() => void);
-    constructor(cleanup: (() => void), res: Iterable<T>);
-    Dispose(): void;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function CachedSeq$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function CachedSeq$1_$ctor_Z7A8347D4<T>(cleanup: (() => void), res: Iterable<T>): CachedSeq$1<T>;
-export declare function CachedSeq$1__Clear<T>(_: CachedSeq$1<T>): void;
-export declare function cache<T>(source: Iterable<T>): Iterable<T>;
-export declare function allPairs<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[T1, T2]>;
-export declare function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: Iterable<T>): [Iterable<Result>, State];
-export declare function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), xs: Iterable<T>, state: State): [Iterable<Result>, State];
-export declare function tryPick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): Option<$a>;
-export declare function pick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): $a;
-export declare function reduce<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T;
-export declare function reduceBack<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T;
-export declare function replicate<$a>(n: int32, x: $a): Iterable<$a>;
-export declare function reverse<T>(xs: Iterable<T>): Iterable<T>;
-export declare function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state: State, xs: Iterable<T>): Iterable<State>;
-export declare function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: Iterable<T>, state: State): Iterable<State>;
-export declare function skip<T>(count: int32, source: Iterable<T>): Iterable<T>;
-export declare function skipWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function tail<T>(xs: Iterable<T>): Iterable<T>;
-export declare function take<T>(count: int32, xs: Iterable<T>): Iterable<T>;
-export declare function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function truncate<T>(count: int32, xs: Iterable<T>): Iterable<T>;
-export declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[T1, T2]>;
-export declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Iterable<[T1, T2, T3]>;
-export declare function collect<T, Collection extends Iterable<U>, U>(mapping: ((arg0: T) => Collection), xs: Iterable<T>): Iterable<U>;
-export declare function where<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function pairwise<T>(xs: Iterable<T>): Iterable<[T, T]>;
-export declare function splitInto<T>(chunks: int32, xs: Iterable<T>): Iterable<T[]>;
-export declare function windowed<T>(windowSize: int32, xs: Iterable<T>): Iterable<T[]>;
-export declare function transpose<$a extends Iterable<T>, T>(xss: Iterable<$a>): Iterable<Iterable<T>>;
-export declare function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>): Iterable<T>;
-export declare function sort<T>(xs: Iterable<T>, comparer: IComparer<T>): Iterable<T>;
-export declare function sortBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): Iterable<T>;
-export declare function sortDescending<T>(xs: Iterable<T>, comparer: IComparer<T>): Iterable<T>;
-export declare function sortByDescending<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): Iterable<T>;
-export declare function sum<T>(xs: Iterable<T>, adder: any): T;
-export declare function sumBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, adder: any): U;
-export declare function maxBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): T;
-export declare function max<T>(xs: Iterable<T>, comparer: IComparer<T>): T;
-export declare function minBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): T;
-export declare function min<T>(xs: Iterable<T>, comparer: IComparer<T>): T;
-export declare function average<T>(xs: Iterable<T>, averager: any): T;
-export declare function averageBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, averager: any): U;
-export declare function permute<T>(f: ((arg0: int32) => int32), xs: Iterable<T>): Iterable<T>;
-export declare function chunkBySize<T>(chunkSize: int32, xs: Iterable<T>): Iterable<T[]>;
-export declare function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T>;
-export declare function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>): Iterable<T>;
-export declare function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T>;
-export declare function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): Iterable<T>;
-export declare function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T>;

package/Seq2.d.ts

@@ -1,18 +0,0 @@
-import { IEqualityComparer } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { FSharpList } from "./List.js";
-export declare function distinct<T>(xs: Iterable<T>, comparer: IEqualityComparer<T>): Iterable<T>;
-export declare function distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>, comparer: IEqualityComparer<Key>): Iterable<T>;
-export declare function except<T>(itemsToExclude: Iterable<T>, xs: Iterable<T>, comparer: IEqualityComparer<T>): Iterable<T>;
-export declare function countBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>, comparer: IEqualityComparer<Key>): Iterable<[Key, int32]>;
-export declare function groupBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>, comparer: IEqualityComparer<Key>): Iterable<[Key, Iterable<T>]>;
-export declare function Array_distinct<T>(xs: T[], comparer: IEqualityComparer<T>): T[];
-export declare function Array_distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): T[];
-export declare function Array_except<T>(itemsToExclude: Iterable<T>, xs: T[], comparer: IEqualityComparer<T>): T[];
-export declare function Array_countBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): [Key, int32][];
-export declare function Array_groupBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): [Key, T[]][];
-export declare function List_distinct<T>(xs: FSharpList<T>, comparer: IEqualityComparer<T>): FSharpList<T>;
-export declare function List_distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: FSharpList<T>, comparer: IEqualityComparer<Key>): FSharpList<T>;
-export declare function List_except<T>(itemsToExclude: Iterable<T>, xs: FSharpList<T>, comparer: IEqualityComparer<T>): FSharpList<T>;
-export declare function List_countBy<T, Key>(projection: ((arg0: T) => Key), xs: FSharpList<T>, comparer: IEqualityComparer<Key>): FSharpList<[Key, int32]>;
-export declare function List_groupBy<T, Key>(projection: ((arg0: T) => Key), xs: FSharpList<T>, comparer: IEqualityComparer<Key>): FSharpList<[Key, FSharpList<T>]>;

package/Set.d.ts

@@ -1,190 +0,0 @@
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { ISet, IEnumerator, IComparer } from "./Util.js";
-import { Record } from "./Types.js";
-import { FSharpList } from "./List.js";
-export declare class SetTreeLeaf$1<T> {
-    readonly k: T;
-    constructor(k: T);
-}
-export declare function SetTreeLeaf$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function SetTreeLeaf$1_$ctor_2B595<T>(k: T): SetTreeLeaf$1<T>;
-export declare function SetTreeLeaf$1__get_Key<T>(_: SetTreeLeaf$1<T>): T;
-export declare class SetTreeNode$1<T> extends SetTreeLeaf$1<T> {
-    readonly right: Option<SetTreeLeaf$1<T>>;
-    readonly left: Option<SetTreeLeaf$1<T>>;
-    readonly h: int32;
-    constructor(v: T, left: Option<SetTreeLeaf$1<T>>, right: Option<SetTreeLeaf$1<T>>, h: int32);
-}
-export declare function SetTreeNode$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function SetTreeNode$1_$ctor_5F465FC9<T>(v: T, left: Option<SetTreeLeaf$1<T>>, right: Option<SetTreeLeaf$1<T>>, h: int32): SetTreeNode$1<T>;
-export declare function SetTreeNode$1__get_Left<T>(_: SetTreeNode$1<T>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeNode$1__get_Right<T>(_: SetTreeNode$1<T>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeNode$1__get_Height<T>(_: SetTreeNode$1<T>): int32;
-export declare function SetTreeModule_empty<T>(): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_countAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: int32): int32;
-export declare function SetTreeModule_count<$a>(s: Option<SetTreeLeaf$1<$a>>): int32;
-export declare function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_balance<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, k: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: T, t: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_spliceOutSuccessor<T>(t: Option<SetTreeLeaf$1<T>>): [T, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_remove<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: T, t_mut: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_iter<T>(f_mut: ((arg0: T) => void), t_mut: Option<SetTreeLeaf$1<T>>): void;
-export declare function SetTreeModule_foldBackOpt<T, $a>(f_mut: any, t_mut: Option<SetTreeLeaf$1<T>>, x_mut: $a): $a;
-export declare function SetTreeModule_foldBack<$a, $b>(f: ((arg0: $a, arg1: $b) => $b), m: Option<SetTreeLeaf$1<$a>>, x: $b): $b;
-export declare function SetTreeModule_foldOpt<$a, T>(f_mut: any, x_mut: $a, t_mut: Option<SetTreeLeaf$1<T>>): $a;
-export declare function SetTreeModule_fold<$a, $b>(f: ((arg0: $a, arg1: $b) => $a), x: $a, m: Option<SetTreeLeaf$1<$b>>): $a;
-export declare function SetTreeModule_forall<T>(f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_exists<T>(f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_subset<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): boolean;
-export declare function SetTreeModule_properSubset<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): boolean;
-export declare function SetTreeModule_filterAux<T>(comparer_mut: IComparer<T>, f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_filter<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), s: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_diffAux<T>(comparer_mut: IComparer<T>, t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_diff<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_union<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_intersectionAux<T>(comparer_mut: IComparer<T>, b_mut: Option<SetTreeLeaf$1<T>>, t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_intersection<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_partition1<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), k: $a, acc1: Option<SetTreeLeaf$1<$a>>, acc2: Option<SetTreeLeaf$1<$a>>): [Option<SetTreeLeaf$1<$a>>, Option<SetTreeLeaf$1<$a>>];
-export declare function SetTreeModule_partitionAux<T>(comparer_mut: IComparer<T>, f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>, acc__mut: Option<SetTreeLeaf$1<T>>, acc__1_mut: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_partition<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), s: Option<SetTreeLeaf$1<$a>>): [Option<SetTreeLeaf$1<$a>>, Option<SetTreeLeaf$1<$a>>];
-export declare function SetTreeModule_minimumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, n_mut: T): T;
-export declare function SetTreeModule_minimumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>): Option<T>;
-export declare function SetTreeModule_maximumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, n_mut: T): T;
-export declare function SetTreeModule_maximumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>): Option<T>;
-export declare function SetTreeModule_minimumElement<$a>(s: Option<SetTreeLeaf$1<$a>>): $a;
-export declare function SetTreeModule_maximumElement<$a>(s: Option<SetTreeLeaf$1<$a>>): $a;
-export declare class SetTreeModule_SetIterator$1<T> extends Record {
-    stack: FSharpList<Option<SetTreeLeaf$1<T>>>;
-    started: boolean;
-    constructor(stack: FSharpList<Option<SetTreeLeaf$1<T>>>, started: boolean);
-}
-export declare function SetTreeModule_SetIterator$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function SetTreeModule_collapseLHS<T>(stack_mut: FSharpList<Option<SetTreeLeaf$1<T>>>): FSharpList<Option<SetTreeLeaf$1<T>>>;
-export declare function SetTreeModule_mkIterator<$a>(s: Option<SetTreeLeaf$1<$a>>): SetTreeModule_SetIterator$1<$a>;
-export declare function SetTreeModule_notStarted<$a>(): $a;
-export declare function SetTreeModule_alreadyFinished<$a>(): $a;
-export declare function SetTreeModule_current<$a>(i: SetTreeModule_SetIterator$1<$a>): $a;
-export declare function SetTreeModule_moveNext<T>(i: SetTreeModule_SetIterator$1<T>): boolean;
-export declare function SetTreeModule_mkIEnumerator<a>(s: Option<SetTreeLeaf$1<a>>): IEnumerator<a>;
-/**
- * Set comparison.  Note this can be expensive.
- */
-export declare function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mut: FSharpList<Option<SetTreeLeaf$1<T>>>, l2_mut: FSharpList<Option<SetTreeLeaf$1<T>>>): int32;
-export declare function SetTreeModule_compare<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, t2: Option<SetTreeLeaf$1<T>>): int32;
-export declare function SetTreeModule_choose<$a>(s: Option<SetTreeLeaf$1<$a>>): $a;
-export declare function SetTreeModule_toList<T>(t: Option<SetTreeLeaf$1<T>>): FSharpList<T>;
-export declare function SetTreeModule_copyToArray<$a>(s: Option<SetTreeLeaf$1<$a>>, arr: $a[], i: int32): void;
-export declare function SetTreeModule_toArray<$a>(s: Option<SetTreeLeaf$1<$a>>): $a[];
-export declare function SetTreeModule_mkFromEnumerator<$a>(comparer_mut: IComparer<$a>, acc_mut: Option<SetTreeLeaf$1<$a>>, e_mut: IEnumerator<$a>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_ofArray<$a>(comparer: IComparer<$a>, l: $a[]): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_ofList<$a>(comparer: IComparer<$a>, l: FSharpList<$a>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_ofSeq<T>(comparer: IComparer<T>, c: Iterable<T>): Option<SetTreeLeaf$1<T>>;
-export declare class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
-    readonly tree: Option<SetTreeLeaf$1<T>>;
-    readonly comparer: IComparer<T>;
-    constructor(comparer: IComparer<T>, tree: Option<SetTreeLeaf$1<T>>);
-    GetHashCode(): int32;
-    Equals(that: any): boolean;
-    toString(): string;
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    CompareTo(that: any): int32;
-    "System.Collections.Generic.ICollection`1.Add2B595"(x: T): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(x: T): boolean;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(x: T): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: T[], i: int32): void;
-    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
-    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
-    "System.Collections.Generic.IReadOnlyCollection`1.get_Count"(): int32;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    get size(): int32;
-    add(k: T): ISet<T>;
-    clear(): void;
-    delete(k: T): boolean;
-    has(k: T): boolean;
-    keys(): Iterable<T>;
-    values(): Iterable<T>;
-    entries(): Iterable<[T, T]>;
-    forEach(f: ((arg0: T, arg1: T, arg2: ISet<T>) => void), thisArg?: Option<any>): void;
-}
-export declare function FSharpSet_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function FSharpSet_$ctor<T>(comparer: IComparer<T>, tree: Option<SetTreeLeaf$1<T>>): FSharpSet<T>;
-export declare function FSharpSet__get_Comparer<T>(set$: FSharpSet<T>): IComparer<T>;
-export declare function FSharpSet__get_Tree<T>(set$: FSharpSet<T>): Option<SetTreeLeaf$1<T>>;
-export declare function FSharpSet_Empty<T>(comparer: IComparer<T>): FSharpSet<T>;
-export declare function FSharpSet__Add<T>(s: FSharpSet<T>, value: T): FSharpSet<T>;
-export declare function FSharpSet__Remove<T>(s: FSharpSet<T>, value: T): FSharpSet<T>;
-export declare function FSharpSet__get_Count<T>(s: FSharpSet<T>): int32;
-export declare function FSharpSet__Contains<T>(s: FSharpSet<T>, value: T): boolean;
-export declare function FSharpSet__Iterate<T>(s: FSharpSet<T>, x: ((arg0: T) => void)): void;
-export declare function FSharpSet__Fold<T, $a>(s: FSharpSet<T>, f: ((arg0: T, arg1: $a) => $a), z: $a): $a;
-export declare function FSharpSet__get_IsEmpty<T>(s: FSharpSet<T>): boolean;
-export declare function FSharpSet__Partition<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): [FSharpSet<T>, FSharpSet<T>];
-export declare function FSharpSet__Filter<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): FSharpSet<T>;
-export declare function FSharpSet__Map<T, U>(s: FSharpSet<T>, f: ((arg0: T) => U), comparer: IComparer<U>): FSharpSet<U>;
-export declare function FSharpSet__Exists<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): boolean;
-export declare function FSharpSet__ForAll<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): boolean;
-export declare function FSharpSet_op_Subtraction<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function FSharpSet_op_Addition<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function FSharpSet_Intersection<T>(a: FSharpSet<T>, b: FSharpSet<T>): FSharpSet<T>;
-export declare function FSharpSet_IntersectionMany<T>(sets: Iterable<FSharpSet<T>>): FSharpSet<T>;
-export declare function FSharpSet_Equality<T>(a: FSharpSet<T>, b: FSharpSet<T>): boolean;
-export declare function FSharpSet_Compare<T>(a: FSharpSet<T>, b: FSharpSet<T>): int32;
-export declare function FSharpSet__get_Choose<T>(x: FSharpSet<T>): T;
-export declare function FSharpSet__get_MinimumElement<T>(x: FSharpSet<T>): T;
-export declare function FSharpSet__get_MaximumElement<T>(x: FSharpSet<T>): T;
-export declare function FSharpSet__IsSubsetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__IsSupersetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__IsProperSubsetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__IsProperSupersetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__ToList<T>(x: FSharpSet<T>): FSharpList<T>;
-export declare function FSharpSet__ToArray<T>(x: FSharpSet<T>): T[];
-export declare function FSharpSet__ComputeHashCode<T>(this$: FSharpSet<T>): int32;
-export declare function isEmpty<T>(set$: FSharpSet<T>): boolean;
-export declare function contains<T>(element: T, set$: FSharpSet<T>): boolean;
-export declare function add<T>(value: T, set$: FSharpSet<T>): FSharpSet<T>;
-export declare function singleton<T>(value: T, comparer: IComparer<T>): FSharpSet<T>;
-export declare function remove<T>(value: T, set$: FSharpSet<T>): FSharpSet<T>;
-export declare function union<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function unionMany<T>(sets: Iterable<FSharpSet<T>>, comparer: IComparer<T>): FSharpSet<T>;
-export declare function intersect<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function intersectMany<T>(sets: Iterable<FSharpSet<T>>): FSharpSet<T>;
-export declare function iterate<T>(action: ((arg0: T) => void), set$: FSharpSet<T>): void;
-export declare function empty<T>(comparer: IComparer<T>): FSharpSet<T>;
-export declare function forAll<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): boolean;
-export declare function exists<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): boolean;
-export declare function filter<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): FSharpSet<T>;
-export declare function partition<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): [FSharpSet<T>, FSharpSet<T>];
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, set$: FSharpSet<T>): State;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), set$: FSharpSet<T>, state: State): State;
-export declare function map<T, U>(mapping: ((arg0: T) => U), set$: FSharpSet<T>, comparer: IComparer<U>): FSharpSet<U>;
-export declare function count<T>(set$: FSharpSet<T>): int32;
-export declare function ofList<T>(elements: Iterable<T>, comparer: IComparer<T>): FSharpSet<T>;
-export declare function ofArray<T>(array: T[], comparer: IComparer<T>): FSharpSet<T>;
-export declare function toList<T>(set$: FSharpSet<T>): FSharpList<T>;
-export declare function toArray<T>(set$: FSharpSet<T>): T[];
-export declare function toSeq<T>(set$: FSharpSet<T>): Iterable<T>;
-export declare function ofSeq<T>(elements: Iterable<T>, comparer: IComparer<T>): FSharpSet<T>;
-export declare function difference<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function isSubset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function isSuperset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function isProperSubset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function isProperSuperset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function minElement<T>(set$: FSharpSet<T>): T;
-export declare function maxElement<T>(set$: FSharpSet<T>): T;
-export declare function unionWith<T>(s1: ISet<T>, s2: Iterable<T>): ISet<T>;
-export declare function newMutableSetWith<T>(s1: ISet<T>, s2: Iterable<T>): ISet<T>;
-export declare function intersectWith<T>(s1: ISet<T>, s2: Iterable<T>): void;
-export declare function exceptWith<T>(s1: ISet<T>, s2: Iterable<T>): void;
-export declare function isSubsetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;
-export declare function isSupersetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;
-export declare function isProperSubsetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;
-export declare function isProperSupersetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;

package/String.d.ts

@@ -1,58 +0,0 @@
-declare const enum StringComparison {
-    CurrentCulture = 0,
-    CurrentCultureIgnoreCase = 1,
-    InvariantCulture = 2,
-    InvariantCultureIgnoreCase = 3,
-    Ordinal = 4,
-    OrdinalIgnoreCase = 5
-}
-export declare function compare(...args: any[]): number;
-export declare function compareOrdinal(x: string, y: string): number;
-export declare function compareTo(x: string, y: string): number;
-export declare function startsWith(str: string, pattern: string, ic: boolean | StringComparison): boolean;
-export declare function endsWith(str: string, pattern: string, ic: boolean | StringComparison): boolean;
-export declare function indexOfAny(str: string, anyOf: string[], ...args: number[]): number;
-export type IPrintfFormatContinuation = (f: (x: string) => any) => any;
-export interface IPrintfFormat {
-    input: string;
-    cont: IPrintfFormatContinuation;
-}
-export declare function printf(input: string): IPrintfFormat;
-export declare function interpolate(str: string, values: any[]): string;
-export declare function toConsole(arg: IPrintfFormat | string): any;
-export declare function toConsoleError(arg: IPrintfFormat | string): any;
-export declare function toText(arg: IPrintfFormat | string): any;
-export declare function toFail(arg: IPrintfFormat | string): any;
-export declare function fsFormat(str: string): (cont: (...args: any[]) => any) => any;
-export declare function format(str: string | object, ...args: any[]): string;
-export declare function initialize(n: number, f: (i: number) => string): string;
-export declare function insert(str: string, startIndex: number, value: string): string;
-export declare function isNullOrEmpty(str: string | any): boolean;
-export declare function isNullOrWhiteSpace(str: string | any): boolean;
-export declare function concat(...xs: any[]): string;
-export declare function join<T>(delimiter: string, xs: Iterable<T>): string;
-export declare function joinWithIndices(delimiter: string, xs: string[], startIndex: number, count: number): string;
-export declare function toBase64String(inArray: ArrayLike<number>): string;
-export declare function fromBase64String(b64Encoded: string): number[];
-export declare function padLeft(str: string, len: number, ch?: string): string;
-export declare function padRight(str: string, len: number, ch?: string): string;
-export declare function remove(str: string, startIndex: number, count?: number): string;
-export declare function replace(str: string, search: string, replace: string): string;
-export declare function replicate(n: number, x: string): string;
-export declare function getCharAtIndex(input: string, index: number): string;
-export declare function split(str: string, splitters: string[], count?: number, options?: number): string[];
-export declare function trim(str: string, ...chars: string[]): string;
-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[];
-    fmts?: string[];
-}
-export declare function fmt(strs: TemplateStringsArray, ...args: any[]): FormattableString;
-export declare function fmtWith(fmts: string[]): (strs: TemplateStringsArray, ...args: any[]) => FormattableString;
-export declare function getFormat(s: FormattableString): string;
-export {};

package/System.Collections.Generic.d.ts

@@ -1,79 +0,0 @@
-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> {
-    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_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> {
-    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_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;
-    constructor(initialContents: T[], initialCount: int32);
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function Stack$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Stack$1_$ctor_Z524259A4<T>(initialCapacity: int32): Stack$1<T>;
-export declare function Stack$1_$ctor<T>(): Stack$1<T>;
-export declare function Stack$1_$ctor_BB573A<T>(xs: Iterable<T>): Stack$1<T>;
-export declare function Stack$1__Ensure_Z524259A4<T>(_: Stack$1<T>, newSize: int32): void;
-export declare function Stack$1__get_Count<T>(_: Stack$1<T>): int32;
-export declare function Stack$1__Pop<T>(_: Stack$1<T>): T;
-export declare function Stack$1__Peek<T>(_: Stack$1<T>): T;
-export declare function Stack$1__Contains_2B595<T>(_: Stack$1<T>, x: T): boolean;
-export declare function Stack$1__TryPeek_1F3DB691<T>(this$: Stack$1<T>, result: FSharpRef<T>): boolean;
-export declare function Stack$1__TryPop_1F3DB691<T>(this$: Stack$1<T>, result: FSharpRef<T>): boolean;
-export declare function Stack$1__Push_2B595<T>(this$: Stack$1<T>, x: T): void;
-export declare function Stack$1__Clear<T>(_: Stack$1<T>): void;
-export declare function Stack$1__TrimExcess<T>(this$: Stack$1<T>): void;
-export declare function Stack$1__ToArray<T>(_: Stack$1<T>): T[];
-export declare class Queue$1<T> implements Iterable<T> {
-    contents: T[];
-    count: int32;
-    head: int32;
-    tail: int32;
-    constructor(initialContents: T[], initialCount: int32);
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function Queue$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Queue$1_$ctor_Z524259A4<T>(initialCapacity: int32): Queue$1<T>;
-export declare function Queue$1_$ctor<T>(): Queue$1<T>;
-export declare function Queue$1_$ctor_BB573A<T>(xs: Iterable<T>): Queue$1<T>;
-export declare function Queue$1__get_Count<T>(_: Queue$1<T>): int32;
-export declare function Queue$1__Enqueue_2B595<T>(_: Queue$1<T>, value: T): void;
-export declare function Queue$1__Dequeue<T>(_: Queue$1<T>): T;
-export declare function Queue$1__Peek<T>(_: Queue$1<T>): T;
-export declare function Queue$1__TryDequeue_1F3DB691<T>(this$: Queue$1<T>, result: FSharpRef<T>): boolean;
-export declare function Queue$1__TryPeek_1F3DB691<T>(this$: Queue$1<T>, result: FSharpRef<T>): boolean;
-export declare function Queue$1__Contains_2B595<T>(_: Queue$1<T>, x: T): boolean;
-export declare function Queue$1__Clear<T>(_: Queue$1<T>): void;
-export declare function Queue$1__TrimExcess<T>(_: Queue$1<T>): void;
-export declare function Queue$1__ToArray<T>(_: Queue$1<T>): T[];
-export declare function Queue$1__CopyTo_Z3B4C077E<T>(_: Queue$1<T>, target: T[], start: int32): void;
-export declare function Queue$1__size<T>(this$: Queue$1<T>): int32;
-export declare function Queue$1__toIndex_Z524259A4<T>(this$: Queue$1<T>, i: int32): int32;
-export declare function Queue$1__ensure_Z524259A4<T>(this$: Queue$1<T>, requiredSize: int32): void;
-export declare function Queue$1__toSeq<T>(this$: Queue$1<T>): Iterable<T>;

package/System.Text.d.ts

@@ -1,39 +0,0 @@
-import { float64, int32 } from "./Int32.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class StringBuilder {
-    readonly buf: string[];
-    constructor(value: string, capacity: int32);
-    toString(): string;
-}
-export declare function StringBuilder_$reflection(): TypeInfo;
-export declare function StringBuilder_$ctor_Z18115A39(value: string, capacity: int32): StringBuilder;
-export declare function StringBuilder_$ctor_Z524259A4(capacity: int32): StringBuilder;
-export declare function StringBuilder_$ctor_Z721C83C5(value: string): StringBuilder;
-export declare function StringBuilder_$ctor(): StringBuilder;
-export declare function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
-export declare function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder;
-export declare function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): StringBuilder;
-export declare function StringBuilder__Append_61B1CA(x: StringBuilder, c: string, repeatCount: int32): StringBuilder;
-export declare function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder;
-export declare function StringBuilder__Append_5E38073B(x: StringBuilder, o: float64): StringBuilder;
-export declare function StringBuilder__Append_Z1FBCCD16(x: StringBuilder, o: boolean): StringBuilder;
-export declare function StringBuilder__Append_4E60E31B(x: StringBuilder, o: any): StringBuilder;
-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;

package/SystemException.d.ts

@@ -1,5 +0,0 @@
-import { Exception } from "./Types.js";
-export declare class SystemException extends Exception {
-}
-export declare class TimeoutException extends SystemException {
-}

package/SystemException.js

@@ -1,5 +0,0 @@
-import { Exception } from "./Types.js";
-export class SystemException extends Exception {
-}
-export class TimeoutException extends SystemException {
-}

package/TimeOnly.d.ts

@@ -1,15 +0,0 @@
-import { FSharpRef } from "./Types.js";
-import { IDateTime } from "./Util.js";
-export declare function create(h?: number, m?: number, s?: number, ms?: number): number;
-export declare function fromTicks(ticks: number | bigint): number;
-export declare function fromTimeSpan(timeSpan: number): number;
-export declare function fromDateTime(d: IDateTime): number;
-export declare function maxValue(): number;
-export declare function add(t: number, ts: number, wrappedDays?: FSharpRef<number>): number;
-export declare function addHours(t: number, h: number): number;
-export declare function addMinutes(t: number, m: number): number;
-export declare function isBetween(t: number, start: number, end: number): boolean;
-export declare function toString(t: number, format?: string, _provider?: any): string;
-export declare function parse(str: string): number;
-export declare function tryParse(v: string, defValue: FSharpRef<number>): boolean;
-export declare function op_Subtraction(left: number, right: number): number;