@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,63 @@
+const symbol = Symbol("numeric");
+function isNumeric(x) {
+  return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
+}
+function isIntegral(x) {
+  return typeof x === "number" && Number.isInteger(x) || typeof x === "bigint";
+}
+function compare(x, y) {
+  if (typeof x === "number") {
+    return x < y ? -1 : x > y ? 1 : 0;
+  } else if (typeof x === "bigint") {
+    return x < y ? -1 : x > y ? 1 : 0;
+  } else {
+    return x.CompareTo(y);
+  }
+}
+function multiply(x, y) {
+  if (typeof x === "number") {
+    return x * y;
+  } else if (typeof x === "bigint") {
+    return x * BigInt(y);
+  } else {
+    return x[symbol]().multiply(y);
+  }
+}
+function toFixed(x, dp) {
+  if (typeof x === "number") {
+    return x.toFixed(dp);
+  } else if (typeof x === "bigint") {
+    return x.toString();
+  } else {
+    return x[symbol]().toFixed(dp);
+  }
+}
+function toPrecision(x, sd) {
+  if (typeof x === "number") {
+    return x.toPrecision(sd);
+  } else if (typeof x === "bigint") {
+    return x.toString();
+  } else {
+    return x[symbol]().toPrecision(sd);
+  }
+}
+function toExponential(x, dp) {
+  if (typeof x === "number") {
+    return x.toExponential(dp);
+  } else if (typeof x === "bigint") {
+    return x;
+  } else {
+    return x[symbol]().toExponential(dp);
+  }
+}
+function toHex(x) {
+  if (typeof x === "number") {
+    return (Number(x) >>> 0).toString(16);
+  } else if (typeof x === "bigint") {
+    return BigInt.asUintN(64, x).toString(16);
+  } else {
+    return x[symbol]().toHex();
+  }
+}
+
+export { compare, isIntegral, isNumeric, multiply, symbol, toExponential, toFixed, toHex, toPrecision };

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

@@ -0,0 +1,81 @@
+import { structuralHash, equals, compare, Exception } from './Util.js';
+
+class Some {
+  constructor(value2) {
+    this.value = value2;
+  }
+  toJSON() {
+    return this.value;
+  }
+  // Don't add "Some" for consistency with erased options
+  toString() {
+    return String(this.value);
+  }
+  GetHashCode() {
+    return structuralHash(this.value);
+  }
+  Equals(other) {
+    if (other == null) {
+      return false;
+    } else {
+      return equals(this.value, other instanceof Some ? other.value : other);
+    }
+  }
+  CompareTo(other) {
+    if (other == null) {
+      return 1;
+    } else {
+      return compare(this.value, other instanceof Some ? other.value : other);
+    }
+  }
+}
+function nonNullValue(x) {
+  if (x == null) {
+    throw new Exception("Nullable has no value");
+  } else {
+    return x;
+  }
+}
+function value(x) {
+  if (x == null) {
+    throw new Exception("Option has no value");
+  } else {
+    return x instanceof Some ? x.value : x;
+  }
+}
+function unwrap(opt) {
+  return opt instanceof Some ? opt.value : opt;
+}
+function some(x) {
+  return x == null || x instanceof Some ? new Some(x) : x;
+}
+function ofNullable(x) {
+  return x == null ? void 0 : x;
+}
+function toNullable(x) {
+  return x == null ? null : value(x);
+}
+function flatten(x) {
+  return x == null ? void 0 : value(x);
+}
+function toArray(opt) {
+  return opt == null ? [] : [value(opt)];
+}
+function defaultArg(opt, defaultValue) {
+  return opt != null ? value(opt) : defaultValue;
+}
+function orElse(opt, ifNone) {
+  return opt == null ? ifNone : opt;
+}
+function map(mapping, opt) {
+  return opt != null ? some(mapping(value(opt))) : void 0;
+}
+function tryOp(op, arg) {
+  try {
+    return some(op(arg));
+  } catch {
+    return void 0;
+  }
+}
+
+export { Some, defaultArg, flatten, map, nonNullValue, ofNullable, orElse, some, toArray, toNullable, tryOp, unwrap, value };

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

