@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,148 @@
+import { structuralHash, equals, Exception, defaultOf, disposeSafe } from './Util.js';
+import { ComparisonIdentity_Structural, HashIdentity_Structural } from './FSharp.Collections.js';
+import { nonNullValue } from './Option.js';
+import { ArgumentNullException_$ctor_Z721C83C5, NullReferenceException_$ctor } from './System.js';
+import { FSharpChoice$2_Choice1Of2, FSharpChoice$2_Choice2Of2 } from './Choice.js';
+import { StringBuilder__Append_Z721C83C5 } from './System.Text.js';
+
+const LanguagePrimitives_GenericEqualityComparer = {
+  Equals(x, y) {
+    return equals(x, y);
+  },
+  GetHashCode(x_1) {
+    return structuralHash(x_1) | 0;
+  }
+};
+const LanguagePrimitives_GenericEqualityERComparer = {
+  Equals(x, y) {
+    return equals(x, y);
+  },
+  GetHashCode(x_1) {
+    return structuralHash(x_1) | 0;
+  }
+};
+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 Exception(message);
+}
+function Operators_FailurePattern(exn) {
+  return exn.message;
+}
+function Operators_NullArg(argumentName) {
+  throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
+}
+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 Operators_IsNull(value) {
+  if (equals(value, defaultOf())) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function Operators_IsNotNull(value) {
+  if (equals(value, defaultOf())) {
+    return false;
+  } else {
+    return true;
+  }
+}
+function Operators_IsNullV(value) {
+  return !(value != null);
+}
+function Operators_NonNull(value) {
+  if (equals(value, defaultOf())) {
+    throw NullReferenceException_$ctor();
+  } else {
+    return value;
+  }
+}
+function Operators_NonNullV(value) {
+  if (value != null) {
+    return nonNullValue(value);
+  } else {
+    throw NullReferenceException_$ctor();
+  }
+}
+function Operators_NullMatchPattern(value) {
+  if (equals(value, defaultOf())) {
+    return FSharpChoice$2_Choice1Of2(void 0);
+  } else {
+    return FSharpChoice$2_Choice2Of2(value);
+  }
+}
+function Operators_NullValueMatchPattern(value) {
+  if (value != null) {
+    return FSharpChoice$2_Choice2Of2(nonNullValue(value));
+  } else {
+    return FSharpChoice$2_Choice1Of2(void 0);
+  }
+}
+function Operators_NonNullQuickPattern(value) {
+  if (equals(value, defaultOf())) {
+    throw NullReferenceException_$ctor();
+  } else {
+    return value;
+  }
+}
+function Operators_NonNullQuickValuePattern(value) {
+  if (value != null) {
+    return nonNullValue(value);
+  } else {
+    throw NullReferenceException_$ctor();
+  }
+}
+function Operators_WithNull(value) {
+  return value;
+}
+function Operators_WithNullV(value) {
+  return value;
+}
+function Operators_NullV() {
+  return null;
+}
+function Operators_NullArgCheck(argumentName, value) {
+  if (equals(value, defaultOf())) {
+    throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
+  } else {
+    return value;
+  }
+}
+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 { ExtraTopLevelOperators_LazyPattern, LanguagePrimitives_FastGenericComparer, LanguagePrimitives_FastGenericComparerFromTable, LanguagePrimitives_FastGenericEqualityComparer, LanguagePrimitives_FastGenericEqualityComparerFromTable, LanguagePrimitives_GenericEqualityComparer, LanguagePrimitives_GenericEqualityERComparer, Operators_Failure, Operators_FailurePattern, Operators_IsNotNull, Operators_IsNull, Operators_IsNullV, Operators_Lock, Operators_NonNull, Operators_NonNullQuickPattern, Operators_NonNullQuickValuePattern, Operators_NonNullV, Operators_NullArg, Operators_NullArgCheck, Operators_NullMatchPattern, Operators_NullV, Operators_NullValueMatchPattern, Operators_Using, Operators_WithNull, Operators_WithNullV, PrintfModule_PrintFormatToStringBuilder, PrintfModule_PrintFormatToStringBuilderThen };

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

@@ -0,0 +1,31 @@
+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.";
+const SR_Arg_ApplicationException = "Error in the application.";
+const SR_Arg_ArgumentException = "Value does not fall within the expected range.";
+const SR_Arg_ArgumentOutOfRangeException = "Specified argument was out of the range of valid values.";
+const SR_ArgumentNull_Generic = "Value cannot be null.";
+const SR_Arg_ParamName_Name = " (Parameter '";
+const SR_Arg_ArithmeticException = "Overflow or underflow in the arithmetic operation.";
+const SR_Arg_DivideByZero = "Attempted to divide by zero.";
+const SR_Arg_FormatException = "One of the identified items was in an invalid format.";
+const SR_Arg_IndexOutOfRangeException = "Index was outside the bounds of the array.";
+const SR_Arg_InvalidOperationException = "Operation is not valid due to the current state of the object.";
+const SR_Arg_KeyNotFound = "The given key was not present in the dictionary.";
+const SR_Arg_NotFiniteNumberException = "Number encountered was not a finite quantity.";
+const SR_Arg_NotImplementedException = "The method or operation is not implemented.";
+const SR_Arg_NotSupportedException = "Specified method is not supported.";
+const SR_Arg_NullReferenceException = "Object reference not set to an instance of an object.";
+const SR_Arg_OutOfMemoryException = "Insufficient memory to continue the execution of the program.";
+const SR_Arg_OverflowException = "Arithmetic operation resulted in an overflow.";
+const SR_Arg_RankException = "Attempted to operate on an array with the incorrect number of dimensions.";
+const SR_Arg_StackOverflowException = "Operation caused a stack overflow.";
+const SR_Arg_SystemException = "System error.";
+const SR_Arg_TimeoutException = "The operation has timed out.";
+
+export { SR_Arg_ApplicationException, SR_Arg_ArgumentException, SR_Arg_ArgumentOutOfRangeException, SR_Arg_ArithmeticException, SR_Arg_DivideByZero, SR_Arg_FormatException, SR_Arg_IndexOutOfRangeException, SR_Arg_InvalidOperationException, SR_Arg_KeyNotFound, SR_Arg_NotFiniteNumberException, SR_Arg_NotImplementedException, SR_Arg_NotSupportedException, SR_Arg_NullReferenceException, SR_Arg_OutOfMemoryException, SR_Arg_OverflowException, SR_Arg_ParamName_Name, SR_Arg_RankException, SR_Arg_StackOverflowException, SR_Arg_SystemException, SR_Arg_TimeoutException, SR_ArgumentNull_Generic, 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-ts/Guid.js

@@ -0,0 +1,140 @@
+import { trim } from './String.js';
+import { Exception } from './Util.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 Exception("Unrecognized Guid print format");
+    }
+  } else {
+    return str;
+  }
+}
+function parse(str) {
+  function hyphenateGuid(str2) {
+    return str2.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 Exception("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;
+  }
+}
+function newGuid() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function createVersion7(timestamp) {
+  const ms = timestamp != null ? timestamp.getTime() : Date.now();
+  const msHex = Math.floor(ms).toString(16).padStart(12, "0");
+  const bytes = new Uint8Array(10);
+  crypto.getRandomValues(bytes);
+  const view = new DataView(bytes.buffer);
+  const randA = view.getUint16(0) & 4095;
+  const randB1 = view.getUint16(2) & 16383;
+  const randB2 = view.getUint32(4);
+  const randB3 = view.getUint16(8);
+  const timeLow = msHex.slice(0, 8);
+  const timeMid = msHex.slice(8, 12);
+  const ver = (28672 | randA).toString(16).padStart(4, "0");
+  const variantAndRandB = (32768 | randB1).toString(16).padStart(4, "0");
+  const node = randB2.toString(16).padStart(8, "0") + randB3.toString(16).padStart(4, "0");
+  return `${timeLow}-${timeMid}-${ver}-${variantAndRandB}-${node}`;
+}
+let _convertMapsInitialized = false;
+let _byteToHex;
+let _hexToByte;
+function initConvertMaps() {
+  _byteToHex = new Array(256);
+  _hexToByte = {};
+  for (let i = 0; i < 256; i++) {
+    _byteToHex[i] = i.toString(16).padStart(2, "0");
+    _hexToByte[_byteToHex[i]] = i;
+  }
+  _convertMapsInitialized = true;
+}
+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;
+    }
+  });
+  while (i < 16) {
+    buf[i++] = 0;
+  }
+  return buf;
+}
+function arrayToGuid(buf) {
+  if (buf.length !== 16) {
+    throw new Exception("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 { arrayToGuid, createVersion7, guidToArray, newGuid, parse, toString, tryParse };

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

@@ -0,0 +1,165 @@
+import { Exception } from './Util.js';
+
+const NumberStyles = {
+  // None: 0x00000000,
+  // AllowLeadingWhite: 0x00000001,
+  // AllowTrailingWhite: 0x00000002,
+  // AllowLeadingSign: 0x00000004,
+  // AllowTrailingSign: 0x00000008,
+  // AllowParentheses: 0x00000010,
+  // AllowDecimalPoint: 0x00000020,
+  // AllowThousands: 0x00000040,
+  // AllowExponent: 0x00000080,
+  // AllowCurrencySymbol: 0x00000100,
+  AllowHexSpecifier: 512
+  // 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,
+};
+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 Exception("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 Exception("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 Exception(`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_Int8(x) {
+  return x === -128 ? x : -x;
+}
+function op_UnaryNegation_Int16(x) {
+  return x === -32768 ? x : -x;
+}
+function op_UnaryNegation_Int32(x) {
+  return x === -2147483648 ? x : -x;
+}
+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;
+  }
+}
+
+export { NumberStyles, divRem, getPrefix, getRadix, isValid, op_UnaryNegation_Int16, op_UnaryNegation_Int32, op_UnaryNegation_Int8, parse, tryParse };