@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

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

@@ -0,0 +1,59 @@
+/**
+ * DateTimeOffset functions.
+ *
+ * Note: DateOffset instances are always DateObjects in local
+ * timezone (because JS dates are all kinds of messed up).
+ * A local date returns UTC epoch when `.getTime()` is called.
+ *
+ * However, this means that in order to construct an UTC date
+ * from a DateOffset with offset of +5 hours, you first need
+ * to subtract those 5 hours, than add the "local" offset.
+ * As said, all kinds of messed up.
+ *
+ * Basically; invariant: date.getTime() always return UTC time.
+ */
+function DateTimeOffset(value, offset) {
+    checkOffsetInRange(offset);
+    const d = new Date(value);
+    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -6e4;
+    return d;
+}
+function offset(value) {
+    return value.offset || 0;
+}
+function checkOffsetInRange(offset) {
+    if (offset != null && offset !== 0) {
+        if (offset % 60000 !== 0) {
+            throw new Error("Offset must be specified in whole minutes.");
+        }
+        if (Math.abs(offset / 3600000) > 14) {
+            throw new Error("Offset must be within plus or minus 14 hours.");
+        }
+    }
+}
+function fromDate(date, offset) {
+    let offset2 = 0;
+    switch (date.kind) {
+        case 1 /* DateKind.UTC */:
+            offset2 = 0;
+            break;
+        case 2 /* DateKind.Local */:
+            offset2 = date.getTimezoneOffset() * -6e4;
+            break;
+        case 0 /* DateKind.Unspecified */:
+        default:
+            {
+                offset2 = date.getTimezoneOffset() * -6e4;
+            }
+            break;
+    }
+    return DateTimeOffset(date.getTime(), offset2);
+}
+function add(d, ts) {
+    return DateTimeOffset(d.getTime() + ts, (d.offset ?? 0));
+}
+function op_Addition(x, y) {
+    return add(x, y);
+}
+
+export { add, DateTimeOffset as default, fromDate, offset, op_Addition };

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

@@ -0,0 +1,65 @@
+import { Big } from './lib/big.js';
+import { symbol } from './Numeric.js';
+import { FSharpRef } from './Types.js';
+import { combineHashCodes } from './Util.js';
+
+Big.prototype.GetHashCode = function () {
+    return combineHashCodes([this.s, this.e].concat(this.c));
+};
+Big.prototype.Equals = function (x) {
+    return !this.cmp(x);
+};
+Big.prototype.CompareTo = function (x) {
+    return this.cmp(x);
+};
+Big.prototype[symbol] = function () {
+    const _this = this;
+    return {
+        multiply: (y) => _this.mul(y),
+        toPrecision: (sd) => _this.toPrecision(sd),
+        toExponential: (dp) => _this.toExponential(dp),
+        toFixed: (dp) => _this.toFixed(dp),
+        toHex: () => (Number(_this) >>> 0).toString(16),
+    };
+};
+const get_Zero = new Big(0);
+new Big(1);
+new Big(-1);
+new Big("79228162514264337593543950335");
+new Big("-79228162514264337593543950335");
+function tryParse(str, defValue) {
+    try {
+        defValue.contents = new Big(str.trim());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parse(str) {
+    const defValue = new FSharpRef(get_Zero);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`The input string ${str} was not in a correct format.`);
+    }
+}
+// export function makeRangeStepFunction(step: Decimal, last: Decimal) {
+//   const stepComparedWithZero = step.cmp(get_Zero);
+//   if (stepComparedWithZero === 0) {
+//     throw new Error("The step of a range cannot be zero");
+//   }
+//   const stepGreaterThanZero = stepComparedWithZero > 0;
+//   return (x: Decimal) => {
+//     const comparedWithLast = x.cmp(last);
+//     if ((stepGreaterThanZero && comparedWithLast <= 0)
+//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {
+//       return [x, op_Addition(x, step)];
+//     } else {
+//       return undefined;
+//     }
+//   };
+// }
+
+export { Big as default, get_Zero, parse, tryParse };

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

@@ -0,0 +1,30 @@
+import { FSharpRef } from './Types.js';
+
+function tryParse(str, defValue) {
+    // TODO: test if value is valid and in range
+    if (str != null && /\S/.test(str)) {
+        const v = +str.replace("_", "");
+        if (!Number.isNaN(v)) {
+            defValue.contents = v;
+            return true;
+        }
+    }
+    return false;
+}
+function parse(str) {
+    const defValue = new FSharpRef(0);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`The input string ${str} was not in a correct format.`);
+    }
+}
+function max(x, y) {
+    return x > y ? x : y;
+}
+function min(x, y) {
+    return x < y ? x : y;
+}
+
+export { max, min, parse, tryParse };

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

@@ -0,0 +1,5 @@
+function Operators_NullArg(x) {
+    throw new Error(x);
+}
+
+export { Operators_NullArg };

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

