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

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

@@ -1,12 +1,104 @@
 import { toString } from './Date.js';
-import { isNumeric, multiply, toFixed, toHex, toExponential, toPrecision, compare } from './Numeric.js';
+import { compare as compare$1, isNumeric, multiply, toHex, toExponential, toPrecision, toFixed } from './Numeric.js';
 import { escape } from './RegExp.js';
 import { toString as toString$1 } from './Types.js';
 
 const fsFormatRegExp = /(^|[^%])%([0+\- ]*)(\*|\d+)?(?:\.(\d+))?(\w)/g;
+const interpolateRegExp = /(?:(^|[^%])%([0+\- ]*)(\d+)?(?:\.(\d+))?(\w))?%P\(\)/g;
 const formatRegExp = /\{(\d+)(,-?\d+)?(?:\:([a-zA-Z])(\d{0,2})|\:(.+?))?\}/g;
 function isLessThan(x, y) {
-    return compare(x, y) < 0;
+    return compare$1(x, y) < 0;
+}
+function cmp(x, y, ic) {
+    function isIgnoreCase(i) {
+        return i === true ||
+            i === 1 /* StringComparison.CurrentCultureIgnoreCase */ ||
+            i === 3 /* StringComparison.InvariantCultureIgnoreCase */ ||
+            i === 5 /* StringComparison.OrdinalIgnoreCase */;
+    }
+    function isOrdinal(i) {
+        return i === 4 /* StringComparison.Ordinal */ ||
+            i === 5 /* StringComparison.OrdinalIgnoreCase */;
+    }
+    if (x == null) {
+        return y == null ? 0 : -1;
+    }
+    if (y == null) {
+        return 1;
+    } // everything is bigger than null
+    if (isOrdinal(ic)) {
+        if (isIgnoreCase(ic)) {
+            x = x.toLowerCase();
+            y = y.toLowerCase();
+        }
+        return (x === y) ? 0 : (x < y ? -1 : 1);
+    }
+    else {
+        if (isIgnoreCase(ic)) {
+            x = x.toLocaleLowerCase();
+            y = y.toLocaleLowerCase();
+        }
+        return x.localeCompare(y);
+    }
+}
+function compare(...args) {
+    switch (args.length) {
+        case 2: return cmp(args[0], args[1], false);
+        case 3: return cmp(args[0], args[1], args[2]);
+        case 4: return cmp(args[0], args[1], args[2] === true);
+        case 5: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), false);
+        case 6: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5]);
+        case 7: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5] === true);
+        default: throw new Error("String.compare: Unsupported number of parameters");
+    }
+}
+function compareOrdinal(x, y) {
+    return cmp(x, y, 4 /* StringComparison.Ordinal */);
+}
+function compareTo(x, y) {
+    return cmp(x, y, 0 /* StringComparison.CurrentCulture */);
+}
+function startsWith(str, pattern, ic) {
+    if (ic === 4 /* StringComparison.Ordinal */) { // to avoid substring allocation
+        return str.startsWith(pattern);
+    }
+    if (str.length >= pattern.length) {
+        return cmp(str.substr(0, pattern.length), pattern, ic) === 0;
+    }
+    return false;
+}
+function endsWith(str, pattern, ic) {
+    if (ic === 4 /* StringComparison.Ordinal */) { // to avoid substring allocation
+        return str.endsWith(pattern);
+    }
+    if (str.length >= pattern.length) {
+        return cmp(str.substr(str.length - pattern.length, pattern.length), pattern, ic) === 0;
+    }
+    return false;
+}
+function indexOfAny(str, anyOf, ...args) {
+    if (str == null || str === "") {
+        return -1;
+    }
+    const startIndex = (args.length > 0) ? args[0] : 0;
+    if (startIndex < 0) {
+        throw new Error("Start index cannot be negative");
+    }
+    const length = (args.length > 1) ? args[1] : str.length - startIndex;
+    if (length < 0) {
+        throw new Error("Length cannot be negative");
+    }
+    if (startIndex + length > str.length) {
+        throw new Error("Invalid startIndex and length");
+    }
+    const endIndex = startIndex + length;
+    const anyOfAsStr = "".concat.apply("", anyOf);
+    for (let i = startIndex; i < endIndex; i++) {
+        if (anyOfAsStr.indexOf(str[i]) > -1) {
+            return i;
+        }
+    }
+    return -1;
 }
 function printf(input) {
     return {
@@ -14,6 +106,29 @@ function printf(input) {
         cont: fsFormat(input),
     };
 }
+function interpolate(str, values) {
+    let valIdx = 0;
+    let strIdx = 0;
+    let result = "";
+    interpolateRegExp.lastIndex = 0;
+    let match = interpolateRegExp.exec(str);
+    while (match) {
+        // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char
+        // Note: we don't use negative lookbehind because some browsers don't support it yet
+        const matchIndex = match.index + (match[1] || "").length;
+        result += str.substring(strIdx, matchIndex).replace(/%%/g, "%");
+        const [, , flags, padLength, precision, format] = match;
+        // Save interpolateRegExp.lastIndex before running formatReplacement because the values
+        // may also involve interpolation and make use of interpolateRegExp (see #3078)
+        strIdx = interpolateRegExp.lastIndex;
+        result += formatReplacement(values[valIdx++], flags, padLength, precision, format);
+        // Move interpolateRegExp.lastIndex one char behind to make sure we match the no-escape char next time
+        interpolateRegExp.lastIndex = strIdx - 1;
+        match = interpolateRegExp.exec(str);
+    }
+    result += str.substring(strIdx).replace(/%%/g, "%");
+    return result;
+}
 function continuePrint(cont, arg) {
     return typeof arg === "string" ? cont(arg) : arg.cont(cont);
 }
@@ -21,6 +136,9 @@ function toConsole(arg) {
     // Don't remove the lambda here, see #1357
     return continuePrint((x) => console.log(x), arg);
 }
+function toConsoleError(arg) {
+    return continuePrint((x) => console.error(x), arg);
+}
 function toText(arg) {
     return continuePrint((x) => x, arg);
 }
@@ -266,9 +384,21 @@ function initialize(n, f) {
     }
     return xs.join("");
 }
