@nfdi4plants/arctrl 2.3.1 → 2.5.0

package/ROCrate/LDObject.js

@@ -1,27 +1,254 @@
-import { DynamicObj_$reflection, DynamicObj } from "../fable_modules/DynamicObj.4.0.3/DynamicObj.fs.js";
+import { isArrayLike, structuralHash, curry2, getEnumerator, defaultOf, stringHash, identityHash, equals, isIterable } from "../fable_modules/fable-library-js.4.24.0/Util.js";
+import { mergeHashes } from "../fable_modules/DynamicObj.7.0.1/HashCodes.fs.js";
+import { map, some, value as value_3, unwrap, defaultArg } from "../fable_modules/fable-library-js.4.24.0/Option.js";
 import { class_type } from "../fable_modules/fable-library-js.4.24.0/Reflection.js";
-import { value as value_1, unwrap } from "../fable_modules/fable-library-js.4.24.0/Option.js";
+import { addToDict, tryGetValue, getItemFromDict } from "../fable_modules/fable-library-js.4.24.0/MapUtil.js";
+import { FSharpRef } from "../fable_modules/fable-library-js.4.24.0/Types.js";
+import { LDContext } from "./LDContext.js";
+import { collect, append, enumerateFromFunctions, map as map_1, tryFind, empty, singleton as singleton_2, enumerateWhile, delay, toList, exists, choose, filter as filter_2, iterate } from "../fable_modules/fable-library-js.4.24.0/Seq.js";
+import { DynamicObj_$reflection, DynamicObj } from "../fable_modules/DynamicObj.7.0.1/DynamicObj.fs.js";
+import { ResizeArray_map } from "../Core/Helper/Collections.js";
+import { List_distinctBy } from "../fable_modules/fable-library-js.4.24.0/Seq2.js";
 
-export class LDContext extends DynamicObj {
-    constructor() {
+export function ActivePattern_$007CNonStringEnumerable$007C_$007C(o) {
+    if (typeof o === "string") {
+        return undefined;
+    }
+    else if (isIterable(o)) {
+        return o;
+    }
+    else {
+        return undefined;
+    }
+}
+
+export function DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5(this$, propertyName) {
+    return this$.TryGetPropertyValue(propertyName) != null;
+}
+
+export 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;
+    }
+}
+
+export function LDValue_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDValue", undefined, LDValue);
+}
+
+export function LDValue_$ctor_77809003(value, valueType) {
+    return new LDValue(value, valueType);
+}
+
+export 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;
+    }
+}
+
+export function LDRef_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDRef", undefined, LDRef);
+}
+
+export function LDRef_$ctor_Z721C83C5(id) {
+    return new LDRef(id);
+}
+
+export class LDGraph extends DynamicObj {
+    constructor(id, nodes, context) {
         super();
+        const this$ = new FSharpRef(defaultOf());
+        this$.contents = this;
+        this["id@94"] = id;
+        this.mappings = (new Map([]));
+        this["init@90"] = 1;
+        if (context == null) {
+        }
+        else {
+            const ctx = context;
+            this$.contents.SetContext(ctx);
+        }
+        if (nodes == null) {
+        }
+        else {
+            iterate((node) => {
+                addToDict(this.mappings, node.Id, node);
+            }, 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] : undefined;
+    }
+    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 = 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 matchValue = this$.TryGetPropertyValue("@context");
+        if (matchValue != null) {
+            const o = value_3(matchValue);
+            return (o instanceof LDContext) ? o : undefined;
+        }
+        else {
+            return undefined;
+        }
+    }
+    static tryGetContext() {
+        return (roc) => roc.TryGetContext();
+    }
+    RemoveContext() {
+        const this$ = this;
+        return this$.RemoveProperty("@context");
+    }
+    GetDynamicPropertyHelpers() {
+        const this$ = this;
+        return filter_2((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 = context_1;
+                const matchValue = ctx.TryResolveTerm(ph.Name);
+                name = ((matchValue == null) ? ph.Name : matchValue);
+            }
+            if (name === "@context") {
+                return undefined;
+            }
+            else {
+                return name;
+            }
+        }, this$.GetDynamicPropertyHelpers());
     }
 }
 
