@nfdi4plants/arctrl 3.0.0-beta.5 → 3.0.0-beta.6

package/dist/ts/node_modules/@fable-org/fable-library-js/DateOffset.js

@@ -1,3 +1,7 @@
+import { toFloat64, fromFloat64 } from './BigInt.js';
+import { ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks, parseRaw, dateOffsetToString, DateTime, create as create$1, daysInMonth } from './Date.js';
+import { padWithZeros, compareDates } from './Util.js';
+
 /**
  * DateTimeOffset functions.
  *
@@ -15,7 +19,7 @@
 function DateTimeOffset(value, offset) {
     checkOffsetInRange(offset);
     const d = new Date(value);
-    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -6e4;
+    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;
     return d;
 }
 function offset(value) {
@@ -35,25 +39,233 @@ function fromDate(date, offset) {
     let offset2 = 0;
     switch (date.kind) {
         case 1 /* DateKind.UTC */:
+            if (offset != null && offset !== 0) {
+                throw new Error("The UTC Offset for Utc DateTime instances must be 0.");
+            }
             offset2 = 0;
             break;
         case 2 /* DateKind.Local */:
-            offset2 = date.getTimezoneOffset() * -6e4;
+            offset2 = date.getTimezoneOffset() * -60000;
+            if (offset != null && offset !== offset2) {
+                throw new Error("The UTC Offset of the local dateTime parameter does not match the offset argument.");
+            }
             break;
         case 0 /* DateKind.Unspecified */:
         default:
-            {
-                offset2 = date.getTimezoneOffset() * -6e4;
+            if (offset == null) {
+                offset2 = date.getTimezoneOffset() * -60000;
+            }
+            else {
+                offset2 = offset;
             }
             break;
     }
     return DateTimeOffset(date.getTime(), offset2);
 }
+function fromTicks(ticks, offset) {
+    const ms = ticksToUnixEpochMilliseconds(ticks) - offset;
+    return DateTimeOffset(ms, offset);
+}
+function fromUnixTimeMilliseconds(ms) {
+    return DateTimeOffset(toFloat64(ms), 0);
+}
+function fromUnixTimeSeconds(seconds) {
+    return DateTimeOffset(toFloat64(seconds * 1000n), 0);
+}
+function getUtcTicks(date) {
+    return unixEpochMillisecondsToTicks(date.getTime(), 0);
+}
+function minValue() {
+    // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
+    return DateTimeOffset(-62135596800000, 0);
+}
+function maxValue() {
+    // This is "9999-12-31T23:59:59.999Z", actual JS max value is 8640000000000000
+    return DateTimeOffset(253402300799999, 0);
+}
+function parse(str) {
+    const [date, offsetMatch] = parseRaw(str);
+    const offset = offsetMatch == null
+        ? date.getTimezoneOffset() * -60000
+        : (offsetMatch === "Z" ? 0 : offsetMatch * 60000);
+    return DateTimeOffset(date.getTime(), offset);
+}
+function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch (_err) {
+        return false;
+    }
+}
+function create(year, month, day, h, m, s, ms, offset) {
+    if (offset == null) {
+        offset = ms;
+        ms = 0;
+    }
+    checkOffsetInRange(offset);
+    let date;
+    if (offset === 0) {
+        date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));
+        if (year <= 99) {
+            date.setUTCFullYear(year, month - 1, day);
+        }
+    }
+    else {
+        const str = padWithZeros(year, 4) + "-" +
+            padWithZeros(month, 2) + "-" +
+            padWithZeros(day, 2) + "T" +
+            padWithZeros(h, 2) + ":" +
+            padWithZeros(m, 2) + ":" +
+            padWithZeros(s, 2) + "." +
+            padWithZeros(ms, 3) +
+            dateOffsetToString(offset);
+        date = new Date(str);
+    }
+    const dateValue = date.getTime();
+    if (isNaN(dateValue)) {
+        throw new Error("The parameters describe an unrepresentable Date");
+    }
+    return DateTimeOffset(dateValue, offset);
+}
+function now() {
+    const date = new Date();
+    const offset = date.getTimezoneOffset() * -60000;
+    return DateTimeOffset(date.getTime(), offset);
+}
+function utcNow() {
+    const date = now();
+    return DateTimeOffset(date.getTime(), 0);
+}
+function toUniversalTime(date) {
+    return DateTime(date.getTime(), 1 /* DateKind.UTC */);
+}
+function toLocalTime(date) {
+    return DateTime(date.getTime(), 2 /* DateKind.Local */);
+}
+function timeOfDay(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    return d2.getUTCHours() * 3600000
+        + d2.getUTCMinutes() * 60000
+        + d2.getUTCSeconds() * 1000
+        + d2.getUTCMilliseconds();
+}
+function date(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    return create$1(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);
+}
+function day(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCDate();
+}
+function hour(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCHours();
+}
+function millisecond(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMilliseconds();
+}
+function minute(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMinutes();
+}
+function month(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMonth() + 1;
+}
+function second(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCSeconds();
+}
+function year(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCFullYear();
+}
+function dayOfWeek(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCDay();
+}
+function dayOfYear(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    const _year = d2.getUTCFullYear();
+    const _month = d2.getUTCMonth() + 1;
+    let _day = d2.getUTCDate();
+    for (let i = 1; i < _month; i++) {
+        _day += daysInMonth(_year, i);
+    }
+    return _day;
+}
 function add(d, ts) {
     return DateTimeOffset(d.getTime() + ts, (d.offset ?? 0));
 }