@@ -0,0 +1,5 @@
+const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
+const SR_inputWasEmpty = "Collection was empty.";
+const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+
+export { SR_indexOutOfBounds, SR_inputWasEmpty, SR_keyNotFoundAlt };

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

@@ -0,0 +1,48 @@
+import { trim } from './String.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}\}\}$/;
+/** Validates UUID as specified in RFC4122 (versions 1-5). */
+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 Error("Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+    }
+}
+function tryParse(str, defValue) {
+    try {
+        defValue.contents = parse(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// From https://gist.github.com/LeverOne/1308368
+function newGuid() {
+    let b = "";
+    for (let a = 0; a++ < 36;) {
+        b += a * 51 & 52
+            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)
+            : "-";
+    }
+    return b;
+}
+
+export { newGuid, parse, tryParse };

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

@@ -0,0 +1,120 @@
+var NumberStyles;
+(function (NumberStyles) {
+    // None = 0x00000000,
+    // AllowLeadingWhite = 0x00000001,
+    // AllowTrailingWhite = 0x00000002,
+    // AllowLeadingSign = 0x00000004,
+    // AllowTrailingSign = 0x00000008,
+    // AllowParentheses = 0x00000010,
+    // AllowDecimalPoint = 0x00000020,
+    // AllowThousands = 0x00000040,
+    // AllowExponent = 0x00000080,
+    // AllowCurrencySymbol = 0x00000100,
+    NumberStyles[NumberStyles["AllowHexSpecifier"] = 512] = "AllowHexSpecifier";
+    // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,
+    // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,
+    // Number = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |
+    //          AllowTrailingSign | AllowDecimalPoint | AllowThousands,
+    // Float = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |
+    //         AllowDecimalPoint | AllowExponent,
+    // Currency = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
+    //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,
+    // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
+    //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,
+})(NumberStyles || (NumberStyles = {}));
+function validResponse(regexMatch, radix) {
+    const [/*all*/ , sign, prefix, digits] = regexMatch;
+    return {
+        sign: sign || "",
+        prefix: prefix || "",
+        digits,
+        radix,
+    };
+}
+function getRange(unsigned, bitsize) {
+    switch (bitsize) {
+        case 8: return unsigned ? [0, 255] : [-128, 127];
+        case 16: return unsigned ? [0, 65535] : [-32768, 32767];
+        case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];
+        default: throw new Error("Invalid bit size.");
+    }
+}
+function getInvalidDigits(radix) {
+    switch (radix) {
+        case 2: return /[^0-1]/;
+        case 8: return /[^0-7]/;
+        case 10: return /[^0-9]/;
+        case 16: return /[^0-9a-fA-F]/;
+        default:
+            throw new Error("Invalid Base.");
+    }
+}
+function getPrefix(radix) {
+    switch (radix) {
+        case 2: return "0b";
+        case 8: return "0o";
+        case 10: return "";
+        case 16: return "0x";
+        default: return "";
+    }
+}
+function getRadix(prefix, style) {
+    if (style & NumberStyles.AllowHexSpecifier) {
+        return 16;
+    }
+    else {
+        switch (prefix) {
+            case "0b":
+            case "0B": return 2;
+            case "0o":
+            case "0O": return 8;
+            case "0x":
+            case "0X": return 16;
+            default: return 10;
+        }
+    }
+}
+function isValid(str, style, radix) {
+    const integerRegex = /^\s*([\+\-])?(0[xXoObB])?([0-9a-fA-F]+)\s*$/;
+    const res = integerRegex.exec(str.replace(/_/g, ""));
+    if (res != null) {
+        const [/*all*/ , /*sign*/ , prefix, digits] = res;
+        radix = radix || getRadix(prefix, style);
+        const invalidDigits = getInvalidDigits(radix);
+        if (!invalidDigits.test(digits)) {
+            return validResponse(res, radix);
+        }
+    }
+    return null;
+}
+function parse(str, style, unsigned, bitsize, radix) {
+    const res = isValid(str, style, radix);
+    if (res != null) {
+        let v = Number.parseInt(res.sign + res.digits, res.radix);
+        if (!Number.isNaN(v)) {
+            const [umin, umax] = getRange(true, bitsize);
+            if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {
+                v = v << (32 - bitsize) >> (32 - bitsize);
+            }
+            const [min, max] = getRange(unsigned, bitsize);
+            if (v >= min && v <= max) {
+                return v;
+            }
+        }
+    }
+    throw new Error(`The input string ${str} was not in a correct format.`);
+}
+function tryParse(str, style, unsigned, bitsize, defValue) {
+    try {
+        defValue.contents = parse(str, style, unsigned, bitsize);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function op_UnaryNegation_Int32(x) {
+    return x === -2147483648 ? x : -x;
+}
+
+export { NumberStyles, getPrefix, getRadix, isValid, op_UnaryNegation_Int32, parse, tryParse };