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

package/dist/ts/ts/ROCrate/LDObject.js

@@ -0,0 +1,891 @@
+import { isIterable, equals, identityHash, stringHash, defaultOf, getEnumerator, curry2, structuralHash, isArrayLike } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { defaultArg, value, unwrap, some, map } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { DynamicObj, DynamicObj_$reflection } from '../fable_modules/DynamicObj.7.0.1/DynamicObj.fs.js';
+import { mergeHashes } from '../fable_modules/DynamicObj.7.0.1/HashCodes.fs.js';
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { addToDict, getItemFromDict, tryGetValue } from '../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { FSharpRef } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { LDContext } from './LDContext.js';
+import { iterate, filter, choose, exists, toList, delay, enumerateWhile, singleton, empty, tryFind, map as map$1, enumerateFromFunctions, collect, append } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ResizeArray_map } from '../Core/Helper/Collections.js';
+import { List_distinctBy } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+
+function ActivePattern_$007CNonStringEnumerable$007C_$007C(o) {
+  if (typeof o === "string") {
+    const s = o;
+    return void 0;
+  } else if (isIterable(o)) {
+    return o;
+  } else {
+    return void 0;
+  }
+}
+function DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5(this$, propertyName) {
+  return this$.TryGetPropertyValue(propertyName) != null;
+}
+class LDValue {
+  constructor(value, valueType) {
+    this["valueType@54"] = defaultArg(valueType, "string");
+    this["value@55"] = value;
+  }
+  get Value() {
+    const this$ = this;
+    return this$["value@55"];
+  }
+  set Value(v) {
+    const this$ = this;
+    this$["value@55"] = v;
+  }
+  get ValueType() {
+    const this$ = this;
+    return this$["valueType@54"];
+  }
+  set ValueType(v) {
+    const this$ = this;
+    this$["valueType@54"] = v;
+  }
+  Equals(other) {
+    let other_1;
+    const this$ = this;
+    return other instanceof LDValue && (other_1 = other, equals(this$.Value, other_1.Value));
+  }
+  GetHashCode() {
+    const this$ = this;
+    return mergeHashes(123, identityHash(this$.Value)) | 0;
+  }
+}
+function LDValue_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDValue", void 0, LDValue);
+}
+function LDValue_$ctor_77809003(value, valueType) {
+  return new LDValue(value, valueType);
+}
+class LDRef {
+  constructor(id) {
+    this["id@75"] = id;
+  }
+  get Id() {
+    const this$ = this;
+    return this$["id@75"];
+  }
+  set Id(v) {
+    const this$ = this;
+    this$["id@75"] = v;
+  }
+  Equals(other) {
+    let other_1;
+    const this$ = this;
+    return other instanceof LDRef && (other_1 = other, this$.Id === other_1.Id);
+  }
+  GetHashCode() {
+    const this$ = this;
+    return mergeHashes(123, stringHash(this$.Id)) | 0;
+  }
+}
+function LDRef_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDRef", void 0, LDRef);
+}
+function LDRef_$ctor_Z721C83C5(id) {
+  return new LDRef(id);
+}
+class LDGraph extends DynamicObj {
+  constructor(id, nodes, context) {
+    super();
+    const this$ = new FSharpRef(defaultOf());
+    this$.contents = this;
+    this["id@94"] = id;
+    this.mappings = /* @__PURE__ */ new Map([]);
+    this["init@90"] = 1;
+    if (context == null) {
+    } else {
+      const ctx = value(context);
+      this$.contents.SetContext(ctx);
+    }
+    if (nodes == null) {
+    } else {
+      iterate((node) => {
+        addToDict(this.mappings, node.Id, node);
+      }, value(nodes));
+    }
+  }
+  get Id() {
+    const this$ = this;
+    return unwrap(this$["id@94"]);
+  }
+  set Id(v) {
+    const this$ = this;
+    this$["id@94"] = v;
+  }
+  get Nodes() {
+    const this$ = this;
+    const collection = this$.mappings.values();
+    return Array.from(collection);
+  }
+  ContainsNode(id) {
+    const this$ = this;
+    return this$.mappings.has(id);
+  }
+  GetNode(id) {
+    const this$ = this;
+    return getItemFromDict(this$.mappings, id);
+  }
+  TryGetNode(id) {
+    const this$ = this;
+    let matchValue;
+    let outArg = defaultOf();
+    matchValue = [tryGetValue(this$.mappings, id, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg];
+    return matchValue[0] ? matchValue[1] : void 0;
+  }
+  AddNode(node) {
+    const this$ = this;
+    const id = node.Id;
+    const matchValue = this$.TryGetNode(id);
+    if (matchValue == null) {
+      addToDict(this$.mappings, id, node);
+    } else {
+      const existingNode = value(matchValue);
+      node.MergeAppendInto_InPlace(existingNode, this$);
+    }
+  }
+  Compact_InPlace(context) {
+    const this$ = this;
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    iterate((node) => {
+      node.Compact_InPlace(unwrap(context_1));
+    }, this$.Nodes);
+  }
+  SetContext(context) {
+    const this$ = this;
+    this$.SetProperty("@context", context);
+  }
+  static setContext(context) {
+    return (roc) => {
+      roc.SetContext(context);
+    };
+  }
+  TryGetContext() {
+    const this$ = this;
+    const dynObj = this$;
+    const matchValue = dynObj.TryGetPropertyValue("@context");
+    if (matchValue != null) {
+      const o = value(matchValue);
+      return o instanceof LDContext ? o : void 0;
+    } else {
+      return void 0;
+    }
+  }
+  static tryGetContext() {
+    return (roc) => roc.TryGetContext();
+  }
+  RemoveContext() {
+    const this$ = this;
+    return this$.RemoveProperty("@context");
+  }
+  GetDynamicPropertyHelpers() {
+    const this$ = this;
+    return filter((ph) => !(ph.Name.startsWith("init@") ? true : ph.Name === "mappings"), this$.GetPropertyHelpers(false));
+  }
+  GetDynamicPropertyNames(context) {
+    const this$ = this;
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    return choose((ph) => {
+      let name;
+      if (context_1 == null) {
+        name = ph.Name;
+      } else {
+        const ctx = value(context_1);
+        const matchValue = ctx.TryResolveTerm(ph.Name);
+        name = matchValue == null ? ph.Name : value(matchValue);
+      }
+      if (name === "@context") {
+        return void 0;
+      } else {
+        return name;
+      }
+    }, this$.GetDynamicPropertyHelpers());
+  }
+}
+function LDGraph_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDGraph", void 0, LDGraph, DynamicObj_$reflection());
+}
+function LDGraph_$ctor_5FC797DE(id, nodes, context) {
+  return new LDGraph(id, nodes, context);
+}
+class LDNode extends DynamicObj {
+  constructor(id, schemaType, additionalType, context) {
+    super();
+    const this$ = new FSharpRef(defaultOf());
+    this.id = id;
+    this$.contents = this;
+    this["schemaType@178"] = schemaType;
+    this["additionalType@179"] = defaultArg(additionalType, []);
+    this["init@175-1"] = 1;
+    if (context == null) {
+    } else {
+      const ctx = value(context);
+      this$.contents.SetContext(ctx);
+    }
+  }
+  get Id() {
+    const this$ = this;
+    return this$.id;
+  }
+  get SchemaType() {
+    const this$ = this;
+    return this$["schemaType@178"];
+  }
+  set SchemaType(value) {
+    const this$ = this;
+    this$["schemaType@178"] = value;
+  }
+  get AdditionalType() {
+    const this$ = this;
+    return this$["additionalType@179"];
+  }
+  set AdditionalType(value) {
+    const this$ = this;
+    this$["additionalType@179"] = value;
+  }
+  HasType(schemaType, context) {
+    const this$ = this;
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    return exists((st) => {
+      if (st === schemaType) {
+        return true;
+      } else if (context_1 == null) {
+        return false;
+      } else {
+        const ctx = value(context_1);
+        const matchValue = ctx.TryResolveTerm(st);
+        const matchValue_1 = ctx.TryResolveTerm(schemaType);
+        if (matchValue == null) {
+          if (matchValue_1 != null) {
+            const schemaType_2 = value(matchValue_1);
+            return st === schemaType_2;
+          } else {
+            return false;
+          }
+        } else if (matchValue_1 == null) {
+          const st_2 = value(matchValue);
+          return st_2 === schemaType;
+        } else {
+          const schemaType_1 = value(matchValue_1);
+          const st_1 = value(matchValue);
+          return st_1 === schemaType_1;
+        }
+      }
+    }, this$.SchemaType);
+  }
+  TryGetProperty(propertyName, context) {
+    const this$ = this;
+    const matchValue = this$.TryGetPropertyValue(propertyName);
+    if (matchValue == null) {
+      let matchValue_1;
+      const specificContext = this$.TryGetContext();
+      matchValue_1 = LDContext.tryCombineOptional(context, specificContext);
+      if (matchValue_1 == null) {
+        return void 0;
+      } else {
+        const ctx = value(matchValue_1);
+        const matchValue_2 = ctx.TryResolveTerm(propertyName);
+        if (matchValue_2 == null) {
+          const matchValue_3 = ctx.TryGetTerm(propertyName);
+          if (matchValue_3 == null) {
+            return void 0;
+          } else {
+            const term_1 = value(matchValue_3);
+            return this$.TryGetPropertyValue(term_1);
+          }
+        } else {
+          const term = value(matchValue_2);
+          return this$.TryGetPropertyValue(term);
+        }
+      }
+    } else {
+      return some(value(matchValue));
+    }
+  }
+  TryGetPropertyAsSingleton(propertyName, context) {
+    const this$ = this;
+    const matchValue = this$.TryGetProperty(propertyName, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const s = value(matchValue);
+        return some(s);
+      } else if (isIterable(value(matchValue))) {
+        const e = value(matchValue);
+        const en = getEnumerator(e);
+        return en["System.Collections.IEnumerator.MoveNext"]() ? some(en["System.Collections.IEnumerator.get_Current"]()) : void 0;
+      } else {
+        const o = value(matchValue);
+        return some(o);
+      }
+    } else {
+      return void 0;
+    }
+  }
+  GetPropertyValues(propertyName, filter, context) {
+    const this$ = this;
+    const filter_1 = defaultArg(map(curry2, filter), (_arg) => (_arg_1) => true);
+    const matchValue = this$.TryGetProperty(propertyName, unwrap(context));
+    let matchResult, s, e, o_1;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        s = value(matchValue);
+      } else if (isIterable(value(matchValue))) {
+        matchResult = 1;
+        e = value(matchValue);
+      } else if (filter_1(value(matchValue))(context)) {
+        matchResult = 2;
+        o_1 = value(matchValue);
+      } else {
+        matchResult = 3;
+      }
+    } else {
+      matchResult = 3;
+    }
+    switch (matchResult) {
+      case 0:
+        return filter_1(s)(context) ? [s] : [];
+      case 1: {
+        const en = getEnumerator(e);
+        const collection = toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => filter_1(en["System.Collections.IEnumerator.get_Current"]())(context) ? singleton(en["System.Collections.IEnumerator.get_Current"]()) : empty()))));
+        return Array.from(collection);
+      }
+      case 2:
+        return [o_1];
+      default:
+        return [];
+    }
+  }
+  TryGetPropertyAsSingleNode(propertyName, graph, context) {
+    let r;
+    const this$ = this;
+    const matchValue = this$.TryGetPropertyAsSingleton(propertyName, unwrap(context));
+    let matchResult, n, r_1;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof LDNode) {
+        matchResult = 0;
+        n = value(matchValue);
+      } else if (value(matchValue) instanceof LDRef) {
+        if (r = value(matchValue), graph != null) {
+          matchResult = 1;
+          r_1 = value(matchValue);
+        } else {
+          matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+    } else {
+      matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      case 1: {
+        const matchValue_1 = value(graph).TryGetNode(r_1.Id);
+        return matchValue_1 == null ? void 0 : value(matchValue_1);
+      }
+      default:
+        return void 0;
+    }
+  }
+  GetPropertyNodes(propertyName, filter, graph, context) {
+    const this$ = this;
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    const collection = choose((o) => {
+      let r;
+      let matchResult;
+      if (o instanceof LDRef) {
+        if (r = o, graph != null) {
+          matchResult = 0;
+        } else {
+          matchResult = 2;
+        }
+      } else if (o instanceof LDNode) {
+        matchResult = 1;
+      } else {
+        matchResult = 2;
+      }
+      switch (matchResult) {
+        case 0: {
+          const r_1 = o;
+          const matchValue = value(graph).TryGetNode(r_1.Id);
+          if (matchValue == null) {
+            return void 0;
+          } else {
+            const n = value(matchValue);
+            if (filter == null) {
+              return n;
+            } else if (value(filter)(n, context_1)) {
+              const f_1 = value(map(curry2, filter));
+              return n;
+            } else {
+              return void 0;
+            }
+          }
+        }
+        case 1: {
+          const n_1 = o;
+          if (filter == null) {
+            return n_1;
+          } else if (value(filter)(n_1, context_1)) {
+            const f_3 = value(map(curry2, filter));
+            return n_1;
+          } else {
+            return void 0;
+          }
+        }
+        default:
+          return void 0;
+      }
+    }, this$.GetPropertyValues(propertyName, void 0, unwrap(context_1)));
+    return Array.from(collection);
+  }
+  GetDynamicPropertyHelpers() {
+    const this$ = this;
+    return filter((ph) => !(ph.Name.startsWith("init@") ? true : ph.Name === "id"), this$.GetPropertyHelpers(false));
+  }
+  GetPropertyNames(context) {
+    const this$ = this;
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    return choose((ph) => {
+      let name;
+      if (context_1 == null) {
+        name = ph.Name;
+      } else {
+        const ctx = value(context_1);
+        const matchValue = ctx.TryResolveTerm(ph.Name);
+        name = matchValue == null ? ph.Name : value(matchValue);
+      }
+      if (name === "@context") {
+        return void 0;
+      } else {
+        return name;
+      }
+    }, this$.GetDynamicPropertyHelpers());
+  }
+  SetProperty(propertyName, value$1, context) {
+    const this$ = this;
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    const propertyName_1 = defaultArg(tryFind((pn) => {
+      if (context_1 == null) {
+        return pn === propertyName;
+      } else {
+        const c = value(context_1);
+        return c.PropertyNamesMatch(pn, propertyName);
+      }
+    }, this$.GetPropertyNames()), propertyName);
+    super.SetProperty(propertyName_1, value$1);
+  }
+  SetOptionalProperty(propertyName, value$1, context) {
+    const this$ = this;
+    if (value$1 == null) {
+    } else {
+      const v = value(value$1);
+      this$.SetProperty(propertyName, v, unwrap(context));
+    }
+  }
+  HasProperty(propertyName, context) {
+    let v_2, e;
+    const this$ = this;
+    const v = this$.TryGetProperty(propertyName, unwrap(context));
+    return v != null && (equals(value(v), defaultOf()) ? (v_2 = value(v), false) : isIterable(value(v)) ? (e = value(v), getEnumerator(e)["System.Collections.IEnumerator.MoveNext"]()) : true);
+  }
+  SetContext(context) {
+    const this$ = this;
+    this$.SetProperty("@context", context);
+  }
+  static setContext(context) {
+    return (roc) => {
+      roc.SetContext(context);
+    };
+  }
+  TryGetContext() {
+    const this$ = this;
+    const dynObj = this$;
+    const matchValue = dynObj.TryGetPropertyValue("@context");
+    if (matchValue != null) {
+      const o = value(matchValue);
+      return o instanceof LDContext ? o : void 0;
+    } else {
+      return void 0;
+    }
+  }
+  static tryGetContext() {
+    return (roc) => roc.TryGetContext();
+  }
+  RemoveContext() {
+    const this$ = this;
+    return this$.RemoveProperty("@context");
+  }
+  MergeAppendInto_InPlace(other, flattenTo) {
+    const this$ = this;
+    let flattenTo_Singleton;
+    if (flattenTo == null) {
+      flattenTo_Singleton = (x) => x;
+    } else {
+      const graph = value(flattenTo);
+      flattenTo_Singleton = (o) => {
+        if (o instanceof LDNode) {
+          const n = o;
+          n.Flatten(graph);
+          return new LDRef(n.Id);
+        } else {
+          return o;
+        }
+      };
+    }
+    let flattenTo_RA;
+    if (flattenTo == null) {
+      flattenTo_RA = (x_1) => x_1;
+    } else {
+      const graph_1 = value(flattenTo);
+      flattenTo_RA = (a) => ResizeArray_map(flattenTo_Singleton, a);
+    }
+    let flattenToAny;
+    if (flattenTo == null) {
+      flattenToAny = (x_2) => x_2;
+    } else {
+      const graph_2 = value(flattenTo);
+      const f_2 = (o_1) => {
+        let collection;
+        if (o_1 instanceof LDNode) {
+          const n_1 = o_1;
+          n_1.Flatten(graph_2);
+          return new LDRef(n_1.Id);
+        } else {
+          const activePatternResult = ActivePattern_$007CNonStringEnumerable$007C_$007C(o_1);
+          if (activePatternResult != null) {
+            const e = value(activePatternResult);
+            return collection = toList(delay(() => map$1(f_2, enumerateFromFunctions(() => getEnumerator(e), (enumerator) => enumerator["System.Collections.IEnumerator.MoveNext"](), (enumerator_1) => enumerator_1["System.Collections.IEnumerator.get_Current"]())))), Array.from(collection);
+          } else {
+            return o_1;
+          }
+        }
+      };
+      flattenToAny = f_2;
+    }
+    const toEqualitor = (o_2) => {
+      if (o_2 instanceof LDNode) {
+        const n_2 = o_2;
+        return n_2.Id;
+      } else if (o_2 instanceof LDRef) {
+        const r = o_2;
+        return r.Id;
+      } else {
+        return o_2;
+      }
+    };
+    iterate((pn) => {
+      let collection_1;
+      const matchValue = other.TryGetProperty(pn);
+      if (matchValue == null) {
+        const v_3 = flattenToAny(value(this$.TryGetProperty(pn)));
+        other.SetProperty(pn, v_3);
+      } else {
+        const otherVal = value(matchValue);
+        const thisVal = value(this$.TryGetProperty(pn));
+        let matchResult, e1, e2;
+        const activePatternResult_1 = ActivePattern_$007CNonStringEnumerable$007C_$007C(thisVal);
+        if (activePatternResult_1 != null) {
+          const activePatternResult_2 = ActivePattern_$007CNonStringEnumerable$007C_$007C(otherVal);
+          if (activePatternResult_2 != null) {
+            matchResult = 0;
+            e1 = value(activePatternResult_1);
+            e2 = value(activePatternResult_2);
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0: {
+            const l = flattenTo_RA((collection_1 = List_distinctBy(toEqualitor, toList(delay(() => append(map$1((v_1) => v_1, enumerateFromFunctions(() => getEnumerator(e2), (enumerator_2) => enumerator_2["System.Collections.IEnumerator.MoveNext"](), (enumerator_3) => enumerator_3["System.Collections.IEnumerator.get_Current"]())), delay(() => map$1((v_2) => v_2, enumerateFromFunctions(() => getEnumerator(e1), (enumerator_4) => enumerator_4["System.Collections.IEnumerator.MoveNext"](), (enumerator_5) => enumerator_5["System.Collections.IEnumerator.get_Current"]())))))), {
+              Equals: equals,
+              GetHashCode: structuralHash
+            }), Array.from(collection_1)));
+            other.SetProperty(pn, l);
+            break;
+          }
+          case 1: {
+            const activePatternResult_3 = ActivePattern_$007CNonStringEnumerable$007C_$007C(thisVal);
+            if (activePatternResult_3 != null) {
+              const theseVals = value(activePatternResult_3);
+              let isContained = false;
+              const l_1 = Array.from(toList(delay(() => collect((thisVal_1) => {
+                if (equals(toEqualitor(thisVal_1), toEqualitor(otherVal))) {
+                  isContained = true;
+                  return singleton(flattenTo_Singleton(thisVal_1));
+                } else {
+                  return singleton(thisVal_1);
+                }
+              }, enumerateFromFunctions(() => getEnumerator(theseVals), (enumerator_6) => enumerator_6["System.Collections.IEnumerator.MoveNext"](), (enumerator_7) => enumerator_7["System.Collections.IEnumerator.get_Current"]())))));
+              if (!isContained) {
+                void l_1.push(otherVal);
+                other.SetProperty(pn, l_1);
+              }
+            } else {
+              const activePatternResult_4 = ActivePattern_$007CNonStringEnumerable$007C_$007C(otherVal);
+              if (activePatternResult_4 != null) {
+                const otherVals = value(activePatternResult_4);
+                let isContained_1 = false;
+                const l_2 = Array.from(toList(delay(() => collect((otherVal_2) => append(equals(toEqualitor(thisVal), toEqualitor(otherVal_2)) ? (isContained_1 = true, empty()) : empty(), delay(() => singleton(otherVal_2))), enumerateFromFunctions(() => getEnumerator(otherVals), (enumerator_8) => enumerator_8["System.Collections.IEnumerator.MoveNext"](), (enumerator_9) => enumerator_9["System.Collections.IEnumerator.get_Current"]())))));
+                if (!isContained_1) {
+                  void l_2.push(flattenTo_Singleton(thisVal));
+                  other.SetProperty(pn, l_2);
+                }
+              } else if (equals(toEqualitor(thisVal), toEqualitor(otherVal))) {
+              } else {
+                const l_3 = [flattenTo_Singleton(thisVal), otherVal];
+                other.SetProperty(pn, l_3);
+              }
+            }
+            break;
+          }
+        }
+      }
+    }, this$.GetPropertyNames());
+  }
+  Compact_InPlace(context, setContext) {
+    const this$ = this;
+    const setContext_1 = defaultArg(setContext, false);
+    let context_1;
+    const specificContext = this$.TryGetContext();
+    context_1 = LDContext.tryCombineOptional(context, specificContext);
+    if (context_1 != null) {
+      const context_2 = value(context_1);
+      if (setContext_1) {
+        this$.SetContext(context_2);
+      }
+      const newTypes = Array.from(toList(delay(() => collect((st) => {
+        const matchValue = context_2.TryGetTerm(st);
+        return matchValue == null ? singleton(st) : singleton(value(matchValue));
+      }, this$.SchemaType))));
+      this$.SchemaType = newTypes;
+    }
+    const compactValue_inPlace = (o) => {
+      let matchResult, n, s, e, v, x;
+      if (o instanceof LDNode) {
+        matchResult = 0;
+        n = o;
+      } else if (typeof o === "string") {
+        matchResult = 1;
+        s = o;
+      } else if (o instanceof LDValue) {
+        if (isIterable(o)) {
+          matchResult = 2;
+          e = o;
+        } else {
+          matchResult = 3;
+          v = o;
+        }
+      } else if (isIterable(o)) {
+        matchResult = 2;
+        e = o;
+      } else {
+        matchResult = 4;
+        x = o;
+      }
+      switch (matchResult) {
+        case 0: {
+          n.Compact_InPlace(unwrap(context_1));
+          return n;
+        }
+        case 1:
+          return s;
+        case 2: {
+          const en = getEnumerator(e);
+          const l = Array.from(toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton(compactValue_inPlace(en["System.Collections.IEnumerator.get_Current"]())))))));
+          if (l.length === 1) {
+            return l[0];
+          } else {
+            return l;
+          }
+        }
+        case 3:
+          return v.Value;
+        default:
+          return x;
+      }
+    };
+    iterate((ph) => {
+      let newKey;
+      if (context_1 == null) {
+        newKey = void 0;
+      } else {
+        const ctx = value(context_1);
+        const matchValue_1 = ctx.TryGetTerm(ph.Name);
+        newKey = matchValue_1 == null ? void 0 : value(matchValue_1);
+      }
+      const newValue = compactValue_inPlace(ph.GetValue(this$));
+      let matchResult_1, key_1;
+      if (newKey != null) {
+        if (value(newKey) !== ph.Name) {
+          matchResult_1 = 0;
+          key_1 = value(newKey);
+        } else {
+          matchResult_1 = 1;
+        }
+      } else {
+        matchResult_1 = 1;
+      }
+      switch (matchResult_1) {
+        case 0: {
+          this$.RemoveProperty(ph.Name);
+          this$.SetProperty(key_1, newValue);
+          break;
+        }
+        case 1: {
+          ph.SetValue(this$, newValue);
+          break;
+        }
+      }
+    }, this$.GetDynamicPropertyHelpers());
+  }
+  Flatten(graph) {
+    const this$ = this;
+    const graph_1 = graph == null ? new LDGraph(void 0, void 0, unwrap(this$.TryGetContext())) : value(graph);
+    const flattenValue = (o) => {
+      if (o instanceof LDNode) {
+        const n = o;
+        n.Flatten(graph_1);
+        return new LDRef(n.Id);
+      } else if (typeof o === "string") {
+        const s = o;
+        return s;
+      } else if (isIterable(o)) {
+        const e = o;
+        const en = getEnumerator(e);
+        return Array.from(toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton(flattenValue(en["System.Collections.IEnumerator.get_Current"]())))))));
+      } else {
+        return o;
+      }
+    };
+    iterate((ph) => {
+      ph.SetValue(this$, flattenValue(ph.GetValue(this$)));
+    }, this$.GetDynamicPropertyHelpers());
+    graph_1.AddNode(this$);
+    return graph_1;
+  }
+  Unflatten(graph) {
+    const this$ = this;
+    const unflattenValue = (o) => {
+      if (o instanceof LDRef) {
+        const r = o;
+        const matchValue = graph.TryGetNode(r.Id);
+        if (matchValue == null) {
+          return r;
+        } else {
+          return value(matchValue);
+        }
+      } else if (o instanceof LDNode) {
+        const n_1 = o;
+        n_1.Unflatten(graph);
+        return n_1;
+      } else if (isIterable(o)) {
+        const e = o;
+        const en = getEnumerator(e);
+        return Array.from(toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton(unflattenValue(en["System.Collections.IEnumerator.get_Current"]())))))));
+      } else {
+        return o;
+      }
+    };
+    iterate((ph) => {
+      ph.SetValue(this$, unflattenValue(ph.GetValue(this$)));
+    }, this$.GetDynamicPropertyHelpers());
+  }
+  static removeContext() {
+    return (roc) => roc.RemoveContext();
+  }
+  static tryFromDynamicObj(dynObj) {
+    let matchValue_3, ra_1, singleton_1;
+    let original_id;
+    const matchValue = dynObj.TryGetPropertyValue("@id");
+    if (matchValue != null) {
+      const o = value(matchValue);
+      original_id = typeof o === "string" ? o : void 0;
+    } else {
+      original_id = void 0;
+    }
+    let original_type;
+    const matchValue_1 = dynObj.TryGetPropertyValue("@type");
+    let matchResult, ra, singleton;
+    if (matchValue_1 != null) {
+      if (isArrayLike(value(matchValue_1))) {
+        matchResult = 0;
+        ra = value(matchValue_1);
+      } else if (typeof value(matchValue_1) === "string") {
+        matchResult = 1;
+        singleton = value(matchValue_1);
+      } else {
+        matchResult = 2;
+      }
+    } else {
+      matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0: {
+        original_type = ra;
+        break;
+      }
+      case 1: {
+        original_type = [singleton];
+        break;
+      }
+      default:
+        original_type = void 0;
+    }
+    let matchResult_1, id, st;
+    if (original_id != null) {
+      if (original_type != null) {
+        matchResult_1 = 0;
+        id = value(original_id);
+        st = value(original_type);
+      } else {
+        matchResult_1 = 1;
+      }
+    } else {
+      matchResult_1 = 1;
+    }
+    switch (matchResult_1) {
+      case 0: {
+        const roc = new LDNode(id, st, unwrap((matchValue_3 = dynObj.TryGetPropertyValue("additionalType"), matchValue_3 != null ? isArrayLike(value(matchValue_3)) ? (ra_1 = value(matchValue_3), ra_1) : typeof value(matchValue_3) === "string" ? (singleton_1 = value(matchValue_3), [singleton_1]) : void 0 : void 0)));
+        dynObj.DeepCopyPropertiesTo(roc, void 0, false);
+        iterate((ph) => {
+          if (ph.IsDynamic && ((ph.Name === "@id" ? true : ph.Name === "@type") ? true : ph.Name === "additionalType")) {
+            ph.RemoveValue(roc);
+          }
+        }, roc.GetDynamicPropertyHelpers());
+        return roc;
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+function LDNode_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDNode", void 0, LDNode, DynamicObj_$reflection());
+}
+function LDNode_$ctor_479BCDCF(id, schemaType, additionalType, context) {
+  return new LDNode(id, schemaType, additionalType, context);
+}
+
+export { ActivePattern_$007CNonStringEnumerable$007C_$007C, DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5, LDGraph, LDGraph_$ctor_5FC797DE, LDGraph_$reflection, LDNode, LDNode_$ctor_479BCDCF, LDNode_$reflection, LDRef, LDRef_$ctor_Z721C83C5, LDRef_$reflection, LDValue, LDValue_$ctor_77809003, LDValue_$reflection };