@nfdi4plants/arctrl 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/DynamicObj.fs.js

@@ -0,0 +1,367 @@
+import { safeHash, comparePrimitives, isIterable, getEnumerator, isArrayLike, disposeSafe, structuralHash, equals } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { tryGetStaticPropertyInfo } from './ReflectionUtils.fs.js';
+import { value, map, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryGetDynamicPropertyHelper, getPropertyHelpers } from './FableJS.fs.js';
+import { filter, choose, map as map$1, iterate, sortBy, toList, delay, enumerateWhile, singleton } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { boxHashKeyValSeqBy, hash, mergeHashes } from './HashCodes.fs.js';
+import { isEmpty, reduce, FSharpList } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { Dictionary } from '../../../node_modules/@fable-org/fable-library-js/MutableMap.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import '../../../node_modules/@fable-org/fable-library-js/Decimal.js';
+import { Big } from '../../../node_modules/@fable-org/fable-library-js/lib/big.js';
+
+class DynamicObj {
+  constructor() {
+    this.properties = /* @__PURE__ */ new Map([]);
+  }
+  get Properties() {
+    const this$ = this;
+    return this$.properties;
+  }
+  set Properties(value) {
+    const this$ = this;
+    this$.properties = value;
+  }
+  static ofDict(dynamicProperties) {
+    const obj = new DynamicObj();
+    obj.Properties = dynamicProperties;
+    return obj;
+  }
+  TryGetStaticPropertyHelper(propertyName) {
+    const this$ = this;
+    return tryGetStaticPropertyInfo(this$, propertyName);
+  }
+  TryGetDynamicPropertyHelper(propertyName) {
+    const this$ = this;
+    return tryGetDynamicPropertyHelper(this$, propertyName);
+  }
+  TryGetPropertyHelper(propertyName) {
+    const this$ = this;
+    const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+    return matchValue == null ? this$.TryGetDynamicPropertyHelper(propertyName) : value(matchValue);
+  }
+  TryGetPropertyValue(propertyName) {
+    const this$ = this;
+    return map((pi) => pi.GetValue(this$), this$.TryGetPropertyHelper(propertyName));
+  }
+  GetPropertyValue(propertyName) {
+    const this$ = this;
+    const matchValue = this$.TryGetPropertyValue(propertyName);
+    if (matchValue == null) {
+      throw new Error(`No dynamic or static property "${propertyName}" does exist on object.`);
+    } else {
+      return value(matchValue);
+    }
+  }
+  SetProperty(propertyName, propertyValue) {
+    const this$ = this;
+    const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+    if (matchValue == null) {
+      this$[propertyName] = propertyValue;
+    } else {
+      const pi = value(matchValue);
+      if (pi.IsMutable) {
+        pi.SetValue(this$, propertyValue);
+      } else {
+        throw new Error(`Cannot set value for static, immutable property "${propertyName}"`);
+      }
+    }
+  }
+  RemoveProperty(propertyName) {
+    const this$ = this;
+    const matchValue = this$.TryGetPropertyHelper(propertyName);
+    if (matchValue == null) {
+      return false;
+    } else if (value(matchValue).IsMutable) {
+      const pi_1 = value(matchValue);
+      pi_1.RemoveValue(this$);
+      return true;
+    } else {
+      throw new Error(`Cannot remove value for static, immutable property "${propertyName}"`);
+    }
+  }
+  GetPropertyHelpers(includeInstanceProperties) {
+    const this$ = this;
+    return filter((p) => p.Name.toLocaleLowerCase() !== "properties", filter((pd) => {
+      if (includeInstanceProperties) {
+        return true;
+      } else {
+        return pd.IsDynamic;
+      }
+    }, getPropertyHelpers(this$)));
+  }
+  GetProperties(includeInstanceProperties) {
+    const this$ = this;
+    return choose((kv) => {
+      if (kv.Name !== "properties") {
+        return [kv.Name, kv.GetValue(this$)];
+      } else {
+        return void 0;
+      }
+    }, this$.GetPropertyHelpers(includeInstanceProperties));
+  }
+  GetPropertyNames(includeInstanceProperties) {
+    const this$ = this;
+    return map$1((kv) => kv[0], this$.GetProperties(includeInstanceProperties));
+  }
+  ShallowCopyDynamicPropertiesTo(target, overWrite) {
+    const this$ = this;
+    const overWrite_1 = defaultArg(overWrite, false);
+    iterate((kv) => {
+      let pi;
+      const matchValue = target.TryGetPropertyHelper(kv[0]);
+      if (matchValue == null) {
+        target.SetProperty(kv[0], kv[1]);
+      } else if (pi = value(matchValue), overWrite_1) {
+        const pi_1 = value(matchValue);
+        pi_1.SetValue(target, kv[1]);
+      }
+    }, this$.GetProperties(false));
+  }
+  ShallowCopyDynamicProperties() {
+    const this$ = this;
+    const target = new DynamicObj();
+    this$.ShallowCopyDynamicPropertiesTo(target, true);
+    return target;
+  }
+  DeepCopyPropertiesTo(target, overWrite, includeInstanceProperties) {
+    const this$ = this;
+    const overWrite_1 = defaultArg(overWrite, false);
+    const includeInstanceProperties_1 = defaultArg(includeInstanceProperties, true);
+    iterate((kv) => {
+      let pi;
+      const matchValue = target.TryGetPropertyHelper(kv[0]);
+      if (matchValue == null) {
+        target.SetProperty(kv[0], CopyUtils_tryDeepCopyObj_75B3D832(kv[1]));
+      } else if (pi = value(matchValue), overWrite_1) {
+        const pi_1 = value(matchValue);
+        pi_1.SetValue(target, CopyUtils_tryDeepCopyObj_75B3D832(kv[1]));
+      }
+    }, this$.GetProperties(includeInstanceProperties_1));
+  }
+  DeepCopyProperties(includeInstanceProperties) {
+    const this$ = this;
+    return CopyUtils_tryDeepCopyObj_75B3D832(this$, defaultArg(includeInstanceProperties, true));
+  }
+  static op_Dynamic(lookup, name) {
+    const matchValue = lookup.TryGetPropertyValue(name);
+    if (matchValue == null) {
+      throw new Error();
+    } else {
+      return value(matchValue);
+    }
+  }
+  static op_DynamicAssignment(lookup, name, value) {
+    lookup.SetProperty(name, value);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  StructurallyEquals(other) {
+    const this$ = this;
+    return safeHash(this$) === safeHash(other);
+  }
+  GetHashCode() {
+    const this$ = this;
+    return HashUtils_deepHash_4E60E31B(this$) | 0;
+  }
+  Equals(o) {
+    let other;
+    const this$ = this;
+    return o instanceof DynamicObj && (other = o, this$.StructurallyEquals(other));
+  }
+}
+function DynamicObj_$reflection() {
+  return class_type("DynamicObj.DynamicObj", void 0, DynamicObj);
+}
+function DynamicObj_$ctor() {
+  return new DynamicObj();
+}
+class HashUtils {
+  constructor() {
+  }
+}
+function HashUtils_$reflection() {
+  return class_type("DynamicObj.HashUtils", void 0, HashUtils);
+}
+class CopyUtils {
+  constructor() {
+  }
+}
+function CopyUtils_$reflection() {
+  return class_type("DynamicObj.CopyUtils", void 0, CopyUtils);
+}
+function HashUtils_deepHash_4E60E31B(o) {
+  if (o instanceof DynamicObj) {
+    const o_1 = o;
+    return boxHashKeyValSeqBy(HashUtils_deepHash_4E60E31B, sortBy((pair) => pair[0], o_1.GetProperties(true), {
+      Compare: comparePrimitives
+    })) | 0;
+  } else if (typeof o === "string") {
+    const s = o;
+    return hash(s) | 0;
+  } else if (isIterable(o)) {
+    const e = o;
+    const en = getEnumerator(e);
+    const l = toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton(HashUtils_deepHash_4E60E31B(en["System.Collections.IEnumerator.get_Current"]()))))));
+    if (isEmpty(l)) {
+      return 0;
+    } else {
+      return reduce(mergeHashes, l) | 0;
+    }
+  } else {
+    return hash(o) | 0;
+  }
+}
+function CopyUtils_tryDeepCopyObj_75B3D832(o, includeInstanceProperties) {
+  const includeInstanceProperties_1 = defaultArg(includeInstanceProperties, true);
+  const tryDeepCopyObj = (o_1) => {
+    let matchResult, o_12, o_14, o_16;
+    if (typeof o_1 === "boolean") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "bigint") {
+      matchResult = 0;
+    } else if (typeof o_1 === "bigint") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "string") {
+      matchResult = 0;
+    } else if (typeof o_1 === "string") {
+      matchResult = 0;
+    } else if (o_1 == null) {
+      matchResult = 0;
+    } else if (o_1 instanceof Big) {
+      matchResult = 1;
+    } else if (isArrayLike(o_1)) {
+      if (o_1 instanceof Map) {
+        matchResult = 2;
+        o_12 = o_1;
+      } else if (o_1 instanceof Dictionary) {
+        matchResult = 3;
+        o_14 = o_1;
+      } else {
+        matchResult = 4;
+      }
+    } else if (o_1 instanceof FSharpList) {
+      if (o_1 instanceof Map) {
+        matchResult = 2;
+        o_12 = o_1;
+      } else if (o_1 instanceof Dictionary) {
+        matchResult = 3;
+        o_14 = o_1;
+      } else {
+        matchResult = 5;
+      }
+    } else if (o_1 instanceof DynamicObj) {
+      if (o_1 instanceof Map) {
+        matchResult = 2;
+        o_12 = o_1;
+      } else if (o_1 instanceof Dictionary) {
+        matchResult = 3;
+        o_14 = o_1;
+      } else if (o_1["System.ICloneable.Clone"] != void 0 && typeof o_1["System.ICloneable.Clone"] === "function") {
+        matchResult = 6;
+        o_16 = o_1;
+      } else {
+        matchResult = 7;
+      }
+    } else if (o_1 instanceof Map) {
+      matchResult = 2;
+      o_12 = o_1;
+    } else if (o_1 instanceof Dictionary) {
+      matchResult = 3;
+      o_14 = o_1;
+    } else if (o_1["System.ICloneable.Clone"] != void 0 && typeof o_1["System.ICloneable.Clone"] === "function") {
+      matchResult = 6;
+      o_16 = o_1;
+    } else {
+      matchResult = 8;
+    }
+    switch (matchResult) {
+      case 0:
+        return o_1;
+      case 1:
+        return o_1;
+      case 2: {
+        const o_13 = o_12;
+        const newDict = new Dictionary([], {
+          Equals: equals,
+          GetHashCode: structuralHash
+        });
+        let enumerator = getEnumerator(o_13);
+        try {
+          while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            addToDict(newDict, tryDeepCopyObj(kv[0]), tryDeepCopyObj(kv[1]));
+          }
+        } finally {
+          disposeSafe(enumerator);
+        }
+        return newDict;
+      }
+      case 3: {
+        const o_15 = o_14;
+        const newDict_1 = new Dictionary([], {
+          Equals: equals,
+          GetHashCode: structuralHash
+        });
+        let enumerator_1 = getEnumerator(o_15);
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const kv_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            addToDict(newDict_1, tryDeepCopyObj(kv_1[0]), tryDeepCopyObj(kv_1[1]));
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+        return newDict_1;
+      }
+      case 4: {
+        const dyns = o_1;
+        return Array.from(toList(delay(() => map$1((dyn) => tryDeepCopyObj(dyn), dyns))));
+      }
+      case 5: {
+        const dyns_1 = o_1;
+        return toList(delay(() => map$1((dyn_1) => tryDeepCopyObj(dyn_1), dyns_1)));
+      }
+      case 6:
+        return o_16["System.ICloneable.Clone"]();
+      case 7: {
+        const dyn_2 = o_1;
+        const newDyn = new DynamicObj();
+        const enumerator_2 = getEnumerator(dyn_2.GetProperties(includeInstanceProperties_1));
+        try {
+          while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const kv_2 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            newDyn.SetProperty(kv_2[0], tryDeepCopyObj(kv_2[1]));
+          }
+        } finally {
+          disposeSafe(enumerator_2);
+        }
+        return newDyn;
+      }
+      default:
+        return o_1;
+    }
+  };
+  return tryDeepCopyObj(o);
+}
+
+export { CopyUtils, CopyUtils_$reflection, CopyUtils_tryDeepCopyObj_75B3D832, DynamicObj, DynamicObj_$ctor, DynamicObj_$reflection, HashUtils, HashUtils_$reflection, HashUtils_deepHash_4E60E31B };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/FableJS.fs.js

