@magnusopera/fscript 0.75.0

package/dist/fable_modules/fable-library-js.5.2.0/Async.js

@@ -0,0 +1,134 @@
+import { OperationCanceledException, 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_$ctor } from "./System.js";
+import { Exception } from "./Util.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 Exception("Operation is cancelled");
+    }
+}
+export function startChild(computation, ms) {
+    const promise = startAsPromise(computation);
+    let promiseToRun = promise;
+    if (ms) {
+        // Race the computation against a timeout: whichever settles first wins.
+        promiseToRun = new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
+            promise.then(value => { clearTimeout(timeoutId); resolve(value); }, error => { clearTimeout(timeoutId); reject(error); });
+        });
+    }
+    // JS Promises are hot, computation has already started
+    // but we delay returning the result
+    return protectedCont((ctx) => protectedReturn(awaitPromise(promiseToRun))(ctx));
+}
+export function awaitPromise(p) {
+    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledException
+        ? 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)))));
+}
+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 OperationCanceledException());
+        });
+    });
+}
+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.5.2.0/AsyncBuilder.js

@@ -0,0 +1,183 @@
+import { Exception, ensureErrorOrException } from "./Util.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 OperationCanceledException extends Exception {
+    constructor(msg) {
+        super(msg ?? "The operation was canceled");
+        // Object.setPrototypeOf(this, OperationCanceledException.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 OperationCanceledException());
+        }
+        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.5.2.0/BigInt.js