@@ -0,0 +1,174 @@
+import { ArgumentOutOfRangeException_$ctor_Z721C83C5, ArgumentNullException_$ctor_Z721C83C5 } from './System.js';
+import { Operators_IsNull } from './FSharp.Core.js';
+import { class_type } from './Reflection.js';
+import { toInt64_unchecked, fromInt32, compare, toFloat64, toInt32_unchecked, op_Addition, fromFloat64 } from './BigInt.js';
+import { item, setItem } from './Array.js';
+
+function Native_random() {
+  return Math.random();
+}
+function Native_randomNext(minValue, maxValue) {
+  if (maxValue < minValue) {
+    throw ArgumentOutOfRangeException_$ctor_Z721C83C5("minValue must be less than maxValue");
+  }
+  return Math.floor(Math.random() * (maxValue - minValue)) + minValue;
+}
+function Native_randomBytes(buffer) {
+  if (Operators_IsNull(buffer)) {
+    throw ArgumentNullException_$ctor_Z721C83C5("buffer");
+  }
+  for (let i = 0; i < buffer.length; i += 6) {
+    let r = Math.floor(Math.random() * 281474976710656);
+    const rhi = Math.floor(r / 16777216);
+    for (let j = 0; j < 6 && i + j < buffer.length; j++) {
+      if (j === 3) {
+        r = rhi;
+      }
+      buffer[i + j] = r & 255;
+      r >>>= 8;
+    }
+  }
+  ;
+}
+class NonSeeded {
+  constructor() {
+  }
+  Next0() {
+    return Native_randomNext(0, 2147483647) | 0;
+  }
+  Next1(maxValue) {
+    return Native_randomNext(0, maxValue) | 0;
+  }
+  Next2(minValue, maxValue) {
+    return Native_randomNext(minValue, maxValue) | 0;
+  }
+  NextDouble() {
+    return Native_random();
+  }
+  NextBytes(buffer) {
+    Native_randomBytes(buffer);
+  }
+}
+function NonSeeded_$reflection() {
+  return class_type("Random.NonSeeded", void 0, NonSeeded);
+}
+function NonSeeded_$ctor() {
+  return new NonSeeded();
+}
+class Seeded {
+  constructor(seed) {
+    this.MBIG = 2147483647;
+    this.inext = 0;
+    this.inextp = 0;
+    this.seedArray = new Int32Array(56);
+    let ii = 0;
+    let mj = 0;
+    let mk = 0;
+    const subtraction = (seed === -2147483648 ? 2147483647 : Math.abs(seed)) | 0;
+    mj = 161803398 - subtraction | 0;
+    this.seedArray[55] = mj | 0;
+    mk = 1;
+    for (let i = 1; i <= 54; i++) {
+      ii = 21 * i % 55 | 0;
+      this.seedArray[ii] = mk | 0;
+      mk = mj - mk | 0;
+      if (mk < 0) {
+        mk = mk + this.MBIG | 0;
+      }
+      mj = item(ii, this.seedArray) | 0;
+    }
+    for (let k = 1; k <= 4; k++) {
+      for (let i_1 = 1; i_1 <= 55; i_1++) {
+        this.seedArray[i_1] = item(i_1, this.seedArray) - item(1 + (i_1 + 30) % 55, this.seedArray) | 0;
+        if (item(i_1, this.seedArray) < 0) {
+          this.seedArray[i_1] = item(i_1, this.seedArray) + this.MBIG | 0;
+        }
+      }
+    }
+    this.inext = 0;
+    this.inextp = 21;
+  }
+  Next0() {
+    const this$ = this;
+    return Seeded__InternalSample(this$) | 0;
+  }
+  Next1(maxValue) {
+    const this$ = this;
+    if (maxValue < 0) {
+      throw ArgumentOutOfRangeException_$ctor_Z721C83C5("maxValue must be positive");
+    }
+    return ~~(Seeded__Sample(this$) * maxValue) | 0;
+  }
+  Next2(minValue, maxValue) {
+    const this$ = this;
+    if (minValue > maxValue) {
+      throw ArgumentOutOfRangeException_$ctor_Z721C83C5("minValue must be less than maxValue");
+    }
+    const range = toInt64_unchecked(fromInt32(maxValue - minValue));
+    return (compare(range, toInt64_unchecked(fromInt32(2147483647))) <= 0 ? ~~(Seeded__Sample(this$) * toFloat64(range)) + minValue : ~~toInt32_unchecked(toInt64_unchecked(op_Addition(toInt64_unchecked(fromFloat64(Seeded__GetSampleForLargeRange(this$) * toFloat64(range))), toInt64_unchecked(fromInt32(minValue)))))) | 0;
+  }
+  NextDouble() {
+    const this$ = this;
+    return Seeded__Sample(this$);
+  }
+  NextBytes(buffer) {
+    const this$ = this;
+    if (Operators_IsNull(buffer)) {
+      throw ArgumentNullException_$ctor_Z721C83C5("buffer");
+    }
+    for (let i = 0; i <= buffer.length - 1; i++) {
+      setItem(buffer, i, Seeded__InternalSample(this$) % (~~255 + 1) & 255);
+    }
+  }
+}
+function Seeded_$reflection() {
+  return class_type("Random.Seeded", void 0, Seeded);
+}
+function Seeded_$ctor_Z524259A4(seed) {
+  return new Seeded(seed);
+}
+function Seeded__InternalSample(_) {
+  let retVal = 0;
+  let locINext = _.inext;
+  let locINextp = _.inextp;
+  locINext = locINext + 1 | 0;
+  if (locINext >= 56) {
+    locINext = 1;
+  }
+  locINextp = locINextp + 1 | 0;
+  if (locINextp >= 56) {
+    locINextp = 1;
+  }
+  retVal = item(locINext, _.seedArray) - item(locINextp, _.seedArray) | 0;
+  if (retVal === _.MBIG) {
+    retVal = retVal - 1 | 0;
+  }
+  if (retVal < 0) {
+    retVal = retVal + _.MBIG | 0;
+  }
+  _.seedArray[locINext] = retVal | 0;
+  _.inext = locINext | 0;
+  _.inextp = locINextp | 0;
+  return retVal | 0;
+}
+function Seeded__Sample(this$) {
+  return Seeded__InternalSample(this$) * (1 / this$.MBIG);
+}
+function Seeded__GetSampleForLargeRange(this$) {
+  let result = Seeded__InternalSample(this$);
+  if (Seeded__InternalSample(this$) % 2 === 0) {
+    result = -result;
+  }
+  let d = result;
+  d = d + (2147483647 - 1);
+  d = d / (2 * (2147483647 - 1 >>> 0));
+  return d;
+}
+function nonSeeded() {
+  return NonSeeded_$ctor();
+}
+function seeded(seed) {
+  return Seeded_$ctor_Z524259A4(seed);
+}
+
+export { NonSeeded, NonSeeded_$ctor, NonSeeded_$reflection, Seeded, Seeded_$ctor_Z524259A4, Seeded_$reflection, Seeded__GetSampleForLargeRange, Seeded__Sample, nonSeeded, seeded };

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

