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

package/Int32.d.ts

@@ -1,28 +0,0 @@
-import { FSharpRef } from "./Types.js";
-export type int8 = number;
-export type uint8 = number;
-export type int16 = number;
-export type uint16 = number;
-export type int32 = number;
-export type uint32 = number;
-export type float16 = number;
-export type float32 = number;
-export type float64 = number;
-export declare enum NumberStyles {
-    AllowHexSpecifier = 512
-}
-export declare function getPrefix(radix: number): string;
-export declare function getRadix(prefix: string, style: number): 2 | 8 | 16 | 10;
-export declare function isValid(str: string, style: number, radix?: number): {
-    sign: string;
-    prefix: string;
-    digits: string;
-    radix: number;
-} | null;
-export declare function parse(str: string, style: number, unsigned: boolean, bitsize: number, radix?: number): number;
-export declare function tryParse(str: string, style: number, unsigned: boolean, bitsize: number, defValue: FSharpRef<number>): boolean;
-export declare function op_UnaryNegation_Int8(x: number): number;
-export declare function op_UnaryNegation_Int16(x: number): number;
-export declare function op_UnaryNegation_Int32(x: number): number;
-export declare function divRem(x: number, y: number): [number, number];
-export declare function divRem(x: number, y: number, out: FSharpRef<number>): number;

package/List.d.ts

