@magnusopera/fscript 0.75.0

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

@@ -0,0 +1,185 @@
+const littleEndian = true;
+function utf16le_encode(str) {
+    const bytes = new Uint8Array(str.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        view.setUint16(i * 2, code, littleEndian);
+    }
+    return bytes;
+}
+function utf16le_decode(bytes) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    const chars = new Array(view.byteLength / 2);
+    for (let i = 0; i < chars.length; i++) {
+        const code = view.getUint16(i * 2, littleEndian);
+        chars[i] = String.fromCharCode(code);
+    }
+    return chars.join("");
+}
+function utf8_encode(str) {
+    let pos = 0;
+    let buf = new Uint8Array(str.length * 3);
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+        if (code >= 0xD800 && code <= 0xDBFF) {
+            const nextCode = (i < str.length) ? str.charCodeAt(i + 1) : 0;
+            if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
+                i += 1;
+                code = (code - 0xD800) * 0x400 + nextCode - 0xDC00 + 0x10000;
+                if (code > 0xFFFF) {
+                    buf[pos++] = (0x1E << 3) | (code >>> 18);
+                    buf[pos++] = (0x2 << 6) | ((code >>> 12) & 0x3F);
+                    buf[pos++] = (0x2 << 6) | ((code >>> 6) & 0x3F);
+                    buf[pos++] = (0x2 << 6) | (code & 0x3F);
+                }
+            }
+            else {
+                buf[pos++] = 0xEF;
+                buf[pos++] = 0xBF;
+                buf[pos++] = 0xBD;
+            }
+        }
+        else if (code <= 0x007F) {
+            buf[pos++] = (0x0 << 7) | code;
+        }
+        else if (code <= 0x07FF) {
+            buf[pos++] = (0x6 << 5) | (code >>> 6);
+            buf[pos++] = (0x2 << 6) | (code & 0x3F);
+        }
+        else {
+            buf[pos++] = (0xE << 4) | (code >>> 12);
+            buf[pos++] = (0x2 << 6) | ((code >>> 6) & 0x3F);
+            buf[pos++] = (0x2 << 6) | (code & 0x3F);
+        }
+    }
+    buf = new Uint8Array(buf.buffer.slice(0, pos));
+    return buf;
+}
+function utf8_decode(bytes) {
+    let pos = 0;
+    const decodeUtf8 = () => {
+        const i1 = bytes[pos++];
+        if ((i1 & 0x80) === 0) {
+            return i1;
+        }
+        else if ((i1 & 0xE0) === 0xC0) {
+            const i2 = bytes[pos++];
+            return ((i1 & 0x1F) << 6) | (i2 & 0x3F);
+        }
+        else if ((i1 & 0xF0) === 0xE0) {
+            const i2 = bytes[pos++];
+            const i3 = bytes[pos++];
+            return ((i1 & 0x0F) << 12) | ((i2 & 0x3F) << 6) | (i3 & 0x3F);
+        }
+        else if ((i1 & 0xF8) === 0xF0) {
+            const i2 = bytes[pos++];
+            const i3 = bytes[pos++];
+            const i4 = bytes[pos++];
+            return ((i1 & 0x07) << 18) | ((i2 & 0x3F) << 12) | ((i3 & 0x3F) << 6) | (i4 & 0x3F);
+        }
+        else {
+            throw new RangeError("Invalid UTF8 byte: " + i1);
+        }
+    };
+    const chars = new Array();
+    while (pos < bytes.length) {
+        const code = decodeUtf8();
+        chars.push(String.fromCodePoint(code));
+    }
+    return chars.join("");
+}
+class UTF16LE {
+    getBytes(str, index, count) {
+        str = Array.isArray(str) ? str.join("") : str;
+        if (index != null && count != null) {
+            str = str.substring(index, index + count);
+        }
+        else if (index != null) {
+            str = str.substring(index);
+        }
+        // Allow to compile for Browser environment without @types/node being installed
+        // See https://github.com/fable-compiler/Fable/issues/4368
+        const g = globalThis;
+        if (typeof g.Buffer !== "undefined") {
+            const bytes = g.Buffer.from(str, "utf16le");
+            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        }
+        else {
+            return utf16le_encode(str); // polyfill
+        }
+    }
+    getString(bytes, index, count) {
+        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        if (index != null && count != null) {
+            buffer = buffer.subarray(index, index + count);
+        }
+        else if (index != null) {
+            buffer = buffer.subarray(index);
+        }
+        // Allow to compile for Browser environment without @types/node being installed
+        // See https://github.com/fable-compiler/Fable/issues/4368
+        const g = globalThis;
+        if (typeof TextDecoder !== "undefined") {
+            return new TextDecoder("utf-16le").decode(buffer);
+        }
+        else if (typeof g.Buffer !== "undefined") {
+            return g.Buffer.from(buffer).toString("utf16le");
+        }
+        else {
+            return utf16le_decode(buffer); // polyfill
+        }
+    }
+}
+class UTF8 {
+    getBytes(str, index, count) {
+        str = Array.isArray(str) ? str.join("") : str;
+        if (index != null && count != null) {
+            str = str.substring(index, index + count);
+        }
+        else if (index != null) {
+            str = str.substring(index);
+        }
+        // Allow to compile for Browser environment without @types/node being installed
+        // See https://github.com/fable-compiler/Fable/issues/4368
+        const g = globalThis;
+        if (typeof TextEncoder !== "undefined") {
+            return new TextEncoder().encode(str);
+        }
+        else if (typeof g.Buffer !== "undefined") {
+            const bytes = g.Buffer.from(str, "utf8");
+            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        }
+        else {
+            return utf8_encode(str); // polyfill
+        }
+    }
+    getString(bytes, index, count) {
+        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        if (index != null && count != null) {
+            buffer = buffer.subarray(index, index + count);
+        }
+        else if (index != null) {
+            buffer = buffer.subarray(index);
+        }
+        // Allow to compile for Browser environment without @types/node being installed
+        // See https://github.com/fable-compiler/Fable/issues/4368
+        const g = globalThis;
+        if (typeof TextDecoder !== "undefined") {
+            return new TextDecoder().decode(buffer);
+        }
+        else if (typeof g.Buffer !== "undefined") {
+            return g.Buffer.from(buffer).toString("utf8");
+        }
+        else {
+            return utf8_decode(buffer); // polyfill
+        }
+    }
+}
+const _UTF16 = new UTF16LE();
+const _UTF8 = new UTF8();
+export function get_Unicode() { return _UTF16; }
+export function get_UTF8() { return _UTF8; }

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