@@ -0,0 +1,114 @@
+import { map, value, bind } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { defaultOf } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { PropertyHelper } from './PropertyHelper.fs.js';
+import { choose, append, map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { isMatch, create } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+
+function PropertyDescriptor_tryGetIsWritable(o) {
+  return map((v) => v, o["writable"]);
+}
+function PropertyDescriptor_containsGetter(o) {
+  const matchValue = o["get"];
+  if (matchValue == null) {
+    return false;
+  } else {
+    return true;
+  }
+}
+function PropertyDescriptor_containsSetter(o) {
+  const matchValue = o["set"];
+  if (matchValue == null) {
+    return false;
+  } else {
+    return true;
+  }
+}
+function PropertyDescriptor_isWritable(o) {
+  const matchValue = PropertyDescriptor_tryGetIsWritable(o);
+  if (matchValue == null) {
+    return PropertyDescriptor_containsSetter(o);
+  } else {
+    return value(matchValue);
+  }
+}
+function PropertyDescriptor_isFunction(o) {
+  const matchValue = o["value"];
+  if (matchValue == null) {
+    return false;
+  } else {
+    const v = value(matchValue);
+    return typeof v === "function";
+  }
+}
+function getStaticPropertyNames(o) {
+  let array;
+  const o_1 = Object.getPrototypeOf(o);
+  array = Object.getOwnPropertyNames(o_1);
+  return array.filter((n) => n !== "constructor");
+}
+function createSetter(propName, o, value) {
+  return o[propName] = value;
+}
+function removeStaticPropertyValue(o, propName) {
+  return o[propName] = defaultOf();
+}
+function createRemover(propName, isStatic) {
+  if (isStatic) {
+    return (o) => removeStaticPropertyValue(o, propName);
+  } else {
+    return (o_1) => delete o_1[propName];
+  }
+}
+function createGetter(propName, o) {
+  return o[propName];
+}
+function tryGetStaticPropertyDescriptor(o, propName) {
+  return Object.getOwnPropertyDescriptor(Object.getPrototypeOf(o), propName);
+}
+function tryStaticPropertyHelperFromDescriptor(pd, name) {
+  const isWritable = PropertyDescriptor_isWritable(pd);
+  if (PropertyDescriptor_isFunction(pd)) {
+    return void 0;
+  } else {
+    return new PropertyHelper(name, true, false, isWritable, !isWritable, (o) => createGetter(name, o), (o_1, value) => {
+      createSetter(name, o_1, value);
+    }, createRemover(name, true));
+  }
+}
+function tryGetStaticPropertyHelper(o, propName) {
+  return bind((pd) => tryStaticPropertyHelperFromDescriptor(pd, propName), tryGetStaticPropertyDescriptor(o, propName));
+}
+function getStaticPropertyHelpers(o) {
+  return choose((propName) => tryGetStaticPropertyHelper(o, propName), getStaticPropertyNames(o));
+}
+function tryGetDynamicPropertyDescriptor(o, propName) {
+  return Object.getOwnPropertyDescriptor(o, propName);
+}
+const transpiledPropertyRegex = "^[a-zA-Z]+@[0-9]+$";
+function isTranspiledPropertyHelper(propertyName) {
+  return isMatch(create(transpiledPropertyRegex), propertyName);
+}
+function tryDynamicPropertyHelperFromDescriptor(pd, name) {
+  if (PropertyDescriptor_isFunction(pd) ? true : isTranspiledPropertyHelper(name)) {
+    return void 0;
+  } else {
+    return new PropertyHelper(name, false, true, true, false, (o) => createGetter(name, o), (o_1, value) => {
+      createSetter(name, o_1, value);
+    }, createRemover(name, false));
+  }
+}
+function tryGetDynamicPropertyHelper(o, propName) {
+  return bind((pd) => tryDynamicPropertyHelperFromDescriptor(pd, propName), tryGetDynamicPropertyDescriptor(o, propName));
+}
+function getDynamicPropertyHelpers(o) {
+  return choose((propName) => tryGetDynamicPropertyHelper(o, propName), Object.getOwnPropertyNames(o));
+}
+function getPropertyHelpers(o) {
+  const array_1 = getDynamicPropertyHelpers(o);
+  return append(getStaticPropertyHelpers(o), array_1);
+}
+function getPropertyNames(o) {
+  return map$1((h) => h.Name, getPropertyHelpers(o));
+}
+
+export { PropertyDescriptor_containsGetter, PropertyDescriptor_containsSetter, PropertyDescriptor_isFunction, PropertyDescriptor_isWritable, PropertyDescriptor_tryGetIsWritable, createGetter, createRemover, createSetter, getDynamicPropertyHelpers, getPropertyHelpers, getPropertyNames, getStaticPropertyHelpers, getStaticPropertyNames, isTranspiledPropertyHelper, removeStaticPropertyValue, transpiledPropertyRegex, tryDynamicPropertyHelperFromDescriptor, tryGetDynamicPropertyDescriptor, tryGetDynamicPropertyHelper, tryGetStaticPropertyDescriptor, tryGetStaticPropertyHelper, tryStaticPropertyHelperFromDescriptor };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/HashCodes.fs.js

@@ -0,0 +1,45 @@
+import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { equals, defaultOf, identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+function mergeHashes(hash1, hash2) {
+  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
+}
+function hashDateTime(dt) {
+  let acc = 0;
+  acc = mergeHashes(acc, year(dt)) | 0;
+  acc = mergeHashes(acc, month(dt)) | 0;
+  acc = mergeHashes(acc, day(dt)) | 0;
+  acc = mergeHashes(acc, hour(dt)) | 0;
+  acc = mergeHashes(acc, minute(dt)) | 0;
+  acc = mergeHashes(acc, second(dt)) | 0;
+  return acc | 0;
+}
+function hash(obj) {
+  if (equals(obj, defaultOf())) {
+    return 0;
+  } else {
+    let copyOfStruct = obj;
+    return identityHash(copyOfStruct) | 0;
+  }
+}
+function boxHashOption(a) {
+  let copyOfStruct, copyOfStruct_1;
+  return a != null ? (copyOfStruct = value(a), identityHash(copyOfStruct)) : (copyOfStruct_1 = 0, numberHash(copyOfStruct_1));
+}
+function boxHashArray(a) {
+  return fold((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+function boxHashSeq(a) {
+  return fold$1((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+function boxHashKeyValSeq(a) {
+  return fold$1((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), hash(o[1]))), 0, a);
+}
+function boxHashKeyValSeqBy(f, a) {
+  return fold$1((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), f(o[1]))), 0, a);
+}
+
+export { boxHashArray, boxHashKeyValSeq, boxHashKeyValSeqBy, boxHashOption, boxHashSeq, hash, hashDateTime, mergeHashes };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/PropertyHelper.fs.js

@@ -0,0 +1,21 @@
+import { Record } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { record_type, string_type, bool_type, lambda_type, obj_type, unit_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class PropertyHelper extends Record {
+  constructor(Name, IsStatic, IsDynamic, IsMutable, IsImmutable, GetValue, SetValue, RemoveValue) {
+    super();
+    this.Name = Name;
+    this.IsStatic = IsStatic;
+    this.IsDynamic = IsDynamic;
+    this.IsMutable = IsMutable;
+    this.IsImmutable = IsImmutable;
+    this.GetValue = GetValue;
+    this.SetValue = SetValue;
+    this.RemoveValue = RemoveValue;
+  }
+}
+function PropertyHelper_$reflection() {
+  return record_type("DynamicObj.PropertyHelper", [], PropertyHelper, () => [["Name", string_type], ["IsStatic", bool_type], ["IsDynamic", bool_type], ["IsMutable", bool_type], ["IsImmutable", bool_type], ["GetValue", lambda_type(obj_type, obj_type)], ["SetValue", lambda_type(obj_type, lambda_type(obj_type, unit_type))], ["RemoveValue", lambda_type(obj_type, unit_type)]]);
+}
+
+export { PropertyHelper, PropertyHelper_$reflection };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/ReflectionUtils.fs.js

@@ -0,0 +1,70 @@
+import { getStaticPropertyHelpers, tryGetStaticPropertyHelper } from './FableJS.fs.js';
+import { value, some, map } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function getStaticProperties(o) {
+  return getStaticPropertyHelpers(o);
+}
+function tryGetStaticPropertyInfo(o, propName) {
+  return tryGetStaticPropertyHelper(o, propName);
+}
+function trySetPropertyValue(o, propName, value$1) {
+  const matchValue = tryGetStaticPropertyInfo(o, propName);
+  let matchResult, property_1;
+  if (matchValue != null) {
+    if (value(matchValue).IsMutable) {
+      matchResult = 0;
+      property_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      property_1.SetValue(o, value$1);
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+function tryGetPropertyValue(o, propName) {
+  try {
+    const matchValue = tryGetStaticPropertyInfo(o, propName);
+    return matchValue == null ? void 0 : some(value(matchValue).GetValue(o));
+  } catch (matchValue_1) {
+    throw matchValue_1;
+  }
+}
+function tryGetPropertyValueAs(o, propName) {
+  try {
+    return map((v) => v, tryGetPropertyValue(o, propName));
+  } catch (matchValue) {
+    throw matchValue;
+  }
+}
+function removeProperty(o, propName) {
+  const matchValue = tryGetStaticPropertyInfo(o, propName);
+  let matchResult, property_1;
+  if (matchValue != null) {
+    if (value(matchValue).IsMutable) {
+      matchResult = 0;
+      property_1 = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      property_1.RemoveValue(o);
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+export { getStaticProperties, removeProperty, tryGetPropertyValue, tryGetPropertyValueAs, tryGetStaticPropertyInfo, trySetPropertyValue };

package/dist/ts/ts/fable_modules/Fable.Exceljs.1.6.0/ExcelJs.fs.js

@@ -0,0 +1,5 @@
+import exceljs from '@nfdi4plants/exceljs';
+
+const Excel = exceljs;
+
+export { Excel };