@@ -0,0 +1,47 @@
+import { compare, Exception } from './Util.js';
+import { delay, unfold } from './Seq.js';
+import { fromZero, op_Addition, toInt64_unchecked, toUInt64_unchecked } from './BigInt.js';
+import { fromParts, op_Addition as op_Addition$1 } from './Decimal.js';
+
+function makeRangeStepFunction(step, stop, zero, add) {
+  const stepComparedWithZero = compare(step, zero) | 0;
+  if (stepComparedWithZero === 0) {
+    throw new Exception("The step of a range cannot be zero");
+  }
+  const stepGreaterThanZero = stepComparedWithZero > 0;
+  return (x) => {
+    const comparedWithLast = compare(x, stop) | 0;
+    return (stepGreaterThanZero && comparedWithLast <= 0 ? true : !stepGreaterThanZero && comparedWithLast >= 0) ? [x, add(x, step)] : void 0;
+  };
+}
+function integralRangeStep(start, step, stop, zero, add) {
+  const stepFn = makeRangeStepFunction(step, stop, zero, add);
+  return delay(() => unfold(stepFn, start));
+}
+function rangeBigInt(start, step, stop) {
+  return integralRangeStep(start, step, stop, fromZero(), op_Addition);
+}
+function rangeDecimal(start, step, stop) {
+  return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition$1);
+}
+function rangeDouble(start, step, stop) {
+  return integralRangeStep(start, step, stop, 0, (x, y) => x + y);
+}
+function rangeInt64(start, step, stop) {
+  return integralRangeStep(start, step, stop, 0n, (x, y) => toInt64_unchecked(op_Addition(x, y)));
+}
+function rangeUInt64(start, step, stop) {
+  return integralRangeStep(start, step, stop, 0n, (x, y) => toUInt64_unchecked(op_Addition(x, y)));
+}
+function rangeChar(start, stop) {
+  const intStop = ~~stop.charCodeAt(0) | 0;
+  return delay(() => unfold((i) => {
+    if (i <= intStop) {
+      return [String.fromCharCode(i & 65535), i + 1];
+    } else {
+      return void 0;
+    }
+  }, ~~start.charCodeAt(0)));
+}
+
+export { integralRangeStep, makeRangeStepFunction, rangeBigInt, rangeChar, rangeDecimal, rangeDouble, rangeInt64, rangeUInt64 };