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

package/TimeSpan.js

@@ -1,4 +1,4 @@
-import { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
+import { Exception, comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
 import { toInt64, fromFloat64 } from "./BigInt.js";
 /**
  * Calls:
@@ -98,7 +98,7 @@ export function duration(x) {
 }
 export function toString(ts, format = "c", _provider) {
     if (["c", "g", "G"].indexOf(format) === -1) {
-        throw new Error("Custom formats are not supported");
+        throw new Exception("Custom formats are not supported");
     }
     const d = Math.abs(days(ts));
     const h = Math.abs(hours(ts));
@@ -114,7 +114,7 @@ export function parse(str) {
     if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4
         const d = parseInt(str, 0);
         if (isNaN(d)) {
-            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+            throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
         }
         else {
             return create(d, 0, 0, 0, 0);
@@ -161,13 +161,13 @@ export function parse(str) {
                         ms = +r[8] / 10000;
                         break;
                     default:
-                        throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+                        throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
                 }
             }
             return sign * create(d, h, m, s, ms);
         }
     }
-    throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+    throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
 }
 export function tryParse(v, defValue) {
     try {

package/Types.js

@@ -1,4 +1,4 @@
-import { combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from "./Util.js";
+import { Exception, combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from "./Util.js";
 export function seqToString(self) {
     let count = 0;
     let str = "[";
@@ -172,22 +172,6 @@ export class FSharpRef {
     }
 }
 // EXCEPTIONS
-// Exception is intentionally not derived from Error, for performance reasons (see #2160)
-export class Exception {
-    constructor(message) {
-        this.message = message;
-    }
-}
-export function isException(x) {
-    return x instanceof Exception || x instanceof Error;
-}
-export function isPromise(x) {
-    return x instanceof Promise;
-}
-export function ensureErrorOrException(e) {
-    // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
-    return (isException(e) || isPromise(e)) ? e : new Error(String(e));
-}
 export class FSharpException extends Exception {
     toJSON() { return recordToJSON(this); }
     toString() { return recordToString(this); }

package/Uri.js

@@ -1,3 +1,9 @@
+import { Exception } from "./Util.js";
+export const UriKind = {
+    RelativeOrAbsolute: 0,
+    Absolute: 1,
+    Relative: 2,
+};
 const ok = (value) => ({
     tag: "ok",
     value,
@@ -18,41 +24,41 @@ export class Uri {
     }
     static tryCreateWithKind(uri, kind) {
         switch (kind) {
-            case 1 /* UriKind.Absolute */:
+            case UriKind.Absolute:
                 return Uri.isAbsoluteUri(uri)
                     ? ok(new Uri({ original: uri, value: new URL(uri), kind }))
                     : error("Invalid URI: The format of the URI could not be determined.");
-            case 2 /* UriKind.Relative */:
+            case UriKind.Relative:
                 return Uri.isAbsoluteUri(uri)
                     ? error("URI is not a relative path.")
                     : ok(new Uri({ original: uri, value: uri, kind }));
-            case 0 /* UriKind.RelativeOrAbsolute */:
+            case UriKind.RelativeOrAbsolute:
                 return Uri.isAbsoluteUri(uri)
-                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: 1 /* UriKind.Absolute */ }))
-                    : ok(new Uri({ original: uri, value: uri, kind: 2 /* UriKind.Relative */ }));
+                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: UriKind.Absolute }))
+                    : ok(new Uri({ original: uri, value: uri, kind: UriKind.Relative }));
             default:
                 const never = kind;
                 return never;
         }
     }
     static tryCreateWithBase(baseUri, relativeUri) {
-        return baseUri.uri.kind !== 1 /* UriKind.Absolute */
+        return baseUri.uri.kind !== UriKind.Absolute
             ? error("Base URI should have Absolute kind")
             : typeof relativeUri === "string"
                 ? ok(new Uri({
                     original: new URL(relativeUri, baseUri.uri.value).toString(),
                     value: new URL(relativeUri, baseUri.uri.value),
-                    kind: 1 /* UriKind.Absolute */,
+                    kind: UriKind.Absolute,
                 }))
-                : relativeUri.uri.kind === 2 /* UriKind.Relative */
+                : relativeUri.uri.kind === UriKind.Relative
                     ? ok(new Uri({
                         original: new URL(relativeUri.uri.value, baseUri.uri.value).toString(),
                         value: new URL(relativeUri.uri.value, baseUri.uri.value),
-                        kind: 1 /* UriKind.Absolute */,
+                        kind: UriKind.Absolute,
                     }))
                     : ok(baseUri);
     }
