@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,471 @@
+import { Union, Record } from './Types.js';
+import { stringHash, combineHashCodes, equalArraysWith, Exception } from './Util.js';
+import './Decimal.js';
+import { Some, some } from './Option.js';
+import { Big } from './lib/big.js';
+
+class CaseInfo {
+  constructor(declaringType, tag, name2, fields) {
+    this.declaringType = declaringType;
+    this.tag = tag;
+    this.name = name2;
+    this.fields = fields;
+  }
+}
+class MethodInfo {
+  constructor(name2, parameters, returnType) {
+    this.name = name2;
+    this.parameters = parameters;
+    this.returnType = returnType;
+  }
+}
+class TypeInfo {
+  constructor(fullname, generics, construct, parent, fields, cases, enumCases) {
+    this.fullname = fullname;
+    this.generics = generics;
+    this.construct = construct;
+    this.parent = parent;
+    this.fields = fields;
+    this.cases = cases;
+    this.enumCases = enumCases;
+  }
+  toString() {
+    return fullName(this);
+  }
+  GetHashCode() {
+    return getHashCode(this);
+  }
+  Equals(other) {
+    return equals(this, other);
+  }
+}
+class GenericParameter extends TypeInfo {
+  constructor(name2) {
+    super(name2);
+  }
+}
+function getGenerics(t) {
+  return t.generics != null ? t.generics : [];
+}
+function getHashCode(t) {
+  const fullnameHash = stringHash(t.fullname);
+  const genHashes = getGenerics(t).map(getHashCode);
+  return combineHashCodes([fullnameHash, ...genHashes]);
+}
+function equals(t1, t2) {
+  if (t1.fullname === "") {
+    return t2.fullname === "" && equalArraysWith(
+      getRecordElements(t1),
+      getRecordElements(t2),
+      ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2)
+    );
+  } else {
+    return t1.fullname === t2.fullname && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);
+  }
+}
+function class_type(fullname, generics, construct, parent) {
+  return new TypeInfo(fullname, generics, construct, parent);
+}
+function record_type(fullname, generics, construct, fields) {
+  return new TypeInfo(fullname, generics, construct, void 0, fields);
+}
+function anonRecord_type(...fields) {
+  return new TypeInfo("", void 0, void 0, void 0, () => fields);
+}
+function union_type(fullname, generics, construct, cases) {
+  const t = new TypeInfo(fullname, generics, construct, void 0, void 0, () => {
+    const caseNames = construct.prototype.cases();
+    return cases().map((fields, i) => new CaseInfo(t, i, caseNames[i], fields));
+  });
+  return t;
+}
+function tuple_type(...generics) {
+  return new TypeInfo("System.Tuple`" + generics.length, generics);
+}
+function delegate_type(...generics) {
+  return new TypeInfo("System.Func`" + generics.length, generics);
+}
+function lambda_type(argType, returnType) {
+  return new TypeInfo("Microsoft.FSharp.Core.FSharpFunc`2", [argType, returnType]);
+}
+function option_type(generic) {
+  const t = new TypeInfo(
+    "Microsoft.FSharp.Core.FSharpOption`1",
+    [generic],
+    void 0,
+    void 0,
+    void 0,
+    () => [
+      new CaseInfo(t, 0, "None"),
+      new CaseInfo(t, 1, "Some", [["value", generic]])
+    ]
+  );
+  return t;
+}
+function list_type(generic) {
+  const t = new TypeInfo(
+    "Microsoft.FSharp.Collections.FSharpList`1",
+    [generic],
+    void 0,
+    void 0,
+    void 0,
+    () => [
+      new CaseInfo(t, 0, "Empty"),
+      new CaseInfo(t, 1, "Cons", [["Head", generic], ["Tail", t]])
+    ]
+  );
+  return t;
+}
+function array_type(generic) {
+  return new TypeInfo("[]", [generic]);
+}
+function enum_type(fullname, underlyingType, enumCases) {
+  return new TypeInfo(fullname, [underlyingType], void 0, void 0, void 0, void 0, enumCases);
+}
+function measure_type(fullname) {
+  return new TypeInfo(fullname);
+}
+function generic_type(name2) {
+  return new GenericParameter(name2);
+}
+const obj_type = new TypeInfo("System.Object");
+const unit_type = new TypeInfo("Microsoft.FSharp.Core.Unit");
+const char_type = new TypeInfo("System.Char");
+const string_type = new TypeInfo("System.String");
+const bool_type = new TypeInfo("System.Boolean");
+const int8_type = new TypeInfo("System.SByte");
+const uint8_type = new TypeInfo("System.Byte");
+const int16_type = new TypeInfo("System.Int16");
+const uint16_type = new TypeInfo("System.UInt16");
+const int32_type = new TypeInfo("System.Int32");
+const uint32_type = new TypeInfo("System.UInt32");
+const int64_type = new TypeInfo("System.Int64");
+const uint64_type = new TypeInfo("System.UInt64");
+const int128_type = new TypeInfo("System.Int128");
+const uint128_type = new TypeInfo("System.UInt128");
+const nativeint_type = new TypeInfo("System.IntPtr");
+const unativeint_type = new TypeInfo("System.UIntPtr");
+const float16_type = new TypeInfo("System.Half");
+const float32_type = new TypeInfo("System.Single");
+const float64_type = new TypeInfo("System.Double");
+const decimal_type = new TypeInfo("System.Decimal");
+const bigint_type = new TypeInfo("System.Numerics.BigInteger");
+function name(info) {
+  if (Array.isArray(info)) {
+    return info[0];
+  } else if (info instanceof TypeInfo) {
+    const elemType = getElementType(info);
+    if (elemType != null) {
+      return name(elemType) + "[]";
+    } else {
+      const i = info.fullname.lastIndexOf(".");
+      return i === -1 ? info.fullname : info.fullname.slice(i + 1);
+    }
+  } else {
+    return info.name;
+  }
+}
+function fullName(t) {
+  const elemType = getElementType(t);
+  if (elemType != null) {
+    return fullName(elemType) + "[]";
+  } else if (t.generics == null || t.generics.length === 0) {
+    return t.fullname;
+  } else {
+    return t.fullname + "[" + t.generics.map((x) => fullName(x)).join(",") + "]";
+  }
+}
+function namespace(t) {
+  const elemType = getElementType(t);
+  if (elemType != null) {
+    return namespace(elemType);
+  } else {
+    const i = t.fullname.lastIndexOf(".");
+    return i === -1 ? "" : t.fullname.slice(0, i);
+  }
+}
+function isArray(t) {
+  return getElementType(t) != null;
+}
+function getElementType(t) {
+  return t.fullname === "[]" && t.generics?.length === 1 ? t.generics[0] : void 0;
+}
+function isGenericType(t) {
+  return t.generics != null && t.generics.length > 0;
+}
+function isGenericParameter(t) {
+  return t instanceof GenericParameter;
+}
+function isEnum(t) {
+  return t.enumCases != null && t.enumCases.length > 0;
+}
+function isSubclassOf(t1, t2) {
+  return t2.fullname === obj_type.fullname || t1.parent != null && (t1.parent.Equals(t2) || isSubclassOf(t1.parent, t2));
+}
+function isErasedToNumber(t) {
+  return isEnum(t) || [
+    int8_type.fullname,
+    uint8_type.fullname,
+    int16_type.fullname,
+    uint16_type.fullname,
+    int32_type.fullname,
+    uint32_type.fullname,
+    float16_type.fullname,
+    float32_type.fullname,
+    float64_type.fullname
+  ].includes(t.fullname);
+}
+function isErasedToBigInt(t) {
+  return isEnum(t) || [
+    int64_type.fullname,
+    uint64_type.fullname,
+    int128_type.fullname,
+    uint128_type.fullname,
+    nativeint_type.fullname,
+    unativeint_type.fullname,
+    bigint_type.fullname
+  ].includes(t.fullname);
+}
+function isInstanceOfType(t, o) {
+  if (t.fullname === obj_type.fullname)
+    return true;
+  switch (typeof o) {
+    case "boolean":
+      return t.fullname === bool_type.fullname;
+    case "string":
+      return t.fullname === string_type.fullname;
+    case "function":
+      return isFunction(t);
+    case "number":
+      return isErasedToNumber(t);
+    case "bigint":
+      return isErasedToBigInt(t);
+    default:
+      return t.construct != null && o instanceof t.construct;
+  }
+}
+function getGenericTypeDefinition(t) {
+  return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));
+}
+function getEnumUnderlyingType(t) {
+  return t.generics?.[0];
+}
+function getEnumValues(t) {
+  if (isEnum(t) && t.enumCases != null) {
+    return t.enumCases.map((kv) => kv[1]);
+  } else {
+    throw new Exception(`${t.fullname} is not an enum type`);
+  }
+}
+function getEnumNames(t) {
+  if (isEnum(t) && t.enumCases != null) {
+    return t.enumCases.map((kv) => kv[0]);
+  } else {
+    throw new Exception(`${t.fullname} is not an enum type`);
+  }
+}
+function getEnumCase(t, v) {
+  if (t.enumCases != null) {
+    if (typeof v === "string") {
+      for (const kv of t.enumCases) {
+        if (kv[0] === v) {
+          return kv;
+        }
+      }
+      throw new Exception(`'${v}' was not found in ${t.fullname}`);
+    } else {
+      for (const kv of t.enumCases) {
+        if (kv[1] === v) {
+          return kv;
+        }
+      }
+      return ["", v];
+    }
+  } else {
+    throw new Exception(`${t.fullname} is not an enum type`);
+  }
+}
+function parseEnum(t, str) {
+  const value = parseInt(str, 10);
+  return getEnumCase(t, isNaN(value) ? str : value)[1];
+}
+function tryParseEnum(t, str, defValue) {
+  try {
+    defValue.contents = parseEnum(t, str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getEnumName(t, v) {
+  return getEnumCase(t, v)[0];
+}
+function isEnumDefined(t, v) {
+  try {
+    const kv = getEnumCase(t, v);
+    return kv[0] != null && kv[0] !== "";
+  } catch {
+  }
+  return false;
+}
+function getUnionCases(t) {
+  if (t.cases != null) {
+    return t.cases();
+  } else {
+    throw new Exception(`${t.fullname} is not an F# union type`);
+  }
+}
+function getRecordElements(t) {
+  if (t.fields != null) {
+    return t.fields();
+  } else {
+    throw new Exception(`${t.fullname} is not an F# record type`);
+  }
+}
+function getTupleElements(t) {
+  if (isTuple(t) && t.generics != null) {
+    return t.generics;
+  } else {
+    throw new Exception(`${t.fullname} is not a tuple type`);
+  }
+}
+function getFunctionElements(t) {
+  if (isFunction(t) && t.generics != null) {
+    const gen = t.generics;
+    return [gen[0], gen[1]];
+  } else {
+    throw new Exception(`${t.fullname} is not an F# function type`);
+  }
+}
+function isUnion(t) {
+  return t instanceof TypeInfo ? t.cases != null : t instanceof Union;
+}
+function isRecord(t) {
+  return t instanceof TypeInfo ? t.fields != null : t instanceof Record;
+}
+function isTuple(t) {
+  return t.fullname.startsWith("System.Tuple");
+}
+function isFunction(t) {
+  return t.fullname === "Microsoft.FSharp.Core.FSharpFunc`2";
+}
+function getUnionFields(v, t) {
+  const cases = getUnionCases(t);
+  if (t.fullname === "Microsoft.FSharp.Core.FSharpOption`1") {
+    if (v == null) {
+      return [cases[0], []];
+    } else {
+      const innerValue = v instanceof Some ? v.value : v;
+      return [cases[1], [innerValue]];
+    }
+  }
+  const case_ = cases[v.tag];
+  if (case_ == null) {
+    throw new Exception(`Cannot find case ${v.name} in union type`);
+  }
+  return [case_, v.fields];
+}
+function getUnionCaseFields(uci) {
+  return uci.fields == null ? [] : uci.fields;
+}
+function getRecordFields(v, t) {
+  if (t.fields != null) {
+    return t.fields().map(([key, _]) => v[key]);
+  }
+  return Object.keys(v).map((k) => v[k]);
+}
+function getRecordField(v, field) {
+  return v[field[0]];
+}
+function getTupleFields(v) {
+  return v;
+}
+function getTupleField(v, i) {
+  return v[i];
+}
+function makeUnion(uci, values) {
+  const expectedLength = (uci.fields || []).length;
+  if (values.length !== expectedLength) {
+    throw new Exception(`Expected an array of length ${expectedLength} but got ${values.length}`);
+  }
+  if (uci.declaringType.fullname === "Microsoft.FSharp.Core.FSharpOption`1") {
+    return uci.tag === 0 ? void 0 : some(values[0]);
+  }
+  const construct = uci.declaringType.construct;
+  if (construct == null) {
+    return {};
+  }
+  const isSingleCase = uci.declaringType.cases ? uci.declaringType.cases().length == 1 : false;
+  if (isSingleCase) {
+    return new construct(...values);
+  } else {
+    return new construct(uci.tag, values);
+  }
+}
+function makeRecord(t, values) {
+  const fields = getRecordElements(t);
+  if (fields.length !== values.length) {
+    throw new Exception(`Expected an array of length ${fields.length} but got ${values.length}`);
+  }
+  return t.construct != null ? new t.construct(...values) : fields.reduce((obj, [key, _t], i) => {
+    obj[key] = values[i];
+    return obj;
+  }, {});
+}
+function makeTuple(values, _t) {
+  return values;
+}
+function makeGenericType(t, generics) {
+  return new TypeInfo(
+    t.fullname,
+    generics,
+    t.construct,
+    t.parent,
+    t.fields,
+    t.cases
+  );
+}
+function createInstance(t, consArgs) {
+  if (typeof t.construct === "function") {
+    return new t.construct(...consArgs ?? []);
+  } else if (isErasedToNumber(t)) {
+    return 0;
+  } else if (isErasedToBigInt(t)) {
+    return 0n;
+  } else {
+    switch (t.fullname) {
+      case obj_type.fullname:
+        return {};
+      case bool_type.fullname:
+        return false;
+      case decimal_type.fullname:
+        return new Big(0);
+      case char_type.fullname:
+        return "\0";
+      default:
+        throw new Exception(`Cannot access constructor of ${t.fullname}`);
+    }
+  }
+}
+function getValue(propertyInfo, v) {
+  return v[propertyInfo[0]];
+}
+function assertUnion(x) {
+  if (!(x instanceof Union)) {
+    throw new Exception(`Value is not an F# union type`);
+  }
+}
+function getCaseTag(x) {
+  assertUnion(x);
+  return x.tag;
+}
+function getCaseName(x) {
+  assertUnion(x);
+  return x.cases()[x.tag];
+}
+function getCaseFields(x) {
+  assertUnion(x);
+  return x.fields;
+}
+
+export { CaseInfo, GenericParameter, MethodInfo, TypeInfo, anonRecord_type, array_type, bigint_type, bool_type, char_type, class_type, createInstance, decimal_type, delegate_type, enum_type, equals, float16_type, float32_type, float64_type, fullName, generic_type, getCaseFields, getCaseName, getCaseTag, getElementType, getEnumName, getEnumNames, getEnumUnderlyingType, getEnumValues, getFunctionElements, getGenericTypeDefinition, getGenerics, getHashCode, getRecordElements, getRecordField, getRecordFields, getTupleElements, getTupleField, getTupleFields, getUnionCaseFields, getUnionCases, getUnionFields, getValue, int128_type, int16_type, int32_type, int64_type, int8_type, isArray, isEnum, isEnumDefined, isFunction, isGenericParameter, isGenericType, isInstanceOfType, isRecord, isSubclassOf, isTuple, isUnion, lambda_type, list_type, makeGenericType, makeRecord, makeTuple, makeUnion, measure_type, name, namespace, nativeint_type, obj_type, option_type, parseEnum, record_type, string_type, tryParseEnum, tuple_type, uint128_type, uint16_type, uint32_type, uint64_type, uint8_type, unativeint_type, union_type, unit_type };

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

@@ -0,0 +1,137 @@
+import { Exception } from './Util.js';
+
+function create(pattern, options2 = 0) {
+  if ((options2 & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
+    throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+  }
+  let flags = "gu";
+  flags += options2 & 1 ? "i" : "";
+  flags += options2 & 2 ? "m" : "";
+  flags += options2 & 16 ? "s" : "";
+  return new RegExp(pattern, flags);
+}
+function escape(str) {
+  return str.replace(/[$()*+.?[\\\^{|}\]]/g, "\\$&");
+}
+function unescape(str) {
+  return str.replace(/\\([$()*+.?[\\\^{|}\]])/g, "$1");
+}
+function isMatch(reg, input, startAt = 0) {
+  reg.lastIndex = startAt;
+  return reg.test(input);
+}
+function match(reg, input, startAt = 0) {
+  reg.lastIndex = startAt;
+  return reg.exec(input);
+}
+function matches(reg, input, startAt = 0) {
+  if (input == null) {
+    throw new Exception("Input cannot ve null");
+  }
+  if (!reg.global) {
+    throw new Exception("Non-global RegExp");
+  }
+  reg.lastIndex = startAt;
+  const matches2 = [];
+  let m;
+  let lastMatchIndex = -1;
+  while ((m = reg.exec(input)) != null) {
+    if (m.index === lastMatchIndex) {
+      reg.lastIndex++;
+    } else {
+      lastMatchIndex = m.index;
+      matches2.push(m);
+    }
+  }
+  return matches2;
+}
+function options(reg) {
+  let options2 = 256;
+  options2 |= reg.ignoreCase ? 1 : 0;
+  options2 |= reg.multiline ? 2 : 0;
+  return options2;
+}
+function replace(reg, input, replacement, limit, offset = 0) {
+  function replacer() {
+    let res = arguments[0];
+    if (limit) {
+      limit--;
+      const match2 = [];
+      const len = arguments.length;
+      const withGroups = typeof arguments[len - 1] !== "string";
+      let pLast = withGroups ? len - 3 : len - 2;
+      for (let i = 0; i < pLast; i++) {
+        match2.push(arguments[i]);
+      }
+      match2.index = arguments[pLast++];
+      match2.input = arguments[pLast++];
+      if (withGroups) {
+        match2.groups = arguments[pLast];
+      }
+      res = replacement(match2);
+    }
+    return res;
+  }
+  if (typeof reg === "string") {
+    const tmp = reg;
+    reg = create(input, limit ?? 0);
+    input = tmp;
+    limit = void 0;
+  }
+  if (typeof replacement === "string") {
+    const rep = replacement;
+    replacement = (match2) => rep.replace(
+      /\$(?:(\$)|(&)|(`)|(')|(\d+)|\{(\d+)\}|\{([^}]+)\})/g,
+      (s, dollar, and, before, after, num, numBraced, name) => {
+        if (dollar != null) {
+          return "$";
+        }
+        if (and != null) {
+          return match2[0];
+        }
+        if (before != null) {
+          return match2.input.substring(0, match2.index);
+        }
+        if (after != null) {
+          return match2.input.substring(match2.index + match2[0].length);
+        }
+        const n = num ?? numBraced;
+        if (n != null) {
+          const i = parseInt(n, 10);
+          return i < match2.length ? match2[i] ?? "" : s;
+        }
+        return match2.groups != null && name in match2.groups ? match2.groups[name] ?? "" : s;
+      }
+    );
+  }
+  limit = limit == null ? -1 : limit;
+  return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
+}
+function split(reg, input, limit, offset = 0) {
+  if (typeof reg === "string") {
+    const tmp = reg;
+    reg = create(input, limit ?? 0);
+    input = tmp;
+    limit = void 0;
+  }
+  const result = [];
+  let prev = 0;
+  let count = limit == null ? -1 : limit - 1;
+  for (const m of matches(reg, input, offset)) {
+    if (count === 0) {
+      break;
+    }
+    result.push(input.substring(prev, m.index));
+    prev = m.index + m[0].length;
+    for (let i = 1; i < m.length; i++) {
+      if (m[i] !== void 0) {
+        result.push(m[i]);
+      }
+    }
+    count--;
+  }
+  result.push(input.substring(prev));
+  return result;
+}
+
+export { create, escape, isMatch, match, matches, options, replace, split, unescape };