+function insert(str, startIndex, value) {
+    if (startIndex < 0 || startIndex > str.length) {
+        throw new Error("startIndex is negative or greater than the length of this instance.");
+    }
+    return str.substring(0, startIndex) + value + str.substring(startIndex);
+}
 function isNullOrEmpty(str) {
     return typeof str !== "string" || str.length === 0;
 }
+function isNullOrWhiteSpace(str) {
+    return typeof str !== "string" || /^\s*$/.test(str);
+}
+function concat(...xs) {
+    return xs.map((x) => String(x)).join("");
+}
 function join(delimiter, xs) {
     if (Array.isArray(xs)) {
         return xs.join(delimiter);
@@ -277,6 +407,31 @@ function join(delimiter, xs) {
         return Array.from(xs).join(delimiter);
     }
 }
+function joinWithIndices(delimiter, xs, startIndex, count) {
+    const endIndexPlusOne = startIndex + count;
+    if (endIndexPlusOne > xs.length) {
+        throw new Error("Index and count must refer to a location within the buffer.");
+    }
+    return xs.slice(startIndex, endIndexPlusOne).join(delimiter);
+}
+function notSupported(name) {
+    throw new Error("The environment doesn't support '" + name + "', please use a polyfill.");
+}
+function toBase64String(inArray) {
+    let str = "";
+    for (let i = 0; i < inArray.length; i++) {
+        str += String.fromCharCode(inArray[i]);
+    }
+    return typeof btoa === "function" ? btoa(str) : notSupported("btoa");
+}
+function fromBase64String(b64Encoded) {
+    const binary = typeof atob === "function" ? atob(b64Encoded) : notSupported("atob");
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
 function pad(str, len, ch, isRight) {
     ch = ch || " ";
     len = len - str.length;
@@ -291,9 +446,27 @@ function padLeft(str, len, ch) {
 function padRight(str, len, ch) {
     return pad(str, len, ch, true);
 }
+function remove(str, startIndex, count) {
+    if (startIndex >= str.length) {
+        throw new Error("startIndex must be less than length of string");
+    }
+    if (typeof count === "number" && (startIndex + count) > str.length) {
+        throw new Error("Index and count must refer to a location within the string.");
+    }
+    return str.slice(0, startIndex) + (typeof count === "number" ? str.substr(startIndex + count) : "");
+}
 function replace(str, search, replace) {
     return str.replace(new RegExp(escape(search), "g"), replace);
 }
+function replicate(n, x) {
+    return initialize(n, () => x);
+}
+function getCharAtIndex(input, index) {
+    if (index < 0 || index >= input.length) {
+        throw new Error("Index was outside the bounds of the array.");
+    }
+    return input[index];
+}
 function split(str, splitters, count, options) {
     count = typeof count === "number" ? count : undefined;
     options = typeof options === "number" ? options : 0;
@@ -354,11 +527,31 @@ function trimEnd(str, ...chars) {
         ? str.trimEnd()
         : str.replace(new RegExp("[" + escape(chars.join("")) + "]+$"), "");
 }
+function filter(pred, x) {
+    return x.split("").filter((c) => pred(c)).join("");
+}
 function substring(str, startIndex, length) {
-    if ((startIndex + (0) > str.length)) {
+    if ((startIndex + (length || 0) > str.length)) {
         throw new Error("Invalid startIndex and/or length");
     }
     return length != null ? str.substr(startIndex, length) : str.substr(startIndex);
 }
+function toCharArray2(str, startIndex, length) {
+    return substring(str, startIndex, length).split("");
+}
+function fmt(strs, ...args) {
+    return ({ strs, args });
+}
+function fmtWith(fmts) {
+    return (strs, ...args) => ({ strs, args, fmts });
+}
+function getFormat(s) {
+    const strs = s.strs.map((value) => value.replace(/{/g, '{{').replace(/}/g, '}}'));
+    return s.fmts
+        ? strs
+            .reduce((acc, newPart, index) => acc + `{${String(index - 1) + s.fmts[index - 1]}}` + newPart)
+        : strs
+            .reduce((acc, newPart, index) => acc + `{${index - 1}}` + newPart);
+}
 
-export { format, fsFormat, initialize, isNullOrEmpty, join, padLeft, padRight, printf, replace, split, substring, toConsole, toFail, toText, trim, trimEnd, trimStart };
+export { compare, compareOrdinal, compareTo, concat, endsWith, filter, fmt, fmtWith, format, fromBase64String, fsFormat, getCharAtIndex, getFormat, indexOfAny, initialize, insert, interpolate, isNullOrEmpty, isNullOrWhiteSpace, join, joinWithIndices, padLeft, padRight, printf, remove, replace, replicate, split, startsWith, substring, toBase64String, toCharArray2, toConsole, toConsoleError, toFail, toText, trim, trimEnd, trimStart };

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

@@ -1,5 +1,7 @@
-import { isNullOrEmpty, join } from './String.js';
-import { clear } from './Util.js';
+import { isNullOrEmpty, join, substring, format, replace } from './String.js';
+import { class_type } from './Reflection.js';
+import { int32ToString, clear } from './Util.js';
+import { toString } from './Types.js';
 
 class StringBuilder {
     constructor(value, capacity) {
@@ -13,9 +15,18 @@ class StringBuilder {
         return join("", _.buf);
     }
 }
+function StringBuilder_$reflection() {
+    return class_type("System.Text.StringBuilder", undefined, StringBuilder);
+}
 function StringBuilder_$ctor_Z18115A39(value, capacity) {
     return new StringBuilder(value, capacity);
 }
+function StringBuilder_$ctor_Z524259A4(capacity) {
+    return StringBuilder_$ctor_Z18115A39("", capacity);
+}
+function StringBuilder_$ctor_Z721C83C5(value) {
+    return StringBuilder_$ctor_Z18115A39(value, 16);
+}
 function StringBuilder_$ctor() {
     return StringBuilder_$ctor_Z18115A39("", 16);
 }
@@ -23,10 +34,74 @@ function StringBuilder__Append_Z721C83C5(x, s) {
     void (x.buf.push(s));
     return x;
 }
+function StringBuilder__Append_487EF8FB(x, s, startIndex, count) {
+    void (x.buf.push(substring(s, startIndex, count)));
+    return x;
+}
 function StringBuilder__Append_244C7CD6(x, c) {
     void (x.buf.push(c));
     return x;
 }
+function StringBuilder__Append_Z524259A4(x, o) {
+    void (x.buf.push(int32ToString(o)));
+    return x;
+}
+function StringBuilder__Append_5E38073B(x, o) {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+function StringBuilder__Append_Z1FBCCD16(x, o) {
+    void (x.buf.push(toString(o)));
+    return x;
+}
+function StringBuilder__Append_4E60E31B(x, o) {
+    void (x.buf.push(toString(o)));
+    return x;
+}
+function StringBuilder__Append_Z372E4D23(x, cs) {
+    void (x.buf.push(cs.join('')));
+    return x;
+}
+function StringBuilder__Append_43A65C09(x, s) {
+    void (x.buf.push(toString(s)));
+    return x;
+}
+function StringBuilder__AppendFormat_433E080(x, fmt, o) {
+    void (x.buf.push(format(fmt, o)));
+    return x;
+}
+function StringBuilder__AppendFormat_Z3B30EC65(x, fmt, o1, o2) {
+    void (x.buf.push(format(fmt, o1, o2)));
+    return x;
+}
+function StringBuilder__AppendFormat_10D165E0(x, fmt, o1, o2, o3) {
+    void (x.buf.push(format(fmt, o1, o2, o3)));
+    return x;
+}
+function StringBuilder__AppendFormat_Z17053F5(x, fmt, arr) {
+    void (x.buf.push(format(fmt, ...arr)));
+    return x;
+}
+function StringBuilder__AppendFormat_Z696D8D1B(x, provider, fmt, o) {
+    void (x.buf.push(format(provider, fmt, o)));
+    return x;
+}
+function StringBuilder__AppendFormat_26802C9E(x, provider, fmt, o1, o2) {
+    void (x.buf.push(format(provider, fmt, o1, o2)));
+    return x;
+}
+function StringBuilder__AppendFormat_Z471ADCBB(x, provider, fmt, o1, o2, o3) {
+    void (x.buf.push(format(provider, fmt, o1, o2, o3)));
+    return x;
+}
+function StringBuilder__AppendFormat_6C2E3E6E(x, provider, fmt, arr) {
+    void (x.buf.push(format(provider, fmt, ...arr)));
+    return x;
+}
+function StringBuilder__AppendLine(x) {
+    void (x.buf.push("\n"));
+    return x;
+}
 function StringBuilder__AppendLine_Z721C83C5(x, s) {
     void (x.buf.push(s));
     void (x.buf.push("\n"));
@@ -36,5 +111,55 @@ function StringBuilder__Clear(x) {
     clear(x.buf);
     return x;
 }
+function StringBuilder__get_Chars_Z524259A4(x, index) {
+    let len = 0;
+    let i = -1;
+    while (((i + 1) < x.buf.length) && (len < index)) {
+        i = ((i + 1) | 0);
+        len = ((len + x.buf[i].length) | 0);
+    }
+    if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
+        throw new Error("Index was outside the bounds of the array");
+    }
+    else {
+        const pos = ((len - index) - 1) | 0;
+        return x.buf[i][pos];
+    }
+}
+function StringBuilder__set_Chars_413E0D0A(x, index, value) {
+    let len = 0;
+    let i = -1;
+    while (((i + 1) < x.buf.length) && (len < index)) {
+        i = ((i + 1) | 0);
+        len = ((len + x.buf[i].length) | 0);
+    }
+    if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
+        throw new Error("Index was outside the bounds of the array");
+    }
+    else {
+        const pos = ((len - index) - 1) | 0;
+        x.buf[i] = ((x.buf[i].slice(0, (pos - 1) + 1) + value) + x.buf[i].slice(pos + 1, x.buf[i].length));
+    }
+}
+function StringBuilder__Replace_Z766F94C0(x, oldValue, newValue) {
+    for (let i = x.buf.length - 1; i >= 0; i--) {
+        x.buf[i] = replace(x.buf[i], oldValue, newValue);
+    }
+    return x;
+}
+function StringBuilder__Replace_Z384F8060(x, oldValue, newValue) {
+    const str = replace(toString(x), oldValue, newValue);
+    return StringBuilder__Append_Z721C83C5(StringBuilder__Clear(x), str);
+}
+function StringBuilder__get_Length(x) {
+    let len = 0;
+    for (let i = x.buf.length - 1; i >= 0; i--) {
+        len = ((len + x.buf[i].length) | 0);
+    }
+    return len | 0;
+}
+function StringBuilder__ToString_Z37302880(x, firstIndex, length) {
+    return substring(toString(x), firstIndex, length);
+}
 
-export { StringBuilder, StringBuilder_$ctor, StringBuilder_$ctor_Z18115A39, StringBuilder__AppendLine_Z721C83C5, StringBuilder__Append_244C7CD6, StringBuilder__Append_Z721C83C5, StringBuilder__Clear };
+export { StringBuilder, StringBuilder_$ctor, StringBuilder_$ctor_Z18115A39, StringBuilder_$ctor_Z524259A4, StringBuilder_$ctor_Z721C83C5, StringBuilder_$reflection, StringBuilder__AppendFormat_10D165E0, StringBuilder__AppendFormat_26802C9E, StringBuilder__AppendFormat_433E080, StringBuilder__AppendFormat_6C2E3E6E, StringBuilder__AppendFormat_Z17053F5, StringBuilder__AppendFormat_Z3B30EC65, StringBuilder__AppendFormat_Z471ADCBB, StringBuilder__AppendFormat_Z696D8D1B, StringBuilder__AppendLine, StringBuilder__AppendLine_Z721C83C5, StringBuilder__Append_244C7CD6, StringBuilder__Append_43A65C09, StringBuilder__Append_487EF8FB, StringBuilder__Append_4E60E31B, StringBuilder__Append_5E38073B, StringBuilder__Append_Z1FBCCD16, StringBuilder__Append_Z372E4D23, StringBuilder__Append_Z524259A4, StringBuilder__Append_Z721C83C5, StringBuilder__Clear, StringBuilder__Replace_Z384F8060, StringBuilder__Replace_Z766F94C0, StringBuilder__ToString_Z37302880, StringBuilder__get_Chars_Z524259A4, StringBuilder__get_Length, StringBuilder__set_Chars_413E0D0A };

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

@@ -0,0 +1,8 @@
+import { Exception } from './Types.js';
+
+class SystemException extends Exception {
+}
+class TimeoutException extends SystemException {
+}
+
+export { SystemException, TimeoutException };

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

@@ -0,0 +1,180 @@
+import { comparePrimitives, padWithZeros, padLeftAndRightWithZeros } from './Util.js';
+import { toInt64, fromFloat64 } from './BigInt.js';
+
+/**
+ * Calls:
+ * - `Math.ceil` if the `value` is **negative**
+ * - `Math.floor` if the `value` is **positive**
+ * @param value Value to round
+ */
+function signedRound(value) {
+    return value < 0 ? Math.ceil(value) : Math.floor(value);
+}
+function create(d = 0, h = 0, m = 0, s = 0, ms = 0) {
+    switch (arguments.length) {
+        case 1:
+            // ticks
+            return fromTicks(arguments[0]);
+        case 3:
+            // h,m,s
+            d = 0, h = arguments[0], m = arguments[1], s = arguments[2], ms = 0;
+            break;
+        default:
+            // d,h,m,s,ms
+            break;
+    }
+    return d * 86400000 + h * 3600000 + m * 60000 + s * 1000 + ms;
+}
+function fromTicks(ticks) {
+    return Number(BigInt(ticks) / 10000n);
+}
+function fromDays(d) {
+    return create(d, 0, 0, 0);
+}
+function fromHours(h) {
+    return create(h, 0, 0);
+}
+function fromMinutes(m) {
+    return create(0, m, 0);
+}
+function fromSeconds(s) {
+    return create(0, 0, s);
+}
+function days(ts) {
+    return signedRound(ts / 86400000);
+}
+function hours(ts) {
+    return signedRound(ts % 86400000 / 3600000);
+}
+function minutes(ts) {
+    return signedRound(ts % 3600000 / 60000);
+}
+function seconds(ts) {
+    return signedRound(ts % 60000 / 1000);
+}
+function milliseconds(ts) {
+    return signedRound(ts % 1000);
+}
+function ticks(ts) {
+    return toInt64(fromFloat64(ts * 10000));
+}
+function totalDays(ts) {
+    return ts / 86400000;
+}
+function totalHours(ts) {
+    return ts / 3600000;
+}
+function totalMinutes(ts) {
+    return ts / 60000;
+}
+function totalSeconds(ts) {
+    return ts / 1000;
+}
+function negate(ts) {
+    return ts * -1;
+}
+function add(ts1, ts2) {
+    return ts1 + ts2;
+}
+function subtract(ts1, ts2) {
+    return ts1 - ts2;
+}
+function multiply(ts, factor) {
+    return ts * factor;
+}
+function divide(ts, b) {
+    return ts / b;
+}
+const op_Addition = add;
+const op_Subtraction = subtract;
+const op_Multiply = multiply;
+const op_Division = divide;
+const compare = comparePrimitives;
+const compareTo = comparePrimitives;
+function duration(x) {
+    return Math.abs(x);
+}
+function toString(ts, format = "c", _provider) {
+    if (["c", "g", "G"].indexOf(format) === -1) {
+        throw new Error("Custom formats are not supported");
+    }
+    const d = Math.abs(days(ts));
+    const h = Math.abs(hours(ts));
+    const m = Math.abs(minutes(ts));
+    const s = Math.abs(seconds(ts));
+    const ms = Math.abs(milliseconds(ts));
+    const sign = ts < 0 ? "-" : "";
+    return `${sign}${d === 0 && (format === "c" || format === "g") ? "" : format === "c" ? d + "." : d + ":"}${format === "g" ? h : padWithZeros(h, 2)}:${padWithZeros(m, 2)}:${padWithZeros(s, 2)}${ms === 0 && (format === "c" || format === "g") ? "" : format === "g" ? "." + padWithZeros(ms, 3) : "." + padLeftAndRightWithZeros(ms, 3, 7)}`;
+}
+function parse(str) {
+    const firstDot = str.search("\\.");
+    const firstColon = str.search("\\:");
+    if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4
+        const d = parseInt(str, 0);
+        if (isNaN(d)) {
+            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+        }
+        else {
+            return create(d, 0, 0, 0, 0);
+        }
+    }
+    if (firstColon > 0) { // process time part
+        // WIP: (-?)(((\d+)\.)?([0-9]|0[0-9]|1[0-9]|2[0-3]):(\d+)(:\d+(\.\d{1,7})?)?|\d+(?:(?!\.)))
+        const r = /^(-?)((\d+)\.)?(?:0*)([0-9]|0[0-9]|1[0-9]|2[0-3]):(?:0*)([0-5][0-9]|[0-9])(:(?:0*)([0-5][0-9]|[0-9]))?\.?(\d+)?$/.exec(str);
+        if (r != null && r[4] != null && r[5] != null) {
+            let d = 0;
+            let ms = 0;
+            let s = 0;
+            const sign = r[1] != null && r[1] === "-" ? -1 : 1;
+            const h = +r[4];
+            const m = +r[5];
+            if (r[3] != null) {
+                d = +r[3];
+            }
+            if (r[7] != null) {
+                s = +r[7];
+            }
+            if (r[8] != null) {
+                // Depending on the number of decimals passed, we need to adapt the numbers
+                switch (r[8].length) {
+                    case 1:
+                        ms = +r[8] * 100;
+                        break;
+                    case 2:
+                        ms = +r[8] * 10;
+                        break;
+                    case 3:
+                        ms = +r[8];
+                        break;
+                    case 4:
+                        ms = +r[8] / 10;
+                        break;
+                    case 5:
+                        ms = +r[8] / 100;
+                        break;
+                    case 6:
+                        ms = +r[8] / 1000;
+                        break;
+                    case 7:
+                        ms = +r[8] / 10000;
+                        break;
+                    default:
+                        throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+                }
+            }
+            return sign * create(d, h, m, s, ms);
+        }
+    }
+    throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+}
+function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export { add, compare, compareTo, create, days, divide, duration, fromDays, fromHours, fromMinutes, fromSeconds, fromTicks, hours, milliseconds, minutes, multiply, negate, op_Addition, op_Division, op_Multiply, op_Subtraction, parse, seconds, subtract, ticks, toString, totalDays, totalHours, totalMinutes, totalSeconds, tryParse };

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

@@ -1,4 +1,4 @@
-import { structuralHash, combineHashCodes, sameConstructor, equals, compare, numberHash, equalArrays, compareArrays } from './Util.js';
+import { structuralHash, numberHash, combineHashCodes, sameConstructor, equalArrays, compareArrays, equals, compare } from './Util.js';
 
 function seqToString(self) {
     let count = 0;
@@ -189,5 +189,23 @@ function ensureErrorOrException(e) {
     // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
     return (isException(e) || isPromise(e)) ? e : new Error(String(e));
 }
+class FSharpException extends Exception {
+    toJSON() { return recordToJSON(this); }
+    toString() { return recordToString(this); }
+    GetHashCode() { return recordGetHashCode(this); }
+    Equals(other) { return recordEquals(this, other); }
+    CompareTo(other) { return recordCompareTo(this, other); }
+}
+class MatchFailureException extends FSharpException {
+    constructor(arg1, arg2, arg3) {
+        super();
+        this.arg1 = arg1;
+        this.arg2 = arg2 | 0;
+        this.arg3 = arg3 | 0;
+        this.message = "The match cases were incomplete";
+    }
+}
+class Attribute {
+}
 
-export { Exception, FSharpRef, Record, Union, ensureErrorOrException, isException, isPromise, seqToString, toString, unionToString };
+export { Attribute, Exception, FSharpException, FSharpRef, MatchFailureException, Record, Union, ensureErrorOrException, isException, isPromise, seqToString, toString, unionToString };