@magnusopera/fscript 0.75.0

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

@@ -0,0 +1,47 @@
+import { getPrefix, isValid } from "./Int32.js";
+import { fromString } from "./BigInt.js";
+import { Exception } from "./Util.js";
+function getMaxValue(unsigned, radix, isNegative) {
+    switch (radix) {
+        case 2: return unsigned ?
+            "1111111111111111111111111111111111111111111111111111111111111111" :
+            (isNegative ? "1000000000000000000000000000000000000000000000000000000000000000"
+                : "111111111111111111111111111111111111111111111111111111111111111");
+        case 8: return unsigned ?
+            "1777777777777777777777" :
+            (isNegative ? "1000000000000000000000" : "777777777777777777777");
+        case 10: return unsigned ?
+            "18446744073709551615" :
+            (isNegative ? "9223372036854775808" : "9223372036854775807");
+        case 16: return unsigned ?
+            "FFFFFFFFFFFFFFFF" :
+            (isNegative ? "8000000000000000" : "7FFFFFFFFFFFFFFF");
+        default: throw new Exception("Invalid radix.");
+    }
+}
+export function parse(str, style, unsigned, _bitsize, radix) {
+    const res = isValid(str, style, radix);
+    if (res != null) {
+        const lessOrEqual = (x, y) => {
+            const len = Math.max(x.length, y.length);
+            return x.padStart(len, "0") <= y.padStart(len, "0");
+        };
+        const isNegative = res.sign === "-";
+        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);
+        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {
+            str = getPrefix(res.radix) + res.digits;
+            str = isNegative ? res.sign + str : str;
+            return fromString(str);
+        }
+    }
+    throw new Exception(`The input string ${str} was not in a correct format.`);
+}
+export function tryParse(str, style, unsigned, bitsize, defValue) {
+    try {
+        defValue.contents = parse(str, style, unsigned, bitsize);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,94 @@
+import { defaultCancellationToken } from "./Async.js";
+import { fromContinuations } from "./Async.js";
+import { startImmediate } from "./Async.js";
+import { Exception } from "./Util.js";
+class QueueCell {
+    constructor(message) {
+        this.value = message;
+    }
+}
+class MailboxQueue {
+    add(message) {
+        const itCell = new QueueCell(message);
+        if (this.firstAndLast) {
+            this.firstAndLast[1].next = itCell;
+            this.firstAndLast = [this.firstAndLast[0], itCell];
+        }
+        else {
+            this.firstAndLast = [itCell, itCell];
+        }
+    }
+    tryGet() {
+        if (this.firstAndLast) {
+            const value = this.firstAndLast[0].value;
+            if (this.firstAndLast[0].next) {
+                this.firstAndLast = [this.firstAndLast[0].next, this.firstAndLast[1]];
+            }
+            else {
+                delete this.firstAndLast;
+            }
+            return value;
+        }
+        return void 0;
+    }
+}
+export class MailboxProcessor {
+    constructor(body, cancellationToken) {
+        this.body = body;
+        this.cancellationToken = cancellationToken || defaultCancellationToken;
+        this.messages = new MailboxQueue();
+    }
+}
+function __processEvents($this) {
+    if ($this.continuation) {
+        const value = $this.messages.tryGet();
+        if (value) {
+            const cont = $this.continuation;
+            delete $this.continuation;
+            cont(value);
+        }
+    }
+}
+export function startInstance($this) {
+    startImmediate($this.body($this), $this.cancellationToken);
+}
+export function receive($this) {
+    return fromContinuations((conts) => {
+        if ($this.continuation) {
+            throw new Exception("Receive can only be called once!");
+        }
+        $this.continuation = conts[0];
+        __processEvents($this);
+    });
+}
+export function post($this, message) {
+    $this.messages.add(message);
+    __processEvents($this);
+}
+export function postAndAsyncReply($this, buildMessage) {
+    let result;
+    let continuation;
+    function checkCompletion() {
+        if (result !== void 0 && continuation !== void 0) {
+            continuation(result);
+        }
+    }
+    const reply = {
+        reply: (res) => {
+            result = res;
+            checkCompletion();
+        },
+    };
+    $this.messages.add(buildMessage(reply));
+    __processEvents($this);
+    return fromContinuations((conts) => {
+        continuation = conts[0];
+        checkCompletion();
+    });
+}
+export function start(body, cancellationToken) {
+    const mbox = new MailboxProcessor(body, cancellationToken);
+    startInstance(mbox);
+    return mbox;
+}
+export default MailboxProcessor;