compostjs 0.0.8 → 0.0.12

package/dist/fable_modules/fable-library-js.4.28.0/Async.d.ts

@@ -0,0 +1,26 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Async.js

@@ -0,0 +1,145 @@
+import { OperationCanceledError, Trampoline } from "./AsyncBuilder.js";
+import { CancellationToken } from "./AsyncBuilder.js";
+import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
+import { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
+import { TimeoutException } from "./SystemException.js";
+function emptyContinuation(_x) {
+    // NOP
+}
+// see AsyncBuilder.Delay
+function delay(generator) {
+    return protectedCont((ctx) => generator()(ctx));
+}
+// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
+export function makeAsync(body) {
+    return body;
+}
+// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
+export function invoke(computation, ctx) {
+    return computation(ctx);
+}
+// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
+export function callThenInvoke(ctx, result1, part2) {
+    return part2(result1)(ctx);
+}
+// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
+export function bind(ctx, part1, part2) {
+    return protectedBind(part1, part2)(ctx);
+}
+export function createCancellationToken(arg) {
+    const token = new CancellationToken(typeof arg === "boolean" ? arg : false);
+    if (typeof arg === "number") {
+        setTimeout(() => { token.cancel(); }, arg);
+    }
+    return token;
+}
+export function cancel(token) {
+    token.cancel();
+}
+export function cancelAfter(token, ms) {
+    setTimeout(() => { token.cancel(); }, ms);
+}
+export function isCancellationRequested(token) {
+    return token != null && token.isCancelled;
+}
+export function throwIfCancellationRequested(token) {
+    if (token != null && token.isCancelled) {
+        throw new Error("Operation is cancelled");
+    }
+}
+function throwAfter(millisecondsDueTime) {
+    return protectedCont((ctx) => {
+        let tokenId;
+        const timeoutId = setTimeout(() => {
+            ctx.cancelToken.removeListener(tokenId);
+            ctx.onError(new TimeoutException());
+        }, millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => {
+            clearTimeout(timeoutId);
+            ctx.onCancel(new OperationCanceledError());
+        });
+    });
+}
+export function startChild(computation, ms) {
+    if (ms) {
+        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));
+        return startChild(computationWithTimeout);
+    }
+    const promise = startAsPromise(computation);
+    // JS Promises are hot, computation has already started
+    // but we delay returning the result
+    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));
+}
+export function awaitPromise(p) {
+    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError
+        ? conts[2] : conts[1])(err)));
+}
+export function cancellationToken() {
+    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));
+}
+export const defaultCancellationToken = new CancellationToken();
+export function catchAsync(work) {
+    return protectedCont((ctx) => {
+        work({
+            onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),
+            onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),
+            onCancel: ctx.onCancel,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    });
+}
+export function fromContinuations(f) {
+    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+}
+export function ignore(computation) {
+    return protectedBind(computation, (_x) => protectedReturn(void 0));
+}
+export function parallel(computations) {
+    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
+}
+function parallel2(a, b) {
+    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
+}
+export function sequential(computations) {
+    function _sequential(computations) {
+        let pr = Promise.resolve([]);
+        for (const c of computations) {
+            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));
+        }
+        return pr;
+    }
+    return delay(() => awaitPromise(_sequential(computations)));
+}
+export function sleep(millisecondsDueTime) {
+    return protectedCont((ctx) => {
+        let tokenId;
+        const timeoutId = setTimeout(() => {
+            ctx.cancelToken.removeListener(tokenId);
+            ctx.onSuccess(void 0);
+        }, millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => {
+            clearTimeout(timeoutId);
+            ctx.onCancel(new OperationCanceledError());
+        });
+    });
+}
+export function start(computation, cancellationToken) {
+    return startWithContinuations(computation, emptyContinuation, function (err) { throw err; }, emptyContinuation, cancellationToken);
+}
+export function startImmediate(computation, cancellationToken) {
+    return start(computation, cancellationToken);
+}
+export function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
+    const trampoline = new Trampoline();
+    computation({
+        onSuccess: continuation ? continuation : emptyContinuation,
+        onError: exceptionContinuation,
+        onCancel: cancellationContinuation,
+        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
+        trampoline,
+    });
+}
+export function startAsPromise(computation, cancellationToken) {
+    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
+}

package/dist/fable_modules/fable-library-js.4.28.0/AsyncBuilder.d.ts

@@ -0,0 +1,59 @@
+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/dist/fable_modules/fable-library-js.4.28.0/AsyncBuilder.js