+function addDays(d, v) {
+    return add(d, v * 86400000);
+}
+function addHours(d, v) {
+    return add(d, v * 3600000);
+}
+function addMinutes(d, v) {
+    return add(d, v * 60000);
+}
+function addSeconds(d, v) {
+    return add(d, v * 1000);
+}
+function addMilliseconds(d, v) {
+    return add(d, v);
+}
+function addTicks(d, v) {
+    return add(d, toFloat64(v / 10000n));
+}
+function addYears(d, v) {
+    const newMonth = d.getUTCMonth() + 1;
+    const newYear = d.getUTCFullYear() + v;
+    const _daysInMonth = daysInMonth(newYear, newMonth);
+    const newDay = Math.min(_daysInMonth, d.getUTCDate());
+    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), (d.offset ?? 0));
+}
+function addMonths(d, v) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    let newMonth = d2.getUTCMonth() + 1 + v;
+    let newMonth_ = 0;
+    let yearOffset = 0;
+    if (newMonth > 12) {
+        newMonth_ = newMonth % 12;
+        yearOffset = Math.floor(newMonth / 12);
+        newMonth = newMonth_;
+    }
+    else if (newMonth < 1) {
+        newMonth_ = 12 + newMonth % 12;
+        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
+        newMonth = newMonth_;
+    }
+    const newYear = d2.getUTCFullYear() + yearOffset;
+    const _daysInMonth = daysInMonth(newYear, newMonth);
+    const newDay = Math.min(_daysInMonth, d2.getUTCDate());
+    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), (d.offset ?? 0));
+}
+function subtract(d, that) {
+    return typeof that === "number"
+        ? DateTimeOffset(d.getTime() - that, (d.offset ?? 0))
+        : d.getTime() - that.getTime();
+}
+function equals(d1, d2) {
+    return d1.getTime() === d2.getTime();
+}
+function equalsExact(d1, d2) {
+    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;
+}
+function compare(d1, d2) {
+    return compareDates(d1, d2);
+}
+const compareTo = compare;
 function op_Addition(x, y) {
     return add(x, y);
 }
+function op_Subtraction(x, y) {
+    return subtract(x, y);
+}
+function toOffset(d, offset) {
+    return DateTimeOffset(d.getTime(), offset);
+}
+function toUnixTimeMilliseconds(d) {
+    return fromFloat64(d.getTime());
+}
+function toUnixTimeSeconds(d) {
+    return fromFloat64(d.getTime() / 1000.0);
+}
 
-export { add, DateTimeOffset as default, fromDate, offset, op_Addition };
+export { add, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addTicks, addYears, compare, compareTo, create, date, day, dayOfWeek, dayOfYear, DateTimeOffset as default, equals, equalsExact, fromDate, fromTicks, fromUnixTimeMilliseconds, fromUnixTimeSeconds, getUtcTicks, hour, maxValue, millisecond, minValue, minute, month, now, offset, op_Addition, op_Subtraction, parse, second, subtract, timeOfDay, toLocalTime, toOffset, toUniversalTime, toUnixTimeMilliseconds, toUnixTimeSeconds, tryParse, utcNow, year };

package/dist/ts/node_modules/@fable-org/fable-library-js/Decimal.js

@@ -23,10 +23,75 @@ Big.prototype[symbol] = function () {
     };
 };
 const get_Zero = new Big(0);
