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

package/Date.d.ts

@@ -1,69 +0,0 @@
-/**
- * DateTimeOffset functions.
- *
- * Note: Date instances are always DateObjects in local
- * timezone (because JS dates are all kinds of messed up).
- * A local date returns UTC epoch when `.getTime()` is called.
- *
- * Basically; invariant: date.getTime() always return UTC time.
- */
-import { int64 } from "./BigInt.js";
-import { FSharpRef } from "./Types.js";
-import { compareDates, DateKind, IDateTime, IDateTimeOffset } from "./Util.js";
-export type OffsetInMinutes = number;
-export type Offset = "Z" | OffsetInMinutes | null;
-export declare function kind(value: IDateTime): number;
-export declare function unixEpochMillisecondsToTicks(ms: number, offset: number): int64;
-export declare function ticksToUnixEpochMilliseconds(ticks: number | bigint): number;
-export declare function dateOffsetToString(offset: number): string;
-export declare function toString(date: IDateTime | IDateTimeOffset, format?: string, _provider?: any): string;
-export declare function DateTime(value: number, kind?: DateKind): IDateTime;
-export declare function fromTicks(ticks: number | bigint, kind?: DateKind): IDateTime;
-export declare function fromDateTimeOffset(date: IDateTimeOffset, kind: DateKind): IDateTime;
-export declare function getTicks(date: IDateTime | IDateTimeOffset): bigint;
-export declare function minValue(): IDateTime;
-export declare function maxValue(): IDateTime;
-export declare function parseRaw(input: string): [Date, Offset];
-export declare function parse(str: string, detectUTC?: boolean): IDateTime;
-export declare function tryParse(v: string, defValue: FSharpRef<IDateTime>): boolean;
-export declare function create(year: number, month: number, day: number, h?: number, m?: number, s?: number, ms?: number, kind?: DateKind): IDateTime;
-export declare function now(): IDateTime;
-export declare function utcNow(): IDateTime;
-export declare function today(): IDateTime;
-export declare function isLeapYear(year: number): boolean;
-export declare function daysInMonth(year: number, month: number): 29 | 28 | 31 | 30;
-export declare function toUniversalTime(date: IDateTime): IDateTime;
-export declare function toLocalTime(date: IDateTime): IDateTime;
-export declare function specifyKind(d: IDateTime, kind: DateKind): IDateTime;
-export declare function timeOfDay(d: IDateTime): number;
-export declare function date(d: IDateTime): IDateTime;
-export declare function day(d: IDateTime): number;
-export declare function hour(d: IDateTime): number;
-export declare function millisecond(d: IDateTime): number;
-export declare function minute(d: IDateTime): number;
-export declare function month(d: IDateTime): number;
-export declare function second(d: IDateTime): number;
-export declare function year(d: IDateTime): number;
-export declare function dayOfWeek(d: IDateTime): number;
-export declare function dayOfYear(d: IDateTime): number;
-export declare function add(d: IDateTime, ts: number): IDateTime;
-export declare function addDays(d: IDateTime, v: number): IDateTime;
-export declare function addHours(d: IDateTime, v: number): IDateTime;
-export declare function addMinutes(d: IDateTime, v: number): IDateTime;
-export declare function addSeconds(d: IDateTime, v: number): IDateTime;
-export declare function addMilliseconds(d: IDateTime, v: number): IDateTime;
-export declare function addTicks(d: IDateTime, v: int64): IDateTime;
-export declare function addYears(d: IDateTime, v: number): IDateTime;
-export declare function addMonths(d: IDateTime, v: number): IDateTime;
-export declare function subtract<Input extends number | IDateTime, Output = Input extends number ? IDateTime : number>(d: IDateTime, that: Input): Output;
-export declare function toLongDateString(d: IDateTime): string;
-export declare function toShortDateString(d: IDateTime): string;
-export declare function toLongTimeString(d: IDateTime): string;
-export declare function toShortTimeString(d: IDateTime): string;
-export declare function equals(d1: IDateTime, d2: IDateTime): boolean;
-export declare const compare: typeof compareDates;
-export declare const compareTo: typeof compareDates;
-export declare function op_Addition(x: IDateTime, y: number): IDateTime;
-export declare function op_Subtraction<Input extends number | IDateTime, Output = Input extends number ? IDateTime : number>(x: IDateTime, y: Input): Output;
-export declare function isDaylightSavingTime(x: IDateTime): boolean;
-export default DateTime;

