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

package/Array.d.ts

@@ -1,123 +0,0 @@
-import { int32 } from "./Int32.js";
-import { Option } from "./Option.js";
-import { IComparer, IEqualityComparer } from "./Util.js";
-import { FSharpRef } from "./Types.js";
-export declare function append<T>(array1: T[], array2: T[], cons?: any): T[];
-export declare function filter<T>(predicate: ((arg0: T) => boolean), array: T[]): T[];
-export declare function fill<T>(target: T[], targetIndex: int32, count: int32, value: T): T[];
-export declare function getSubArray<T>(array: T[], start: int32, count: int32): T[];
-export declare function last<T>(array: T[]): T;
-export declare function tryLast<T>(array: T[]): Option<T>;
-export declare function mapIndexed<T, U>(f: ((arg0: int32, arg1: T) => U), source: T[], cons?: any): U[];
-export declare function map<T, U>(f: ((arg0: T) => U), source: T[], cons?: any): U[];
-export declare function mapIndexed2<T1, T2, U>(f: ((arg0: int32, arg1: T1, arg2: T2) => U), source1: T1[], source2: T2[], cons?: any): U[];
-export declare function map2<T1, T2, U>(f: ((arg0: T1, arg1: T2) => U), source1: T1[], source2: T2[], cons?: any): U[];
-export declare function mapIndexed3<T1, T2, T3, U>(f: ((arg0: int32, arg1: T1, arg2: T2, arg3: T3) => U), source1: T1[], source2: T2[], source3: T3[], cons?: any): U[];
-export declare function map3<T1, T2, T3, U>(f: ((arg0: T1, arg1: T2, arg2: T3) => U), source1: T1[], source2: T2[], source3: T3[], cons?: any): U[];
-export declare function mapFold<T, State, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, array: T[], cons?: any): [Result[], State];
-export declare function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), array: T[], state: State, cons?: any): [Result[], State];
-export declare function indexed<T>(source: T[]): [int32, T][];
-export declare function truncate<T>(count: int32, array: T[]): T[];
-export declare function concat<T>(arrays: Iterable<T[]>, cons?: any): T[];
-export declare function collect<T, U>(mapping: ((arg0: T) => U[]), array: T[], cons?: any): U[];
-export declare function where<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $a[];
-export declare function indexOf<T>(array: T[], item_1: T, start: Option<int32>, count: Option<int32>, eq: IEqualityComparer<T>): int32;
-export declare function contains<T>(value: T, array: T[], eq: IEqualityComparer<T>): boolean;
-export declare function empty<$a>(cons: any): $a[];
-export declare function singleton<T>(value: T, cons?: any): T[];
-export declare function initialize<T>(count: int32, initializer: ((arg0: int32) => T), cons?: any): T[];
-export declare function pairwise<T>(array: T[]): [T, T][];
-export declare function replicate<T>(count: int32, initial: T, cons?: any): T[];
-export declare function copy<T>(array: T[]): T[];
-export declare function copyTo<T>(source: T[], sourceIndex: int32, target: T[], targetIndex: int32, count: int32): void;
-export declare function reverse<T>(array: T[]): T[];
-export declare function scan<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: T[], cons?: any): State[];
-export declare function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: T[], state: State, cons?: any): State[];
-export declare function skip<T>(count: int32, array: T[], cons?: any): T[];
-export declare function skipWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons?: any): T[];
-export declare function take<T>(count: int32, array: T[], cons?: any): T[];
-export declare function takeWhile<T>(predicate: ((arg0: T) => boolean), array: T[], cons?: any): T[];
-export declare function addInPlace<T>(x: T, array: T[]): void;
-export declare function addRangeInPlace<T>(range: Iterable<T>, array: T[]): void;
-export declare function insertRangeInPlace<T>(index: int32, range: Iterable<T>, array: T[]): void;
-export declare function removeInPlace<T>(item_1: T, array: T[], eq: IEqualityComparer<T>): boolean;
-export declare function removeAllInPlace<T>(predicate: ((arg0: T) => boolean), array: T[]): int32;
-export declare function partition<T>(f: ((arg0: T) => boolean), source: T[], cons?: any): [T[], T[]];
-export declare function find<T>(predicate: ((arg0: T) => boolean), array: T[]): T;
-export declare function tryFind<T>(predicate: ((arg0: T) => boolean), array: T[]): Option<T>;
-export declare function findIndex<T>(predicate: ((arg0: T) => boolean), array: T[]): int32;
-export declare function tryFindIndex<T>(predicate: ((arg0: T) => boolean), array: T[]): Option<int32>;
-export declare function pick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]): $b;
-export declare function tryPick<$a, $b>(chooser: ((arg0: $a) => Option<$b>), array: $a[]): Option<$b>;
-export declare function findBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): $a;
-export declare function tryFindBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): Option<$a>;
-export declare function findLastIndex<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): int32;
-export declare function findIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): int32;
-export declare function tryFindIndexBack<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): Option<int32>;
-export declare function choose<T, U>(chooser: ((arg0: T) => Option<U>), array: T[], cons?: any): U[];
-export declare function foldIndexed<T, State>(folder: ((arg0: int32, arg1: State, arg2: T) => State), state: State, array: T[]): State;
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, array: T[]): State;
-export declare function iterate<T>(action: ((arg0: T) => void), array: T[]): void;
-export declare function iterateIndexed<T>(action: ((arg0: int32, arg1: T) => void), array: T[]): void;
-export declare function iterate2<T1, T2>(action: ((arg0: T1, arg1: T2) => void), array1: T1[], array2: T2[]): void;
-export declare function iterateIndexed2<T1, T2>(action: ((arg0: int32, arg1: T1, arg2: T2) => void), array1: T1[], array2: T2[]): void;
-export declare function isEmpty<T>(array: T[]): boolean;
-export declare function forAll<T>(predicate: ((arg0: T) => boolean), array: T[]): boolean;
-export declare function permute<T>(f: ((arg0: int32) => int32), array: T[]): T[];
-export declare function setSlice<T>(target: T[], lower: Option<int32>, upper: Option<int32>, source: T[]): void;
-export declare function sortInPlaceBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): void;
-export declare function sortInPlace<T>(xs: T[], comparer: IComparer<T>): void;
-export declare function sort<T>(xs: T[], comparer: IComparer<T>): T[];
-export declare function sortBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a[];
-export declare function sortDescending<T>(xs: T[], comparer: IComparer<T>): T[];
-export declare function sortByDescending<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a[];
-export declare function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: T[]): T[];
-export declare function allPairs<T1, T2>(xs: T1[], ys: T2[]): [T1, T2][];
-export declare function unfold<T, State>(generator: ((arg0: State) => Option<[T, State]>), state: State): T[];
-export declare function unzip<$a, $b>(array: [$a, $b][]): [$a[], $b[]];
-export declare function unzip3<$a, $b, $c>(array: [$a, $b, $c][]): [$a[], $b[], $c[]];
-export declare function zip<T, U>(array1: T[], array2: U[]): [T, U][];
-export declare function zip3<T, U, V>(array1: T[], array2: U[], array3: V[]): [T, U, V][];
-export declare function chunkBySize<T>(chunkSize: int32, array: T[]): T[][];
-export declare function splitAt<T>(index: int32, array: T[]): [T[], T[]];
-export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32;
-export declare function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32;
-export declare function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), array1: T[], array2: T[]): boolean;
-export declare function exactlyOne<T>(array: T[]): T;
-export declare function tryExactlyOne<T>(array: T[]): Option<T>;
-export declare function head<T>(array: T[]): T;
-export declare function tryHead<T>(array: T[]): Option<T>;
-export declare function tail<T>(array: T[]): T[];
-export declare function item<T>(index: int32, array: T[]): T;
-export declare function setItem<T>(array: T[], index: int32, value: T): void;
-export declare function tryItem<T>(index: int32, array: T[]): Option<T>;
-export declare function foldBackIndexed<T, State>(folder: ((arg0: int32, arg1: T, arg2: State) => State), array: T[], state: State): State;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), array: T[], state: State): State;
-export declare function foldIndexed2<$a, $b, $c>(folder: ((arg0: int32, arg1: $a, arg2: $b, arg3: $c) => $a), state: $a, array1: $b[], array2: $c[]): $a;
-export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, array1: T1[], array2: T2[]): State;
-export declare function foldBackIndexed2<T1, T2, State>(folder: ((arg0: int32, arg1: T1, arg2: T2, arg3: State) => State), array1: T1[], array2: T2[], state: State): State;
-export declare function foldBack2<T1, T2, State>(f: ((arg0: T1, arg1: T2, arg2: State) => State), array1: T1[], array2: T2[], state: State): State;
-export declare function reduce<T>(reduction: ((arg0: T, arg1: T) => T), array: T[]): T;
-export declare function reduceBack<T>(reduction: ((arg0: T, arg1: T) => T), array: T[]): T;
-export declare function forAll2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), array1: $a[], array2: $b[]): boolean;
-export declare function existsOffset<T>(predicate_mut: ((arg0: T) => boolean), array_mut: T[], index_mut: int32): boolean;
-export declare function exists<$a>(predicate: ((arg0: $a) => boolean), array: $a[]): boolean;
-export declare function existsOffset2<$a, $b>(predicate_mut: ((arg0: $a, arg1: $b) => boolean), array1_mut: $a[], array2_mut: $b[], index_mut: int32): boolean;
-export declare function exists2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), array1: $a[], array2: $b[]): boolean;
-export declare function sum<T>(array: T[], adder: any): T;
-export declare function sumBy<T, T2>(projection: ((arg0: T) => T2), array: T[], adder: any): T2;
-export declare function maxBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a;
-export declare function max<a>(xs: a[], comparer: IComparer<a>): a;
-export declare function minBy<a, b>(projection: ((arg0: a) => b), xs: a[], comparer: IComparer<b>): a;
-export declare function min<a>(xs: a[], comparer: IComparer<a>): a;
-export declare function average<T>(array: T[], averager: any): T;
-export declare function averageBy<T, T2>(projection: ((arg0: T) => T2), array: T[], averager: any): T2;
-export declare function windowed<T>(windowSize: int32, source: T[]): T[][];
-export declare function splitInto<T>(chunks: int32, array: T[]): T[][];
-export declare function transpose<T>(arrays: Iterable<T[]>, cons?: any): T[][];
-export declare function insertAt<T>(index: int32, y: T, xs: T[], cons?: any): T[];
-export declare function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: T[], cons?: any): T[];
-export declare function removeAt<T>(index: int32, xs: T[]): T[];
-export declare function removeManyAt<T>(index: int32, count: int32, xs: T[]): T[];
-export declare function updateAt<T>(index: int32, y: T, xs: T[], cons?: any): T[];
-export declare function resize<T>(xs: FSharpRef<T[]>, newSize: int32, zero?: Option<T>, cons?: any): void;

