@magnusopera/fscript 0.75.0

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

@@ -0,0 +1,75 @@
+export const symbol = Symbol("numeric");
+export function isNumeric(x) {
+    return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
+}
+export function isIntegral(x) {
+    // Not perfect, because in JS we can't distinguish between 1.0 and 1
+    return typeof x === "number" && Number.isInteger(x) || typeof x === "bigint";
+}
+export function compare(x, y) {
+    if (typeof x === "number") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    }
+    else if (typeof x === "bigint") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    }
+    else {
+        return x.CompareTo(y);
+    }
+}
+export function multiply(x, y) {
+    if (typeof x === "number") {
+        return x * y;
+    }
+    else if (typeof x === "bigint") {
+        return x * BigInt(y);
+    }
+    else {
+        return x[symbol]().multiply(y);
+    }
+}
+export function toFixed(x, dp) {
+    if (typeof x === "number") {
+        return x.toFixed(dp);
+    }
+    else if (typeof x === "bigint") {
+        return x.toString();
+    }
+    else {
+        return x[symbol]().toFixed(dp);
+    }
+}
+export function toPrecision(x, sd) {
+    if (typeof x === "number") {
+        return x.toPrecision(sd);
+    }
+    else if (typeof x === "bigint") {
+        return x.toString();
+    }
+    else {
+        return x[symbol]().toPrecision(sd);
+    }
+}
+export function toExponential(x, dp) {
+    if (typeof x === "number") {
+        return x.toExponential(dp);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toExponential(dp);
+    }
+}
+export function toHex(x) {
+    if (typeof x === "number") {
+        return (Number(x) >>> 0).toString(16);
+    }
+    else if (typeof x === "bigint") {
+        // TODO: properly handle other bit sizes
+        return BigInt.asUintN(64, x).toString(16);
+    }
+    else {
+        return x[symbol]().toHex();
+    }
+}

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

@@ -0,0 +1,113 @@
+import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+import { value } from "./Option.js";
+export class Observer {
+    constructor(onNext, onError, onCompleted) {
+        this.OnNext = onNext;
+        this.OnError = onError || ((_e) => { return; });
+        this.OnCompleted = onCompleted || (() => { return; });
+    }
+}
+class Observable {
+    constructor(subscribe) {
+        this.Subscribe = subscribe;
+    }
+}
+function protect(f, succeed, fail) {
+    try {
+        return succeed(f());
+    }
+    catch (e) {
+        fail(e);
+    }
+}
+export function add(callback, source) {
+    source.Subscribe(new Observer(callback));
+}
+export function choose(chooser, source) {
+    return new Observable((observer) => source.Subscribe(new Observer((t) => protect(() => chooser(t), (u) => { if (u != null) {
+        observer.OnNext(value(u));
+    } }, observer.OnError), observer.OnError, observer.OnCompleted)));
+}
+export function filter(predicate, source) {
+    return choose((x) => predicate(x) ? x : void 0, source);
+}
+export function map(mapping, source) {
+    return new Observable((observer) => source.Subscribe(new Observer((t) => {
+        protect(() => mapping(t), observer.OnNext, observer.OnError);
+    }, observer.OnError, observer.OnCompleted)));
+}
+export function merge(source1, source2) {
+    return new Observable((observer) => {
+        let stopped = false;
+        let completed1 = false;
+        let completed2 = false;
+        const h1 = source1.Subscribe(new Observer((v) => { if (!stopped) {
+            observer.OnNext(v);
+        } }, (e) => {
+            if (!stopped) {
+                stopped = true;
+                observer.OnError(e);
+            }
+        }, () => {
+            if (!stopped) {
+                completed1 = true;
+                if (completed2) {
+                    stopped = true;
+                    observer.OnCompleted();
+                }
+            }
+        }));
+        const h2 = source2.Subscribe(new Observer((v) => { if (!stopped) {
+            observer.OnNext(v);
+        } }, (e) => {
+            if (!stopped) {
+                stopped = true;
+                observer.OnError(e);
+            }
+        }, () => {
+            if (!stopped) {
+                completed2 = true;
+                if (completed1) {
+                    stopped = true;
+                    observer.OnCompleted();
+                }
+            }
+        }));
+        return {
+            Dispose() {
+                h1.Dispose();
+                h2.Dispose();
+            },
+        };
+    });
+}
+export function pairwise(source) {
+    return new Observable((observer) => {
+        let last;
+        return source.Subscribe(new Observer((next) => {
+            if (last != null) {
+                observer.OnNext([last, next]);
+            }
+            last = next;
+        }, observer.OnError, observer.OnCompleted));
+    });
+}
+export function partition(predicate, source) {
+    return [filter(predicate, source), filter((x) => !predicate(x), source)];
+}
+export function scan(collector, state, source) {
+    return new Observable((observer) => {
+        return source.Subscribe(new Observer((t) => {
+            protect(() => collector(state, t), (u) => { state = u; observer.OnNext(u); }, observer.OnError);
+        }, observer.OnError, observer.OnCompleted));
+    });
+}
+export function split(splitter, source) {
+    return [
+        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), source),
+        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), source)
+    ];
+}
+export function subscribe(callback, source) {
+    return source.Subscribe(new Observer(callback));
+}

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