package/DateOffset.d.ts

@@ -1,64 +0,0 @@
-/**
- * DateTimeOffset functions.
- *
- * Note: DateOffset instances are always DateObjects in local
- * timezone (because JS dates are all kinds of messed up).
- * A local date returns UTC epoch when `.getTime()` is called.
- *
- * However, this means that in order to construct an UTC date
- * from a DateOffset with offset of +5 hours, you first need
- * to subtract those 5 hours, than add the "local" offset.
- * As said, all kinds of messed up.
- *
- * Basically; invariant: date.getTime() always return UTC time.
- */
-import { int64 } from "./BigInt.js";
-import { FSharpRef } from "./Types.js";
-import { IDateTime, IDateTimeOffset } from "./Util.js";
-export default function DateTimeOffset(value: number, offset?: number): IDateTimeOffset;
-export declare function offset(value: IDateTimeOffset): number;
-export declare function fromDate(date: IDateTime, offset?: number): IDateTimeOffset;
-export declare function fromTicks(ticks: int64, offset: number): IDateTimeOffset;
-export declare function fromUnixTimeMilliseconds(ms: int64): IDateTimeOffset;
-export declare function fromUnixTimeSeconds(seconds: int64): IDateTimeOffset;
-export declare function getUtcTicks(date: IDateTimeOffset): bigint;
-export declare function minValue(): IDateTimeOffset;
-export declare function maxValue(): IDateTimeOffset;
-export declare function parse(str: string): IDateTimeOffset;
-export declare function tryParse(v: string, defValue: FSharpRef<IDateTimeOffset>): boolean;
-export declare function create(year: number, month: number, day: number, h: number, m: number, s: number, ms: number, offset?: number): IDateTimeOffset;
-export declare function now(): IDateTimeOffset;
-export declare function utcNow(): IDateTimeOffset;
-export declare function toUniversalTime(date: IDateTimeOffset): Date;
-export declare function toLocalTime(date: IDateTimeOffset): Date;
-export declare function localDateTime(date: IDateTimeOffset): Date;
-export declare function timeOfDay(d: IDateTimeOffset): number;
-export declare function date(d: IDateTimeOffset): IDateTime;
-export declare function day(d: IDateTimeOffset): number;
-export declare function hour(d: IDateTimeOffset): number;
-export declare function millisecond(d: IDateTimeOffset): number;
-export declare function minute(d: IDateTimeOffset): number;
-export declare function month(d: IDateTimeOffset): number;
-export declare function second(d: IDateTimeOffset): number;
-export declare function year(d: IDateTimeOffset): number;
-export declare function dayOfWeek(d: IDateTimeOffset): number;
-export declare function dayOfYear(d: IDateTimeOffset): number;
-export declare function add(d: IDateTimeOffset, ts: number): IDateTimeOffset;
-export declare function addDays(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function addHours(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function addMinutes(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function addSeconds(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function addMilliseconds(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function addTicks(d: IDateTimeOffset, v: int64): IDateTimeOffset;
-export declare function addYears(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function addMonths(d: IDateTimeOffset, v: number): IDateTimeOffset;
-export declare function subtract<Input extends number | IDateTimeOffset, Output = Input extends number ? IDateTimeOffset : number>(d: IDateTimeOffset, that: Input): Output;
-export declare function equals(d1: IDateTimeOffset, d2: IDateTimeOffset): boolean;
-export declare function equalsExact(d1: IDateTimeOffset, d2: IDateTimeOffset): boolean;
-export declare function compare(d1: IDateTimeOffset, d2: IDateTimeOffset): 0 | 1 | -1;
-export declare const compareTo: typeof compare;
-export declare function op_Addition(x: IDateTimeOffset, y: number): IDateTimeOffset;
-export declare function op_Subtraction<Input extends number | IDateTimeOffset, Output = Input extends number ? IDateTimeOffset : number>(x: IDateTimeOffset, y: Input): Output;
-export declare function toOffset(d: IDateTimeOffset, offset: number): IDateTimeOffset;
-export declare function toUnixTimeMilliseconds(d: IDateTimeOffset): int64;
-export declare function toUnixTimeSeconds(d: IDateTimeOffset): int64;

package/DateOnly.d.ts

@@ -1,18 +0,0 @@
-import { FSharpRef } from "./Types.js";
-import { IDateTime, DateKind } from "./Util.js";
-export declare function fromUnixMilliseconds(value: number): IDateTime;
-export declare function create(year: number, month: number, day: number): IDateTime;
-export declare function maxValue(): IDateTime;
-export declare function minValue(): IDateTime;
-export declare function dayNumber(d: IDateTime): number;
-export declare function fromDayNumber(dayNumber: number): IDateTime;
-export declare function fromDateTime(d: IDateTime): IDateTime;
-export declare function day(d: IDateTime): number;
-export declare function month(d: IDateTime): number;
-export declare function year(d: IDateTime): number;
-export declare function dayOfWeek(d: IDateTime): number;
-export declare function dayOfYear(d: IDateTime): number;
-export declare function toDateTime(d: IDateTime, time: number, kind?: DateKind): IDateTime;
-export declare function toString(d: IDateTime, format?: string, _provider?: any): string;
-export declare function parse(str: string): IDateTime;
-export declare function tryParse(v: string, defValue: FSharpRef<IDateTime>): boolean;

package/Decimal.d.ts

@@ -1,63 +0,0 @@
-import Decimal from "./lib/big.js";
-import { FSharpRef } from "./Types.js";
-import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
-import { int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.js";
-export default Decimal;
-export type decimal = Decimal;
-export declare const get_Zero: Decimal;
-export declare const get_One: Decimal;
-export declare const get_MinusOne: Decimal;
-export declare const get_MaxValue: Decimal;
-export declare const get_MinValue: Decimal;
-export declare function compare(x: Decimal, y: Decimal): import("./lib/big.js").Comparison;
-export declare function equals(x: Decimal, y: Decimal): boolean;
-export declare function abs(x: Decimal): Decimal;
-export declare function sign(x: Decimal): number;
-export declare function max(x: Decimal, y: Decimal): Decimal;
-export declare function min(x: Decimal, y: Decimal): Decimal;
-export declare function maxMagnitude(x: Decimal, y: Decimal): Decimal;
-export declare function minMagnitude(x: Decimal, y: Decimal): Decimal;
-export declare function clamp(x: Decimal, min: Decimal, max: Decimal): Decimal;
-export declare function round(x: Decimal, digits?: number): Decimal;
-export declare function truncate(x: Decimal): Decimal;
-export declare function ceiling(x: Decimal): Decimal;
-export declare function floor(x: Decimal): Decimal;
-export declare function pow(x: Decimal, n: number): Decimal;
-export declare function sqrt(x: Decimal): Decimal;
-export declare function op_Addition(x: Decimal, y: Decimal): Decimal;
-export declare function op_Subtraction(x: Decimal, y: Decimal): Decimal;
-export declare function op_Multiply(x: Decimal, y: Decimal): Decimal;
-export declare function op_Division(x: Decimal, y: Decimal): Decimal;
-export declare function op_Modulus(x: Decimal, y: Decimal): Decimal;
-export declare function op_UnaryNegation(x: Decimal): Decimal;
-export declare function op_UnaryPlus(x: Decimal): Decimal;
-export declare const add: typeof op_Addition;
-export declare const subtract: typeof op_Subtraction;
-export declare const multiply: typeof op_Multiply;
-export declare const divide: typeof op_Division;
-export declare const remainder: typeof op_Modulus;
-export declare const negate: typeof op_UnaryNegation;
-export declare function toString(x: Decimal): string;
-export declare function tryParse(str: string, defValue: FSharpRef<Decimal>): boolean;
-export declare function parse(str: string): Decimal;
-export declare function toNumber(x: Decimal): number;
-export declare function toChar(x: Decimal): string;
-export declare function toInt8(x: Decimal): int8;
-export declare function toUInt8(x: Decimal): uint8;
-export declare function toInt16(x: Decimal): int16;
-export declare function toUInt16(x: Decimal): uint16;
-export declare function toInt32(x: Decimal): int32;
-export declare function toUInt32(x: Decimal): uint32;
-export declare function toInt64(x: Decimal): int64;
-export declare function toUInt64(x: Decimal): uint64;
-export declare function toInt128(x: Decimal): int128;
-export declare function toUInt128(x: Decimal): uint128;
-export declare function toNativeInt(x: Decimal): nativeint;
-export declare function toUNativeInt(x: Decimal): unativeint;
-export declare function toFloat16(x: Decimal): float16;
-export declare function toFloat32(x: Decimal): float32;
-export declare function toFloat64(x: Decimal): float64;
-export declare function fromIntArray(bits: ArrayLike<number>): Decimal;
-export declare function fromInts(low: number, mid: number, high: number, signExp: number): Decimal;
-export declare function fromParts(low: number, mid: number, high: number, isNegative: boolean, scale: number): Decimal;
-export declare function getBits(d: Decimal): number[];

package/Double.d.ts

@@ -1,11 +0,0 @@
-import { FSharpRef } from "./Types.js";
-export declare function tryParse(str: string, defValue: FSharpRef<number>): boolean;
-export declare function parse(str: string): number;
-export declare function isPositiveInfinity(x: number): boolean;
-export declare function isNegativeInfinity(x: number): boolean;
-export declare function isInfinity(x: number): boolean;
-export declare function max(x: number, y: number): number;
-export declare function min(x: number, y: number): number;
-export declare function maxMagnitude(x: number, y: number): number;
-export declare function minMagnitude(x: number, y: number): number;
-export declare function clamp(x: number, min: number, max: number): number;

package/Encoding.d.ts

@@ -1,12 +0,0 @@
-import { uint8 } from "./Int32.js";
-declare class UTF16LE {
-    getBytes(str: string | string[], index?: number, count?: number): Uint8Array;
-    getString(bytes: ArrayLike<uint8>, index?: number, count?: number): string;
-}
-declare class UTF8 {
-    getBytes(str: string | string[], index?: number, count?: number): Uint8Array;
-    getString(bytes: ArrayLike<uint8>, index?: number, count?: number): string;
-}
-export declare function get_Unicode(): UTF16LE;
-export declare function get_UTF8(): UTF8;
-export {};

package/Event.d.ts

@@ -1,31 +0,0 @@
-import { IObservable } from "./Observable.js";
-import { Option } from "./Option.js";
-import { FSharpChoice$2_$union } from "./Choice.js";
-export type Handler<T> = (sender: any, x: T) => void;
-export interface IDelegateEvent<Delegate extends Function> {
-    AddHandler(d: Delegate): void;
-    RemoveHandler(d: Delegate): void;
-}
-export interface IEvent$2<Delegate extends Function, Args> extends IDelegateEvent<Delegate>, IObservable<Args> {
-}
-export type IEvent<T> = IEvent$2<Handler<T>, T>;
-export declare class Event$2<Delegate extends Function, Args> {
-    private delegates;
-    private _add;
-    private _remove;
-    get Publish(): IEvent$2<Delegate, Args>;
-    Trigger(value: Args): void;
-    Trigger(sender: any, value: Args): void;
-}
-export declare class Event<T> extends Event$2<Handler<T>, T> {
-}
-export declare function add<Del extends Function, T>(callback: (x: T) => void, sourceEvent: IEvent$2<Del, T>): void;
-export declare function choose<Del extends Function, T, U>(chooser: (x: T) => Option<U>, sourceEvent: IEvent$2<Del, T>): IEvent<U>;
-export declare function filter<Del extends Function, T>(predicate: (x: T) => boolean, sourceEvent: IEvent$2<Del, T>): IEvent<T>;
-export declare function map<Del extends Function, T, U>(mapping: (x: T) => U, sourceEvent: IEvent$2<Del, T>): IEvent<U>;
-export declare function merge<Del1 extends Function, Del2 extends Function, T>(event1: IEvent$2<Del1, T>, event2: IEvent$2<Del2, T>): IEvent<T>;
-export declare function pairwise<Del extends Function, T>(sourceEvent: IEvent$2<Del, T>): IEvent<[T, T]>;
-export declare function partition<Del extends Function, T>(predicate: (x: T) => boolean, sourceEvent: IEvent$2<Del, T>): [IEvent<T>, IEvent<T>];
-export declare function scan<Del extends Function, U, T>(collector: (u: U, t: T) => U, state: U, sourceEvent: IEvent$2<Del, T>): IEvent<U>;
-export declare function split<Del extends Function, T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, sourceEvent: IEvent$2<Del, T>): [IEvent<U1>, IEvent<U2>];
-export declare function createEvent<Del extends Function, T>(addHandler: (h: Del) => void, removeHandler: (h: Del) => void): IEvent$2<Del, T>;

package/FSharp.Collections.d.ts

@@ -1,7 +0,0 @@
-import { int32 } from "./Int32.js";
-import { IComparer, IEqualityComparer } from "./Util.js";
-export declare function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T>;
-export declare function HashIdentity_Structural<T>(): IEqualityComparer<T>;
-export declare function HashIdentity_Reference<T>(): IEqualityComparer<T>;
-export declare function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T>;
-export declare function ComparisonIdentity_Structural<T>(): IComparer<T>;

package/FSharp.Core.CompilerServices.d.ts

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

package/FSharp.Core.d.ts

@@ -1,31 +0,0 @@
-import { IDisposable, IEqualityComparer, IComparer } from "./Util.js";
-import { Nullable, Option } from "./Option.js";
-import { FSharpChoice$2_$union } from "./Choice.js";
-import { StringBuilder } from "./System.Text.js";
-export declare const LanguagePrimitives_GenericEqualityComparer: any;
-export declare const LanguagePrimitives_GenericEqualityERComparer: any;
-export declare function LanguagePrimitives_FastGenericComparer<T>(): IComparer<T>;
-export declare function LanguagePrimitives_FastGenericComparerFromTable<T>(): IComparer<T>;
-export declare function LanguagePrimitives_FastGenericEqualityComparer<T>(): IEqualityComparer<T>;
-export declare function LanguagePrimitives_FastGenericEqualityComparerFromTable<T>(): IEqualityComparer<T>;
-export declare function Operators_Failure(message: string): Error;
-export declare function Operators_FailurePattern(exn: Error): Option<string>;
-export declare function Operators_NullArg<$a>(x: string): $a;
-export declare function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R;
-export declare function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b;
-export declare function Operators_IsNull<T>(value: T): boolean;
-export declare function Operators_IsNotNull<T>(value: T): boolean;
-export declare function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean;
-export declare function Operators_NonNull<T>(value: T): T;
-export declare function Operators_NonNullV<T extends any>(value: Nullable<T>): T;
-export declare function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T>;
-export declare function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T>;
-export declare function Operators_NonNullQuickPattern<T>(value: T): T;
-export declare function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T;
-export declare function Operators_WithNull<T>(value: T): T;
-export declare function Operators_WithNullV<T extends any>(value: T): T;
-export declare function Operators_NullV<T extends any>(): Nullable<T>;
-export declare function Operators_NullArgCheck<T>(argumentName: string, value: T): T;
-export declare function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a;
-export declare function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b;
-export declare function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a;

package/Global.d.ts

@@ -1,24 +0,0 @@
-import { int32 } from "./Int32.js";
-export interface Fable_Core_IGenericAdder$1<T> {
-    Add(arg0: T, arg1: T): T;
-    GetZero(): T;
-}
-export interface Fable_Core_IGenericAverager$1<T> {
-    Add(arg0: T, arg1: T): T;
-    DivideByInt(arg0: T, arg1: int32): T;
-    GetZero(): T;
-}
-export interface Fable_Core_Symbol_wellknown {
-    [Symbol.toStringTag]: string;
-}
-export interface Fable_Core_IJsonSerializable {
-    toJSON(): any;
-}
-export declare const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
-export declare const SR_inputWasEmpty = "Collection was empty.";
-export declare const SR_inputMustBeNonNegative = "The input must be non-negative.";
-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_differentLengths = "The collections had different lengths.";
-export declare const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";

package/Guid.d.ts

@@ -1,10 +0,0 @@
-import { FSharpRef } from "./Types.js";
-export declare function toString(str: string, format?: string, _provider?: any): string;
-/** Validates UUID as specified in RFC4122 (versions 1-5). */
-export declare function parse(str: string): string;
-export declare function tryParse(str: string, defValue: FSharpRef<string>): boolean;
-export declare function newGuid(): string;
-/** Parse a UUID into it's component bytes */
-export declare function guidToArray(s: string): number[];
-/** Convert UUID byte array into a string */
-export declare function arrayToGuid(buf: ArrayLike<number>): string;

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 } 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: any): boolean;
-    GetHashCode(): int32;
-    toJSON(): any;
-    CompareTo(other: 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"(): 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;