package/Async.d.ts

@@ -1,26 +0,0 @@
-import { Continuation, Continuations } from "./AsyncBuilder.js";
-import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.js";
-import { FSharpChoice$2_$union } from "./Choice.js";
-export declare function makeAsync<T>(body: Async<T>): Async<T>;
-export declare function invoke<T>(computation: Async<T>, ctx: IAsyncContext<T>): void;
-export declare function callThenInvoke<T, U>(ctx: IAsyncContext<T>, result1: U, part2: (x: U) => Async<T>): void;
-export declare function bind<T, U>(ctx: IAsyncContext<T>, part1: Async<U>, part2: (x: U) => Async<T>): void;
-export declare function createCancellationToken(arg?: boolean | number): CancellationToken;
-export declare function cancel(token: CancellationToken): void;
-export declare function cancelAfter(token: CancellationToken, ms: number): void;
-export declare function isCancellationRequested(token: CancellationToken): boolean;
-export declare function throwIfCancellationRequested(token: CancellationToken): void;
-export declare function startChild<T>(computation: Async<T>, ms?: number): Async<Async<T>>;
-export declare function awaitPromise<T>(p: Promise<T>): (ctx: IAsyncContext<T>) => void;
-export declare function cancellationToken(): (ctx: IAsyncContext<CancellationToken>) => void;
-export declare const defaultCancellationToken: CancellationToken;
-export declare function catchAsync<T>(work: Async<T>): (ctx: IAsyncContext<FSharpChoice$2_$union<T, Error>>) => void;
-export declare function fromContinuations<T>(f: (conts: Continuations<T>) => void): (ctx: IAsyncContext<T>) => void;
-export declare function ignore<T>(computation: Async<T>): (ctx: IAsyncContext<undefined>) => void;
-export declare function parallel<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<Awaited<T>[]>) => void;
-export declare function sequential<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<T[]>) => void;
-export declare function sleep(millisecondsDueTime: number): (ctx: IAsyncContext<void>) => void;
-export declare function start<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
-export declare function startImmediate<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
-export declare function startWithContinuations<T>(computation: Async<T>, continuation: Continuation<T>, exceptionContinuation: Continuation<any>, cancellationContinuation: Continuation<any>, cancelToken?: CancellationToken): void;
-export declare function startAsPromise<T>(computation: Async<T>, cancellationToken?: CancellationToken): Promise<T>;