@@ -0,0 +1,183 @@
+import { ensureErrorOrException } from './Types.js';
+export class CancellationToken {
+    constructor(cancelled = false) {
+        this._id = 0;
+        this._cancelled = cancelled;
+        this._listeners = new Map();
+    }
+    get isCancelled() {
+        return this._cancelled;
+    }
+    cancel() {
+        if (!this._cancelled) {
+            this._cancelled = true;
+            for (const [, listener] of this._listeners) {
+                listener();
+            }
+        }
+    }
+    addListener(f) {
+        const id = this._id;
+        this._listeners.set(this._id++, f);
+        return id;
+    }
+    removeListener(id) {
+        return this._listeners.delete(id);
+    }
+    register(f, state) {
+        const $ = this;
+        const id = this.addListener(state == null ? f : () => f(state));
+        return { Dispose() { $.removeListener(id); } };
+    }
+    Dispose() {
+        // Implement IDisposable for compatibility but do nothing
+        // According to docs, calling Dispose does not trigger cancellation
+        // https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource.dispose?view=net-6.0
+    }
+}
+export class OperationCanceledError extends Error {
+    constructor() {
+        super("The operation was canceled");
+        Object.setPrototypeOf(this, OperationCanceledError.prototype);
+    }
+}
+export class Trampoline {
+    static get maxTrampolineCallCount() {
+        return 2000;
+    }
+    constructor() {
+        this.callCount = 0;
+    }
+    incrementAndCheck() {
+        return this.callCount++ > Trampoline.maxTrampolineCallCount;
+    }
+    hijack(f) {
+        this.callCount = 0;
+        setTimeout(f, 0);
+    }
+}
+export function protectedCont(f) {
+    return (ctx) => {
+        if (ctx.cancelToken.isCancelled) {
+            ctx.onCancel(new OperationCanceledError());
+        }
+        else if (ctx.trampoline.incrementAndCheck()) {
+            ctx.trampoline.hijack(() => {
+                try {
+                    f(ctx);
+                }
+                catch (err) {
+                    ctx.onError(ensureErrorOrException(err));
+                }
+            });
+        }
+        else {
+            try {
+                f(ctx);
+            }
+            catch (err) {
+                ctx.onError(ensureErrorOrException(err));
+            }
+        }
+    };
+}
+export function protectedBind(computation, binder) {
+    return protectedCont((ctx) => {
+        computation({
+            onSuccess: (x) => {
+                try {
+                    binder(x)(ctx);
+                }
+                catch (err) {
+                    ctx.onError(ensureErrorOrException(err));
+                }
+            },
+            onError: ctx.onError,
+            onCancel: ctx.onCancel,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    });
+}
+export function protectedReturn(value) {
+    return protectedCont((ctx) => ctx.onSuccess(value));
+}
+export class AsyncBuilder {
+    Bind(computation, binder) {
+        return protectedBind(computation, binder);
+    }
+    Combine(computation1, computation2) {
+        return this.Bind(computation1, () => computation2);
+    }
+    Delay(generator) {
+        return protectedCont((ctx) => generator()(ctx));
+    }
+    For(sequence, body) {
+        const iter = sequence[Symbol.iterator]();
+        let cur = iter.next();
+        return this.While(() => !cur.done, this.Delay(() => {
+            const res = body(cur.value);
+            cur = iter.next();
+            return res;
+        }));
+    }
+    Return(value) {
+        return protectedReturn(value);
+    }
+    ReturnFrom(computation) {
+        return computation;
+    }
+    TryFinally(computation, compensation) {
+        return protectedCont((ctx) => {
+            computation({
+                onSuccess: (x) => {
+                    compensation();
+                    ctx.onSuccess(x);
+                },
+                onError: (x) => {
+                    compensation();
+                    ctx.onError(x);
+                },
+                onCancel: (x) => {
+                    compensation();
+                    ctx.onCancel(x);
+                },
+                cancelToken: ctx.cancelToken,
+                trampoline: ctx.trampoline,
+            });
+        });
+    }
+    TryWith(computation, catchHandler) {
+        return protectedCont((ctx) => {
+            computation({
+                onSuccess: ctx.onSuccess,
+                onCancel: ctx.onCancel,
+                cancelToken: ctx.cancelToken,
+                trampoline: ctx.trampoline,
+                onError: (ex) => {
+                    try {
+                        catchHandler(ex)(ctx);
+                    }
+                    catch (err) {
+                        ctx.onError(ensureErrorOrException(err));
+                    }
+                },
+            });
+        });
+    }
+    Using(resource, binder) {
+        return this.TryFinally(binder(resource), () => resource.Dispose());
+    }
+    While(guard, computation) {
+        if (guard()) {
+            return this.Bind(computation, () => this.While(guard, computation));
+        }
+        else {
+            return this.Return(void 0);
+        }
+    }
+    Zero() {
+        return protectedCont((ctx) => ctx.onSuccess(void 0));
+    }
+}
+export const singleton = new AsyncBuilder();

package/dist/fable_modules/fable-library-js.4.28.0/BigInt.d.ts

@@ -0,0 +1,115 @@
+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 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 toFloat16(x: bigint): float32;
+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;