@@ -1,143 +0,0 @@
-import { Option } from "./Option.js";
-import { IComparer, IEqualityComparer, IDisposable, IEnumerator, Nullable } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { Record } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class FSharpList<T> extends Record implements Iterable<T> {
-    readonly head: T;
-    tail: Option<FSharpList<T>>;
-    constructor(head: T, tail: Option<FSharpList<T>>);
-    toString(): string;
-    Equals(other: Nullable<any>): boolean;
-    GetHashCode(): int32;
-    toJSON(): any;
-    CompareTo(other: Nullable<any>): int32;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function FSharpList_$reflection(gen0: TypeInfo): TypeInfo;
-export declare class ListEnumerator$1<T> implements IEnumerator<T>, IDisposable {
-    readonly xs: FSharpList<T>;
-    it: FSharpList<T>;
-    current: T;
-    constructor(xs: FSharpList<T>);
-    "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
-    "System.Collections.IEnumerator.get_Current"(): Nullable<any>;
-    "System.Collections.IEnumerator.MoveNext"(): boolean;
-    "System.Collections.IEnumerator.Reset"(): void;
-    Dispose(): void;
-}
-export declare function ListEnumerator$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function ListEnumerator$1_$ctor_3002E699<T>(xs: FSharpList<T>): ListEnumerator$1<T>;
-export declare function FSharpList_get_Empty<T>(): FSharpList<T>;
-export declare function FSharpList_Cons_305B8EAC<T>(x: T, xs: FSharpList<T>): FSharpList<T>;
-export declare function FSharpList__get_IsEmpty<T>(xs: FSharpList<T>): boolean;
-export declare function FSharpList__get_Length<T>(xs: FSharpList<T>): int32;
-export declare function FSharpList__get_Head<T>(xs: FSharpList<T>): T;
-export declare function FSharpList__get_Tail<T>(xs: FSharpList<T>): FSharpList<T>;
-export declare function FSharpList__get_Item_Z524259A4<T>(xs: FSharpList<T>, index: int32): T;
-export declare function indexNotFound<$a>(): $a;
-export declare function empty<$a>(): FSharpList<$a>;
-export declare function cons<T>(x: T, xs: FSharpList<T>): FSharpList<T>;
-export declare function singleton<$a>(x: $a): FSharpList<$a>;
-export declare function isEmpty<T>(xs: FSharpList<T>): boolean;
-export declare function length<T>(xs: FSharpList<T>): int32;
-export declare function head<T>(xs: FSharpList<T>): T;
-export declare function tryHead<T>(xs: FSharpList<T>): Option<T>;
-export declare function tail<T>(xs: FSharpList<T>): FSharpList<T>;
-export declare function tryLast<T>(xs_mut: FSharpList<T>): Option<T>;
-export declare function last<T>(xs: FSharpList<T>): T;
-export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: FSharpList<T>, ys: FSharpList<T>): int32;
-export declare function toArray<T>(xs: FSharpList<T>): T[];
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, xs: FSharpList<T>): State;
-export declare function reverse<T>(xs: FSharpList<T>): FSharpList<T>;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: FSharpList<T>, state: State): State;
-export declare function foldIndexed<State, T>(folder: ((arg0: int32, arg1: State, arg2: T) => State), state: State, xs: FSharpList<T>): State;
-export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, xs: FSharpList<T1>, ys: FSharpList<T2>): State;
-export declare function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: FSharpList<T1>, ys: FSharpList<T2>, state: State): State;
-export declare function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>), state: State): FSharpList<T>;
-export declare function iterate<$a>(action: ((arg0: $a) => void), xs: FSharpList<$a>): void;
-export declare function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: FSharpList<$a>, ys: FSharpList<$b>): void;
-export declare function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: FSharpList<$a>): void;
-export declare function iterateIndexed2<$a, $b>(action: ((arg0: int32, arg1: $a, arg2: $b) => void), xs: FSharpList<$a>, ys: FSharpList<$b>): void;
-export declare function toSeq<T>(xs: FSharpList<T>): Iterable<T>;
-export declare function ofArrayWithTail<T>(xs: T[], tail_1: FSharpList<T>): FSharpList<T>;
-export declare function ofArray<T>(xs: T[]): FSharpList<T>;
-export declare function ofSeq<T>(xs: Iterable<T>): FSharpList<T>;
-export declare function concat<T>(lists: Iterable<FSharpList<T>>): FSharpList<T>;
-export declare function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state: State, xs: FSharpList<T>): FSharpList<State>;
-export declare function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: FSharpList<T>, state: State): FSharpList<State>;
-export declare function append<T>(xs: FSharpList<T>, ys: FSharpList<T>): FSharpList<T>;
-export declare function collect<T, U>(mapping: ((arg0: T) => FSharpList<U>), xs: FSharpList<T>): FSharpList<U>;
-export declare function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: FSharpList<T>): FSharpList<U>;
-export declare function map<T, U>(mapping: ((arg0: T) => U), xs: FSharpList<T>): FSharpList<U>;
-export declare function indexed<$a>(xs: FSharpList<$a>): FSharpList<[int32, $a]>;
-export declare function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<U>;
-export declare function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T2) => U), xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<U>;
-export declare function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) => U), xs: FSharpList<T1>, ys: FSharpList<T2>, zs: FSharpList<T3>): FSharpList<U>;
-export declare function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: FSharpList<T>): [FSharpList<Result>, State];
-export declare function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), xs: FSharpList<T>, state: State): [FSharpList<Result>, State];
-export declare function tryPick<T, $a>(f: ((arg0: T) => Option<$a>), xs: FSharpList<T>): Option<$a>;
-export declare function pick<$a, $b>(f: ((arg0: $a) => Option<$b>), xs: FSharpList<$a>): $b;
-export declare function tryFind<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<$a>;
-export declare function find<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): $a;
-export declare function tryFindBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<$a>;
-export declare function findBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): $a;
-export declare function tryFindIndex<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): Option<int32>;
-export declare function findIndex<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): int32;
-export declare function tryFindIndexBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<int32>;
-export declare function findIndexBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): int32;
-export declare function tryItem<T>(n: int32, xs: FSharpList<T>): Option<T>;
-export declare function item<T>(n: int32, xs: FSharpList<T>): T;
-export declare function filter<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpList<T>;
-export declare function partition<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): [FSharpList<T>, FSharpList<T>];
-export declare function choose<T, U>(f: ((arg0: T) => Option<U>), xs: FSharpList<T>): FSharpList<U>;
-export declare function contains<T>(value: T, xs: FSharpList<T>, eq: IEqualityComparer<T>): boolean;
-export declare function initialize<T>(n: int32, f: ((arg0: int32) => T)): FSharpList<T>;
-export declare function replicate<$a>(n: int32, x: $a): FSharpList<$a>;
-export declare function reduce<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T;
-export declare function reduceBack<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T;
-export declare function forAll<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): boolean;
-export declare function forAll2<$a, $b>(f: ((arg0: $a, arg1: $b) => boolean), xs: FSharpList<$a>, ys: FSharpList<$b>): boolean;
-export declare function exists<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): boolean;
-export declare function exists2<T1, T2>(f_mut: ((arg0: T1, arg1: T2) => boolean), xs_mut: FSharpList<T1>, ys_mut: FSharpList<T2>): boolean;
-export declare function unzip<$a, $b>(xs: FSharpList<[$a, $b]>): [FSharpList<$a>, FSharpList<$b>];
-export declare function unzip3<$a, $b, $c>(xs: FSharpList<[$a, $b, $c]>): [FSharpList<$a>, FSharpList<$b>, FSharpList<$c>];
-export declare function zip<$a, $b>(xs: FSharpList<$a>, ys: FSharpList<$b>): FSharpList<[$a, $b]>;
-export declare function zip3<$a, $b, $c>(xs: FSharpList<$a>, ys: FSharpList<$b>, zs: FSharpList<$c>): FSharpList<[$a, $b, $c]>;
-export declare function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: FSharpList<T>): FSharpList<T>;
-export declare function sort<T>(xs: FSharpList<T>, comparer: IComparer<T>): FSharpList<T>;
-export declare function sortBy<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): FSharpList<T>;
-export declare function sortDescending<T>(xs: FSharpList<T>, comparer: IComparer<T>): FSharpList<T>;
-export declare function sortByDescending<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): FSharpList<T>;
-export declare function sum<T>(xs: FSharpList<T>, adder: any): T;
-export declare function sumBy<T, U>(f: ((arg0: T) => U), xs: FSharpList<T>, adder: any): U;
-export declare function maxBy<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): T;
-export declare function max<T>(xs: FSharpList<T>, comparer: IComparer<T>): T;
-export declare function minBy<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): T;
-export declare function min<T>(xs: FSharpList<T>, comparer: IComparer<T>): T;
-export declare function average<T>(xs: FSharpList<T>, averager: any): T;
-export declare function averageBy<T, U>(f: ((arg0: T) => U), xs: FSharpList<T>, averager: any): U;
-export declare function permute<T>(f: ((arg0: int32) => int32), xs: FSharpList<T>): FSharpList<T>;
-export declare function chunkBySize<T>(chunkSize: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>>;
-export declare function allPairs<T1, T2>(xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<[T1, T2]>;
-export declare function skip<T>(count_mut: int32, xs_mut: FSharpList<T>): FSharpList<T>;
-export declare function skipWhile<T>(predicate_mut: ((arg0: T) => boolean), xs_mut: FSharpList<T>): FSharpList<T>;
-export declare function take<T>(count: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpList<T>;
-export declare function truncate<T>(count: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function getSlice<T>(startIndex: Option<int32>, endIndex: Option<int32>, xs: FSharpList<T>): FSharpList<T>;
-export declare function splitAt<T>(index: int32, xs: FSharpList<T>): [FSharpList<T>, FSharpList<T>];
-export declare function exactlyOne<T>(xs: FSharpList<T>): T;
-export declare function tryExactlyOne<T>(xs: FSharpList<T>): Option<T>;
-export declare function where<T>(predicate: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpList<T>;
-export declare function pairwise<T>(xs: FSharpList<T>): FSharpList<[T, T]>;
-export declare function windowed<T>(windowSize: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>>;
-export declare function splitInto<T>(chunks: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>>;
-export declare function transpose<T>(lists: Iterable<FSharpList<T>>): FSharpList<FSharpList<T>>;
-export declare function insertAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T>;
-export declare function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: FSharpList<T>): FSharpList<T>;
-export declare function removeAt<T>(index: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function removeManyAt<T>(index: int32, count: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function updateAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T>;

package/Long.d.ts

@@ -1,3 +0,0 @@
-import { FSharpRef } from "./Types.js";
-export declare function parse(str: string, style: number, unsigned: boolean, _bitsize: number, radix?: number): bigint;
-export declare function tryParse(str: string, style: number, unsigned: boolean, bitsize: number, defValue: FSharpRef<bigint>): boolean;

package/MailboxProcessor.d.ts

@@ -1,25 +0,0 @@
-import { Async } from "./AsyncBuilder.js";
-import { Continuation } from "./AsyncBuilder.js";
-import { CancellationToken } from "./AsyncBuilder.js";
-declare class MailboxQueue<Msg> {
-    private firstAndLast?;
-    add(message: Msg): void;
-    tryGet(): Msg | undefined;
-}
-export type MailboxBody<Msg> = (m: MailboxProcessor<Msg>) => Async<void>;
-export interface AsyncReplyChannel<Reply> {
-    reply: (r: Reply) => void;
-}
-export declare class MailboxProcessor<Msg> {
-    body: MailboxBody<Msg>;
-    cancellationToken: CancellationToken;
-    messages: MailboxQueue<Msg>;
-    continuation?: Continuation<Msg>;
-    constructor(body: MailboxBody<Msg>, cancellationToken?: CancellationToken);
-}
-export declare function startInstance<Msg>($this: MailboxProcessor<Msg>): void;
-export declare function receive<Msg>($this: MailboxProcessor<Msg>): (ctx: import("./AsyncBuilder.js").IAsyncContext<Msg>) => void;
-export declare function post<Msg>($this: MailboxProcessor<Msg>, message: Msg): void;
-export declare function postAndAsyncReply<Reply, Msg>($this: MailboxProcessor<Msg>, buildMessage: (c: AsyncReplyChannel<Reply>) => Msg): (ctx: import("./AsyncBuilder.js").IAsyncContext<Reply>) => void;
-export declare function start<Msg>(body: MailboxBody<Msg>, cancellationToken?: CancellationToken): MailboxProcessor<Msg>;
-export default MailboxProcessor;

package/Map.d.ts

@@ -1,178 +0,0 @@
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { IMap, IEnumerator, IComparer, Nullable } from "./Util.js";
-import { FSharpList } from "./List.js";
-import { FSharpRef, Record } from "./Types.js";
-export declare class MapTreeLeaf$2<Key, Value> {
-    readonly v: Value;
-    readonly k: Key;
-    constructor(k: Key, v: Value);
-}
-export declare function MapTreeLeaf$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function MapTreeLeaf$2_$ctor_5BDDA1<Key, Value>(k: Key, v: Value): MapTreeLeaf$2<Key, Value>;
-export declare function MapTreeLeaf$2__get_Key<Key, Value>(_: MapTreeLeaf$2<Key, Value>): Key;
-export declare function MapTreeLeaf$2__get_Value<Key, Value>(_: MapTreeLeaf$2<Key, Value>): Value;
-export declare class MapTreeNode$2<Key, Value> extends MapTreeLeaf$2<Key, Value> {
-    readonly right: Option<MapTreeLeaf$2<Key, Value>>;
-    readonly left: Option<MapTreeLeaf$2<Key, Value>>;
-    readonly h: int32;
-    constructor(k: Key, v: Value, left: Option<MapTreeLeaf$2<Key, Value>>, right: Option<MapTreeLeaf$2<Key, Value>>, h: int32);
-}
-export declare function MapTreeNode$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function MapTreeNode$2_$ctor_Z39DE9543<Key, Value>(k: Key, v: Value, left: Option<MapTreeLeaf$2<Key, Value>>, right: Option<MapTreeLeaf$2<Key, Value>>, h: int32): MapTreeNode$2<Key, Value>;
-export declare function MapTreeNode$2__get_Left<Key, Value>(_: MapTreeNode$2<Key, Value>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeNode$2__get_Right<Key, Value>(_: MapTreeNode$2<Key, Value>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeNode$2__get_Height<Key, Value>(_: MapTreeNode$2<Key, Value>): int32;
-export declare function MapTreeModule_empty<Key, Value>(): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_sizeAux<Key, Value>(acc_mut: int32, m_mut: Option<MapTreeLeaf$2<Key, Value>>): int32;
-export declare function MapTreeModule_size<$a, $b>(x: Option<MapTreeLeaf$2<$a, $b>>): int32;
-export declare function MapTreeModule_mk<Key, Value>(l: Option<MapTreeLeaf$2<Key, Value>>, k: Key, v: Value, r: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key, Value>>, k: Key, v: Value, t2: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_add<Key, Value>(comparer: IComparer<Key>, k: Key, v: Value, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_tryFind<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Key, m_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<Value>;
-export declare function MapTreeModule_find<Key, Value>(comparer: IComparer<Key>, k: Key, m: Option<MapTreeLeaf$2<Key, Value>>): Value;
-export declare function MapTreeModule_partition1<Key, $a>(comparer: IComparer<Key>, f: any, k: Key, v: $a, acc1: Option<MapTreeLeaf$2<Key, $a>>, acc2: Option<MapTreeLeaf$2<Key, $a>>): [Option<MapTreeLeaf$2<Key, $a>>, Option<MapTreeLeaf$2<Key, $a>>];
-export declare function MapTreeModule_partitionAux<Key, Value>(comparer_mut: IComparer<Key>, f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, acc__mut: Option<MapTreeLeaf$2<Key, Value>>, acc__1_mut: Option<MapTreeLeaf$2<Key, Value>>): [Option<MapTreeLeaf$2<Key, Value>>, Option<MapTreeLeaf$2<Key, Value>>];
-export declare function MapTreeModule_partition<Key, $a>(comparer: IComparer<Key>, f: ((arg0: Key, arg1: $a) => boolean), m: Option<MapTreeLeaf$2<Key, $a>>): [Option<MapTreeLeaf$2<Key, $a>>, Option<MapTreeLeaf$2<Key, $a>>];
-export declare function MapTreeModule_filter1<Key, $a>(comparer: IComparer<Key>, f: any, k: Key, v: $a, acc: Option<MapTreeLeaf$2<Key, $a>>): Option<MapTreeLeaf$2<Key, $a>>;
-export declare function MapTreeModule_filterAux<Key, Value>(comparer_mut: IComparer<Key>, f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, acc_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_filter<Key, $a>(comparer: IComparer<Key>, f: ((arg0: Key, arg1: $a) => boolean), m: Option<MapTreeLeaf$2<Key, $a>>): Option<MapTreeLeaf$2<Key, $a>>;
-export declare function MapTreeModule_spliceOutSuccessor<Key, Value>(m: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value, Option<MapTreeLeaf$2<Key, Value>>];
-export declare function MapTreeModule_remove<Key, Value>(comparer: IComparer<Key>, k: Nullable<Key>, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Key, u: ((arg0: Option<Value>) => Option<Value>), m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_mem<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Nullable<Key>, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
-export declare function MapTreeModule_iterOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): void;
-export declare function MapTreeModule_iter<$a, $b>(f: ((arg0: $a, arg1: $b) => void), m: Option<MapTreeLeaf$2<$a, $b>>): void;
-export declare function MapTreeModule_tryPickOpt<Key, Value, $a>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<$a>;
-export declare function MapTreeModule_tryPick<$a, $b, $c>(f: ((arg0: $a, arg1: $b) => Option<$c>), m: Option<MapTreeLeaf$2<$a, $b>>): Option<$c>;
-export declare function MapTreeModule_existsOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
-export declare function MapTreeModule_exists<$a, $b>(f: ((arg0: $a, arg1: $b) => boolean), m: Option<MapTreeLeaf$2<$a, $b>>): boolean;
-export declare function MapTreeModule_forallOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
-export declare function MapTreeModule_forall<$a, $b>(f: ((arg0: $a, arg1: $b) => boolean), m: Option<MapTreeLeaf$2<$a, $b>>): boolean;
-export declare function MapTreeModule_map<Value, Result, Key>(f: ((arg0: Value) => Result), m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Result>>;
-export declare function MapTreeModule_mapiOpt<Key, Value, Result>(f: any, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Result>>;
-export declare function MapTreeModule_mapi<$a, $b, $c>(f: ((arg0: $a, arg1: $b) => $c), m: Option<MapTreeLeaf$2<$a, $b>>): Option<MapTreeLeaf$2<$a, $c>>;
-export declare function MapTreeModule_foldBackOpt<Key, Value, $a>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, x_mut: $a): $a;
-export declare function MapTreeModule_foldBack<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c;
-export declare function MapTreeModule_foldOpt<$a, Key, Value>(f_mut: any, x_mut: $a, m_mut: Option<MapTreeLeaf$2<Key, Value>>): $a;
-export declare function MapTreeModule_fold<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c) => $a), x: $a, m: Option<MapTreeLeaf$2<$b, $c>>): $a;
-export declare function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<Key>, lo: Nullable<Key>, hi: Nullable<Key>, f: any, m: Option<MapTreeLeaf$2<Key, Value>>, x: a): a;
-export declare function MapTreeModule_foldSection<$a, $b, $c>(comparer: IComparer<$a>, lo: Nullable<$a>, hi: Nullable<$a>, f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c;
-export declare function MapTreeModule_toList<Key, Value>(m: Option<MapTreeLeaf$2<Key, Value>>): FSharpList<[Key, Value]>;
-export declare function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>, arr: [$a, $b][], i: int32): void;
-export declare function MapTreeModule_toArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): [$a, $b][];
-export declare function MapTreeModule_ofList<$a, $b>(comparer: IComparer<$a>, l: FSharpList<[$a, $b]>): Option<MapTreeLeaf$2<$a, $b>>;
-export declare function MapTreeModule_mkFromEnumerator<$a, $b>(comparer_mut: IComparer<$a>, acc_mut: Option<MapTreeLeaf$2<$a, $b>>, e_mut: IEnumerator<[$a, $b]>): Option<MapTreeLeaf$2<$a, $b>>;
-export declare function MapTreeModule_ofArray<Key, Value>(comparer: IComparer<Key>, arr: [Key, Value][]): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_ofSeq<Key, Value>(comparer: IComparer<Key>, c: Iterable<[Key, Value]>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare class MapTreeModule_MapIterator$2<Key, Value> extends Record {
-    stack: FSharpList<Option<MapTreeLeaf$2<Key, Value>>>;
-    started: boolean;
-    constructor(stack: FSharpList<Option<MapTreeLeaf$2<Key, Value>>>, started: boolean);
-}
-export declare function MapTreeModule_MapIterator$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function MapTreeModule_collapseLHS<Key, Value>(stack_mut: FSharpList<Option<MapTreeLeaf$2<Key, Value>>>): FSharpList<Option<MapTreeLeaf$2<Key, Value>>>;
-export declare function MapTreeModule_mkIterator<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): MapTreeModule_MapIterator$2<$a, $b>;
-export declare function MapTreeModule_notStarted<$a>(): $a;
-export declare function MapTreeModule_alreadyFinished<$a>(): $a;
-export declare function MapTreeModule_current<Key, Value>(i: MapTreeModule_MapIterator$2<Key, Value>): [Key, Value];
-export declare function MapTreeModule_moveNext<Key, Value>(i: MapTreeModule_MapIterator$2<Key, Value>): boolean;
-export declare function MapTreeModule_mkIEnumerator<a, b>(m: Option<MapTreeLeaf$2<a, b>>): IEnumerator<[a, b]>;
-export declare function MapTreeModule_toSeq<$a, $b>(s: Option<MapTreeLeaf$2<$a, $b>>): Iterable<[$a, $b]>;
-export declare function MapTreeModule_leftmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value];
-export declare function MapTreeModule_rightmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value];
-export declare class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, Value]>, Iterable<[Key, Value]> {
-    readonly tree: Option<MapTreeLeaf$2<Key, Value>>;
-    readonly comparer: IComparer<Key>;
-    constructor(comparer: IComparer<Key>, tree: Option<MapTreeLeaf$2<Key, Value>>);
-    GetHashCode(): int32;
-    Equals(other: Nullable<any>): boolean;
-    toString(): string;
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    GetEnumerator(): IEnumerator<[Key, Value]>;
-    [Symbol.iterator](): Iterator<[Key, Value]>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    CompareTo(other: Nullable<any>): int32;
-    "System.Collections.Generic.ICollection`1.Add2B595"(x: [Key, Value]): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(x: [Key, Value]): boolean;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(x: [Key, Value]): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: [Key, Value][], 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;
-    get size(): int32;
-    clear(): void;
-    delete(_arg: Key): boolean;
-    entries(): Iterable<[Key, Value]>;
-    get(k: Key): Value;
-    has(k: Key): boolean;
-    keys(): Iterable<Key>;
-    set(k: Key, v: Value): IMap<Key, Value>;
-    values(): Iterable<Value>;
-    forEach(f: ((arg0: Value, arg1: Key, arg2: IMap<Key, Value>) => void), thisArg?: Option<any>): void;
-}
-export declare function FSharpMap_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function FSharpMap_$ctor<Key, Value>(comparer: IComparer<Key>, tree: Option<MapTreeLeaf$2<Key, Value>>): FSharpMap<Key, Value>;
-export declare function FSharpMap_Empty<Key, Value>(comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function FSharpMap__get_Comparer<Key, Value>(m: FSharpMap<Key, Value>): IComparer<Key>;
-export declare function FSharpMap__get_Tree<Key, Value>(m: FSharpMap<Key, Value>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function FSharpMap__Add<Key, Value>(m: FSharpMap<Key, Value>, key: Key, value: Value): FSharpMap<Key, Value>;
-export declare function FSharpMap__Change<Key, Value>(m: FSharpMap<Key, Value>, key: Key, f: ((arg0: Option<Value>) => Option<Value>)): FSharpMap<Key, Value>;
-export declare function FSharpMap__get_IsEmpty<Key, Value>(m: FSharpMap<Key, Value>): boolean;
-export declare function FSharpMap__get_Item<Key, Value>(m: FSharpMap<Key, Value>, key: Key): Value;
-export declare function FSharpMap__TryPick<Key, Value, $a>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => Option<$a>)): Option<$a>;
-export declare function FSharpMap__Exists<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): boolean;
-export declare function FSharpMap__Filter<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): FSharpMap<Key, Value>;
-export declare function FSharpMap__ForAll<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): boolean;
-export declare function FSharpMap__Fold<Key, Value, $a>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a;
-export declare function FSharpMap__FoldSection<Key, Value, $a>(m: FSharpMap<Key, Value>, lo: Nullable<Key>, hi: Nullable<Key>, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a;
-export declare function FSharpMap__Iterate<Key, Value>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => void)): void;
-export declare function FSharpMap__MapRange<Key, Value, Result>(m: FSharpMap<Key, Value>, f: ((arg0: Value) => Result)): FSharpMap<Key, Result>;
-export declare function FSharpMap__Map<Key, Value, b>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => b)): FSharpMap<Key, b>;
-export declare function FSharpMap__Partition<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): [FSharpMap<Key, Value>, FSharpMap<Key, Value>];
-export declare function FSharpMap__get_Count<Key, Value>(m: FSharpMap<Key, Value>): int32;
-export declare function FSharpMap__ContainsKey<Key, Value>(m: FSharpMap<Key, Value>, key: Nullable<Key>): boolean;
-export declare function FSharpMap__Remove<Key, Value>(m: FSharpMap<Key, Value>, key: Nullable<Key>): FSharpMap<Key, Value>;
-export declare function FSharpMap__TryGetValue<Key, Value>(_: FSharpMap<Key, Value>, key: Key, value: FSharpRef<Value>): boolean;
-export declare function FSharpMap__get_Keys<Key, Value>(_: FSharpMap<Key, Value>): Iterable<Key>;
-export declare function FSharpMap__get_Values<Key, Value>(_: FSharpMap<Key, Value>): Iterable<Value>;
-export declare function FSharpMap__get_MinKeyValue<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value];
-export declare function FSharpMap__get_MaxKeyValue<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value];
-export declare function FSharpMap__TryFind<Key, Value>(m: FSharpMap<Key, Value>, key: Key): Option<Value>;
-export declare function FSharpMap__ToList<Key, Value>(m: FSharpMap<Key, Value>): FSharpList<[Key, Value]>;
-export declare function FSharpMap__ToArray<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value][];
-export declare function FSharpMap__ComputeHashCode<Key, Value>(this$: FSharpMap<Key, Value>): int32;
-export declare function isEmpty<$a, $b>(table: FSharpMap<$a, $b>): boolean;
-export declare function add<$a, $b>(key: $a, value: $b, table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function change<$a, $b>(key: $a, f: ((arg0: Option<$b>) => Option<$b>), table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function find<$a, $b>(key: $a, table: FSharpMap<$a, $b>): $b;
-export declare function tryFind<$a, $b>(key: $a, table: FSharpMap<$a, $b>): Option<$b>;
-export declare function remove<$a, $b>(key: Nullable<$a>, table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function containsKey<$a, $b>(key: Nullable<$a>, table: FSharpMap<$a, $b>): boolean;
-export declare function iterate<$a, $b>(action: ((arg0: $a, arg1: $b) => void), table: FSharpMap<$a, $b>): void;
-export declare function tryPick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>), table: FSharpMap<$a, $b>): Option<$c>;
-export declare function pick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>), table: FSharpMap<$a, $b>): $c;
-export declare function exists<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): boolean;
-export declare function filter<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function partition<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): [FSharpMap<$a, $b>, FSharpMap<$a, $b>];
-export declare function forAll<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): boolean;
-export declare function map<$a, $b, $c>(mapping: ((arg0: $a, arg1: $b) => $c), table: FSharpMap<$a, $b>): FSharpMap<$a, $c>;
-export declare function fold<Key, T, State>(folder: ((arg0: State, arg1: Key, arg2: T) => State), state: State, table: FSharpMap<Key, T>): State;
-export declare function foldBack<Key, T, State>(folder: ((arg0: Key, arg1: T, arg2: State) => State), table: FSharpMap<Key, T>, state: State): State;
-export declare function toSeq<$a, $b>(table: FSharpMap<$a, $b>): Iterable<[$a, $b]>;
-export declare function findKey<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): $a;
-export declare function tryFindKey<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): Option<$a>;
-export declare function ofList<Key, Value>(elements: FSharpList<[Key, Value]>, comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function ofSeq<T, $a>(elements: Iterable<[T, $a]>, comparer: IComparer<T>): FSharpMap<T, $a>;
-export declare function ofArray<Key, Value>(elements: [Key, Value][], comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function toList<$a, $b>(table: FSharpMap<$a, $b>): FSharpList<[$a, $b]>;
-export declare function toArray<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b][];
-export declare function keys<K, V>(table: FSharpMap<K, V>): Iterable<K>;
-export declare function values<K, V>(table: FSharpMap<K, V>): Iterable<V>;
-export declare function minKeyValue<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b];
-export declare function maxKeyValue<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b];
-export declare function empty<Key, Value>(comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function count<$a, $b>(table: FSharpMap<$a, $b>): int32;

package/MapUtil.d.ts

@@ -1,12 +0,0 @@
-import { IMap, IMapOrWeakMap, ISet } from "./Util.js";
-import { FSharpRef } from "./Types.js";
-export declare function keyValueList(fields: Iterable<any>, caseRule?: number): {
-    [k: string]: any;
-};
-export declare function containsValue<K, V>(v: V, map: IMap<K, V>): boolean;
-export declare function tryGetValue<K, V>(map: IMapOrWeakMap<K, V>, key: K, defaultValue: FSharpRef<V>): boolean;
-export declare function addToSet<T>(v: T, set: ISet<T>): boolean;
-export declare function tryAddToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): boolean;
-export declare function addToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): void;
-export declare function getItemFromDict<K, V>(map: IMap<K, V>, key: K): V;
-export declare function getItemFromDictOrCreate<K, V>(map: IMapOrWeakMap<K, V>, key: K, createValue: (key: K) => V): V;