package/AsyncBuilder.d.ts

@@ -1,59 +0,0 @@
-import { IDisposable } from "./Util.js";
-export interface AsyncReplyChannel<Reply> {
-    reply(value: Reply): void;
-}
-export type Continuation<T> = (x: T) => void;
-export type Continuations<T> = [
-    Continuation<T>,
-    Continuation<Error>,
-    Continuation<OperationCanceledError>
-];
-export declare class CancellationToken implements IDisposable {
-    private _id;
-    private _cancelled;
-    private _listeners;
-    constructor(cancelled?: boolean);
-    get isCancelled(): boolean;
-    cancel(): void;
-    addListener(f: () => void): number;
-    removeListener(id: number): boolean;
-    register(f: (state?: any) => void, state?: any): {
-        Dispose(): void;
-    };
-    Dispose(): void;
-}
-export declare class OperationCanceledError extends Error {
-    constructor();
-}
-export declare class Trampoline {
-    static get maxTrampolineCallCount(): number;
-    private callCount;
-    constructor();
-    incrementAndCheck(): boolean;
-    hijack(f: () => void): void;
-}
-export interface IAsyncContext<T> {
-    onSuccess: Continuation<T>;
-    onError: Continuation<Error>;
-    onCancel: Continuation<OperationCanceledError>;
-    cancelToken: CancellationToken;
-    trampoline: Trampoline;
-}
-export type Async<T> = (x: IAsyncContext<T>) => void;
-export declare function protectedCont<T>(f: Async<T>): (ctx: IAsyncContext<T>) => void;
-export declare function protectedBind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
-export declare function protectedReturn<T>(value: T): (ctx: IAsyncContext<T>) => void;
-export declare class AsyncBuilder {
-    Bind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
-    Combine<T>(computation1: Async<void>, computation2: Async<T>): (ctx: IAsyncContext<T>) => void;
-    Delay<T>(generator: () => Async<T>): (ctx: IAsyncContext<T>) => void;
-    For<T>(sequence: Iterable<T>, body: (x: T) => Async<void>): Async<void>;
-    Return<T>(value: T): (ctx: IAsyncContext<T>) => void;
-    ReturnFrom<T>(computation: Async<T>): Async<T>;
-    TryFinally<T>(computation: Async<T>, compensation: () => void): (ctx: IAsyncContext<T>) => void;
-    TryWith<T>(computation: Async<T>, catchHandler: (e: any) => Async<T>): (ctx: IAsyncContext<T>) => void;
-    Using<T extends IDisposable, U>(resource: T, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
-    While(guard: () => boolean, computation: Async<void>): Async<void>;
-    Zero(): (ctx: IAsyncContext<void>) => void;
-}
-export declare const singleton: AsyncBuilder;

package/BigInt.d.ts

@@ -1,129 +0,0 @@
-import { FSharpRef } from "./Types.js";
-import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
-import { decimal } from "./Decimal.js";
-export type int64 = bigint;
-export type uint64 = bigint;
-export type int128 = bigint;
-export type uint128 = bigint;
-export type nativeint = bigint;
-export type unativeint = bigint;
-export declare function isBigInt(x: any): boolean;
-export declare function hash(x: bigint): int32;
-export declare function equals(x: bigint, y: bigint): boolean;
-export declare function compare(x: bigint, y: bigint): int32;
-export declare function abs(x: bigint): bigint;
-export declare function sign(x: bigint): int32;
-export declare function max(x: bigint, y: bigint): bigint;
-export declare function min(x: bigint, y: bigint): bigint;
-export declare function maxMagnitude(x: bigint, y: bigint): bigint;
-export declare function minMagnitude(x: bigint, y: bigint): bigint;
-export declare function clamp(x: bigint, min: bigint, max: bigint): bigint;
-export declare function add(x: bigint, y: bigint): bigint;
-export declare function subtract(x: bigint, y: bigint): bigint;
-export declare function multiply(x: bigint, y: bigint): bigint;
-export declare function divide(x: bigint, y: bigint): bigint;
-export declare function remainder(x: bigint, y: bigint): bigint;
-export declare function negate(x: bigint): bigint;
-export declare function op_UnaryNegation(x: bigint): bigint;
-export declare function op_LogicalNot(x: bigint): bigint;
-export declare function op_UnaryPlus(x: bigint): bigint;
-export declare function op_Addition(x: bigint, y: bigint): bigint;
-export declare function op_Subtraction(x: bigint, y: bigint): bigint;
-export declare function op_Multiply(x: bigint, y: bigint): bigint;
-export declare function op_Division(x: bigint, y: bigint): bigint;
-export declare function op_Modulus(x: bigint, y: bigint): bigint;
-export declare function op_RightShift(x: bigint, n: int32): bigint;
-export declare function op_LeftShift(x: bigint, n: int32): bigint;
-export declare function op_BitwiseAnd(x: bigint, y: bigint): bigint;
-export declare function op_BitwiseOr(x: bigint, y: bigint): bigint;
-export declare function op_ExclusiveOr(x: bigint, y: bigint): bigint;
-export declare function op_LessThan(x: bigint, y: bigint): boolean;
-export declare function op_LessThanOrEqual(x: bigint, y: bigint): boolean;
-export declare function op_GreaterThan(x: bigint, y: bigint): boolean;
-export declare function op_GreaterThanOrEqual(x: bigint, y: bigint): boolean;
-export declare function op_Equality(x: bigint, y: bigint): boolean;
-export declare function op_Inequality(x: bigint, y: bigint): boolean;
-export declare function get_Zero(): bigint;
-export declare function get_One(): bigint;
-export declare function get_MinusOne(): bigint;
-export declare function get_IsZero(x: bigint): boolean;
-export declare function get_IsOne(x: bigint): boolean;
-export declare function get_IsEven(x: bigint): boolean;
-export declare function get_IsPowerOfTwo(x: bigint): boolean;
-export declare function get_Sign(x: bigint): int32;
-export declare function isNegative(x: bigint): boolean;
-export declare function isPositive(x: bigint): boolean;
-export declare function isEvenInteger(x: bigint): boolean;
-export declare function isOddInteger(x: bigint): boolean;
-export declare function isPow2(x: bigint): boolean;
-export declare function fromZero(): bigint;
-export declare function fromOne(): bigint;
-export declare function fromInt8(n: int8): bigint;
-export declare function fromUInt8(n: uint8): bigint;
-export declare function fromInt16(n: int16): bigint;
-export declare function fromUInt16(n: uint16): bigint;
-export declare function fromInt32(n: int32): bigint;
-export declare function fromUInt32(n: uint32): bigint;
-export declare function fromInt64(n: int64): bigint;
-export declare function fromUInt64(n: uint64): bigint;
-export declare function fromInt128(n: int128): bigint;
-export declare function fromUInt128(n: uint128): bigint;
-export declare function fromNativeInt(n: nativeint): bigint;
-export declare function fromUNativeInt(n: unativeint): bigint;
-export declare function fromFloat16(n: float16): bigint;
-export declare function fromFloat32(n: float32): bigint;
-export declare function fromFloat64(n: float64): bigint;
-export declare function fromDecimal(d: decimal): bigint;
-export declare function fromBigInt(x: bigint): bigint;
-export declare function fromBoolean(b: boolean): bigint;
-export declare function fromChar(c: string): bigint;
-export declare function fromString(s: string): bigint;
-export declare function fromByteArray(bytes: ArrayLike<uint8>): bigint;
-export declare function toByteArray(value: bigint): number[];
-export declare function toIntN_unchecked(bits: number, x: bigint, signed: boolean): bigint;
-export declare function toIntN(bits: number, x: bigint, signed: boolean): bigint;
-export declare function toInt8(x: bigint): int8;
-export declare function toUInt8(x: bigint): uint8;
-export declare function toInt16(x: bigint): int16;
-export declare function toUInt16(x: bigint): uint16;
-export declare function toInt32(x: bigint): int32;
-export declare function toUInt32(x: bigint): uint32;
-export declare function toInt64(x: bigint): int64;
-export declare function toUInt64(x: bigint): uint64;
-export declare function toInt128(x: bigint): int128;
-export declare function toUInt128(x: bigint): uint128;
-export declare function toNativeInt(x: bigint): nativeint;
-export declare function toUNativeInt(x: bigint): unativeint;
-export declare function toInt8_unchecked(x: bigint): int8;
-export declare function toUInt8_unchecked(x: bigint): uint8;
-export declare function toInt16_unchecked(x: bigint): int16;
-export declare function toUInt16_unchecked(x: bigint): uint16;
-export declare function toInt32_unchecked(x: bigint): int32;
-export declare function toUInt32_unchecked(x: bigint): uint32;
-export declare function toInt64_unchecked(x: bigint): int64;
-export declare function toUInt64_unchecked(x: bigint): uint64;
-export declare function toInt128_unchecked(x: bigint): int128;
-export declare function toUInt128_unchecked(x: bigint): uint128;
-export declare function toNativeInt_unchecked(x: bigint): nativeint;
-export declare function toUNativeInt_unchecked(x: bigint): unativeint;
-export declare function toFloat16(x: bigint): float16;
-export declare function toFloat32(x: bigint): float32;
-export declare function toFloat64(x: bigint): float64;
-export declare function toDecimal(x: bigint): decimal;
-export declare function toBigInt(x: bigint): bigint;
-export declare function toBoolean(x: bigint): boolean;
-export declare function toChar(x: bigint): string;
-export declare function toString(x: bigint): string;
-export declare function tryParse(s: string, res: FSharpRef<bigint>): boolean;
-export declare function parse(s: string): bigint;
-export declare function pow(x: bigint, n: int32): bigint;
-export declare function modPow(x: bigint, e: bigint, m: bigint): bigint;
-export declare function divRem(x: bigint, y: bigint): [bigint, bigint];
-export declare function divRem(x: bigint, y: bigint, out: FSharpRef<bigint>): bigint;
-export declare function greatestCommonDivisor(x: bigint, y: bigint): bigint;
-export declare function getBitLength(x: bigint): int64;
-export declare function log2(x: bigint): float64;
-export declare function log10(x: bigint): float64;
-export declare function ln(x: bigint): float64;
-export declare function log(x: bigint, base: float64): float64;
-export declare function ilog2(x: bigint): bigint;

package/BitConverter.d.ts

@@ -1,27 +0,0 @@
-import { uint8, int16, uint16, int32, uint32, float32, float64 } from "./Int32.js";
-import { int64, uint64 } from "./BigInt.js";
-import { char } from "./Char.js";
-export declare function isLittleEndian(): boolean;
-export declare function getBytesBoolean(value: boolean): Uint8Array;
-export declare function getBytesChar(value: char): Uint8Array;
-export declare function getBytesInt16(value: int16): Uint8Array;
-export declare function getBytesInt32(value: int32): Uint8Array;
-export declare function getBytesInt64(value: int64): Uint8Array;
-export declare function getBytesUInt16(value: uint16): Uint8Array;
-export declare function getBytesUInt32(value: uint32): Uint8Array;
-export declare function getBytesUInt64(value: uint64): Uint8Array;
-export declare function getBytesSingle(value: float32): Uint8Array;
-export declare function getBytesDouble(value: float64): Uint8Array;
-export declare function int64BitsToDouble(value: int64): float64;
-export declare function doubleToInt64Bits(value: float64): int64;
-export declare function toBoolean(bytes: ArrayLike<uint8>, offset: int32): boolean;
-export declare function toChar(bytes: ArrayLike<uint8>, offset: int32): char;
-export declare function toInt16(bytes: ArrayLike<uint8>, offset: int32): int16;
-export declare function toInt32(bytes: ArrayLike<uint8>, offset: int32): int32;
-export declare function toInt64(bytes: ArrayLike<uint8>, offset: int32): int64;
-export declare function toUInt16(bytes: ArrayLike<uint8>, offset: int32): uint16;
-export declare function toUInt32(bytes: ArrayLike<uint8>, offset: int32): uint32;
-export declare function toUInt64(bytes: ArrayLike<uint8>, offset: int32): uint64;
-export declare function toSingle(bytes: ArrayLike<uint8>, offset: int32): float32;
-export declare function toDouble(bytes: ArrayLike<uint8>, offset: int32): float64;
-export declare function toString(bytes: ArrayLike<uint8>, offset?: int32, count?: int32): string;

package/Boolean.d.ts

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

package/Char.d.ts

@@ -1,65 +0,0 @@
-export type char = string;
-export declare const enum UnicodeCategory {
-    UppercaseLetter = 0,
-    LowercaseLetter = 1,
-    TitlecaseLetter = 2,
-    ModifierLetter = 3,
-    OtherLetter = 4,
-    NonSpacingMark = 5,
-    SpacingCombiningMark = 6,
-    EnclosingMark = 7,
-    DecimalDigitNumber = 8,
-    LetterNumber = 9,
-    OtherNumber = 10,
-    SpaceSeparator = 11,
-    LineSeparator = 12,
-    ParagraphSeparator = 13,
-    Control = 14,
-    Format = 15,
-    Surrogate = 16,
-    PrivateUse = 17,
-    ConnectorPunctuation = 18,
-    DashPunctuation = 19,
-    OpenPunctuation = 20,
-    ClosePunctuation = 21,
-    InitialQuotePunctuation = 22,
-    FinalQuotePunctuation = 23,
-    OtherPunctuation = 24,
-    MathSymbol = 25,
-    CurrencySymbol = 26,
-    ModifierSymbol = 27,
-    OtherSymbol = 28,
-    OtherNotAssigned = 29
-}
-export declare const getUnicodeCategory: (s: string) => number;
-export declare const isControl: (s: string) => boolean;
-export declare const isDigit: (s: string) => boolean;
-export declare const isLetter: (s: string) => boolean;
-export declare const isLetterOrDigit: (s: string) => boolean;
-export declare const isUpper: (s: string) => boolean;
-export declare const isLower: (s: string) => boolean;
-export declare const isNumber: (s: string) => boolean;
-export declare const isPunctuation: (s: string) => boolean;
-export declare const isSeparator: (s: string) => boolean;
-export declare const isSymbol: (s: string) => boolean;
-export declare const isWhiteSpace: (s: string) => boolean;
-export declare const isHighSurrogate: (s: string) => boolean;
-export declare const isLowSurrogate: (s: string) => boolean;
-export declare const isSurrogate: (s: string) => boolean;
-export declare function getUnicodeCategory2(s: string, index: number): number;
-export declare function isControl2(s: string, index: number): boolean;
-export declare function isDigit2(s: string, index: number): boolean;
-export declare function isLetter2(s: string, index: number): boolean;
-export declare function isLetterOrDigit2(s: string, index: number): boolean;
-export declare function isUpper2(s: string, index: number): boolean;
-export declare function isLower2(s: string, index: number): boolean;
-export declare function isNumber2(s: string, index: number): boolean;
-export declare function isPunctuation2(s: string, index: number): boolean;
-export declare function isSeparator2(s: string, index: number): boolean;
-export declare function isSymbol2(s: string, index: number): boolean;
-export declare function isWhiteSpace2(s: string, index: number): boolean;
-export declare function isHighSurrogate2(s: string, index: number): boolean;
-export declare function isLowSurrogate2(s: string, index: number): boolean;
-export declare function isSurrogate2(s: string, index: number): boolean;
-export declare function isSurrogatePair(s: string, index: string | number): boolean;
-export declare function parse(input: string): string;

package/Choice.d.ts

@@ -1,121 +0,0 @@
-import { Union } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-export type FSharpChoice$2_$union<T1, T2> = FSharpChoice$2<T1, T2, 0> | FSharpChoice$2<T1, T2, 1>;
-export type FSharpChoice$2_$cases<T1, T2> = {
-    0: ["Choice1Of2", [T1]];
-    1: ["Choice2Of2", [T2]];
-};
-export declare function FSharpChoice$2_Choice1Of2<T1, T2>(Item: T1): FSharpChoice$2<T1, T2, 0>;
-export declare function FSharpChoice$2_Choice2Of2<T1, T2>(Item: T2): FSharpChoice$2<T1, T2, 1>;
-export declare class FSharpChoice$2<T1, T2, Tag extends keyof FSharpChoice$2_$cases<T1, T2>> extends Union<Tag, FSharpChoice$2_$cases<T1, T2>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpChoice$2_$cases<T1, T2>[Tag][1];
-    constructor(tag: Tag, fields: FSharpChoice$2_$cases<T1, T2>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpChoice$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export type FSharpChoice$3_$union<T1, T2, T3> = FSharpChoice$3<T1, T2, T3, 0> | FSharpChoice$3<T1, T2, T3, 1> | FSharpChoice$3<T1, T2, T3, 2>;
-export type FSharpChoice$3_$cases<T1, T2, T3> = {
-    0: ["Choice1Of3", [T1]];
-    1: ["Choice2Of3", [T2]];
-    2: ["Choice3Of3", [T3]];
-};
-export declare function FSharpChoice$3_Choice1Of3<T1, T2, T3>(Item: T1): FSharpChoice$3<T1, T2, T3, 0>;
-export declare function FSharpChoice$3_Choice2Of3<T1, T2, T3>(Item: T2): FSharpChoice$3<T1, T2, T3, 1>;
-export declare function FSharpChoice$3_Choice3Of3<T1, T2, T3>(Item: T3): FSharpChoice$3<T1, T2, T3, 2>;
-export declare class FSharpChoice$3<T1, T2, T3, Tag extends keyof FSharpChoice$3_$cases<T1, T2, T3>> extends Union<Tag, FSharpChoice$3_$cases<T1, T2, T3>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpChoice$3_$cases<T1, T2, T3>[Tag][1];
-    constructor(tag: Tag, fields: FSharpChoice$3_$cases<T1, T2, T3>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpChoice$3_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo): TypeInfo;
-export type FSharpChoice$4_$union<T1, T2, T3, T4> = FSharpChoice$4<T1, T2, T3, T4, 0> | FSharpChoice$4<T1, T2, T3, T4, 1> | FSharpChoice$4<T1, T2, T3, T4, 2> | FSharpChoice$4<T1, T2, T3, T4, 3>;
-export type FSharpChoice$4_$cases<T1, T2, T3, T4> = {
-    0: ["Choice1Of4", [T1]];
-    1: ["Choice2Of4", [T2]];
-    2: ["Choice3Of4", [T3]];
-    3: ["Choice4Of4", [T4]];
-};
-export declare function FSharpChoice$4_Choice1Of4<T1, T2, T3, T4>(Item: T1): FSharpChoice$4<T1, T2, T3, T4, 0>;
-export declare function FSharpChoice$4_Choice2Of4<T1, T2, T3, T4>(Item: T2): FSharpChoice$4<T1, T2, T3, T4, 1>;
-export declare function FSharpChoice$4_Choice3Of4<T1, T2, T3, T4>(Item: T3): FSharpChoice$4<T1, T2, T3, T4, 2>;
-export declare function FSharpChoice$4_Choice4Of4<T1, T2, T3, T4>(Item: T4): FSharpChoice$4<T1, T2, T3, T4, 3>;
-export declare class FSharpChoice$4<T1, T2, T3, T4, Tag extends keyof FSharpChoice$4_$cases<T1, T2, T3, T4>> extends Union<Tag, FSharpChoice$4_$cases<T1, T2, T3, T4>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpChoice$4_$cases<T1, T2, T3, T4>[Tag][1];
-    constructor(tag: Tag, fields: FSharpChoice$4_$cases<T1, T2, T3, T4>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpChoice$4_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo): TypeInfo;
-export type FSharpChoice$5_$union<T1, T2, T3, T4, T5> = FSharpChoice$5<T1, T2, T3, T4, T5, 0> | FSharpChoice$5<T1, T2, T3, T4, T5, 1> | FSharpChoice$5<T1, T2, T3, T4, T5, 2> | FSharpChoice$5<T1, T2, T3, T4, T5, 3> | FSharpChoice$5<T1, T2, T3, T4, T5, 4>;
-export type FSharpChoice$5_$cases<T1, T2, T3, T4, T5> = {
-    0: ["Choice1Of5", [T1]];
-    1: ["Choice2Of5", [T2]];
-    2: ["Choice3Of5", [T3]];
-    3: ["Choice4Of5", [T4]];
-    4: ["Choice5Of5", [T5]];
-};
-export declare function FSharpChoice$5_Choice1Of5<T1, T2, T3, T4, T5>(Item: T1): FSharpChoice$5<T1, T2, T3, T4, T5, 0>;
-export declare function FSharpChoice$5_Choice2Of5<T1, T2, T3, T4, T5>(Item: T2): FSharpChoice$5<T1, T2, T3, T4, T5, 1>;
-export declare function FSharpChoice$5_Choice3Of5<T1, T2, T3, T4, T5>(Item: T3): FSharpChoice$5<T1, T2, T3, T4, T5, 2>;
-export declare function FSharpChoice$5_Choice4Of5<T1, T2, T3, T4, T5>(Item: T4): FSharpChoice$5<T1, T2, T3, T4, T5, 3>;
-export declare function FSharpChoice$5_Choice5Of5<T1, T2, T3, T4, T5>(Item: T5): FSharpChoice$5<T1, T2, T3, T4, T5, 4>;
-export declare class FSharpChoice$5<T1, T2, T3, T4, T5, Tag extends keyof FSharpChoice$5_$cases<T1, T2, T3, T4, T5>> extends Union<Tag, FSharpChoice$5_$cases<T1, T2, T3, T4, T5>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpChoice$5_$cases<T1, T2, T3, T4, T5>[Tag][1];
-    constructor(tag: Tag, fields: FSharpChoice$5_$cases<T1, T2, T3, T4, T5>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpChoice$5_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo): TypeInfo;
-export type FSharpChoice$6_$union<T1, T2, T3, T4, T5, T6> = FSharpChoice$6<T1, T2, T3, T4, T5, T6, 0> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 1> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 2> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 3> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 4> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 5>;
-export type FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6> = {
-    0: ["Choice1Of6", [T1]];
-    1: ["Choice2Of6", [T2]];
-    2: ["Choice3Of6", [T3]];
-    3: ["Choice4Of6", [T4]];
-    4: ["Choice5Of6", [T5]];
-    5: ["Choice6Of6", [T6]];
-};
-export declare function FSharpChoice$6_Choice1Of6<T1, T2, T3, T4, T5, T6>(Item: T1): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 0>;
-export declare function FSharpChoice$6_Choice2Of6<T1, T2, T3, T4, T5, T6>(Item: T2): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 1>;
-export declare function FSharpChoice$6_Choice3Of6<T1, T2, T3, T4, T5, T6>(Item: T3): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 2>;
-export declare function FSharpChoice$6_Choice4Of6<T1, T2, T3, T4, T5, T6>(Item: T4): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 3>;
-export declare function FSharpChoice$6_Choice5Of6<T1, T2, T3, T4, T5, T6>(Item: T5): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 4>;
-export declare function FSharpChoice$6_Choice6Of6<T1, T2, T3, T4, T5, T6>(Item: T6): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 5>;
-export declare class FSharpChoice$6<T1, T2, T3, T4, T5, T6, Tag extends keyof FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>> extends Union<Tag, FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>[Tag][1];
-    constructor(tag: Tag, fields: FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpChoice$6_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo, gen5: TypeInfo): TypeInfo;
-export type FSharpChoice$7_$union<T1, T2, T3, T4, T5, T6, T7> = FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 0> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 1> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 2> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 3> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 4> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 5> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 6>;
-export type FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7> = {
-    0: ["Choice1Of7", [T1]];
-    1: ["Choice2Of7", [T2]];
-    2: ["Choice3Of7", [T3]];
-    3: ["Choice4Of7", [T4]];
-    4: ["Choice5Of7", [T5]];
-    5: ["Choice6Of7", [T6]];
-    6: ["Choice7Of7", [T7]];
-};
-export declare function FSharpChoice$7_Choice1Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T1): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 0>;
-export declare function FSharpChoice$7_Choice2Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T2): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 1>;
-export declare function FSharpChoice$7_Choice3Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T3): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 2>;
-export declare function FSharpChoice$7_Choice4Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T4): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 3>;
-export declare function FSharpChoice$7_Choice5Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T5): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 4>;
-export declare function FSharpChoice$7_Choice6Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T6): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 5>;
-export declare function FSharpChoice$7_Choice7Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T7): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 6>;
-export declare class FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, Tag extends keyof FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>> extends Union<Tag, FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>[Tag][1];
-    constructor(tag: Tag, fields: FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpChoice$7_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo, gen5: TypeInfo, gen6: TypeInfo): TypeInfo;
-export declare function Choice_makeChoice1Of2<T1, a>(x: T1): FSharpChoice$2_$union<T1, a>;
-export declare function Choice_makeChoice2Of2<T2, a>(x: T2): FSharpChoice$2_$union<a, T2>;
-export declare function Choice_tryValueIfChoice1Of2<T1, T2>(x: FSharpChoice$2_$union<T1, T2>): Option<T1>;
-export declare function Choice_tryValueIfChoice2Of2<T1, T2>(x: FSharpChoice$2_$union<T1, T2>): Option<T2>;

package/CollectionUtil.d.ts

@@ -1,7 +0,0 @@
-export declare function count<T>(col: Iterable<T>): number;
-export declare function isReadOnly<T>(col: Iterable<T>): boolean;
-export declare function copyTo<T>(col: Iterable<T>, array: T[], arrayIndex: number): void;
-export declare function contains<T>(col: Iterable<T>, item: T): boolean;
-export declare function add<T>(col: Iterable<T>, item: T): void;
-export declare function remove<T>(col: Iterable<T>, item: T): boolean;
-export declare function clear<T>(col: Iterable<T>): void;

package/ConditionalWeakTable.d.ts

@@ -1,9 +0,0 @@
-export declare class ConditionalWeakTable<TKey extends object, TValue> {
-    private weakMap;
-    delete(key: TKey): boolean;
-    get(key: TKey): TValue | undefined;
-    has(key: TKey): boolean;
-    set(key: TKey, value: TValue): WeakMap<TKey, TValue>;
-    clear(): void;
-}
-export default ConditionalWeakTable;