-new Big(1);
-new Big(-1);
-new Big("79228162514264337593543950335");
-new Big("-79228162514264337593543950335");
+const get_One = new Big(1);
+const get_MinusOne = new Big(-1);
+const get_MaxValue = new Big("79228162514264337593543950335");
+const get_MinValue = new Big("-79228162514264337593543950335");
+function compare(x, y) {
+    return x.cmp(y);
+}
+function equals(x, y) {
+    return !x.cmp(y);
+}
+function abs(x) { return x.abs(); }
+function sign(x) { return x.lt(get_Zero) ? -1 : x.gt(get_Zero) ? 1 : 0; }
+function max(x, y) { return x.gt(y) ? x : y; }
+function min(x, y) { return x.lt(y) ? x : y; }
+function maxMagnitude(x, y) { return abs(x).gt(abs(y)) ? x : y; }
+function minMagnitude(x, y) { return abs(x).lt(abs(y)) ? x : y; }
+function clamp(x, min, max) {
+    return x.lt(min) ? min : x.gt(max) ? max : x;
+}
+function round(x, digits = 0) {
+    return x.round(digits, 2 /* ROUND_HALF_EVEN */);
+}
+function truncate(x) {
+    return x.round(0, 0 /* ROUND_DOWN */);
+}
+function ceiling(x) {
+    return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);
+}
+function floor(x) {
+    return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);
+}
+function pow(x, n) {
+    return x.pow(n);
+}
+function sqrt(x) {
+    return x.sqrt();
+}
+function op_Addition(x, y) {
+    return x.add(y);
+}
+function op_Subtraction(x, y) {
+    return x.sub(y);
+}
+function op_Multiply(x, y) {
+    return x.mul(y);
+}
+function op_Division(x, y) {
+    return x.div(y);
+}
+function op_Modulus(x, y) {
+    return x.mod(y);
+}
+function op_UnaryNegation(x) {
+    const x2 = new Big(x);
+    x2.s = -x2.s || 0;
+    return x2;
+}
+function op_UnaryPlus(x) {
+    return x;
+}
+const add = op_Addition;
+const subtract = op_Subtraction;
+const multiply = op_Multiply;
+const divide = op_Division;
+const remainder = op_Modulus;
+const negate = op_UnaryNegation;
+function toString(x) {
+    return x.toString();
+}
 function tryParse(str, defValue) {
     try {
         defValue.contents = new Big(str.trim());
@@ -45,6 +110,90 @@ function parse(str) {
         throw new Error(`The input string ${str} was not in a correct format.`);
     }
 }
+function toNumber(x) {
+    return +x;
+}
+function decimalToHex(dec, bitSize) {
+    const hex = new Uint8Array(bitSize / 4 | 0);
+    let hexCount = 1;
+    for (let d = 0; d < dec.length; d++) {
+        let value = dec[d];
+        for (let i = 0; i < hexCount; i++) {
+            const digit = hex[i] * 10 + value | 0;
+            hex[i] = digit & 0xF;
+            value = digit >> 4;
+        }
+        if (value !== 0) {
+            hex[hexCount++] = value;
+        }
+    }
+    return hex.slice(0, hexCount); // digits in reverse order
+}
+function hexToDecimal(hex, bitSize) {
+    const dec = new Uint8Array(bitSize * 301 / 1000 + 1 | 0);
+    let decCount = 1;
+    for (let d = hex.length - 1; d >= 0; d--) {
+        let carry = hex[d];
+        for (let i = 0; i < decCount; i++) {
+            const val = dec[i] * 16 + carry | 0;
+            dec[i] = (val % 10) | 0;
+            carry = (val / 10) | 0;
+        }
+        while (carry > 0) {
+            dec[decCount++] = (carry % 10) | 0;
+            carry = (carry / 10) | 0;
+        }
+    }
+    return dec.slice(0, decCount); // digits in reverse order
+}
+function setInt32Bits(hexDigits, bits, offset) {
+    for (let i = 0; i < 8; i++) {
+        hexDigits[offset + i] = (bits >> (i * 4)) & 0xF;
+    }
+}
+function getInt32Bits(hexDigits, offset) {
+    let bits = 0;
+    for (let i = 0; i < 8; i++) {
+        bits = bits | (hexDigits[offset + i] << (i * 4));
+    }
+    return bits;
+}
+function fromIntArray(bits) {
+    return fromInts(bits[0], bits[1], bits[2], bits[3]);
+}
+function fromInts(low, mid, high, signExp) {
+    const isNegative = signExp < 0;
+    const scale = (signExp >> 16) & 0x7F;
+    return fromParts(low, mid, high, isNegative, scale);
+}
+function fromParts(low, mid, high, isNegative, scale) {
+    const bitSize = 96;
+    const hexDigits = new Uint8Array(bitSize / 4);
+    setInt32Bits(hexDigits, low, 0);
+    setInt32Bits(hexDigits, mid, 8);
+    setInt32Bits(hexDigits, high, 16);
+    const decDigits = hexToDecimal(hexDigits, bitSize);
+    scale = scale & 0x7F;
+    const big = new Big(0);
+    big.c = Array.from(decDigits.reverse());
+    big.e = decDigits.length - scale - 1;
+    big.s = isNegative ? -1 : 1;
+    const d = new Big(big);
+    return d;
+}
+function getBits(d) {
+    const bitSize = 96;
+    const decDigits = Uint8Array.from(d.c);
+    const hexDigits = decimalToHex(decDigits, bitSize);
+    const low = getInt32Bits(hexDigits, 0);
+    const mid = getInt32Bits(hexDigits, 8);
+    const high = getInt32Bits(hexDigits, 16);
+    const decStr = d.toString();
+    const dotPos = decStr.indexOf(".");
+    const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;
+    const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);
+    return [low, mid, high, signExp];
+}
 // export function makeRangeStepFunction(step: Decimal, last: Decimal) {
 //   const stepComparedWithZero = step.cmp(get_Zero);
 //   if (stepComparedWithZero === 0) {