@@ -0,0 +1,93 @@
+import { subscribe } from "./Observable.js";
+import { some, value } from "./Option.js";
+import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+export class Event$2 {
+    constructor() {
+        this.delegates = [];
+    }
+    _add(d) {
+        this.delegates.push(d);
+    }
+    _remove(d) {
+        const index = this.delegates.indexOf(d);
+        if (index > -1) {
+            this.delegates.splice(index, 1);
+        }
+    }
+    get Publish() {
+        return createEvent(h => { this._add(h); }, h => { this._remove(h); });
+    }
+    Trigger(senderOrValue, valueOrUndefined) {
+        let sender = null;
+        const value = valueOrUndefined === undefined ? senderOrValue : (sender = senderOrValue, valueOrUndefined);
+        this.delegates.forEach(f => { f(sender, value); });
+    }
+}
+export class Event extends Event$2 {
+}
+export function add(callback, sourceEvent) {
+    subscribe(callback, sourceEvent);
+}
+export function choose(chooser, sourceEvent) {
+    const ev = new Event();
+    add((t) => {
+        const u = chooser(t);
+        if (u != null) {
+            ev.Trigger(value(u));
+        }
+    }, sourceEvent);
+    return ev.Publish;
+}
+export function filter(predicate, sourceEvent) {
+    return choose((x) => predicate(x) ? some(x) : undefined, sourceEvent);
+}
+export function map(mapping, sourceEvent) {
+    const ev = new Event();
+    add((t) => ev.Trigger(mapping(t)), sourceEvent);
+    return ev.Publish;
+}
+export function merge(event1, event2) {
+    const ev = new Event();
+    const fn = (x) => ev.Trigger(x);
+    add(fn, event1);
+    add(fn, event2);
+    return ev.Publish;
+}
+export function pairwise(sourceEvent) {
+    const ev = new Event();
+    let last;
+    let haveLast = false;
+    add((next) => {
+        if (haveLast) {
+            ev.Trigger([last, next]);
+        }
+        last = next;
+        haveLast = true;
+    }, sourceEvent);
+    return ev.Publish;
+}
+export function partition(predicate, sourceEvent) {
+    return [filter(predicate, sourceEvent), filter((x) => !predicate(x), sourceEvent)];
+}
+export function scan(collector, state, sourceEvent) {
+    return map((t) => state = collector(state, t), sourceEvent);
+}
+export function split(splitter, sourceEvent) {
+    return [
+        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), sourceEvent),
+        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), sourceEvent),
+    ];
+}
+export function createEvent(addHandler, removeHandler) {
+    return {
+        AddHandler(h) { addHandler(h); },
+        RemoveHandler(h) { removeHandler(h); },
+        Subscribe(r) {
+            const h = ((_, args) => r.OnNext(args));
+            addHandler(h);
+            return {
+                Dispose() { removeHandler(h); }
+            };
+        }
+    };
+}