-export function LDContext_$reflection() {
-    return class_type("ARCtrl.ROCrate.LDContext", undefined, LDContext, DynamicObj_$reflection());
+export function LDGraph_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDGraph", undefined, LDGraph, DynamicObj_$reflection());
 }
 
-export function LDContext_$ctor() {
-    return new LDContext();
+export function LDGraph_$ctor_5FC797DE(id, nodes, context) {
+    return new LDGraph(id, nodes, context);
 }
 
-export class LDObject extends DynamicObj {
-    constructor(id, schemaType, additionalType) {
+export class LDNode extends DynamicObj {
+    constructor(id, schemaType, additionalType, context) {
         super();
+        const this$ = new FSharpRef(defaultOf());
         this.id = id;
-        this["schemaType@22"] = schemaType;
-        this["additionalType@23"] = additionalType;
+        this$.contents = this;
+        this["schemaType@178"] = schemaType;
+        this["additionalType@179"] = defaultArg(additionalType, []);
+        this["init@175-1"] = 1;
+        if (context == null) {
+        }
+        else {
+            const ctx = context;
+            this$.contents.SetContext(ctx);
+        }
     }
     get Id() {
         const this$ = this;
@@ -29,19 +256,305 @@ export class LDObject extends DynamicObj {
     }
     get SchemaType() {
         const this$ = this;
-        return this$["schemaType@22"];
+        return this$["schemaType@178"];
     }
     set SchemaType(value) {
         const this$ = this;
-        this$["schemaType@22"] = value;
+        this$["schemaType@178"] = value;
     }
     get AdditionalType() {
         const this$ = this;
-        return unwrap(this$["additionalType@23"]);
+        return this$["additionalType@179"];
     }
     set AdditionalType(value) {
         const this$ = this;
-        this$["additionalType@23"] = value;
+        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 = context_1;
+                const matchValue = ctx.TryResolveTerm(st);
+                const matchValue_1 = ctx.TryResolveTerm(schemaType);
+                if (matchValue == null) {
+                    if (matchValue_1 != null) {
+                        const schemaType_2 = matchValue_1;
+                        return st === schemaType_2;
+                    }
+                    else {
+                        return false;
+                    }
+                }
+                else if (matchValue_1 == null) {
+                    const st_2 = matchValue;
+                    return st_2 === schemaType;
+                }
+                else {
+                    const schemaType_1 = matchValue_1;
+                    const st_1 = 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 undefined;
+            }
+            else {
+                const ctx = matchValue_1;
+                const matchValue_2 = ctx.TryResolveTerm(propertyName);
+                if (matchValue_2 == null) {
+                    const matchValue_3 = ctx.TryGetTerm(propertyName);
+                    if (matchValue_3 == null) {
+                        return undefined;
+                    }
+                    else {
+                        const term_1 = matchValue_3;
+                        return this$.TryGetPropertyValue(term_1);
+                    }
+                }
+                else {
+                    const term = matchValue_2;
+                    return this$.TryGetPropertyValue(term);
+                }
+            }
+        }
+        else {
+            return some(value_3(matchValue));
+        }
+    }
+    TryGetPropertyAsSingleton(propertyName, context) {
+        const this$ = this;
+        const matchValue = this$.TryGetProperty(propertyName, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                const s = value_3(matchValue);
+                return some(s);
+            }
+            else if (isIterable(value_3(matchValue))) {
+                const e = value_3(matchValue);
+                const en = getEnumerator(e);
+                return en["System.Collections.IEnumerator.MoveNext"]() ? some(en["System.Collections.IEnumerator.get_Current"]()) : undefined;
+            }
+            else {
+                const o = value_3(matchValue);
+                return some(o);
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    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_3(matchValue) === "string") {
+                matchResult = 0;
+                s = value_3(matchValue);
+            }
+            else if (isIterable(value_3(matchValue))) {
+                matchResult = 1;
+                e = value_3(matchValue);
+            }
+            else if (filter_1(value_3(matchValue))(context)) {
+                matchResult = 2;
+                o_1 = value_3(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_2(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_3(matchValue) instanceof LDNode) {
+                matchResult = 0;
+                n = value_3(matchValue);
+            }
+            else if (value_3(matchValue) instanceof LDRef) {
+                if ((r = value_3(matchValue), graph != null)) {
+                    matchResult = 1;
+                    r_1 = value_3(matchValue);
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            case 1: {
+                const matchValue_1 = value_3(graph).TryGetNode(r_1.Id);
+                return (matchValue_1 == null) ? undefined : matchValue_1;
+            }
+            default:
+                return undefined;
+        }
+    }
+    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 matchResult;
+            if (o instanceof LDRef) {
+                if (graph != null) {
+                    matchResult = 0;
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else if (o instanceof LDNode) {
+                matchResult = 1;
+            }
+            else {
+                matchResult = 2;
+            }
+            switch (matchResult) {
+                case 0: {
+                    const matchValue = value_3(graph).TryGetNode(o.Id);
+                    if (matchValue == null) {
+                        return undefined;
+                    }
+                    else {
+                        const n = matchValue;
+                        if (filter == null) {
+                            return n;
+                        }
+                        else if (filter(n, context_1)) {
+                            const f_1 = map(curry2, filter);
+                            return n;
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                }
+                case 1: {
+                    const n_1 = o;
+                    if (filter == null) {
+                        return n_1;
+                    }
+                    else if (filter(n_1, context_1)) {
+                        const f_3 = map(curry2, filter);
+                        return n_1;
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                default:
+                    return undefined;
+            }
+        }, this$.GetPropertyValues(propertyName, undefined, unwrap(context_1)));
+        return Array.from(collection);
+    }
+    GetDynamicPropertyHelpers() {
+        const this$ = this;
+        return filter_2((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 = context_1;
+                const matchValue = ctx.TryResolveTerm(ph.Name);
+                name = ((matchValue == null) ? ph.Name : matchValue);
+            }
+            if (name === "@context") {
+                return undefined;
+            }
+            else {
+                return name;
+            }
+        }, this$.GetDynamicPropertyHelpers());
+    }
+    SetProperty(propertyName, value, 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 = context_1;
+                return c.PropertyNamesMatch(pn, propertyName);
+            }
+        }, this$.GetPropertyNames()), propertyName);
+        super.SetProperty(propertyName_1,value);
+    }
+    SetOptionalProperty(propertyName, value, context) {
+        const this$ = this;
+        if (value == null) {
+        }
+        else {
+            const v = value_3(value);
+            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_3(v), defaultOf()) ? ((v_2 = value_3(v), false)) : (isIterable(value_3(v)) ? ((e = value_3(v), getEnumerator(e)["System.Collections.IEnumerator.MoveNext"]())) : true));
     }
     SetContext(context) {
         const this$ = this;
@@ -56,8 +569,8 @@ export class LDObject extends DynamicObj {
         const this$ = this;
         const matchValue = this$.TryGetPropertyValue("@context");
         if (matchValue != null) {
-            const o = value_1(matchValue);
-            return (o instanceof DynamicObj) ? o : undefined;
+            const o = value_3(matchValue);
+            return (o instanceof LDContext) ? o : undefined;
         }
         else {
             return undefined;
@@ -70,36 +583,389 @@ export class LDObject extends DynamicObj {
         const this$ = this;
         return this$.RemoveProperty("@context");
     }
-    static removeContext() {
-        return (roc) => roc.RemoveContext();
-    }
-    get SchemaType() {
+    MergeAppendInto_InPlace(other, flattenTo) {
         const this$ = this;
-        return this$["schemaType@22"];
+        let flattenTo_Singleton;
+        if (flattenTo == null) {
+            flattenTo_Singleton = ((x) => x);
+        }
+        else {
+            const graph = 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 = flattenTo;
+            flattenTo_RA = ((a) => ResizeArray_map(flattenTo_Singleton, a));
+        }
+        let flattenToAny;
+        if (flattenTo == null) {
+            flattenToAny = ((x_2) => x_2);
+        }
+        else {
+            const graph_2 = 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 = 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) {
+                return o_2.Id;
+            }
+            else if (o_2 instanceof LDRef) {
+                return o_2.Id;
+            }
+            else {
+                return o_2;
+            }
+        };
+        iterate((pn) => {
+            let collection_1;
+            const matchValue = other.TryGetProperty(pn);
+            if (matchValue == null) {
+                const v_3 = flattenToAny(value_3(this$.TryGetProperty(pn)));
+                other.SetProperty(pn, v_3);
+            }
+            else {
+                const otherVal = value_3(matchValue);
+                const thisVal = value_3(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 = activePatternResult_1;
+                        e2 = 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 = 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_2(flattenTo_Singleton(thisVal_1));
+                                }
+                                else {
+                                    return singleton_2(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 = 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_2(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());
     }
-    set SchemaType(value) {
+    Compact_InPlace(context, setContext) {
         const this$ = this;
-        this$["schemaType@22"] = value;
+        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_3(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_2(st) : singleton_2(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_2(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 = undefined;
+            }
+            else {
+                const ctx = context_1;
+                const matchValue_1 = ctx.TryGetTerm(ph.Name);
+                newKey = ((matchValue_1 == null) ? undefined : matchValue_1);
+            }
+            const newValue = compactValue_inPlace(ph.GetValue(this$));
+            let matchResult_1, key_1;
+            if (newKey != null) {
+                if (newKey !== ph.Name) {
+                    matchResult_1 = 0;
+                    key_1 = 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());
     }
-    get Id() {
+    Flatten(graph) {
         const this$ = this;
-        return this$.id;
+        const graph_1 = (graph == null) ? (new LDGraph(undefined, undefined, unwrap(this$.TryGetContext()))) : graph;
+        const flattenValue = (o) => {
+            if (o instanceof LDNode) {
+                o.Flatten(graph_1);
+                return new LDRef(o.Id);
+            }
+            else if (typeof o === "string") {
+                return o;
+            }
+            else if (isIterable(o)) {
+                const e = o;
+                const en = getEnumerator(e);
+                return Array.from(toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton_2(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;
     }
-    get AdditionalType() {
+    Unflatten(graph) {
         const this$ = this;
-        return unwrap(this$["additionalType@23"]);
+        const unflattenValue = (o) => {
+            if (o instanceof LDRef) {
+                const matchValue = graph.TryGetNode(o.Id);
+                if (matchValue == null) {
+                    return o;
+                }
+                else {
+                    return matchValue;
+                }
+            }
+            else if (o instanceof LDNode) {
+                o.Unflatten(graph);
+                return o;
+            }
+            else if (isIterable(o)) {
+                const e = o;
+                const en = getEnumerator(e);
+                return Array.from(toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton_2(unflattenValue(en["System.Collections.IEnumerator.get_Current"]())))))));
+            }
+            else {
+                return o;
+            }
+        };
+        iterate((ph) => {
+            ph.SetValue(this$, unflattenValue(ph.GetValue(this$)));
+        }, this$.GetDynamicPropertyHelpers());
     }
-    set AdditionalType(value) {
-        const this$ = this;
-        this$["additionalType@23"] = value;
+    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_3(matchValue);
+            original_id = ((typeof o === "string") ? o : undefined);
+        }
+        else {
+            original_id = undefined;
+        }
+        let original_type;
+        const matchValue_1 = dynObj.TryGetPropertyValue("@type");
+        let matchResult, ra, singleton;
+        if (matchValue_1 != null) {
+            if (isArrayLike(value_3(matchValue_1))) {
+                matchResult = 0;
+                ra = value_3(matchValue_1);
+            }
+            else if (typeof value_3(matchValue_1) === "string") {
+                matchResult = 1;
+                singleton = value_3(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 = undefined;
+        }
+        let matchResult_1, id, st;
+        if (original_id != null) {
+            if (original_type != null) {
+                matchResult_1 = 0;
+                id = original_id;
+                st = 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_3(matchValue_3)) ? ((ra_1 = value_3(matchValue_3), ra_1)) : ((typeof value_3(matchValue_3) === "string") ? ((singleton_1 = value_3(matchValue_3), [singleton_1])) : undefined)) : undefined)));
+                dynObj.DeepCopyPropertiesTo(roc, undefined, 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 undefined;
+        }
     }
 }
 
-export function LDObject_$reflection() {
-    return class_type("ARCtrl.ROCrate.LDObject", undefined, LDObject, DynamicObj_$reflection());
+export function LDNode_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDNode", undefined, LDNode, DynamicObj_$reflection());
 }
 
-export function LDObject_$ctor_Z2FC25A28(id, schemaType, additionalType) {
-    return new LDObject(id, schemaType, additionalType);
+export function LDNode_$ctor_479BCDCF(id, schemaType, additionalType, context) {
+    return new LDNode(id, schemaType, additionalType, context);
 }