@@ -62,4 +211,4 @@ function parse(str) {
 //   };
 // }
 
-export { Big as default, get_Zero, parse, tryParse };
+export { abs, add, ceiling, clamp, compare, Big as default, divide, equals, floor, fromIntArray, fromInts, fromParts, getBits, get_MaxValue, get_MinValue, get_MinusOne, get_One, get_Zero, max, maxMagnitude, min, minMagnitude, multiply, negate, op_Addition, op_Division, op_Modulus, op_Multiply, op_Subtraction, op_UnaryNegation, op_UnaryPlus, parse, pow, remainder, round, sign, sqrt, subtract, toNumber, toString, truncate, tryParse };

package/dist/ts/node_modules/@fable-org/fable-library-js/Double.js

@@ -20,11 +20,30 @@ function parse(str) {
         throw new Error(`The input string ${str} was not in a correct format.`);
     }
 }
+// JS Number.isFinite function evals false for NaN
+function isPositiveInfinity(x) {
+    return x === Number.POSITIVE_INFINITY;
+}
+function isNegativeInfinity(x) {
+    return x === Number.NEGATIVE_INFINITY;
+}
+function isInfinity(x) {
+    return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;
+}
 function max(x, y) {
     return x > y ? x : y;
 }
 function min(x, y) {
     return x < y ? x : y;
 }
+function maxMagnitude(x, y) {
+    return Math.abs(x) > Math.abs(y) ? x : y;
+}
+function minMagnitude(x, y) {
+    return Math.abs(x) < Math.abs(y) ? x : y;
+}
+function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}
 
-export { max, min, parse, tryParse };
+export { clamp, isInfinity, isNegativeInfinity, isPositiveInfinity, max, maxMagnitude, min, minMagnitude, parse, tryParse };

package/dist/ts/node_modules/@fable-org/fable-library-js/FSharp.Collections.js

@@ -0,0 +1,30 @@
+import { structuralHash, equals, physicalHash, compare } from './Util.js';
+
+function HashIdentity_FromFunctions(hash, eq) {
+    return {
+        Equals(x, y) {
+            return eq(x, y);
+        },
+        GetHashCode(x_1) {
+            return hash(x_1);
+        },
+    };
+}
+function HashIdentity_Structural() {
+    return HashIdentity_FromFunctions(structuralHash, equals);
+}
+function HashIdentity_Reference() {
+    return HashIdentity_FromFunctions(physicalHash, (e, e_1) => (e === e_1));
+}
+function ComparisonIdentity_FromFunction(comparer) {
+    return {
+        Compare(x, y) {
+            return comparer(x, y);
+        },
+    };
+}
+function ComparisonIdentity_Structural() {
+    return ComparisonIdentity_FromFunction(compare);
+}
+
+export { ComparisonIdentity_FromFunction, ComparisonIdentity_Structural, HashIdentity_FromFunctions, HashIdentity_Reference, HashIdentity_Structural };

package/dist/ts/node_modules/@fable-org/fable-library-js/FSharp.Core.js

