@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,247 @@
+import { toFloat64, fromFloat64 } from './BigInt.js';
+import { ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks, parseRaw, DateTime, create as create$1, daysInMonth } from './Date.js';
+import { Exception, DateTimeKind, compareDates } from './Util.js';
+
+function DateTimeOffset(value, offset2) {
+  checkOffsetInRange(offset2);
+  const d = new Date(value);
+  d.offset = offset2 != null ? offset2 : (/* @__PURE__ */ new Date()).getTimezoneOffset() * -6e4;
+  return d;
+}
+function offset(value) {
+  return value.offset || 0;
+}
+function checkOffsetInRange(offset2) {
+  if (offset2 != null && offset2 !== 0) {
+    if (offset2 % 6e4 !== 0) {
+      throw new Exception("Offset must be specified in whole minutes.");
+    }
+    if (Math.abs(offset2 / 36e5) > 14) {
+      throw new Exception("Offset must be within plus or minus 14 hours.");
+    }
+  }
+}
+function fromDate(date2, offset2) {
+  let offset22 = 0;
+  switch (date2.kind) {
+    case DateTimeKind.Utc:
+      if (offset2 != null && offset2 !== 0) {
+        throw new Exception("The UTC Offset for Utc DateTime instances must be 0.");
+      }
+      offset22 = 0;
+      break;
+    case DateTimeKind.Local:
+      offset22 = date2.getTimezoneOffset() * -6e4;
+      if (offset2 != null && offset2 !== offset22) {
+        throw new Exception("The UTC Offset of the local dateTime parameter does not match the offset argument.");
+      }
+      break;
+    case DateTimeKind.Unspecified:
+    default:
+      if (offset2 == null) {
+        offset22 = date2.getTimezoneOffset() * -6e4;
+      } else {
+        offset22 = offset2;
+      }
+      break;
+  }
+  return DateTimeOffset(date2.getTime(), offset22);
+}
+function fromDateTime(dateOnly, timeOnly, offset2) {
+  return DateTimeOffset(dateOnly.getTime() - offset2 + timeOnly, offset2);
+}
+function fromTicks(ticks, offset2) {
+  const ms = ticksToUnixEpochMilliseconds(ticks) - offset2;
+  return DateTimeOffset(ms, offset2);
+}
+function fromUnixTimeMilliseconds(ms) {
+  return DateTimeOffset(toFloat64(ms), 0);
+}
+function fromUnixTimeSeconds(seconds) {
+  return DateTimeOffset(toFloat64(seconds * 1000n), 0);
+}
+function getUtcTicks(date2) {
+  return unixEpochMillisecondsToTicks(date2.getTime(), 0);
+}
+function minValue() {
+  return DateTimeOffset(-621355968e5, 0);
+}
+function maxValue() {
+  return DateTimeOffset(253402300799999, 0);
+}
+function parse(str) {
+  const [date2, offsetMatch] = parseRaw(str);
+  const offset2 = offsetMatch == null ? date2.getTimezoneOffset() * -6e4 : offsetMatch === "Z" ? 0 : offsetMatch * 6e4;
+  return DateTimeOffset(date2.getTime(), offset2);
+}
+function tryParse(v, defValue) {
+  try {
+    defValue.contents = parse(v);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+function create(year2, month2, day2, h, m, s, ms, offset2) {
+  if (offset2 == null) {
+    offset2 = ms;
+    ms = 0;
+  }
+  checkOffsetInRange(offset2);
+  let date2 = new Date(Date.UTC(year2, month2 - 1, day2, h, m, s, ms) - offset2);
+  if (year2 <= 99) {
+    date2.setUTCFullYear(year2, month2 - 1, day2);
+  }
+  const dateValue = date2.getTime();
+  if (isNaN(dateValue)) {
+    throw new Exception("The parameters describe an unrepresentable Date");
+  }
+  return DateTimeOffset(dateValue, offset2);
+}
+function now() {
+  const date2 = /* @__PURE__ */ new Date();
+  const offset2 = date2.getTimezoneOffset() * -6e4;
+  return DateTimeOffset(date2.getTime(), offset2);
+}
+function utcNow() {
+  const date2 = /* @__PURE__ */ new Date();
+  return DateTimeOffset(date2.getTime(), 0);
+}
+function toUniversalTime(date2) {
+  return DateTime(date2.getTime(), DateTimeKind.Utc);
+}
+function toLocalTime(date2) {
+  return DateTime(date2.getTime(), DateTimeKind.Local);
+}
+function localDateTime(date2) {
+  return DateTime(date2.getTime(), DateTimeKind.Local);
+}
+function timeOfDay(d) {
+  const d2 = new Date(d.getTime() + offset(d));
+  return d2.getUTCHours() * 36e5 + d2.getUTCMinutes() * 6e4 + d2.getUTCSeconds() * 1e3 + d2.getUTCMilliseconds();
+}
+function date(d) {
+  const d2 = new Date(d.getTime() + offset(d));
+  return create$1(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);
+}
+function day(d) {
+  return new Date(d.getTime() + offset(d)).getUTCDate();
+}
+function hour(d) {
+  return new Date(d.getTime() + offset(d)).getUTCHours();
+}
+function millisecond(d) {
+  return new Date(d.getTime() + offset(d)).getUTCMilliseconds();
+}
+function minute(d) {
+  return new Date(d.getTime() + offset(d)).getUTCMinutes();
+}
+function month(d) {
+  return new Date(d.getTime() + offset(d)).getUTCMonth() + 1;
+}
+function second(d) {
+  return new Date(d.getTime() + offset(d)).getUTCSeconds();
+}
+function year(d) {
+  return new Date(d.getTime() + offset(d)).getUTCFullYear();
+}
+function dayOfWeek(d) {
+  return new Date(d.getTime() + offset(d)).getUTCDay();
+}
+function dayOfYear(d) {
+  const d2 = new Date(d.getTime() + offset(d));
+  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, offset(d));
+}
+function addDays(d, v) {
+  return add(d, v * 864e5);
+}
+function addHours(d, v) {
+  return add(d, v * 36e5);
+}
+function addMinutes(d, v) {
+  return add(d, v * 6e4);
+}
+function addSeconds(d, v) {
+  return add(d, v * 1e3);
+}
+function addMilliseconds(d, v) {
+  return add(d, v);
+}
+function addTicks(d, v) {
+  return add(d, toFloat64(v / 10000n));
+}
+function addYears(d, v) {
+  const d2 = new Date(d.getTime() + offset(d));
+  const newMonth = d2.getUTCMonth() + 1;
+  const newYear = d2.getUTCFullYear() + v;
+  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(),
+    offset(d)
+  );
+}
+function addMonths(d, v) {
+  const d2 = new Date(d.getTime() + offset(d));
+  const totalMonths = d2.getUTCMonth() + 1 + v;
+  const newMonth = ((totalMonths - 1) % 12 + 12) % 12 + 1;
+  const yearOffset = Math.floor((totalMonths - 1) / 12);
+  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(),
+    offset(d)
+  );
+}
+function subtract(d, that) {
+  return typeof that === "number" ? DateTimeOffset(d.getTime() - that, offset(d)) : 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, offset2) {
+  return DateTimeOffset(d.getTime(), offset2);
+}
+function toUnixTimeMilliseconds(d) {
+  return fromFloat64(d.getTime());
+}
+function toUnixTimeSeconds(d) {
+  return fromFloat64(d.getTime() / 1e3);
+}
+
+export { add, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addTicks, addYears, compare, compareTo, create, date, day, dayOfWeek, dayOfYear, DateTimeOffset as default, equals, equalsExact, fromDate, fromDateTime, fromTicks, fromUnixTimeMilliseconds, fromUnixTimeSeconds, getUtcTicks, hour, localDateTime, 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-ts/Decimal.js

@@ -0,0 +1,279 @@
+import { Big } from './lib/big.js';
+import { symbol } from './Numeric.js';
+import { FSharpRef } from './Types.js';
+import { combineHashCodes, Exception } from './Util.js';
+import { toInt8 as toInt8$1, fromDecimal, toUInt8 as toUInt8$1, toInt16 as toInt16$1, toUInt16 as toUInt16$1, toInt32 as toInt32$1, toUInt32 as toUInt32$1, toInt64 as toInt64$1, toUInt64 as toUInt64$1, toInt128 as toInt128$1, toUInt128 as toUInt128$1, toNativeInt as toNativeInt$1, toUNativeInt as toUNativeInt$1 } from './BigInt.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);
+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, min2, max2) {
+  return x.lt(min2) ? min2 : x.gt(max2) ? max2 : 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 : 0
+    /* ROUND_DOWN */
+  );
+}
+function floor(x) {
+  return x.round(
+    0,
+    x.cmp(0) >= 0 ? 0 : 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());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parse(str) {
+  const defValue = new FSharpRef(get_Zero);
+  if (tryParse(str, defValue)) {
+    return defValue.contents;
+  } else {
+    throw new Exception(`The input string ${str} was not in a correct format.`);
+  }
+}
+function toNumber(x) {
+  return +x;
+}
+function toChar(x) {
+  const n = toNumber(x);
+  if (n < 0 || n > 65535 || isNaN(n)) {
+    throw new Exception("Value was either too large or too small for a character.");
+  }
+  return String.fromCharCode(n);
+}
+function toInt8(x) {
+  return toInt8$1(fromDecimal(x));
+}
+function toUInt8(x) {
+  return toUInt8$1(fromDecimal(x));
+}
+function toInt16(x) {
+  return toInt16$1(fromDecimal(x));
+}
+function toUInt16(x) {
+  return toUInt16$1(fromDecimal(x));
+}
+function toInt32(x) {
+  return toInt32$1(fromDecimal(x));
+}
+function toUInt32(x) {
+  return toUInt32$1(fromDecimal(x));
+}
+function toInt64(x) {
+  return toInt64$1(fromDecimal(x));
+}
+function toUInt64(x) {
+  return toUInt64$1(fromDecimal(x));
+}
+function toInt128(x) {
+  return toInt128$1(fromDecimal(x));
+}
+function toUInt128(x) {
+  return toUInt128$1(fromDecimal(x));
+}
+function toNativeInt(x) {
+  return toNativeInt$1(fromDecimal(x));
+}
+function toUNativeInt(x) {
+  return toUNativeInt$1(fromDecimal(x));
+}
+function toFloat16(x) {
+  return toNumber(x);
+}
+function toFloat32(x) {
+  return toNumber(x);
+}
+function toFloat64(x) {
+  return toNumber(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 & 15;
+      value = digit >> 4;
+    }
+    if (value !== 0) {
+      hex[hexCount++] = value;
+    }
+  }
+  return hex.slice(0, hexCount);
+}
+function hexToDecimal(hex, bitSize) {
+  const dec = new Uint8Array(bitSize * 301 / 1e3 + 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);
+}
+function setInt32Bits(hexDigits, bits, offset) {
+  for (let i = 0; i < 8; i++) {
+    hexDigits[offset + i] = bits >> i * 4 & 15;
+  }
+}
+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 & 127;
+  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 & 127;
+  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 decStr = d.toString();
+  const absStr = decStr[0] === "-" ? decStr.slice(1) : decStr;
+  const dotPos = absStr.indexOf(".");
+  const scale = dotPos < 0 ? 0 : absStr.length - dotPos - 1;
+  const mantissaStr = absStr.replace(".", "");
+  const decDigits = Uint8Array.from(mantissaStr, (ch) => ch.charCodeAt(0) - 48);
+  const hexDigits = decimalToHex(decDigits, bitSize);
+  const low = getInt32Bits(hexDigits, 0);
+  const mid = getInt32Bits(hexDigits, 8);
+  const high = getInt32Bits(hexDigits, 16);
+  const signExp = (scale & 127) << 16 | (d.s < 0 ? 2147483648 : 0);
+  return [low, mid, high, signExp];
+}
+
+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, toChar, toFloat16, toFloat32, toFloat64, toInt128, toInt16, toInt32, toInt64, toInt8, toNativeInt, toNumber, toString, toUInt128, toUInt16, toUInt32, toUInt64, toUInt8, toUNativeInt, truncate, tryParse };

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