@@ -0,0 +1,306 @@
+import { fromParts, truncate } from "./Decimal.js";
+import { Exception, bigintHash } from "./Util.js";
+const isBigEndian = false;
+BigInt.prototype.toJSON = function () {
+    return `${this.toString()}`;
+};
+const zero = 0n;
+const one = 1n;
+const two = 2n;
+const minusOne = -1n;
+export function isBigInt(x) {
+    return typeof x === "bigint";
+}
+export function hash(x) {
+    return bigintHash(x);
+}
+export function equals(x, y) {
+    return x === y;
+}
+export function compare(x, y) {
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+export function abs(x) { return x < zero ? -x : x; }
+export function sign(x) { return x < zero ? -1 : x > zero ? 1 : 0; }
+export function max(x, y) { return x > y ? x : y; }
+export function min(x, y) { return x < y ? x : y; }
+export function maxMagnitude(x, y) { return abs(x) > abs(y) ? x : y; }
+export function minMagnitude(x, y) { return abs(x) < abs(y) ? x : y; }
+export function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}
+export function add(x, y) { return x + y; }
+export function subtract(x, y) { return x - y; }
+export function multiply(x, y) { return x * y; }
+export function divide(x, y) { return x / y; }
+export function remainder(x, y) { return x % y; }
+export function negate(x) { return -x; }
+export function op_UnaryNegation(x) { return -x; }
+export function op_LogicalNot(x) { return ~x; }
+export function op_UnaryPlus(x) { return x; }
+export function op_Addition(x, y) { return x + y; }
+export function op_Subtraction(x, y) { return x - y; }
+export function op_Multiply(x, y) { return x * y; }
+export function op_Division(x, y) { return x / y; }
+export function op_Modulus(x, y) { return x % y; }
+export function op_RightShift(x, n) { return x >> BigInt(n); }
+export function op_LeftShift(x, n) { return x << BigInt(n); }
+export function op_BitwiseAnd(x, y) { return x & y; }
+export function op_BitwiseOr(x, y) { return x | y; }
+export function op_ExclusiveOr(x, y) { return x ^ y; }
+export function op_LessThan(x, y) { return x < y; }
+export function op_LessThanOrEqual(x, y) { return x <= y; }
+export function op_GreaterThan(x, y) { return x > y; }
+export function op_GreaterThanOrEqual(x, y) { return x >= y; }
+export function op_Equality(x, y) { return x === y; }
+export function op_Inequality(x, y) { return x !== y; }
+export function get_Zero() { return zero; }
+export function get_One() { return one; }
+export function get_MinusOne() { return minusOne; }
+export function get_IsZero(x) { return x === zero; }
+export function get_IsOne(x) { return x === one; }
+export function get_IsEven(x) { return isEvenInteger(x); }
+export function get_IsPowerOfTwo(x) { return isPow2(x); }
+export function get_Sign(x) { return sign(x); }
+export function isNegative(x) { return x < zero; }
+export function isPositive(x) { return x > zero; }
+export function isEvenInteger(x) { return (x % two) === zero; }
+export function isOddInteger(x) { return (x % two) !== zero; }
+export function isPow2(x) { return (x & (x - one)) === zero; }
+export function fromZero() { return zero; }
+export function fromOne() { return one; }
+export function fromInt8(n) { return BigInt(n); }
+export function fromUInt8(n) { return BigInt(n); }
+export function fromInt16(n) { return BigInt(n); }
+export function fromUInt16(n) { return BigInt(n); }
+export function fromInt32(n) { return BigInt(n); }
+export function fromUInt32(n) { return BigInt(n); }
+export function fromInt64(n) { return n; }
+export function fromUInt64(n) { return n; }
+export function fromInt128(n) { return n; }
+export function fromUInt128(n) { return n; }
+export function fromNativeInt(n) { return n; }
+export function fromUNativeInt(n) { return n; }
+export function fromFloat16(n) { return BigInt(Math.trunc(n)); }
+export function fromFloat32(n) { return BigInt(Math.trunc(n)); }
+export function fromFloat64(n) { return BigInt(Math.trunc(n)); }
+export function fromDecimal(d) { return BigInt(truncate(d).toString()); }
+export function fromBigInt(x) { return x; }
+export function fromBoolean(b) { return BigInt(b); }
+export function fromChar(c) { return BigInt(c.charCodeAt(0)); }
+export function fromString(s) { return BigInt(s); }
+export function fromByteArray(bytes) {
+    return fromSignedBytes(bytes, isBigEndian);
+}
+export function toByteArray(value) {
+    return toSignedBytes(value, isBigEndian);
+}
+export function toIntN_unchecked(bits, x, signed) {
+    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+}
+export function toIntN(bits, x, signed) {
+    let higher_bits = abs(x) >> BigInt(bits);
+    if (higher_bits !== 0n) {
+        const s = signed ? "a signed" : "an unsigned";
+        throw new Exception(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
+    }
+    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+}
+export function toInt8(x) { return Number(toIntN(8, x, true)); }
+export function toUInt8(x) { return Number(toIntN(8, x, false)); }
+export function toInt16(x) { return Number(toIntN(16, x, true)); }
+export function toUInt16(x) { return Number(toIntN(16, x, false)); }
+export function toInt32(x) { return Number(toIntN(32, x, true)); }
+export function toUInt32(x) { return Number(toIntN(32, x, false)); }
+export function toInt64(x) { return toIntN(64, x, true); }
+export function toUInt64(x) { return toIntN(64, x, false); }
+export function toInt128(x) { return toIntN(128, x, true); }
+export function toUInt128(x) { return toIntN(128, x, false); }
+export function toNativeInt(x) { return toIntN(64, x, true); }
+export function toUNativeInt(x) { return toIntN(64, x, false); }
+export function toInt8_unchecked(x) { return Number(toIntN_unchecked(8, x, true)); }
+export function toUInt8_unchecked(x) { return Number(toIntN_unchecked(8, x, false)); }
+export function toInt16_unchecked(x) { return Number(toIntN_unchecked(16, x, true)); }
+export function toUInt16_unchecked(x) { return Number(toIntN_unchecked(16, x, false)); }
+export function toInt32_unchecked(x) { return Number(toIntN_unchecked(32, x, true)); }
+export function toUInt32_unchecked(x) { return Number(toIntN_unchecked(32, x, false)); }
+export function toInt64_unchecked(x) { return toIntN_unchecked(64, x, true); }
+export function toUInt64_unchecked(x) { return toIntN_unchecked(64, x, false); }
+export function toInt128_unchecked(x) { return toIntN_unchecked(128, x, true); }
+export function toUInt128_unchecked(x) { return toIntN_unchecked(128, x, false); }
+export function toNativeInt_unchecked(x) { return toIntN_unchecked(64, x, true); }
+export function toUNativeInt_unchecked(x) { return toIntN_unchecked(64, x, false); }
+export function toFloat16(x) { return Number(x); }
+export function toFloat32(x) { return Number(x); }
+export function toFloat64(x) { return Number(x); }
+export function toDecimal(x) {
+    const isNegative = x < zero;
+    const bits = abs(x);
+    const low = Number(BigInt.asUintN(32, bits));
+    const mid = Number(BigInt.asUintN(32, bits >> 32n));
+    const high = Number(BigInt.asUintN(32, bits >> 64n));
+    const scale = 0;
+    return fromParts(low, mid, high, isNegative, scale);
+}
+export function toBigInt(x) { return x; }
+export function toBoolean(x) { return x !== zero; }
+export function toChar(x) {
+    return String.fromCharCode(toUInt16(x));
+}
+export function toString(x) { return x.toString(); }
+export function tryParse(s, res) {
+    try {
+        res.contents = BigInt(s);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+export function parse(s) {
+    return BigInt(s);
+}
+export function pow(x, n) {
+    return x ** BigInt(n);
+}
+export function modPow(x, e, m) {
+    return (x ** e) % m;
+}
+export function divRem(x, y, out) {
+    const div = x / y;
+    const rem = x % y;
+    if (out === void 0) {
+        return [div, rem];
+    }
+    else {
+        out.contents = rem;
+        return div;
+    }
+}
+export function greatestCommonDivisor(x, y) {
+    while (y > zero) {
+        const q = x / y;
+        const r = x - q * y;
+        x = y;
+        y = r;
+    }
+    return x;
+}
+export function getBitLength(x) {
+    return fromFloat64(x === zero ? 1 : log2(abs(x)) + 1);
+}
+export function log2(x) {
+    const n = Number(x);
+    if (Number.isFinite(n))
+        return Math.log2(n); // fast path
+    if (x < zero)
+        return Number.NaN;
+    let shift = one;
+    while (x >= (one << shift)) {
+        shift = shift << one;
+    }
+    let log = zero;
+    while (shift > one) {
+        shift = shift >> one;
+        if (x >= (one << shift)) {
+            log = log + shift;
+            x = x >> shift;
+        }
+    }
+    return Number(log);
+}
+export function log10(x) {
+    return log2(x) * Math.log10(2);
+}
+export function ln(x) {
+    return log2(x) * Math.log(2);
+}
+export function log(x, base) {
+    return log2(x) / Math.log2(base);
+}
+export function ilog2(x) {
+    return BigInt(log2(x));
+}
+// export function copySign
+// export function createChecked
+// export function createSaturating
+// export function createTruncating
+// export function getByteCount
+// export function leadingZeroCount
+// export function popCount
+// export function rotateLeft
+// export function rotateRight
+// export function trailingZeroCount
+// export function tryFormat
+// export function tryWriteBytes
+// -------------------------------------------------
+// Binary serialization
+// -------------------------------------------------
+const hexCodes = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102]);
+function fromHexCode(code) {
+    if (48 <= code && code <= 57)
+        return code - 48;
+    if (97 <= code && code <= 102)
+        return code - 97 + 10;
+    if (65 <= code && code <= 70)
+        return code - 65 + 10;
+    throw Error(`Invalid hex code: ${code}`);
+}
+function toSignedBytes(x, isBigEndian) {
+    const isNeg = x < 0n;
+    if (isNeg) {
+        const len = log2(-x);
+        const bits = len + (8 - len % 8);
+        const pow2 = (1n << BigInt(bits));
+        x = x + pow2; // two's complement
+    }
+    const hex = x.toString(16);
+    const len = hex.length;
+    const odd = len % 2;
+    const first = hex.charCodeAt(0);
+    const isLow = 48 <= first && first <= 55; // 0..7
+    const start = (isNeg && isLow) || (!isNeg && !isLow) ? 1 : 0;
+    const bytes = new Uint8Array(start + (len + odd) / 2);
+    const inc = isBigEndian ? 1 : -1;
+    let pos = isBigEndian ? 0 : bytes.length - 1;
+    if (start > 0) {
+        bytes[pos] = isNeg ? 255 : 0;
+        pos += inc;
+    }
+    if (odd > 0) {
+        bytes[pos] = fromHexCode(first);
+        pos += inc;
+    }
+    for (let i = odd; i < len; i += 2, pos += inc) {
+        const a = fromHexCode(hex.charCodeAt(i));
+        const b = fromHexCode(hex.charCodeAt(i + 1));
+        bytes[pos] = (a << 4) | b;
+    }
+    return bytes;
+}
+function fromSignedBytes(bytes, isBigEndian) {
+    if (bytes == null) {
+        throw new Exception("bytes is null");
+    }
+    const len = bytes.length;
+    const first = isBigEndian ? 0 : len - 1;
+    const isNeg = bytes[first] > 127;
+    const codes = new Uint16Array(len * 2 + 2);
+    codes[0] = 48; // 0
+    codes[1] = 120; // x
+    const inc = isBigEndian ? 1 : -1;
+    let pos = isBigEndian ? 0 : len - 1;
+    for (let i = 0; i < bytes.length; i++, pos += inc) {
+        const byte = bytes[pos];
+        codes[2 * i + 2] = hexCodes[byte >> 4];
+        codes[2 * i + 3] = hexCodes[byte & 15];
+    }
+    const str = String.fromCharCode.apply(null, codes);
+    let x = BigInt(str);
+    if (isNeg) {
+        const bits = len * 8;
+        const pow2 = (1n << BigInt(bits));
+        x = x - pow2; // two's complement
+    }
+    return x;
+}