@@ -1,5 +1,72 @@
+import { structuralHash, equals, defaultOf, disposeSafe } from './Util.js';
+import { ComparisonIdentity_Structural, HashIdentity_Structural } from './FSharp.Collections.js';
+import { StringBuilder__Append_Z721C83C5 } from './System.Text.js';
+
+const LanguagePrimitives_GenericEqualityComparer = {
+    "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
+        return equals(x, y);
+    },
+    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
+        return structuralHash(x_1);
+    },
+};
+const LanguagePrimitives_GenericEqualityERComparer = {
+    "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
+        return equals(x, y);
+    },
+    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
+        return structuralHash(x_1);
+    },
+};
+function LanguagePrimitives_FastGenericComparer() {
+    return ComparisonIdentity_Structural();
+}
+function LanguagePrimitives_FastGenericComparerFromTable() {
+    return ComparisonIdentity_Structural();
+}
+function LanguagePrimitives_FastGenericEqualityComparer() {
+    return HashIdentity_Structural();
+}
+function LanguagePrimitives_FastGenericEqualityComparerFromTable() {
+    return HashIdentity_Structural();
+}
+function Operators_Failure(message) {
+    return new Error(message);
+}
+function Operators_FailurePattern(exn) {
+    return exn.message;
+}
 function Operators_NullArg(x) {
     throw new Error(x);
 }
+function Operators_Using(resource, action) {
+    try {
+        return action(resource);
+    }
+    finally {
+        if (equals(resource, defaultOf())) {
+        }
+        else {
+            let copyOfStruct = resource;
+            disposeSafe(copyOfStruct);
+        }
+    }
+}
+function Operators_Lock(_lockObj, action) {
+    return action();
+}
+function ExtraTopLevelOperators_LazyPattern(input) {
+    return input.Value;
+}
+function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {
+    return format.cont((s) => {
+        StringBuilder__Append_Z721C83C5(builder, s);
+        return continuation();
+    });
+}
+function PrintfModule_PrintFormatToStringBuilder(builder, format) {
+    return PrintfModule_PrintFormatToStringBuilderThen(() => {
+    }, builder, format);
+}
 
-export { Operators_NullArg };
+export { ExtraTopLevelOperators_LazyPattern, LanguagePrimitives_FastGenericComparer, LanguagePrimitives_FastGenericComparerFromTable, LanguagePrimitives_FastGenericEqualityComparer, LanguagePrimitives_FastGenericEqualityComparerFromTable, LanguagePrimitives_GenericEqualityComparer, LanguagePrimitives_GenericEqualityERComparer, Operators_Failure, Operators_FailurePattern, Operators_Lock, Operators_NullArg, Operators_Using, PrintfModule_PrintFormatToStringBuilder, PrintfModule_PrintFormatToStringBuilderThen };

package/dist/ts/node_modules/@fable-org/fable-library-js/Global.js

@@ -1,5 +1,10 @@
 const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
 const SR_inputWasEmpty = "Collection was empty.";
+const SR_inputMustBeNonNegative = "The input must be non-negative.";
+const SR_inputSequenceEmpty = "The input sequence was empty.";
+const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
 const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+const SR_differentLengths = "The collections had different lengths.";
+const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
 
-export { SR_indexOutOfBounds, SR_inputWasEmpty, SR_keyNotFoundAlt };
+export { SR_differentLengths, SR_indexOutOfBounds, SR_inputMustBeNonNegative, SR_inputSequenceEmpty, SR_inputSequenceTooLong, SR_inputWasEmpty, SR_keyNotFoundAlt, SR_notEnoughElements };

package/dist/ts/node_modules/@fable-org/fable-library-js/Guid.js

@@ -6,6 +6,28 @@ import { trim } from './String.js';
 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})$/;
+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 Error("Unrecognized Guid print format");
+        }
+    }
+    else {
+        return str;
+    }
+}
 /** Validates UUID as specified in RFC4122 (versions 1-5). */
 function parse(str) {
     function hyphenateGuid(str) {
@@ -44,5 +66,80 @@ function newGuid() {
     }
     return b;
 }
+// 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 + 0x100).toString(16).substr(1);
+        _hexToByte[_byteToHex[i]] = i;
+    }
+    _convertMapsInitialized = true;
+}
+/** Parse a UUID into it's component bytes */
+// Adapted from https://github.com/zefferus/uuid-parse
+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 */
+function arrayToGuid(buf) {
+    if (buf.length !== 16) {
+        throw new Error("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;
+}
 
-export { newGuid, parse, tryParse };
+export { arrayToGuid, guidToArray, newGuid, parse, toString, tryParse };