package/dist/fable_modules/fable-library-js.5.2.0/FSharp.Collections.js

@@ -0,0 +1,45 @@
+import { compare, physicalHash, equals as equals_1, structuralHash } from "./Util.js";
+export function HashIdentity_FromFunctions(hasher, equals) {
+    return {
+        GetHashCode(x) {
+            return hasher(x) | 0;
+        },
+        Equals(x_1, y) {
+            return (x_1 == null) ? (y == null) : ((y == null) ? false : equals(x_1, y));
+        },
+    };
+}
+export function HashIdentity_Structural() {
+    return {
+        GetHashCode(x) {
+            return structuralHash(x) | 0;
+        },
+        Equals(x_1, y) {
+            return equals_1(x_1, y);
+        },
+    };
+}
+export function HashIdentity_Reference() {
+    return {
+        GetHashCode(x) {
+            return physicalHash(x) | 0;
+        },
+        Equals(x_1, y) {
+            return equals_1(x_1, y);
+        },
+    };
+}
+export function ComparisonIdentity_FromFunction(comparer) {
+    return {
+        Compare(x, y) {
+            return ((x == null) ? ((y == null) ? 0 : -1) : ((y == null) ? 1 : comparer(x, y))) | 0;
+        },
+    };
+}
+export function ComparisonIdentity_Structural() {
+    return {
+        Compare(x, y) {
+            return compare(x, y) | 0;
+        },
+    };
+}

package/dist/fable_modules/fable-library-js.5.2.0/FSharp.Core.CompilerServices.js

@@ -0,0 +1,27 @@
+import { class_type } from "./Reflection.js";
+import { addRangeInPlace } from "./Array.js";
+import { toList } from "./Seq.js";
+export class ListCollector$1 {
+    constructor() {
+        this.collector = [];
+    }
+}
+export function ListCollector$1_$reflection(gen0) {
+    return class_type("Microsoft.FSharp.Core.CompilerServices.ListCollector`1", [gen0], ListCollector$1);
+}
+export function ListCollector$1_$ctor() {
+    return new ListCollector$1();
+}
+export function ListCollector$1__Add_2B595(this$, value) {
+    void (this$.collector.push(value));
+}
+export function ListCollector$1__AddMany_BB573A(this$, values) {
+    addRangeInPlace(values, this$.collector);
+}
+export function ListCollector$1__AddManyAndClose_BB573A(this$, values) {
+    addRangeInPlace(values, this$.collector);
+    return toList(this$.collector);
+}
+export function ListCollector$1__Close(this$) {
+    return toList(this$.collector);
+}