-    static tryCreateImpl(value, kindOrUri = 1 /* UriKind.Absolute */) {
+    static tryCreateImpl(value, kindOrUri = UriKind.Absolute) {
         return typeof value === "string"
             ? typeof kindOrUri !== "number"
                 ? error("Kind must be specified when the baseUri is a string.")
@@ -61,19 +67,19 @@ export class Uri {
                 ? error("Kind should not be specified when the baseUri is an absolute Uri.")
                 : Uri.tryCreateWithBase(value, kindOrUri);
     }
-    static create(value, kindOrUri = 1 /* UriKind.Absolute */) {
+    static create(value, kindOrUri = UriKind.Absolute) {
         const result = Uri.tryCreateImpl(value, kindOrUri);
         switch (result.tag) {
             case "ok":
                 return result.value;
             case "error":
-                throw new Error(result.error);
+                throw new Exception(result.error);
             default:
                 const never = result;
                 return never;
         }
     }
-    static tryCreate(value, kindOrUri = 1 /* UriKind.Absolute */, out) {
+    static tryCreate(value, kindOrUri = UriKind.Absolute, out) {
         const result = Uri.tryCreateImpl(value, kindOrUri);
         switch (result.tag) {
             case "ok":
@@ -88,9 +94,9 @@ export class Uri {
     }
     toString() {
         switch (this.uri.kind) {
-            case 1 /* UriKind.Absolute */:
+            case UriKind.Absolute:
                 return decodeURIComponent(this.asUrl().toString());
-            case 2 /* UriKind.Relative */:
+            case UriKind.Relative:
                 return this.uri.value;
             default:
                 const never = this.uri;
@@ -99,17 +105,17 @@ export class Uri {
     }
     asUrl() {
         switch (this.uri.kind) {
-            case 1 /* UriKind.Absolute */:
+            case UriKind.Absolute:
                 return this.uri.value;
-            case 2 /* UriKind.Relative */:
-                throw new Error("This operation is not supported for a relative URI.");
+            case UriKind.Relative:
+                throw new Exception("This operation is not supported for a relative URI.");
             default:
                 const never = this.uri;
                 return never;
         }
     }
     get isAbsoluteUri() {
-        return this.uri.kind === 1 /* UriKind.Absolute */;
+        return this.uri.kind === UriKind.Absolute;
     }
     get absoluteUri() {
         return this.asUrl().href;

package/Util.js

@@ -1,6 +1,31 @@
+// Don't change, this corresponds to DateTimeKind.Kind enum values in .NET
+export const DateTimeKind = {
+    Unspecified: 0,
+    Utc: 1,
+    Local: 2,
+};
+// Exception is intentionally not derived from Error, for performance reasons (see #2160)
+export class Exception {
+    constructor(msg) {
+        this.message = msg ?? "";
+    }
+}
+export function isException(x) {
+    return x instanceof Exception || x instanceof Error;
+}
+export function isPromise(x) {
+    return x instanceof Promise;
+}
+export function ensureErrorOrException(e) {
+    // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
+    return (isException(e) || isPromise(e)) ? e : new Exception(String(e));
+}
 export function isArrayLike(x) {
     return Array.isArray(x) || ArrayBuffer.isView(x);
 }
+export function isMutableArray(x) {
+    return Array.isArray(x) || ArrayBuffer.isView(x);
+}
 export function isIterable(x) {
     return x != null && typeof x === "object" && Symbol.iterator in x;
 }
@@ -34,9 +59,7 @@ export function sameConstructor(x, y) {
     return Object.getPrototypeOf(x)?.constructor === Object.getPrototypeOf(y)?.constructor;
 }
 export class Enumerable {
-    constructor(en) {
-        this.en = en;
-    }
+    constructor(en) { this.en = en; }
     GetEnumerator() { return this.en; }
     "System.Collections.IEnumerable.GetEnumerator"() { return this.en; }
     [Symbol.iterator]() {
@@ -50,8 +73,8 @@ export class Enumerable {
 }
 export class Enumerator {
     constructor(iter) {
-        this.iter = iter;
         this.current = defaultOf();
+        this.iter = iter;
     }
     ["System.Collections.Generic.IEnumerator`1.get_Current"]() {
         return this.current;
@@ -65,7 +88,7 @@ export class Enumerator {
         return !cur.done;
     }
     ["System.Collections.IEnumerator.Reset"]() {
-        throw new Error("JS iterators cannot be reset");
+        throw new Exception("JS iterators cannot be reset");
     }
     Dispose() {
         return;
@@ -124,7 +147,7 @@ export function comparerFromEqualityComparer(comparer) {
 }
 export function assertEqual(actual, expected, msg) {
     if (!equals(actual, expected)) {
-        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
+        throw Object.assign(new Exception(msg || `Expected: ${expected} - Actual: ${actual}`), {
             actual,
             expected,
         });
@@ -132,7 +155,7 @@ export function assertEqual(actual, expected, msg) {
 }
 export function assertNotEqual(actual, expected, msg) {
     if (equals(actual, expected)) {
-        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
+        throw Object.assign(new Exception(msg || `Expected: ${expected} - Actual: ${actual}`), {
             actual,
             expected,
         });
@@ -167,7 +190,7 @@ export function dateOffset(date) {
     const date1 = date;
     return typeof date1.offset === "number"
         ? date1.offset
-        : (date.kind === 1 /* DateKind.UTC */
+        : (date.kind === DateTimeKind.Utc
             ? 0 : date.getTimezoneOffset() * -60000);
 }
 export function int16ToString(i, radix) {
@@ -336,15 +359,6 @@ function equalObjects(x, y) {
 export function physicalEquals(x, y) {
     return x === y;
 }
-export function nullableEquals(x, y) {
-    if (x == null) {
-        return y == null;
-    }
-    if (y == null) {
-        return false;
-    }
-    return equals(x, y);
-}
 export function equals(x, y) {
     if (x === y) {
         return true;

package/package.json

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

package/Array.d.ts

@@ -1,123 +0,0 @@
-import { int32 } from "./Int32.js";
-import { Option } from "./Option.js";
-import { IComparer, Nullable, 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: Nullable<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), source1: T[], source2: 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;