@@ -0,0 +1,104 @@
+import { Exception, structuralHash, equals, compare } from "./Util.js";
+// Using a class here for better compatibility with TS files importing Some
+export class Some {
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+    // Don't add "Some" for consistency with erased options
+    toString() {
+        return String(this.value);
+    }
+    GetHashCode() {
+        return structuralHash(this.value);
+    }
+    Equals(other) {
+        if (other == null) {
+            return false;
+        }
+        else {
+            return equals(this.value, other instanceof Some ? other.value : other);
+        }
+    }
+    CompareTo(other) {
+        if (other == null) {
+            return 1;
+        }
+        else {
+            return compare(this.value, other instanceof Some ? other.value : other);
+        }
+    }
+}
+export function nonNullValue(x) {
+    if (x == null) {
+        throw new Exception("Nullable has no value");
+    }
+    else {
+        return x;
+    }
+}
+export function value(x) {
+    if (x == null) {
+        throw new Exception("Option has no value");
+    }
+    else {
+        return x instanceof Some ? x.value : x;
+    }
+}
+export function unwrap(opt) {
+    return opt instanceof Some ? opt.value : opt;
+}
+export function some(x) {
+    return x == null || x instanceof Some ? new Some(x) : x;
+}
+export function ofNullable(x) {
+    // This will fail with unit probably, an alternative would be:
+    // return x === null ? undefined : (x === undefined ? new Some(x) : x);
+    return x == null ? undefined : x;
+}
+export function toNullable(x) {
+    return x == null ? null : value(x);
+}
+export function flatten(x) {
+    return x == null ? undefined : value(x);
+}
+export function toArray(opt) {
+    return (opt == null) ? [] : [value(opt)];
+}
+export function defaultArg(opt, defaultValue) {
+    return (opt != null) ? value(opt) : defaultValue;
+}
+export function defaultArgWith(opt, defThunk) {
+    return (opt != null) ? value(opt) : defThunk();
+}
+export function orElse(opt, ifNone) {
+    return opt == null ? ifNone : opt;
+}
+export function orElseWith(opt, ifNoneThunk) {
+    return opt == null ? ifNoneThunk() : opt;
+}
+export function filter(predicate, opt) {
+    return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;
+}
+export function map(mapping, opt) {
+    return (opt != null) ? some(mapping(value(opt))) : undefined;
+}
+export function map2(mapping, opt1, opt2) {
+    return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;
+}
+export function map3(mapping, opt1, opt2, opt3) {
+    return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;
+}
+export function bind(binder, opt) {
+    return opt != null ? binder(value(opt)) : undefined;
+}
+export function tryOp(op, arg) {
+    try {
+        return some(op(arg));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/fable_modules/fable-library-js.5.2.0/README.md

@@ -0,0 +1,3 @@
+# fable-library
+
+Core library used by F# projects compiled with [Fable](https://fable.io).

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

@@ -0,0 +1,172 @@
+import { ArgumentNullException_$ctor_Z721C83C5, ArgumentOutOfRangeException_$ctor_Z721C83C5 } from "./System.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
+import { class_type } from "./Reflection.js";
+import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, fromInt32, toInt64_unchecked } from "./BigInt.js";
+import { item, setItem } from "./Array.js";
+function Native_random() {
+    return Math.random();
+}
+function Native_randomNext(minValue, maxValue) {
+    if (maxValue < minValue) {
+        throw ArgumentOutOfRangeException_$ctor_Z721C83C5("minValue must be less than maxValue");
+    }
+    return Math.floor(Math.random() * (maxValue - minValue)) + minValue;
+}
+function Native_randomBytes(buffer) {
+    if (Operators_IsNull(buffer)) {
+        throw ArgumentNullException_$ctor_Z721C83C5("buffer");
+    }
+    for (let i = 0; i < buffer.length; i += 6) {
+        // Pick random 48-bit number. Fill buffer in 2 24-bit chunks to avoid bitwise truncation.
+        let r = Math.floor(Math.random() * 281474976710656); // Low 24 bits = chunk 1.
+        const rhi = Math.floor(r / 16777216); // High 24 bits shifted via division = chunk 2.
+        for (let j = 0; j < 6 && i + j < buffer.length; j++) {
+            if (j === 3) {
+                r = rhi;
+            }
+            buffer[i + j] = r & 255;
+            r >>>= 8;
+        }
+    }
+    ;
+}
+export class NonSeeded {
+    constructor() {
+    }
+    Next0() {
+        return Native_randomNext(0, 2147483647) | 0;
+    }
+    Next1(maxValue) {
+        return Native_randomNext(0, maxValue) | 0;
+    }
+    Next2(minValue, maxValue) {
+        return Native_randomNext(minValue, maxValue) | 0;
+    }
+    NextDouble() {
+        return Native_random();
+    }
+    NextBytes(buffer) {
+        Native_randomBytes(buffer);
+    }
+}
+export function NonSeeded_$reflection() {
+    return class_type("Random.NonSeeded", undefined, NonSeeded);
+}
+export function NonSeeded_$ctor() {
+    return new NonSeeded();
+}
+export class Seeded {
+    constructor(seed) {
+        this.MBIG = 2147483647;
+        this.inext = 0;
+        this.inextp = 0;
+        this.seedArray = (new Int32Array(56));
+        let ii = 0;
+        let mj = 0;
+        let mk = 0;
+        const subtraction = ((seed === -2147483648) ? 2147483647 : Math.abs(seed)) | 0;
+        mj = ((161803398 - subtraction) | 0);
+        this.seedArray[55] = (mj | 0);
+        mk = 1;
+        for (let i = 1; i <= 54; i++) {
+            ii = (((21 * i) % 55) | 0);
+            this.seedArray[ii] = (mk | 0);
+            mk = ((mj - mk) | 0);
+            if (mk < 0) {
+                mk = ((mk + this.MBIG) | 0);
+            }
+            mj = (item(ii, this.seedArray) | 0);
+        }
+        for (let k = 1; k <= 4; k++) {
+            for (let i_1 = 1; i_1 <= 55; i_1++) {
+                this.seedArray[i_1] = ((item(i_1, this.seedArray) - item(1 + ((i_1 + 30) % 55), this.seedArray)) | 0);
+                if (item(i_1, this.seedArray) < 0) {
+                    this.seedArray[i_1] = ((item(i_1, this.seedArray) + this.MBIG) | 0);
+                }
+            }
+        }
+        this.inext = 0;
+        this.inextp = 21;
+    }
+    Next0() {
+        const this$ = this;
+        return Seeded__InternalSample(this$) | 0;
+    }
+    Next1(maxValue) {
+        const this$ = this;
+        if (maxValue < 0) {
+            throw ArgumentOutOfRangeException_$ctor_Z721C83C5("maxValue must be positive");
+        }
+        return ~~(Seeded__Sample(this$) * maxValue) | 0;
+    }
+    Next2(minValue, maxValue) {
+        const this$ = this;
+        if (minValue > maxValue) {
+            throw ArgumentOutOfRangeException_$ctor_Z721C83C5("minValue must be less than maxValue");
+        }
+        const range = toInt64_unchecked(fromInt32(maxValue - minValue));
+        return ((compare(range, toInt64_unchecked(fromInt32(2147483647))) <= 0) ? (~~(Seeded__Sample(this$) * toFloat64(range)) + minValue) : ~~toInt32_unchecked(toInt64_unchecked(op_Addition(toInt64_unchecked(fromFloat64(Seeded__GetSampleForLargeRange(this$) * toFloat64(range))), toInt64_unchecked(fromInt32(minValue)))))) | 0;
+    }
+    NextDouble() {
+        const this$ = this;
+        return Seeded__Sample(this$);
+    }
+    NextBytes(buffer) {
+        const this$ = this;
+        if (Operators_IsNull(buffer)) {
+            throw ArgumentNullException_$ctor_Z721C83C5("buffer");
+        }
+        for (let i = 0; i <= (buffer.length - 1); i++) {
+            setItem(buffer, i, (Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);
+        }
+    }
+}
+export function Seeded_$reflection() {
+    return class_type("Random.Seeded", undefined, Seeded);
+}
+export function Seeded_$ctor_Z524259A4(seed) {
+    return new Seeded(seed);
+}
+function Seeded__InternalSample(_) {
+    let retVal = 0;
+    let locINext = _.inext;
+    let locINextp = _.inextp;
+    locINext = ((locINext + 1) | 0);
+    if (locINext >= 56) {
+        locINext = 1;
+    }
+    locINextp = ((locINextp + 1) | 0);
+    if (locINextp >= 56) {
+        locINextp = 1;
+    }
+    retVal = ((item(locINext, _.seedArray) - item(locINextp, _.seedArray)) | 0);
+    if (retVal === _.MBIG) {
+        retVal = ((retVal - 1) | 0);
+    }
+    if (retVal < 0) {
+        retVal = ((retVal + _.MBIG) | 0);
+    }
+    _.seedArray[locINext] = (retVal | 0);
+    _.inext = (locINext | 0);
+    _.inextp = (locINextp | 0);
+    return retVal | 0;
+}
+export function Seeded__Sample(this$) {
+    return Seeded__InternalSample(this$) * (1 / this$.MBIG);
+}
+export function Seeded__GetSampleForLargeRange(this$) {
+    let result = Seeded__InternalSample(this$);
+    if ((Seeded__InternalSample(this$) % 2) === 0) {
+        result = -result;
+    }
+    let d = result;
+    d = (d + (2147483647 - 1));
+    d = (d / (2 * ((2147483647 - 1) >>> 0)));
+    return d;
+}
+export function nonSeeded() {
+    return NonSeeded_$ctor();
+}
+export function seeded(seed) {
+    return Seeded_$ctor_Z524259A4(seed);
+}

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

@@ -0,0 +1,45 @@
+import { Exception, compare } from "./Util.js";
+import { unfold, delay } from "./Seq.js";
+import { toUInt64_unchecked, toInt64_unchecked, op_Addition, fromZero } from "./BigInt.js";
+import { op_Addition as op_Addition_1, fromParts } from "./Decimal.js";
+export function makeRangeStepFunction(step, stop, zero, add) {
+    const stepComparedWithZero = compare(step, zero) | 0;
+    if (stepComparedWithZero === 0) {
+        throw new Exception("The step of a range cannot be zero");
+    }
+    const stepGreaterThanZero = stepComparedWithZero > 0;
+    return (x) => {
+        const comparedWithLast = compare(x, stop) | 0;
+        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? [x, add(x, step)] : undefined;
+    };
+}
+export function integralRangeStep(start, step, stop, zero, add) {
+    const stepFn = makeRangeStepFunction(step, stop, zero, add);
+    return delay(() => unfold(stepFn, start));
+}
+export function rangeBigInt(start, step, stop) {
+    return integralRangeStep(start, step, stop, fromZero(), op_Addition);
+}
+export function rangeDecimal(start, step, stop) {
+    return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition_1);
+}
+export function rangeDouble(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));
+}
+export function rangeInt64(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0n, (x, y) => toInt64_unchecked(op_Addition(x, y)));
+}
+export function rangeUInt64(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0n, (x, y) => toUInt64_unchecked(op_Addition(x, y)));
+}
+export function rangeChar(start, stop) {
+    const intStop = ~~stop.charCodeAt(0) | 0;
+    return delay(() => unfold((i) => {
+        if (i <= intStop) {
+            return [String.fromCharCode(i & 0xFFFF), i + 1];
+        }
+        else {
+            return undefined;
+        }
+    }, ~~start.charCodeAt(0)));
+}