package/dist/fable_modules/fable-library-js.5.2.0/FSharp.Core.js

@@ -0,0 +1,156 @@
+import { disposeSafe, defaultOf, Exception, structuralHash, equals } from "./Util.js";
+import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
+import { nonNullValue } from "./Option.js";
+import { NullReferenceException_$ctor, ArgumentNullException_$ctor_Z721C83C5 } from "./System.js";
+import { FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
+import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
+export const LanguagePrimitives_GenericEqualityComparer = {
+    Equals(x, y) {
+        return equals(x, y);
+    },
+    GetHashCode(x_1) {
+        return structuralHash(x_1) | 0;
+    },
+};
+export const LanguagePrimitives_GenericEqualityERComparer = {
+    Equals(x, y) {
+        return equals(x, y);
+    },
+    GetHashCode(x_1) {
+        return structuralHash(x_1) | 0;
+    },
+};
+export function LanguagePrimitives_FastGenericComparer() {
+    return ComparisonIdentity_Structural();
+}
+export function LanguagePrimitives_FastGenericComparerFromTable() {
+    return ComparisonIdentity_Structural();
+}
+export function LanguagePrimitives_FastGenericEqualityComparer() {
+    return HashIdentity_Structural();
+}
+export function LanguagePrimitives_FastGenericEqualityComparerFromTable() {
+    return HashIdentity_Structural();
+}
+export function Operators_Failure(message) {
+    return new Exception(message);
+}
+export function Operators_FailurePattern(exn) {
+    return exn.message;
+}
+export function Operators_NullArg(argumentName) {
+    throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
+}
+export function Operators_Using(resource, action) {
+    try {
+        return action(resource);
+    }
+    finally {
+        if (equals(resource, defaultOf())) {
+        }
+        else {
+            let copyOfStruct = resource;
+            disposeSafe(copyOfStruct);
+        }
+    }
+}
+export function Operators_Lock(_lockObj, action) {
+    return action();
+}
+export function Operators_IsNull(value) {
+    if (equals(value, defaultOf())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Operators_IsNotNull(value) {
+    if (equals(value, defaultOf())) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function Operators_IsNullV(value) {
+    return !(value != null);
+}
+export function Operators_NonNull(value) {
+    if (equals(value, defaultOf())) {
+        throw NullReferenceException_$ctor();
+    }
+    else {
+        return value;
+    }
+}
+export function Operators_NonNullV(value) {
+    if (value != null) {
+        return nonNullValue(value);
+    }
+    else {
+        throw NullReferenceException_$ctor();
+    }
+}
+export function Operators_NullMatchPattern(value) {
+    if (equals(value, defaultOf())) {
+        return FSharpChoice$2_Choice1Of2(undefined);
+    }
+    else {
+        return FSharpChoice$2_Choice2Of2(value);
+    }
+}
+export function Operators_NullValueMatchPattern(value) {
+    if (value != null) {
+        return FSharpChoice$2_Choice2Of2(nonNullValue(value));
+    }
+    else {
+        return FSharpChoice$2_Choice1Of2(undefined);
+    }
+}
+export function Operators_NonNullQuickPattern(value) {
+    if (equals(value, defaultOf())) {
+        throw NullReferenceException_$ctor();
+    }
+    else {
+        return value;
+    }
+}
+export function Operators_NonNullQuickValuePattern(value) {
+    if (value != null) {
+        return nonNullValue(value);
+    }
+    else {
+        throw NullReferenceException_$ctor();
+    }
+}
+export function Operators_WithNull(value) {
+    return value;
+}
+export function Operators_WithNullV(value) {
+    return value;
+}
+export function Operators_NullV() {
+    return null;
+}
+export function Operators_NullArgCheck(argumentName, value) {
+    if (equals(value, defaultOf())) {
+        throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
+    }
+    else {
+        return value;
+    }
+}
+export function ExtraTopLevelOperators_LazyPattern(input) {
+    return input.Value;
+}
+export function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {
+    return format.cont((s) => {
+        StringBuilder__Append_Z721C83C5(builder, s);
+        return continuation();
+    });
+}
+export function PrintfModule_PrintFormatToStringBuilder(builder, format) {
+    return PrintfModule_PrintFormatToStringBuilderThen(() => {
+    }, builder, format);
+}

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

@@ -0,0 +1,29 @@
+export const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
+export const SR_inputWasEmpty = "Collection was empty.";
+export const SR_inputMustBeNonNegative = "The input must be non-negative.";
+export const SR_inputSequenceEmpty = "The input sequence was empty.";
+export const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+export const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+export const SR_differentLengths = "The collections had different lengths.";
+export const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
+export const SR_Arg_ApplicationException = "Error in the application.";
+export const SR_Arg_ArgumentException = "Value does not fall within the expected range.";
+export const SR_Arg_ArgumentOutOfRangeException = "Specified argument was out of the range of valid values.";
+export const SR_ArgumentNull_Generic = "Value cannot be null.";
+export const SR_Arg_ParamName_Name = " (Parameter \'";
+export const SR_Arg_ArithmeticException = "Overflow or underflow in the arithmetic operation.";
+export const SR_Arg_DivideByZero = "Attempted to divide by zero.";
+export const SR_Arg_FormatException = "One of the identified items was in an invalid format.";
+export const SR_Arg_IndexOutOfRangeException = "Index was outside the bounds of the array.";
+export const SR_Arg_InvalidOperationException = "Operation is not valid due to the current state of the object.";
+export const SR_Arg_KeyNotFound = "The given key was not present in the dictionary.";
+export const SR_Arg_NotFiniteNumberException = "Number encountered was not a finite quantity.";
+export const SR_Arg_NotImplementedException = "The method or operation is not implemented.";
+export const SR_Arg_NotSupportedException = "Specified method is not supported.";
+export const SR_Arg_NullReferenceException = "Object reference not set to an instance of an object.";
+export const SR_Arg_OutOfMemoryException = "Insufficient memory to continue the execution of the program.";
+export const SR_Arg_OverflowException = "Arithmetic operation resulted in an overflow.";
+export const SR_Arg_RankException = "Attempted to operate on an array with the incorrect number of dimensions.";
+export const SR_Arg_StackOverflowException = "Operation caused a stack overflow.";
+export const SR_Arg_SystemException = "System error.";
+export const SR_Arg_TimeoutException = "The operation has timed out.";

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

@@ -0,0 +1,161 @@
+import { trim } from "./String.js";
+import { Exception } from "./Util.js";
+// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220
+// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+// Relax GUID parsing, see #1637
+const guidRegex = /^[\(\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\)\}]{0,2}$/;
+const guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;
+const guidRegexHex = /^\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\}\}$/;
+const guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;
+export function toString(str, format, _provider) {
+    if (format && format?.length > 0) {
+        switch (format) {
+            case "N":
+                return str.replace(/-/g, '');
+            case "D":
+                return str;
+            case "B":
+                return "{" + str + "}";
+            case "P":
+                return "(" + str + ")";
+            case "X":
+                return str.replace(guidHexCaptures, "{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}");
+            default:
+                throw new Exception("Unrecognized Guid print format");
+        }
+    }
+    else {
+        return str;
+    }
+}
+/** Validates UUID as specified in RFC4122 (versions 1-5). */
+export function parse(str) {
+    function hyphenateGuid(str) {
+        return str.replace(guidRegexNoHyphen, "$1-$2-$3-$4-$5");
+    }
+    const wsTrimAndLowered = str.trim().toLowerCase();
+    if (guidRegex.test(wsTrimAndLowered)) {
+        return trim(wsTrimAndLowered, "{", "}", "(", ")");
+    }
+    else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {
+        return hyphenateGuid(wsTrimAndLowered);
+    }
+    else if (guidRegexHex.test(wsTrimAndLowered)) {
+        return hyphenateGuid(wsTrimAndLowered.replace(/[\{\},]|0x/g, ''));
+    }
+    else {
+        throw new Exception("Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+    }
+}
+export function tryParse(str, defValue) {
+    try {
+        defValue.contents = parse(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function newGuid() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 1
+    const hex = Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+// RFC 9562 UUID v7
+export function createVersion7(timestamp) {
+    const ms = timestamp != null ? timestamp.getTime() : Date.now();
+    // 48-bit timestamp as hex
+    const msHex = Math.floor(ms).toString(16).padStart(12, "0");
+    // random bits
+    const bytes = new Uint8Array(10);
+    crypto.getRandomValues(bytes);
+    const view = new DataView(bytes.buffer);
+    const randA = view.getUint16(0) & 0x0fff; // 12 bits
+    const randB1 = view.getUint16(2) & 0x3fff; // 14 bits
+    const randB2 = view.getUint32(4); // 32 bits
+    const randB3 = view.getUint16(8); // 16 bits
+    const timeLow = msHex.slice(0, 8);
+    const timeMid = msHex.slice(8, 12);
+    const ver = (0x7000 | randA).toString(16).padStart(4, "0");
+    const variantAndRandB = (0x8000 | randB1).toString(16).padStart(4, "0");
+    const node = randB2.toString(16).padStart(8, "0") + randB3.toString(16).padStart(4, "0");
+    return `${timeLow}-${timeMid}-${ver}-${variantAndRandB}-${node}`;
+}
+// Maps for number <-> hex string conversion
+let _convertMapsInitialized = false;
+let _byteToHex;
+let _hexToByte;
+function initConvertMaps() {
+    _byteToHex = new Array(256);
+    _hexToByte = {};
+    for (let i = 0; i < 256; i++) {
+        _byteToHex[i] = i.toString(16).padStart(2, '0');
+        _hexToByte[_byteToHex[i]] = i;
+    }
+    _convertMapsInitialized = true;
+}
+/** Parse a UUID into it's component bytes */
+// Adapted from https://github.com/zefferus/uuid-parse
+export function guidToArray(s) {
+    if (!_convertMapsInitialized) {
+        initConvertMaps();
+    }
+    let i = 0;
+    const buf = new Uint8Array(16);
+    s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct) => {
+        switch (i) {
+            // .NET saves first three byte groups with different endianness
+            // See https://stackoverflow.com/a/16722909/3922220
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+                buf[3 - i++] = _hexToByte[oct];
+                break;
+            case 4:
+            case 5:
+                buf[9 - i++] = _hexToByte[oct];
+                break;
+            case 6:
+            case 7:
+                buf[13 - i++] = _hexToByte[oct];
+                break;
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+                buf[i++] = _hexToByte[oct];
+                break;
+        }
+    }));
+    // Zero out remaining bytes if string was short
+    while (i < 16) {
+        buf[i++] = 0;
+    }
+    return buf;
+}
+/** Convert UUID byte array into a string */
+export function arrayToGuid(buf) {
+    if (buf.length !== 16) {
+        throw new Exception("Byte array for GUID must be exactly 16 bytes long");
+    }
+    if (!_convertMapsInitialized) {
+        initConvertMaps();
+    }
+    const guid = _byteToHex[buf[3]] + _byteToHex[buf[2]] +
+        _byteToHex[buf[1]] + _byteToHex[buf[0]] + "-" +
+        _byteToHex[buf[5]] + _byteToHex[buf[4]] + "-" +
+        _byteToHex[buf[7]] + _byteToHex[buf[6]] + "-" +
+        _byteToHex[buf[8]] + _byteToHex[buf[9]] + "-" +
+        _byteToHex[buf[10]] + _byteToHex[buf[11]] +
+        _byteToHex[buf[12]] + _byteToHex[buf[13]] +
+        _byteToHex[buf[14]] + _byteToHex[buf[15]];
+    return guid;
+}