@@ -0,0 +1,53 @@
+import { FSharpRef } from './Types.js';
+import { Exception } from './Util.js';
+
+function tryParse(str, defValue) {
+  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 Exception(`The input string ${str} was not in a correct format.`);
+  }
+}
+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 Math.max(x, y);
+}
+function min(x, y) {
+  return Math.min(x, y);
+}
+function maxMagnitude(x, y) {
+  if (Number.isNaN(x) || Number.isNaN(y)) {
+    return NaN;
+  }
+  return Math.abs(x) > Math.abs(y) ? x : y;
+}
+function minMagnitude(x, y) {
+  if (Number.isNaN(x) || Number.isNaN(y)) {
+    return NaN;
+  }
+  return Math.abs(x) < Math.abs(y) ? x : y;
+}
+function clamp(x, min2, max2) {
+  return x < min2 ? min2 : x > max2 ? max2 : x;
+}
+
+export { clamp, isInfinity, isNegativeInfinity, isPositiveInfinity, max, maxMagnitude, min, minMagnitude, parse, tryParse };

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

@@ -0,0 +1,48 @@
+import { equals, structuralHash, physicalHash, compare } from './Util.js';
+
+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);
+    }
+  };
+}
+function HashIdentity_Structural() {
+  return {
+    GetHashCode(x) {
+      return structuralHash(x) | 0;
+    },
+    Equals(x_1, y) {
+      return equals(x_1, y);
+    }
+  };
+}
+function HashIdentity_Reference() {
+  return {
+    GetHashCode(x) {
+      return physicalHash(x) | 0;
+    },
+    Equals(x_1, y) {
+      return equals(x_1, y);
+    }
+  };
+}
+function ComparisonIdentity_FromFunction(comparer) {
+  return {
+    Compare(x, y) {
+      return (x == null ? y == null ? 0 : -1 : y == null ? 1 : comparer(x, y)) | 0;
+    }
+  };
+}
+function ComparisonIdentity_Structural() {
+  return {
+    Compare(x, y) {
+      return compare(x, y) | 0;
+    }
+  };
+}
+
+export { ComparisonIdentity_FromFunction, ComparisonIdentity_Structural, HashIdentity_FromFunctions, HashIdentity_Reference, HashIdentity_Structural };