package/MutableMap.d.ts

@@ -1,52 +0,0 @@
-import { IEqualityComparer, IMap, IEnumerator } from "./Util.js";
-import { Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { FSharpRef } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key, Value]>, Iterable<[Key, Value]> {
-    readonly comparer: IEqualityComparer<Key>;
-    readonly hashMap: IMap<int32, [Key, Value][]>;
-    "init@9": int32;
-    constructor(pairs: Iterable<[Key, Value]>, comparer: IEqualityComparer<Key>);
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    GetEnumerator(): IEnumerator<[Key, Value]>;
-    [Symbol.iterator](): Iterator<[Key, Value]>;
-    "System.Collections.Generic.ICollection`1.Add2B595"(item: [Key, Value]): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(item: [Key, Value]): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: [Key, Value][], arrayIndex: int32): void;
-    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
-    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(item: [Key, Value]): boolean;
-    "System.Collections.Generic.IDictionary`2.Add5BDDA1"(key: Key, value: Value): void;
-    "System.Collections.Generic.IDictionary`2.ContainsKey2B595"(key: Key): boolean;
-    "System.Collections.Generic.IDictionary`2.get_Item2B595"(key: Key): Value;
-    "System.Collections.Generic.IDictionary`2.set_Item5BDDA1"(key: Key, v: Value): void;
-    "System.Collections.Generic.IDictionary`2.get_Keys"(): Iterable<Key>;
-    "System.Collections.Generic.IDictionary`2.Remove2B595"(key: Key): boolean;
-    "System.Collections.Generic.IDictionary`2.TryGetValue6DC89625"(key: Key, value: FSharpRef<Value>): boolean;
-    "System.Collections.Generic.IDictionary`2.get_Values"(): Iterable<Value>;
-    get size(): int32;
-    clear(): void;
-    delete(k: Key): boolean;
-    entries(): Iterable<[Key, Value]>;
-    get(k: Key): Value;
-    has(k: Key): boolean;
-    keys(): Iterable<Key>;
-    set(k: Key, v: Value): IMap<Key, Value>;
-    values(): Iterable<Value>;
-    forEach(f: ((arg0: Value, arg1: Key, arg2: IMap<Key, Value>) => void), thisArg?: Option<any>): void;
-}
-export declare function Dictionary_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function Dictionary_$ctor_6623D9B3<Key, Value>(pairs: Iterable<[Key, Value]>, comparer: IEqualityComparer<Key>): Dictionary<Key, Value>;
-export declare function Dictionary__TryFind_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Option<[Key, Value]>;
-export declare function Dictionary__get_Comparer<Key, Value>(this$: Dictionary<Key, Value>): IEqualityComparer<Key>;
-export declare function Dictionary__Clear<Key, Value>(this$: Dictionary<Key, Value>): void;
-export declare function Dictionary__get_Count<Key, Value>(this$: Dictionary<Key, Value>): int32;
-export declare function Dictionary__get_Item_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Value;
-export declare function Dictionary__set_Item_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>, k: Key, v: Value): void;
-export declare function Dictionary__Add_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>, k: Key, v: Value): void;
-export declare function Dictionary__ContainsKey_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean;
-export declare function Dictionary__Remove_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean;

