@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,479 @@
+import { truncate, fromParts } from './Decimal.js';
+import { bigintHash, Exception } from './Util.js';
+
+const isBigEndian = false;
+BigInt.prototype.toJSON = function() {
+  return `${this.toString()}`;
+};
+const zero = 0n;
+const one = 1n;
+const two = 2n;
+const minusOne = -1n;
+function isBigInt(x) {
+  return typeof x === "bigint";
+}
+function hash(x) {
+  return bigintHash(x);
+}
+function equals(x, y) {
+  return x === y;
+}
+function compare(x, y) {
+  return x < y ? -1 : x > y ? 1 : 0;
+}
+function abs(x) {
+  return x < zero ? -x : x;
+}
+function sign(x) {
+  return x < zero ? -1 : x > zero ? 1 : 0;
+}
+function max(x, y) {
+  return x > y ? x : y;
+}
+function min(x, y) {
+  return x < y ? x : y;
+}
+function maxMagnitude(x, y) {
+  return abs(x) > abs(y) ? x : y;
+}
+function minMagnitude(x, y) {
+  return abs(x) < abs(y) ? x : y;
+}
+function clamp(x, min2, max2) {
+  return x < min2 ? min2 : x > max2 ? max2 : x;
+}
+function add(x, y) {
+  return x + y;
+}
+function subtract(x, y) {
+  return x - y;
+}
+function multiply(x, y) {
+  return x * y;
+}
+function divide(x, y) {
+  return x / y;
+}
+function remainder(x, y) {
+  return x % y;
+}
+function negate(x) {
+  return -x;
+}
+function op_UnaryNegation(x) {
+  return -x;
+}
+function op_LogicalNot(x) {
+  return ~x;
+}
+function op_UnaryPlus(x) {
+  return x;
+}
+function op_Addition(x, y) {
+  return x + y;
+}
+function op_Subtraction(x, y) {
+  return x - y;
+}
+function op_Multiply(x, y) {
+  return x * y;
+}
+function op_Division(x, y) {
+  return x / y;
+}
+function op_Modulus(x, y) {
+  return x % y;
+}
+function op_RightShift(x, n) {
+  return x >> BigInt(n);
+}
+function op_LeftShift(x, n) {
+  return x << BigInt(n);
+}
+function op_BitwiseAnd(x, y) {
+  return x & y;
+}
+function op_BitwiseOr(x, y) {
+  return x | y;
+}
+function op_ExclusiveOr(x, y) {
+  return x ^ y;
+}
+function op_LessThan(x, y) {
+  return x < y;
+}
+function op_LessThanOrEqual(x, y) {
+  return x <= y;
+}
+function op_GreaterThan(x, y) {
+  return x > y;
+}
+function op_GreaterThanOrEqual(x, y) {
+  return x >= y;
+}
+function op_Equality(x, y) {
+  return x === y;
+}
+function op_Inequality(x, y) {
+  return x !== y;
+}
+function get_Zero() {
+  return zero;
+}
+function get_One() {
+  return one;
+}
+function get_MinusOne() {
+  return minusOne;
+}
+function get_IsZero(x) {
+  return x === zero;
+}
+function get_IsOne(x) {
+  return x === one;
+}
+function get_IsEven(x) {
+  return isEvenInteger(x);
+}
+function get_IsPowerOfTwo(x) {
+  return isPow2(x);
+}
+function get_Sign(x) {
+  return sign(x);
+}
+function isNegative(x) {
+  return x < zero;
+}
+function isPositive(x) {
+  return x > zero;
+}
+function isEvenInteger(x) {
+  return x % two === zero;
+}
+function isOddInteger(x) {
+  return x % two !== zero;
+}
+function isPow2(x) {
+  return (x & x - one) === zero;
+}
+function fromZero() {
+  return zero;
+}
+function fromOne() {
+  return one;
+}
+function fromInt8(n) {
+  return BigInt(n);
+}
+function fromUInt8(n) {
+  return BigInt(n);
+}
+function fromInt16(n) {
+  return BigInt(n);
+}
+function fromUInt16(n) {
+  return BigInt(n);
+}
+function fromInt32(n) {
+  return BigInt(n);
+}
+function fromUInt32(n) {
+  return BigInt(n);
+}
+function fromInt64(n) {
+  return n;
+}
+function fromUInt64(n) {
+  return n;
+}
+function fromInt128(n) {
+  return n;
+}
+function fromUInt128(n) {
+  return n;
+}
+function fromNativeInt(n) {
+  return n;
+}
+function fromUNativeInt(n) {
+  return n;
+}
+function fromFloat16(n) {
+  return BigInt(Math.trunc(n));
+}
+function fromFloat32(n) {
+  return BigInt(Math.trunc(n));
+}
+function fromFloat64(n) {
+  return BigInt(Math.trunc(n));
+}
+function fromDecimal(d) {
+  return BigInt(truncate(d).toString());
+}
+function fromBigInt(x) {
+  return x;
+}
+function fromBoolean(b) {
+  return BigInt(b);
+}
+function fromChar(c) {
+  return BigInt(c.charCodeAt(0));
+}
+function fromString(s) {
+  return BigInt(s);
+}
+function fromByteArray(bytes) {
+  return fromSignedBytes(bytes, isBigEndian);
+}
+function toByteArray(value) {
+  return toSignedBytes(value, isBigEndian);
+}
+function toIntN_unchecked(bits, x, signed) {
+  return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+}
+function toIntN(bits, x, signed) {
+  const truncated = signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+  if (truncated !== x) {
+    const s = signed ? "a signed" : "an unsigned";
+    throw new Exception(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
+  }
+  return truncated;
+}
+function toInt8(x) {
+  return Number(toIntN(8, x, true));
+}
+function toUInt8(x) {
+  return Number(toIntN(8, x, false));
+}
+function toInt16(x) {
+  return Number(toIntN(16, x, true));
+}
+function toUInt16(x) {
+  return Number(toIntN(16, x, false));
+}
+function toInt32(x) {
+  return Number(toIntN(32, x, true));
+}
+function toUInt32(x) {
+  return Number(toIntN(32, x, false));
+}
+function toInt64(x) {
+  return toIntN(64, x, true);
+}
+function toUInt64(x) {
+  return toIntN(64, x, false);
+}
+function toInt128(x) {
+  return toIntN(128, x, true);
+}
+function toUInt128(x) {
+  return toIntN(128, x, false);
+}
+function toNativeInt(x) {
+  return toIntN(64, x, true);
+}
+function toUNativeInt(x) {
+  return toIntN(64, x, false);
+}
+function toInt8_unchecked(x) {
+  return Number(toIntN_unchecked(8, x, true));
+}
+function toUInt8_unchecked(x) {
+  return Number(toIntN_unchecked(8, x, false));
+}
+function toInt16_unchecked(x) {
+  return Number(toIntN_unchecked(16, x, true));
+}
+function toUInt16_unchecked(x) {
+  return Number(toIntN_unchecked(16, x, false));
+}
+function toInt32_unchecked(x) {
+  return Number(toIntN_unchecked(32, x, true));
+}
+function toUInt32_unchecked(x) {
+  return Number(toIntN_unchecked(32, x, false));
+}
+function toInt64_unchecked(x) {
+  return toIntN_unchecked(64, x, true);
+}
+function toUInt64_unchecked(x) {
+  return toIntN_unchecked(64, x, false);
+}
+function toInt128_unchecked(x) {
+  return toIntN_unchecked(128, x, true);
+}
+function toUInt128_unchecked(x) {
+  return toIntN_unchecked(128, x, false);
+}
+function toNativeInt_unchecked(x) {
+  return toIntN_unchecked(64, x, true);
+}
+function toUNativeInt_unchecked(x) {
+  return toIntN_unchecked(64, x, false);
+}
+function toFloat16(x) {
+  return Number(x);
+}
+function toFloat32(x) {
+  return Number(x);
+}
+function toFloat64(x) {
+  return Number(x);
+}
+function toDecimal(x) {
+  const isNegative2 = x < zero;
+  const bits = abs(x);
+  if (bits >> 96n !== zero) {
+    throw new Exception("Value was either too large or too small for a Decimal.");
+  }
+  const low = Number(BigInt.asUintN(32, bits));
+  const mid = Number(BigInt.asUintN(32, bits >> 32n));
+  const high = Number(BigInt.asUintN(32, bits >> 64n));
+  const scale = 0;
+  return fromParts(low, mid, high, isNegative2, scale);
+}
+function toBigInt(x) {
+  return x;
+}
+function toBoolean(x) {
+  return x !== zero;
+}
+function toChar(x) {
+  return String.fromCharCode(toUInt16(x));
+}
+function toString(x) {
+  return x.toString();
+}
+function tryParse(s, res) {
+  try {
+    res.contents = BigInt(s);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function parse(s) {
+  return BigInt(s);
+}
+function pow(x, n) {
+  return x ** BigInt(n);
+}
+function modPow(x, e, m) {
+  return x ** e % m;
+}
+function divRem(x, y, out) {
+  const div = x / y;
+  const rem = x % y;
+  if (out === void 0) {
+    return [div, rem];
+  } else {
+    out.contents = rem;
+    return div;
+  }
+}
+function greatestCommonDivisor(x, y) {
+  x = abs(x);
+  y = abs(y);
+  while (y > zero) {
+    const q = x / y;
+    const r = x - q * y;
+    x = y;
+    y = r;
+  }
+  return x;
+}
+function bitLength(x) {
+  const hex = x.toString(16);
+  return (hex.length - 1) * 4 + (32 - Math.clz32(fromHexCode(hex.charCodeAt(0))));
+}
+function getBitLength(x) {
+  if (x < zero) {
+    x = -x - one;
+  }
+  return x === zero ? zero : BigInt(bitLength(x));
+}
+function log2(x) {
+  const n = Number(x);
+  if (Number.isFinite(n))
+    return Math.log2(n);
+  if (x < zero) return Number.NaN;
+  let shift = one;
+  while (x >= one << shift) {
+    shift = shift << one;
+  }
+  let log3 = zero;
+  while (shift > one) {
+    shift = shift >> one;
+    if (x >= one << shift) {
+      log3 = log3 + shift;
+      x = x >> shift;
+    }
+  }
+  return Number(log3);
+}
+function log10(x) {
+  return log2(x) * Math.log10(2);
+}
+function ln(x) {
+  return log2(x) * Math.log(2);
+}
+function log(x, base) {
+  return log2(x) / Math.log2(base);
+}
+function ilog2(x) {
+  if (x < zero) {
+    throw new Exception("Value must be non-negative.");
+  }
+  return x === zero ? zero : BigInt(bitLength(x) - 1);
+}
+const hexCodes = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102]);
+function fromHexCode(code) {
+  if (48 <= code && code <= 57) return code - 48;
+  if (97 <= code && code <= 102) return code - 97 + 10;
+  if (65 <= code && code <= 70) return code - 65 + 10;
+  throw Error(`Invalid hex code: ${code}`);
+}
+function toSignedBytes(x, isBigEndian2) {
+  const isNeg = x < 0n;
+  const sentinel = isNeg ? -1n : 0n;
+  const bytes = [];
+  do {
+    bytes.push(Number(BigInt.asUintN(8, x)));
+    x = x >> 8n;
+  } while (x !== sentinel);
+  if (isNeg !== bytes[bytes.length - 1] > 127) {
+    bytes.push(isNeg ? 255 : 0);
+  }
+  if (isBigEndian2) {
+    bytes.reverse();
+  }
+  return new Uint8Array(bytes);
+}
+function fromSignedBytes(bytes, isBigEndian2) {
+  if (bytes == null) {
+    throw new Exception("bytes is null");
+  }
+  const len = bytes.length;
+  const first = isBigEndian2 ? 0 : len - 1;
+  const isNeg = bytes[first] > 127;
+  const codes = new Uint16Array(len * 2 + 2);
+  codes[0] = 48;
+  codes[1] = 120;
+  const inc = isBigEndian2 ? 1 : -1;
+  let pos = isBigEndian2 ? 0 : len - 1;
+  for (let i = 0; i < bytes.length; i++, pos += inc) {
+    const byte = bytes[pos];
+    codes[2 * i + 2] = hexCodes[byte >> 4];
+    codes[2 * i + 3] = hexCodes[byte & 15];
+  }
+  const str = String.fromCharCode.apply(null, codes);
+  let x = BigInt(str);
+  if (isNeg) {
+    const bits = len * 8;
+    const pow2 = 1n << BigInt(bits);
+    x = x - pow2;
+  }
+  return x;
+}
+
+export { abs, add, clamp, compare, divRem, divide, equals, fromBigInt, fromBoolean, fromByteArray, fromChar, fromDecimal, fromFloat16, fromFloat32, fromFloat64, fromInt128, fromInt16, fromInt32, fromInt64, fromInt8, fromNativeInt, fromOne, fromString, fromUInt128, fromUInt16, fromUInt32, fromUInt64, fromUInt8, fromUNativeInt, fromZero, getBitLength, get_IsEven, get_IsOne, get_IsPowerOfTwo, get_IsZero, get_MinusOne, get_One, get_Sign, get_Zero, greatestCommonDivisor, hash, ilog2, isBigInt, isEvenInteger, isNegative, isOddInteger, isPositive, isPow2, ln, log, log10, log2, max, maxMagnitude, min, minMagnitude, modPow, multiply, negate, op_Addition, op_BitwiseAnd, op_BitwiseOr, op_Division, op_Equality, op_ExclusiveOr, op_GreaterThan, op_GreaterThanOrEqual, op_Inequality, op_LeftShift, op_LessThan, op_LessThanOrEqual, op_LogicalNot, op_Modulus, op_Multiply, op_RightShift, op_Subtraction, op_UnaryNegation, op_UnaryPlus, parse, pow, remainder, sign, subtract, toBigInt, toBoolean, toByteArray, toChar, toDecimal, toFloat16, toFloat32, toFloat64, toInt128, toInt128_unchecked, toInt16, toInt16_unchecked, toInt32, toInt32_unchecked, toInt64, toInt64_unchecked, toInt8, toInt8_unchecked, toIntN, toIntN_unchecked, toNativeInt, toNativeInt_unchecked, toString, toUInt128, toUInt128_unchecked, toUInt16, toUInt16_unchecked, toUInt32, toUInt32_unchecked, toUInt64, toUInt64_unchecked, toUInt8, toUInt8_unchecked, toUNativeInt, toUNativeInt_unchecked, tryParse };

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

@@ -0,0 +1,23 @@
+import { FSharpRef } from './Types.js';
+import { Exception } from './Util.js';
+
+function tryParse(str, defValue) {
+  if (str != null && str.match(/^\s*true\s*$/i)) {
+    defValue.contents = true;
+    return true;
+  } else if (str != null && str.match(/^\s*false\s*$/i)) {
+    defValue.contents = false;
+    return true;
+  }
+  return false;
+}
+function parse(str) {
+  const defValue = new FSharpRef(false);
+  if (tryParse(str, defValue)) {
+    return defValue.contents;
+  } else {
+    throw new Exception(`String '${str}' was not recognized as a valid Boolean.`);
+  }
+}
+
+export { parse, tryParse };

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

@@ -0,0 +1,172 @@
+import { rangeDeltas, categories } from './Unicode.13.0.0.js';
+import { Exception } from './Util.js';
+
+function getCategoryFunc() {
+  const offset = 35;
+  const a1 = [...rangeDeltas].map((ch) => (ch.codePointAt(0) ?? 0) - offset);
+  const a2 = [...categories].map((ch) => (ch.codePointAt(0) ?? 0) - offset);
+  const codepoints = new Uint32Array(a1);
+  const categories$1 = new Uint8Array(a2);
+  for (let i = 1; i < codepoints.length; ++i) {
+    codepoints[i] += codepoints[i - 1];
+  }
+  return (cp) => {
+    let hi = codepoints.length;
+    let lo = 0;
+    while (hi - lo > 1) {
+      const mid = Math.floor((hi + lo) / 2);
+      const test = codepoints[mid];
+      if (cp < test) {
+        hi = mid;
+      } else if (cp === test) {
+        hi = lo = mid;
+        break;
+      } else if (test < cp) {
+        lo = mid;
+      }
+    }
+    return categories$1[lo];
+  };
+}
+const UnicodeCategory = {
+  UppercaseLetter: 0,
+  LowercaseLetter: 1,
+  TitlecaseLetter: 2,
+  ModifierLetter: 3,
+  OtherLetter: 4,
+  NonSpacingMark: 5,
+  SpacingCombiningMark: 6,
+  EnclosingMark: 7,
+  DecimalDigitNumber: 8,
+  LetterNumber: 9,
+  OtherNumber: 10,
+  SpaceSeparator: 11,
+  LineSeparator: 12,
+  ParagraphSeparator: 13,
+  Control: 14,
+  Format: 15,
+  Surrogate: 16,
+  PrivateUse: 17,
+  ConnectorPunctuation: 18,
+  DashPunctuation: 19,
+  OpenPunctuation: 20,
+  ClosePunctuation: 21,
+  InitialQuotePunctuation: 22,
+  FinalQuotePunctuation: 23,
+  OtherPunctuation: 24,
+  MathSymbol: 25,
+  CurrencySymbol: 26,
+  ModifierSymbol: 27,
+  OtherSymbol: 28,
+  OtherNotAssigned: 29
+};
+const isControlMask = 1 << UnicodeCategory.Control;
+const isDigitMask = 1 << UnicodeCategory.DecimalDigitNumber;
+const isLetterMask = 0 | 1 << UnicodeCategory.UppercaseLetter | 1 << UnicodeCategory.LowercaseLetter | 1 << UnicodeCategory.TitlecaseLetter | 1 << UnicodeCategory.ModifierLetter | 1 << UnicodeCategory.OtherLetter;
+const isLetterOrDigitMask = isLetterMask | isDigitMask;
+const isUpperMask = 1 << UnicodeCategory.UppercaseLetter;
+const isLowerMask = 1 << UnicodeCategory.LowercaseLetter;
+const isNumberMask = 0 | 1 << UnicodeCategory.DecimalDigitNumber | 1 << UnicodeCategory.LetterNumber | 1 << UnicodeCategory.OtherNumber;
+const isPunctuationMask = 0 | 1 << UnicodeCategory.ConnectorPunctuation | 1 << UnicodeCategory.DashPunctuation | 1 << UnicodeCategory.OpenPunctuation | 1 << UnicodeCategory.ClosePunctuation | 1 << UnicodeCategory.InitialQuotePunctuation | 1 << UnicodeCategory.FinalQuotePunctuation | 1 << UnicodeCategory.OtherPunctuation;
+const isSeparatorMask = 0 | 1 << UnicodeCategory.SpaceSeparator | 1 << UnicodeCategory.LineSeparator | 1 << UnicodeCategory.ParagraphSeparator;
+const isSymbolMask = 0 | 1 << UnicodeCategory.MathSymbol | 1 << UnicodeCategory.CurrencySymbol | 1 << UnicodeCategory.ModifierSymbol | 1 << UnicodeCategory.OtherSymbol;
+const isWhiteSpaceMask = 0 | 1 << UnicodeCategory.SpaceSeparator | 1 << UnicodeCategory.LineSeparator | 1 << UnicodeCategory.ParagraphSeparator;
+const unicodeCategoryFunc = getCategoryFunc();
+function charCodeAt(s, index) {
+  if (index >= 0 && index < s.length) {
+    return s.charCodeAt(index);
+  } else {
+    throw new Exception("Index out of range.");
+  }
+}
+const getUnicodeCategory = (s) => getUnicodeCategory2(s, 0);
+const isControl = (s) => isControl2(s, 0);
+const isDigit = (s) => isDigit2(s, 0);
+const isLetter = (s) => isLetter2(s, 0);
+const isLetterOrDigit = (s) => isLetterOrDigit2(s, 0);
+const isUpper = (s) => isUpper2(s, 0);
+const isLower = (s) => isLower2(s, 0);
+const isNumber = (s) => isNumber2(s, 0);
+const isPunctuation = (s) => isPunctuation2(s, 0);
+const isSeparator = (s) => isSeparator2(s, 0);
+const isSymbol = (s) => isSymbol2(s, 0);
+const isWhiteSpace = (s) => isWhiteSpace2(s, 0);
+const isHighSurrogate = (s) => isHighSurrogate2(s, 0);
+const isLowSurrogate = (s) => isLowSurrogate2(s, 0);
+const isSurrogate = (s) => isSurrogate2(s, 0);
+function getUnicodeCategory2(s, index) {
+  const cp = charCodeAt(s, index);
+  return unicodeCategoryFunc(cp);
+}
+function isControl2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isControlMask) !== 0;
+}
+function isDigit2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isDigitMask) !== 0;
+}
+function isLetter2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isLetterMask) !== 0;
+}
+function isLetterOrDigit2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isLetterOrDigitMask) !== 0;
+}
+function isUpper2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isUpperMask) !== 0;
+}
+function isLower2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isLowerMask) !== 0;
+}
+function isNumber2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isNumberMask) !== 0;
+}
+function isPunctuation2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isPunctuationMask) !== 0;
+}
+function isSeparator2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isSeparatorMask) !== 0;
+}
+function isSymbol2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  return (test & isSymbolMask) !== 0;
+}
+function isWhiteSpace2(s, index) {
+  const test = 1 << getUnicodeCategory2(s, index);
+  if ((test & isWhiteSpaceMask) !== 0) {
+    return true;
+  }
+  const cp = charCodeAt(s, index);
+  return 9 <= cp && cp <= 13 || cp === 133 || cp === 160;
+}
+function isHighSurrogate2(s, index) {
+  const cp = charCodeAt(s, index);
+  return 55296 <= cp && cp <= 56319;
+}
+function isLowSurrogate2(s, index) {
+  const cp = charCodeAt(s, index);
+  return 56320 <= cp && cp <= 57343;
+}
+function isSurrogate2(s, index) {
+  const cp = charCodeAt(s, index);
+  return 55296 <= cp && cp <= 57343;
+}
+function isSurrogatePair(s, index) {
+  return typeof index === "number" ? isHighSurrogate2(s, index) && isLowSurrogate2(s, index + 1) : isHighSurrogate(s) && isLowSurrogate(index);
+}
+function parse(input) {
+  if (input.length === 1) {
+    return input[0];
+  } else {
+    throw new Exception("String must be exactly one character long.");
+  }
+}
+
+export { UnicodeCategory, getUnicodeCategory, getUnicodeCategory2, isControl, isControl2, isDigit, isDigit2, isHighSurrogate, isHighSurrogate2, isLetter, isLetter2, isLetterOrDigit, isLetterOrDigit2, isLowSurrogate, isLowSurrogate2, isLower, isLower2, isNumber, isNumber2, isPunctuation, isPunctuation2, isSeparator, isSeparator2, isSurrogate, isSurrogate2, isSurrogatePair, isSymbol, isSymbol2, isUpper, isUpper2, isWhiteSpace, isWhiteSpace2, parse };