package/MutableSet.d.ts

@@ -1,39 +0,0 @@
-import { IMap, IEqualityComparer, ISet, IEnumerator } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { Option } from "./Option.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
-    readonly comparer: IEqualityComparer<T>;
-    readonly hashMap: IMap<int32, T[]>;
-    "init@9": int32;
-    constructor(items: Iterable<T>, comparer: IEqualityComparer<T>);
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.Generic.ICollection`1.Add2B595"(item: T): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(item: T): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: T[], arrayIndex: int32): void;
-    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
-    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(item: T): boolean;
-    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 HashSet_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function HashSet_$ctor_Z6150332D<T>(items: Iterable<T>, comparer: IEqualityComparer<T>): HashSet<T>;
-export declare function HashSet__get_Comparer<T>(this$: HashSet<T>): IEqualityComparer<T>;
-export declare function HashSet__Clear<T>(this$: HashSet<T>): void;
-export declare function HashSet__get_Count<T>(this$: HashSet<T>): int32;
-export declare function HashSet__Add_2B595<T>(this$: HashSet<T>, k: T): boolean;
-export declare function HashSet__Contains_2B595<T>(this$: HashSet<T>, k: T): boolean;
-export declare function HashSet__Remove_2B595<T>(this$: HashSet<T>, k: T): boolean;

package/Native.d.ts

@@ -1,3 +0,0 @@
-import { Nullable } from "./Util.js";
-import { int32 } from "./Int32.js";
-export declare function Helpers_allocateArrayFromCons<T>(cons: Nullable<any>, len: int32): T[];

package/Numeric.d.ts

@@ -1,20 +0,0 @@
-import { IComparable } from "./Util.js";
-export declare const symbol: unique symbol;
-export interface CustomNumeric extends IComparable<Numeric> {
-    [symbol](): {
-        multiply(y: Numeric): Numeric;
-        toPrecision(sd?: number): string;
-        toExponential(dp?: number): string;
-        toFixed(dp?: number): string;
-        toHex(): string;
-    };
-}
-export type Numeric = number | bigint | CustomNumeric;
-export declare function isNumeric(x: any): any;
-export declare function isIntegral(x: Numeric): boolean;
-export declare function compare(x: Numeric, y: number): number;
-export declare function multiply(x: Numeric, y: number): Numeric;
-export declare function toFixed(x: Numeric, dp?: number): string;
-export declare function toPrecision(x: Numeric, sd?: number): string;
-export declare function toExponential(x: Numeric, dp?: number): string | bigint;
-export declare function toHex(x: Numeric): string;

package/Observable.d.ts

@@ -1,32 +0,0 @@
-import { FSharpChoice$2_$union } from "./Choice.js";
-import { Option } from "./Option.js";
-import { IDisposable } from "./Util.js";
-export interface IObserver<T> {
-    OnNext: (x: T) => void;
-    OnError: (e: any) => void;
-    OnCompleted: () => void;
-}
-export declare class Observer<T> implements IObserver<T> {
-    OnNext: (x: T) => void;
-    OnError: (e: any) => void;
-    OnCompleted: () => void;
-    constructor(onNext: (x: T) => void, onError?: (e: any) => void, onCompleted?: () => void);
-}
-export interface IObservable<T> {
-    Subscribe: (o: IObserver<T>) => IDisposable;
-}
-declare class Observable<T> implements IObservable<T> {
-    Subscribe: (o: IObserver<T>) => IDisposable;
-    constructor(subscribe: (o: IObserver<T>) => IDisposable);
-}
-export declare function add<T>(callback: (x: T) => void, source: IObservable<T>): void;
-export declare function choose<T, U>(chooser: (x: T) => Option<U>, source: IObservable<T>): Observable<U>;
-export declare function filter<T>(predicate: (x: T) => boolean, source: IObservable<T>): IObservable<T>;
-export declare function map<T, U>(mapping: (x: T) => U, source: IObservable<T>): IObservable<U>;
-export declare function merge<T>(source1: IObservable<T>, source2: IObservable<T>): IObservable<T>;
-export declare function pairwise<T>(source: IObservable<T>): IObservable<[T, T]>;
-export declare function partition<T>(predicate: (x: T) => boolean, source: IObservable<T>): [Observable<T>, Observable<T>];
-export declare function scan<U, T>(collector: (u: U, t: T) => U, state: U, source: IObservable<T>): IObservable<U>;
-export declare function split<T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, source: IObservable<T>): [Observable<U1>, Observable<U2>];
-export declare function subscribe<T>(callback: (x: T) => void, source: IObservable<T>): IDisposable;
-export {};

package/Option.d.ts

@@ -1,29 +0,0 @@
-import { Nullable } from "./Util.js";
-export type Option<T> = T | Some<T> | undefined;
-export declare class Some<T> {
-    value: T;
-    constructor(value: T);
-    toJSON(): T;
-    toString(): string;
-    GetHashCode(): number;
-    Equals(other: Option<T>): boolean;
-    CompareTo(other: Option<T>): number;
-}
-export declare function nonNullValue<T>(x: Nullable<T>): T;
-export declare function value<T>(x: Option<T>): T;
-export declare function unwrap<T>(opt: Option<T>): T | undefined;
-export declare function some<T>(x: T): Option<T>;
-export declare function ofNullable<T>(x: Nullable<T>): Option<T>;
-export declare function toNullable<T>(x: Option<T>): Nullable<T>;
-export declare function flatten<T>(x: Option<Option<T>>): T | Some<T> | undefined;
-export declare function toArray<T>(opt: Option<T>): T[];
-export declare function defaultArg<T>(opt: Option<T>, defaultValue: T): T;
-export declare function defaultArgWith<T>(opt: Option<T>, defThunk: () => T): T;
-export declare function orElse<T>(opt: Option<T>, ifNone: Option<T>): Option<T>;
-export declare function orElseWith<T>(opt: Option<T>, ifNoneThunk: () => Option<T>): Option<T>;
-export declare function filter<T>(predicate: (arg: T) => boolean, opt: Option<T>): Option<T>;
-export declare function map<T, U>(mapping: (arg: T) => U, opt: Option<T>): Option<U>;
-export declare function map2<T1, T2, U>(mapping: (arg1: T1, arg2: T2) => Option<U>, opt1: Option<T1>, opt2: Option<T2>): Option<U>;
-export declare function map3<T1, T2, T3, U>(mapping: (arg1: T1, arg2: T2, arg3: T3) => Option<U>, opt1: Option<T1>, opt2: Option<T2>, opt3: Option<T3>): Option<U>;
-export declare function bind<T, U>(binder: (arg: T) => Option<U>, opt: Option<T>): Option<U>;
-export declare function tryOp<T, U>(op: (x: T) => U, arg: T): Option<U>;