@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/Conversion.js

@@ -0,0 +1,1582 @@
+import { fromString } from "./fable_modules/Thoth.Json.JavaScript.0.3.0/Decode.fs.js";
+import { Decode_datetime } from "./Json/Decode.js";
+import { join, remove, toFail, printf, toText } from "@fable-org/fable-library-js/String.js";
+import { bind, defaultArg, map, unwrap, value as value_4 } from "@fable-org/fable-library-js/Option.js";
+import { toString } from "./fable_modules/Thoth.Json.JavaScript.0.3.0/Encode.fs.js";
+import { dateTime } from "./Json/Encode.js";
+import { parse, tryParse } from "@fable-org/fable-library-js/Int32.js";
+import { toString as toString_1, FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { LDRef, LDNode } from "./ROCrate/LDObject.js";
+import { safeHash, equals, disposeSafe, getEnumerator, stringHash, comparePrimitives, int32ToString } from "@fable-org/fable-library-js/Util.js";
+import { class_type } from "@fable-org/fable-library-js/Reflection.js";
+import { LDComment } from "./ROCrate/Generic/Comment.js";
+import { Comment$ } from "./Core/Comment.js";
+import { OntologyAnnotation } from "./Core/OntologyAnnotation.js";
+import { ResizeArray_groupBy, ResizeArray_tryFind, ResizeArray_filter, ResizeArray_collect, ResizeArray_choose, ResizeArray_append, ResizeArray_distinct, ResizeArray_tryPick, ResizeArray_appendSingleton, ResizeArray_zip, ResizeArray_create, ResizeArray_singleton, ResizeArray_map, Option_fromSeq, Option_fromValueWithDefault } from "./Core/Helper/Collections.js";
+import { LDDefinedTerm } from "./ROCrate/Generic/DefinedTerm.js";
+import { LDPropertyValue } from "./ROCrate/Generic/PropertyValue.js";
+import { DataAux_pathAndSelectorFromName, Data } from "./Core/Data.js";
+import { CompositeCell_Data, CompositeCell_FreeText, CompositeCell_Unitized, CompositeCell_Term } from "./Core/Table/CompositeCell.js";
+import { CompositeHeader_Comment, CompositeHeader_ProtocolType, CompositeHeader_ProtocolVersion, CompositeHeader_ProtocolUri, CompositeHeader_ProtocolDescription, CompositeHeader_ProtocolREF, CompositeHeader_Output, IOType_FreeText, IOType_Data, IOType_Sample, IOType_Material, CompositeHeader_Input, IOType_Source, CompositeHeader_Characteristic, CompositeHeader_Factor, CompositeHeader_Parameter, CompositeHeader_Component } from "./Core/Table/CompositeHeader.js";
+import { DataFile_fromString_Z721C83C5, DataFile__get_AsString } from "./Core/DataFile.js";
+import { LDFile } from "./ROCrate/Generic/File.js";
+import { DataContext_$ctor_Z780A8A2A, DataContext__get_Label, DataContext__get_Description, DataContext__get_GeneratedBy, DataContext__get_ObjectType, DataContext__get_Unit, DataContext__get_Explication } from "./Core/DataContext.js";
+import { LDSample } from "./ROCrate/Generic/Sample.js";
+import { ActivePatterns_$007CRegex$007C_$007C } from "./Core/Helper/Regex.js";
+import { LDLabProtocol } from "./ROCrate/Generic/LabProtocol.js";
+import { getItemFromDict } from "@fable-org/fable-library-js/MapUtil.js";
+import { LDPerson } from "./ROCrate/Generic/Person.js";
+import { isEmpty, zip, fold, singleton, empty as empty_1, append, delay, max, map as map_1, choose as choose_1, tryPick, filter, toList, indexed } from "@fable-org/fable-library-js/Seq.js";
+import { ofSeq, collect, initialize, singleton as singleton_2, sortBy, map as map_2, empty, length, choose } from "@fable-org/fable-library-js/List.js";
+import { LDLabProcess } from "./ROCrate/Generic/LabProcess.js";
+import { List_distinct, List_groupBy } from "@fable-org/fable-library-js/Seq2.js";
+import { createMissingIdentifier } from "./Core/Helper/Identifier.js";
+import { ArcTable } from "./Core/Table/ArcTable.js";
+import { singleton as singleton_1 } from "@fable-org/fable-library-js/Array.js";
+import { rangeDouble } from "@fable-org/fable-library-js/Range.js";
+import { Unchecked_alignByHeaders } from "./Core/Table/ArcTableAux.js";
+import { ArcTables } from "./Core/Table/ArcTables.js";
+import { DataMap_init, DataMap_$ctor_4E3220A7, DataMap__get_DataContexts } from "./Core/DataMap.js";
+import { LDOrganization } from "./ROCrate/Generic/Organization.js";
+import { encoder, decoder as decoder_1 } from "./Json/ROCrate/LDNode.js";
+import { Person } from "./Core/Person.js";
+import { tryGetOrcidNumber } from "./Core/Helper/ORCID.js";
+import { StringBuilder__Clear, StringBuilder__Append_244C7CD6, StringBuilder_$ctor } from "@fable-org/fable-library-js/System.Text.js";
+import { LDScholarlyArticle } from "./ROCrate/Generic/ScholarlyArticle.js";
+import { Publication } from "./Core/Publication.js";
+import { LDDataset } from "./ROCrate/Generic/Dataset.js";
+import { ArcInvestigation, ArcStudy, ArcAssay } from "./Core/ArcTypes.js";
+import { now } from "@fable-org/fable-library-js/Date.js";
+export function DateTime_tryFromString(s) {
+    let matchValue;
+    try {
+        return (matchValue = fromString(Decode_datetime, s), (matchValue.tag === /* Error */ 1) ? (() => {
+            let arg;
+            throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+        })() : matchValue.fields[0]);
+    }
+    catch (matchValue_1) {
+        return undefined;
+    }
+}
+export function DateTime_toString(d) {
+    return toString(0, dateTime(d));
+}
+function ColumnIndex_tryInt(str) {
+    let matchValue;
+    let outArg = 0;
+    matchValue = [tryParse(str, 511, false, 32, new FSharpRef(() => outArg, (v) => {
+            outArg = (v | 0);
+        })), outArg];
+    if (matchValue[0]) {
+        return matchValue[1];
+    }
+    else {
+        return undefined;
+    }
+}
+export const ColumnIndex_orderName = "columnIndex";
+export function ColumnIndex_tryGetIndex(node) {
+    const matchValue = node.TryGetPropertyAsSingleton(ColumnIndex_orderName);
+    let matchResult, ci;
+    if (matchValue != null) {
+        if (typeof value_4(matchValue) === "string") {
+            matchResult = 0;
+            ci = value_4(matchValue);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return ColumnIndex_tryInt(ci);
+        default:
+            return undefined;
+    }
+}
+export function ColumnIndex_setIndex(node, index) {
+    node.SetProperty(ColumnIndex_orderName, int32ToString(index));
+}
+export function ARCtrl_ROCrate_LDNode__LDNode_GetColumnIndex(this$) {
+    return value_4(ColumnIndex_tryGetIndex(this$));
+}
+export function ARCtrl_ROCrate_LDNode__LDNode_TryGetColumnIndex(this$) {
+    return ColumnIndex_tryGetIndex(this$);
+}
+export function ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(this$, index) {
+    ColumnIndex_setIndex(this$, index);
+}
+export class BaseTypes {
+    constructor() {
+    }
+}
+export function BaseTypes_$reflection() {
+    return class_type("ARCtrl.Conversion.BaseTypes", undefined, BaseTypes);
+}
+export function BaseTypes_composeComment_Z13201A7E(comment) {
+    let name;
+    const matchValue = comment.Name;
+    if (matchValue == null) {
+        throw new Error("Comment must have a name");
+    }
+    else {
+        name = value_4(matchValue);
+    }
+    return LDComment.create(name, undefined, unwrap(comment.Value));
+}
+export function BaseTypes_decomposeComment_Z2F770004(comment, context) {
+    return new Comment$(LDComment.getNameAsString(comment, unwrap(context)), unwrap(LDComment.tryGetTextAsString(comment, unwrap(context))));
+}
+export function BaseTypes_ontologyTermFromNameAndID_40457300(name, id) {
+    if (id == null) {
+        return OntologyAnnotation.create(unwrap(name));
+    }
+    else {
+        const t = value_4(id);
+        return OntologyAnnotation.fromTermAnnotation(t, unwrap(name));
+    }
+}
+export function BaseTypes_tryOntologyTermFromNameAndID_40457300(name, id) {
+    if ((name == null) && (id == null)) {
+        return undefined;
+    }
+    else {
+        return BaseTypes_ontologyTermFromNameAndID_40457300(unwrap(name), unwrap(id));
+    }
+}
+export function BaseTypes_composeDefinedTerm_ZDED3A0F(term) {
+    const tan = Option_fromValueWithDefault("", term.TermAccessionAndOntobeeUrlIfShort);
+    return LDDefinedTerm.create(term.NameText, undefined, unwrap(tan));
+}
+export function BaseTypes_decomposeDefinedTerm_Z2F770004(term, context) {
+    return BaseTypes_ontologyTermFromNameAndID_40457300(LDDefinedTerm.getNameAsString(term, unwrap(context)), unwrap(LDDefinedTerm.tryGetTermCodeAsString(term, unwrap(context))));
+}
+export function BaseTypes_composePropertyValueFromOA_ZDED3A0F(term) {
+    const tan = Option_fromValueWithDefault("", term.TermAccessionAndOntobeeUrlIfShort);
+    return LDPropertyValue.create(term.NameText, undefined, undefined, unwrap(tan));
+}
+export function BaseTypes_decomposePropertyValueToOA_Z2F770004(term, context) {
+    return BaseTypes_ontologyTermFromNameAndID_40457300(LDPropertyValue.getNameAsString(term, unwrap(context)), unwrap(LDPropertyValue.tryGetPropertyIDAsString(term, unwrap(context))));
+}
+/**
+ * Convert a CompositeCell to a ISA Value and Unit tuple.
+ */
+export function BaseTypes_valuesOfCell_Z436420FE(value) {
+    let term, term_1;
+    switch (value.tag) {
+        case /* Term */ 0:
+            if ((term = value.fields[0], term.isEmpty())) {
+                const term_2 = value.fields[0];
+                return [undefined, undefined, undefined, undefined];
+            }
+            else if ((term_1 = value.fields[0], term_1.TANInfo != null)) {
+                const term_3 = value.fields[0];
+                return [term_3.Name, term_3.TermAccessionAndOntobeeUrlIfShort, undefined, undefined];
+            }
+            else {
+                const term_4 = value.fields[0];
+                return [term_4.Name, undefined, undefined, undefined];
+            }
+        case /* Unitized */ 2: {
+            const text_1 = value.fields[0];
+            const unit = value.fields[1];
+            const patternInput = unit.isEmpty() ? [undefined, undefined] : [unit.Name, Option_fromValueWithDefault("", unit.TermAccessionAndOntobeeUrlIfShort)];
+            return [Option_fromValueWithDefault("", text_1), undefined, patternInput[0], patternInput[1]];
+        }
+        case /* Data */ 3: {
+            const data = value.fields[0];
+            throw new Error("Data cell should not be parsed to isa value");
+        }
+        default:
+            if (value.fields[0] === "") {
+                return [undefined, undefined, undefined, undefined];
+            }
+            else {
+                const text = value.fields[0];
+                return [text, undefined, undefined, undefined];
+            }
+    }
+}
+export function BaseTypes_termOfHeader_6CAF647B(header) {
+    let matchResult, oa;
+    switch (header.tag) {
+        case /* Component */ 0: {
+            matchResult = 0;
+            oa = header.fields[0];
+            break;
+        }
+        case /* Parameter */ 3: {
+            matchResult = 0;
+            oa = header.fields[0];
+            break;
+        }
+        case /* Factor */ 2: {
+            matchResult = 0;
+            oa = header.fields[0];
+            break;
+        }
+        case /* Characteristic */ 1: {
+            matchResult = 0;
+            oa = header.fields[0];
+            break;
+        }
+        default:
+            matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return [oa.NameText, (oa.TANInfo != null) ? oa.TermAccessionAndOntobeeUrlIfShort : undefined];
+        default:
+            return toFail(printf("header %O should not be parsed to isa value"))(header);
+    }
+}
+/**
+ * Convert a CompositeHeader and Cell tuple to a ISA Component
+ */
+export function BaseTypes_composeComponent(header, value) {
+    const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+    const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+    return LDPropertyValue.createComponent(patternInput_1[0], unwrap(patternInput[0]), undefined, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+/**
+ * Convert a CompositeHeader and Cell tuple to a ISA ProcessParameterValue
+ */
+export function BaseTypes_composeParameterValue(header, value) {
+    const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+    const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+    return LDPropertyValue.createParameterValue(patternInput_1[0], unwrap(patternInput[0]), undefined, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+/**
+ * Convert a CompositeHeader and Cell tuple to a ISA FactorValue
+ */
+export function BaseTypes_composeFactorValue(header, value) {
+    const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+    const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+    return LDPropertyValue.createFactorValue(patternInput_1[0], unwrap(patternInput[0]), undefined, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+/**
+ * Convert a CompositeHeader and Cell tuple to a ISA MaterialAttributeValue
+ */
+export function BaseTypes_composeCharacteristicValue(header, value) {
+    const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+    const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+    return LDPropertyValue.createCharacteristicValue(patternInput_1[0], unwrap(patternInput[0]), undefined, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+export function BaseTypes_composeFreetextMaterialName(headerFT, name) {
+    return `${headerFT}=${name}`;
+}
+export function BaseTypes_composeFile_3A03A101(d) {
+    const dataType = map(DataFile__get_AsString, d.DataType);
+    return LDFile.create(d.NameText, d.NameText, undefined, unwrap(dataType), unwrap(d.Format), unwrap(d.SelectorFormat));
+}
+export function BaseTypes_decomposeFile_Z2F770004(f, context) {
+    const dataType = map(DataFile_fromString_Z721C83C5, LDFile.tryGetDisambiguatingDescriptionAsString(f, unwrap(context)));
+    const format = LDFile.tryGetEncodingFormatAsString(f, unwrap(context));
+    const selectorFormat = LDFile.tryGetUsageInfoAsString(f, unwrap(context));
+    return new Data(undefined, LDFile.getNameAsString(f, unwrap(context)), unwrap(dataType), unwrap(format), unwrap(selectorFormat));
+}
+export function BaseTypes_composeFragmentDescriptor_Z4C0BEF62(dc) {
+    if (dc.Name == null) {
+        throw new Error("RO-Crate parsing of DataContext failed: Cannot create a fragment descriptor without a name.");
+    }
+    const id = LDPropertyValue.genIdFragmentDescriptor(dc.NameText);
+    const patternInput = defaultArg(map((e) => [e.Name, Option_fromValueWithDefault("", e.TermAccessionAndOntobeeUrlIfShort)], DataContext__get_Explication(dc)), [undefined, undefined]);
+    const patternInput_1 = defaultArg(map((u) => [u.Name, Option_fromValueWithDefault("", u.TermAccessionAndOntobeeUrlIfShort)], DataContext__get_Unit(dc)), [undefined, undefined]);
+    const disambiguatingDescriptions = Option_fromSeq(ResizeArray_map(toString_1, dc.Comments));
+    const dataFragment = BaseTypes_composeFile_3A03A101(dc);
+    const pattern = map(BaseTypes_composeDefinedTerm_ZDED3A0F, DataContext__get_ObjectType(dc));
+    dataFragment.SetProperty(LDFile.about, new LDRef(id));
+    dataFragment.SetOptionalProperty(LDFile.pattern, pattern);
+    return LDPropertyValue.createFragmentDescriptor(dc.NameText, unwrap(patternInput[0]), undefined, unwrap(patternInput_1[1]), unwrap(patternInput_1[0]), unwrap(patternInput[1]), unwrap(DataContext__get_GeneratedBy(dc)), unwrap(DataContext__get_Description(dc)), unwrap(DataContext__get_Label(dc)), unwrap(disambiguatingDescriptions), dataFragment);
+}
+export function BaseTypes_decomposeFragmentDescriptor_Z6839B9E8(fd, graph, context) {
+    const file = LDPropertyValue.tryGetSubjectOf(fd, unwrap(graph), unwrap(context));
+    let name;
+    if (file == null) {
+        throw new Error("RO-Crate parsing of DataContext failed: Cannot decompose a fragment descriptor without a name.");
+    }
+    else {
+        const f = value_4(file);
+        name = LDFile.getNameAsString(f, unwrap(context));
+    }
+    const objectType = map((pa) => BaseTypes_decomposeDefinedTerm_Z2F770004(pa, unwrap(context)), bind((f_1) => LDFile.tryGetPatternAsDefinedTerm(f_1, unwrap(graph), unwrap(context)), file));
+    const format = bind((f_2) => LDFile.tryGetEncodingFormatAsString(f_2, unwrap(context)), file);
+    const selectorFormat = bind((f_3) => LDFile.tryGetUsageInfoAsString(f_3, unwrap(context)), file);
+    const explication = BaseTypes_tryOntologyTermFromNameAndID_40457300(unwrap(LDPropertyValue.tryGetValueAsString(fd)), unwrap(LDPropertyValue.tryGetValueReferenceAsString(fd)));
+    const unit = BaseTypes_tryOntologyTermFromNameAndID_40457300(unwrap(LDPropertyValue.tryGetUnitTextAsString(fd)), unwrap(LDPropertyValue.tryGetUnitCodeAsString(fd)));
+    const generatedBy = LDPropertyValue.tryGetMeasurementMethodAsString(fd);
+    const description = LDPropertyValue.tryGetDescriptionAsString(fd);
+    return DataContext_$ctor_Z780A8A2A(undefined, name, undefined, unwrap(format), unwrap(selectorFormat), unwrap(explication), unwrap(unit), unwrap(objectType), unwrap(LDPropertyValue.tryGetAlternateNameAsString(fd)), unwrap(description), unwrap(generatedBy), ResizeArray_map((s) => Comment$.fromString(s), LDPropertyValue.getDisambiguatingDescriptionsAsString(fd)));
+}
+/**
+ * Convert a CompositeHeader and Cell tuple to a ISA ProcessInput
+ */
+export function BaseTypes_composeProcessInput(header, value) {
+    if (header.tag === /* Input */ 11) {
+        switch (header.fields[0].tag) {
+            case /* Sample */ 1:
+                return LDSample.createSample(value.AsFreeText);
+            case /* Material */ 3:
+                return LDSample.createMaterial(value.AsFreeText);
+            case /* Data */ 2:
+                switch (value.tag) {
+                    case /* FreeText */ 1: {
+                        const ft = value.fields[0];
+                        return LDFile.create(ft, ft);
+                    }
+                    case /* Data */ 3:
+                        return BaseTypes_composeFile_3A03A101(value.fields[0]);
+                    default:
+                        return toFail(printf("Could not parse input data %O"))(value);
+                }
+            case /* FreeText */ 4: {
+                const ft_1 = header.fields[0].fields[0];
+                const n = new LDNode(BaseTypes_composeFreetextMaterialName(ft_1, value.AsFreeText), [ft_1]);
+                n.SetProperty(LDSample.name, value.AsFreeText);
+                return n;
+            }
+            default:
+                return LDSample.createSource(value.AsFreeText);
+        }
+    }
+    else {
+        return toFail(printf("Could not parse input header %O"))(header);
+    }
+}
+/**
+ * Convert a CompositeHeader and Cell tuple to a ISA ProcessOutput
+ */
+export function BaseTypes_composeProcessOutput(header, value) {
+    let matchResult, ft_1;
+    if (header.tag === /* Output */ 12) {
+        switch (header.fields[0].tag) {
+            case /* Material */ 3: {
+                matchResult = 1;
+                break;
+            }
+            case /* Data */ 2: {
+                matchResult = 2;
+                break;
+            }
+            case /* FreeText */ 4: {
+                matchResult = 3;
+                ft_1 = header.fields[0].fields[0];
+                break;
+            }
+            default:
+                matchResult = 0;
+        }
+    }
+    else {
+        matchResult = 4;
+    }
+    switch (matchResult) {
+        case 0:
+            return LDSample.createSample(value.AsFreeText);
+        case 1:
+            return LDSample.createMaterial(value.AsFreeText);
+        case 2:
+            switch (value.tag) {
+                case /* FreeText */ 1: {
+                    const ft = value.fields[0];
+                    return LDFile.create(ft, ft);
+                }
+                case /* Data */ 3:
+                    return BaseTypes_composeFile_3A03A101(value.fields[0]);
+                default:
+                    return toFail(printf("Could not parse output data %O"))(value);
+            }
+        case 3: {
+            const n = new LDNode(BaseTypes_composeFreetextMaterialName(ft_1, value.AsFreeText), [ft_1]);
+            n.SetProperty(LDSample.name, value.AsFreeText);
+            return n;
+        }
+        default:
+            return toFail(printf("Could not parse output header %O"))(header);
+    }
+}
+export function BaseTypes_headerOntologyOfPropertyValue_Z2F770004(pv, context) {
+    const n = LDPropertyValue.getNameAsString(pv, unwrap(context));
+    const matchValue = LDPropertyValue.tryGetPropertyIDAsString(pv, unwrap(context));
+    if (matchValue == null) {
+        return new OntologyAnnotation(n);
+    }
+    else {
+        const nRef = value_4(matchValue);
+        return OntologyAnnotation.fromTermAnnotation(nRef, n);
+    }
+}
+/**
+ * Convert an ISA Value and Unit tuple to a CompositeCell
+ */
+export function BaseTypes_cellOfPropertyValue_Z2F770004(pv, context) {
+    const v = LDPropertyValue.tryGetValueAsString(pv, unwrap(context));
+    const vRef = LDPropertyValue.tryGetValueReferenceAsString(pv, unwrap(context));
+    const u = LDPropertyValue.tryGetUnitTextAsString(pv, unwrap(context));
+    const uRef = LDPropertyValue.tryGetUnitCodeAsString(pv, unwrap(context));
+    let matchResult, vr, u_1, uRef_1;
+    if (vRef == null) {
+        if (u == null) {
+            if (uRef == null) {
+                matchResult = 3;
+            }
+            else {
+                matchResult = 2;
+                uRef_1 = value_4(uRef);
+            }
+        }
+        else if (uRef != null) {
+            matchResult = 2;
+            uRef_1 = value_4(uRef);
+        }
+        else {
+            matchResult = 1;
+            u_1 = value_4(u);
+        }
+    }
+    else if (u == null) {
+        if (uRef == null) {
+            matchResult = 0;
+            vr = value_4(vRef);
+        }
+        else {
+            matchResult = 4;
+        }
+    }
+    else {
+        matchResult = 4;
+    }
+    switch (matchResult) {
+        case 0:
+            return CompositeCell_Term(OntologyAnnotation.fromTermAnnotation(vr, unwrap(v)));
+        case 1:
+            return CompositeCell_Unitized(defaultArg(v, ""), new OntologyAnnotation(u_1));
+        case 2:
+            return CompositeCell_Unitized(defaultArg(v, ""), OntologyAnnotation.fromTermAnnotation(uRef_1, unwrap(u)));
+        case 3:
+            return CompositeCell_Term(new OntologyAnnotation(unwrap(v)));
+        default: {
+            const arg = defaultArg(v, "");
+            return toFail(printf("Could not parse value %s with unit %O and unit reference %O"))(arg)(u)(uRef);
+        }
+    }
+}
+/**
+ * Convert an ISA Component to a CompositeHeader and Cell tuple
+ */
+export function BaseTypes_decomposeComponent_Z2F770004(c, context) {
+    return [CompositeHeader_Component(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+/**
+ * Convert an ISA ProcessParameterValue to a CompositeHeader and Cell tuple
+ */
+export function BaseTypes_decomposeParameterValue_Z2F770004(c, context) {
+    return [CompositeHeader_Parameter(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+/**
+ * Convert an ISA FactorValue to a CompositeHeader and Cell tuple
+ */
+export function BaseTypes_decomposeFactorValue_Z2F770004(c, context) {
+    return [CompositeHeader_Factor(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+/**
+ * Convert an ISA MaterialAttributeValue to a CompositeHeader and Cell tuple
+ */
+export function BaseTypes_decomposeCharacteristicValue_Z2F770004(c, context) {
+    return [CompositeHeader_Characteristic(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+/**
+ * Convert an ISA ProcessOutput to a CompositeHeader and Cell tuple
+ */
+export function BaseTypes_decomposeProcessInput_Z2F770004(pn, context) {
+    if (LDSample.validateSource(pn, unwrap(context))) {
+        return [CompositeHeader_Input(IOType_Source()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+    }
+    else if (LDSample.validateMaterial(pn, unwrap(context))) {
+        return [CompositeHeader_Input(IOType_Material()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+    }
+    else if (LDSample.validate(pn, unwrap(context))) {
+        return [CompositeHeader_Input(IOType_Sample()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+    }
+    else if (LDFile.validate(pn, unwrap(context))) {
+        return [CompositeHeader_Input(IOType_Data()), CompositeCell_Data(BaseTypes_decomposeFile_Z2F770004(pn, unwrap(context)))];
+    }
+    else {
+        const n = pn;
+        return [CompositeHeader_Input(IOType_FreeText(n.SchemaType[0])), CompositeCell_FreeText(LDSample.getNameAsString(n, unwrap(context)))];
+    }
+}
+export function BaseTypes_decomposeProcessOutput_Z2F770004(pn, context) {
+    if (LDSample.validateMaterial(pn, unwrap(context))) {
+        return [CompositeHeader_Output(IOType_Material()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+    }
+    else if (LDSample.validate(pn, unwrap(context))) {
+        return [CompositeHeader_Output(IOType_Sample()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+    }
+    else if (LDFile.validate(pn, unwrap(context))) {
+        return [CompositeHeader_Output(IOType_Data()), CompositeCell_Data(BaseTypes_decomposeFile_Z2F770004(pn, unwrap(context)))];
+    }
+    else {
+        const n = pn;
+        return [CompositeHeader_Output(IOType_FreeText(n.SchemaType[0])), CompositeCell_FreeText(LDSample.getNameAsString(n, unwrap(context)))];
+    }
+}
+/**
+ * This function creates a string containing the name and the ontology short-string of the given ontology annotation term
+ *
+ * TechnologyPlatforms are plain strings in ISA-JSON.
+ *
+ * This function allows us, to parse them as an ontology term.
+ */
+export function BaseTypes_composeTechnologyPlatform_ZDED3A0F(tp) {
+    const matchValue = tp.TANInfo;
+    if (matchValue == null) {
+        return `${tp.NameText}`;
+    }
+    else {
+        return `${tp.NameText} (${tp.TermAccessionShort})`;
+    }
+}
+/**
+ * This function parses the given string containing the name and the ontology short-string of the given ontology annotation term
+ *
+ * TechnologyPlatforms are plain strings in ISA-JSON.
+ *
+ * This function allows us, to parse them as an ontology term.
+ */
+export function BaseTypes_decomposeTechnologyPlatform_Z721C83C5(name) {
+    const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("^(?<value>.+) \\((?<ontology>[^(]*:[^)]*)\\)$", name);
+    if (activePatternResult != null) {
+        const r = value_4(activePatternResult);
+        let oa;
+        const tan = (r.groups && r.groups.ontology) || "";
+        oa = OntologyAnnotation.fromTermAnnotation(tan);
+        const v = (r.groups && r.groups.value) || "";
+        return OntologyAnnotation.create(v, unwrap(oa.TermSourceREF), unwrap(oa.TermAccessionNumber));
+    }
+    else {
+        return OntologyAnnotation.create(name);
+    }
+}
+export class ProcessConversion {
+    constructor() {
+    }
+}
+export function ProcessConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.ProcessConversion", undefined, ProcessConversion);
+}
+export function ProcessConversion_tryGetProtocolType_Z6839B9E8(pv, graph, context) {
+    const matchValue = LDLabProtocol.tryGetIntendedUseAsDefinedTerm(pv, unwrap(graph), unwrap(context));
+    if (matchValue == null) {
+        const matchValue_1 = LDLabProtocol.tryGetIntendedUseAsString(pv, unwrap(context));
+        if (matchValue_1 == null) {
+            return undefined;
+        }
+        else {
+            const s = value_4(matchValue_1);
+            return OntologyAnnotation.create(s);
+        }
+    }
+    else {
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(value_4(matchValue), unwrap(context));
+    }
+}
+export function ProcessConversion_composeProcessName(processNameRoot, i) {
+    return `${processNameRoot}_${i}`;
+}
+export function ProcessConversion_decomposeProcessName_Z721C83C5(name) {
+    const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("(?<name>.+)_(?<num>\\d+)", name);
+    if (activePatternResult != null) {
+        const r = value_4(activePatternResult);
+        return [(r.groups && r.groups.name) || "", parse((r.groups && r.groups.num) || "", 511, false, 32)];
+    }
+    else {
+        return [name, undefined];
+    }
+}
+/**
+ * If the given headers depict a component, returns a function for parsing the values of the matrix to the values of this component
+ */
+export function ProcessConversion_tryComponentGetter(generalI, valueI, valueHeader) {
+    if (valueHeader.tag === /* Component */ 0) {
+        const oa = valueHeader.fields[0];
+        return (matrix) => ((i) => {
+            const c = BaseTypes_composeComponent(valueHeader, getItemFromDict(matrix, [generalI, i]));
+            ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(c, valueI);
+            return c;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a parameter, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryParameterGetter(generalI, valueI, valueHeader) {
+    if (valueHeader.tag === /* Parameter */ 3) {
+        const oa = valueHeader.fields[0];
+        return (matrix) => ((i) => {
+            const p = BaseTypes_composeParameterValue(valueHeader, getItemFromDict(matrix, [generalI, i]));
+            ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(p, valueI);
+            return p;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a factor, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryFactorGetter(generalI, valueI, valueHeader) {
+    if (valueHeader.tag === /* Factor */ 2) {
+        const oa = valueHeader.fields[0];
+        return (matrix) => ((i) => {
+            const f = BaseTypes_composeFactorValue(valueHeader, getItemFromDict(matrix, [generalI, i]));
+            ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(f, valueI);
+            return f;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a protocolType, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryCharacteristicGetter(generalI, valueI, valueHeader) {
+    if (valueHeader.tag === /* Characteristic */ 1) {
+        const oa = valueHeader.fields[0];
+        return (matrix) => ((i) => {
+            const c = BaseTypes_composeCharacteristicValue(valueHeader, getItemFromDict(matrix, [generalI, i]));
+            ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(c, valueI);
+            return c;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a protocolType, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetProtocolTypeGetter(generalI, header) {
+    if (header.tag === /* ProtocolType */ 4) {
+        return (matrix) => ((i) => BaseTypes_composeDefinedTerm_ZDED3A0F(getItemFromDict(matrix, [generalI, i]).AsTerm));
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a protocolREF, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetProtocolREFGetter(generalI, header) {
+    if (header.tag === /* ProtocolREF */ 8) {
+        return (matrix) => ((i) => getItemFromDict(matrix, [generalI, i]).AsFreeText);
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a protocolDescription, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetProtocolDescriptionGetter(generalI, header) {
+    if (header.tag === /* ProtocolDescription */ 5) {
+        return (matrix) => ((i) => getItemFromDict(matrix, [generalI, i]).AsFreeText);
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a protocolURI, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetProtocolURIGetter(generalI, header) {
+    if (header.tag === /* ProtocolUri */ 6) {
+        return (matrix) => ((i) => getItemFromDict(matrix, [generalI, i]).AsFreeText);
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a protocolVersion, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetProtocolVersionGetter(generalI, header) {
+    if (header.tag === /* ProtocolVersion */ 7) {
+        return (matrix) => ((i) => getItemFromDict(matrix, [generalI, i]).AsFreeText);
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict an input, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetInputGetter(generalI, header) {
+    if (header.tag === /* Input */ 11) {
+        const io = header.fields[0];
+        return (matrix) => ((i) => BaseTypes_composeProcessInput(header, getItemFromDict(matrix, [generalI, i])));
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict an output, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetOutputGetter(generalI, header) {
+    if (header.tag === /* Output */ 12) {
+        const io = header.fields[0];
+        return (matrix) => ((i) => BaseTypes_composeProcessOutput(header, getItemFromDict(matrix, [generalI, i])));
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If the given headers depict a comment, returns a function for parsing the values of the matrix to the values of this type
+ */
+export function ProcessConversion_tryGetCommentGetter(generalI, header) {
+    if (header.tag === /* Comment */ 14) {
+        const c = header.fields[0];
+        return (matrix) => ((i) => toString_1(new Comment$(c, getItemFromDict(matrix, [generalI, i]).AsFreeText)));
+    }
+    else {
+        return undefined;
+    }
+}
+export function ProcessConversion_tryGetPerformerGetter(generalI, header) {
+    if (header.tag === /* Performer */ 9) {
+        return (matrix) => ((i) => {
+            const performer = getItemFromDict(matrix, [generalI, i]).AsFreeText;
+            return LDPerson.create(performer);
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * Given the header sequence of an ArcTable, returns a function for parsing each row of the table to a process
+ */
+export function ProcessConversion_getProcessGetter(processNameRoot, headers) {
+    const headers_1 = indexed(headers);
+    const valueHeaders = toList(indexed(filter((arg) => arg[1].IsCvParamColumn, headers_1)));
+    const charGetters = choose((tupledArg) => {
+        const _arg = tupledArg[1];
+        return ProcessConversion_tryCharacteristicGetter(_arg[0], tupledArg[0], _arg[1]);
+    }, valueHeaders);
+    const factorValueGetters = choose((tupledArg_1) => {
+        const _arg_1 = tupledArg_1[1];
+        return ProcessConversion_tryFactorGetter(_arg_1[0], tupledArg_1[0], _arg_1[1]);
+    }, valueHeaders);
+    const parameterValueGetters = choose((tupledArg_2) => {
+        const _arg_2 = tupledArg_2[1];
+        return ProcessConversion_tryParameterGetter(_arg_2[0], tupledArg_2[0], _arg_2[1]);
+    }, valueHeaders);
+    const componentGetters = choose((tupledArg_3) => {
+        const _arg_3 = tupledArg_3[1];
+        return ProcessConversion_tryComponentGetter(_arg_3[0], tupledArg_3[0], _arg_3[1]);
+    }, valueHeaders);
+    const protocolTypeGetter = tryPick((tupledArg_4) => ProcessConversion_tryGetProtocolTypeGetter(tupledArg_4[0], tupledArg_4[1]), headers_1);
+    const protocolREFGetter = tryPick((tupledArg_5) => ProcessConversion_tryGetProtocolREFGetter(tupledArg_5[0], tupledArg_5[1]), headers_1);
+    const protocolDescriptionGetter = tryPick((tupledArg_6) => ProcessConversion_tryGetProtocolDescriptionGetter(tupledArg_6[0], tupledArg_6[1]), headers_1);
+    const protocolURIGetter = tryPick((tupledArg_7) => ProcessConversion_tryGetProtocolURIGetter(tupledArg_7[0], tupledArg_7[1]), headers_1);
+    const protocolVersionGetter = tryPick((tupledArg_8) => ProcessConversion_tryGetProtocolVersionGetter(tupledArg_8[0], tupledArg_8[1]), headers_1);
+    const performerGetter = tryPick((tupledArg_9) => ProcessConversion_tryGetPerformerGetter(tupledArg_9[0], tupledArg_9[1]), headers_1);
+    const commentGetters = toList(choose_1((tupledArg_10) => ProcessConversion_tryGetCommentGetter(tupledArg_10[0], tupledArg_10[1]), headers_1));
+    let inputGetter_1;
+    const matchValue = tryPick((tupledArg_11) => ProcessConversion_tryGetInputGetter(tupledArg_11[0], tupledArg_11[1]), headers_1);
+    if (matchValue == null) {
+        inputGetter_1 = ((length(charGetters) !== 0) ? ((matrix_1) => ((i_1) => {
+            let chars_1;
+            const collection_1 = map_1((f_1) => f_1(matrix_1)(i_1), charGetters);
+            chars_1 = Array.from(collection_1);
+            return ResizeArray_singleton(LDSample.createSample(`${processNameRoot}_Input_${i_1}`, undefined, chars_1));
+        })) : ((matrix_2) => ((i_2) => [])));
+    }
+    else {
+        const inputGetter = value_4(matchValue);
+        inputGetter_1 = ((matrix) => ((i) => {
+            let chars;
+            const collection = map_1((f) => f(matrix)(i), charGetters);
+            chars = Array.from(collection);
+            const input = inputGetter(matrix)(i);
+            if (chars.length > 0) {
+                LDSample.setAdditionalProperties(input, chars);
+            }
+            return ResizeArray_singleton(input);
+        }));
+    }
+    let outputGetter_1;
+    const matchValue_1 = tryPick((tupledArg_12) => ProcessConversion_tryGetOutputGetter(tupledArg_12[0], tupledArg_12[1]), headers_1);
+    if (matchValue_1 == null) {
+        outputGetter_1 = ((length(factorValueGetters) !== 0) ? ((matrix_4) => ((i_4) => {
+            let factors_1;
+            const collection_3 = map_1((f_3) => f_3(matrix_4)(i_4), factorValueGetters);
+            factors_1 = Array.from(collection_3);
+            return ResizeArray_singleton(LDSample.createSample(`${processNameRoot}_Output_${i_4}`, undefined, factors_1));
+        })) : ((matrix_5) => ((i_5) => [])));
+    }
+    else {
+        const outputGetter = value_4(matchValue_1);
+        outputGetter_1 = ((matrix_3) => ((i_3) => {
+            let factors;
+            const collection_2 = map_1((f_2) => f_2(matrix_3)(i_3), factorValueGetters);
+            factors = Array.from(collection_2);
+            const output = outputGetter(matrix_3)(i_3);
+            if (factors.length > 0) {
+                LDSample.setAdditionalProperties(output, factors);
+            }
+            return ResizeArray_singleton(output);
+        }));
+    }
+    return (matrix_6) => ((i_6) => {
+        const pn = ((1 + max(map_1((tuple_1) => tuple_1[1], matrix_6.keys()), {
+            Compare: comparePrimitives,
+        })) === 1) ? processNameRoot : ProcessConversion_composeProcessName(processNameRoot, i_6);
+        const paramvalues = map((collection_4) => Array.from(collection_4), Option_fromValueWithDefault(empty(), map_2((f_4) => f_4(matrix_6)(i_6), parameterValueGetters)));
+        const comments = map((collection_5) => Array.from(collection_5), Option_fromValueWithDefault(empty(), map_2((f_5) => f_5(matrix_6)(i_6), commentGetters)));
+        const components = map((collection_6) => Array.from(collection_6), Option_fromValueWithDefault(empty(), map_2((f_6) => f_6(matrix_6)(i_6), componentGetters)));
+        let protocol;
+        const name = map((f_7) => f_7(matrix_6)(i_6), protocolREFGetter);
+        const protocolId = LDLabProtocol.genId(unwrap(name), processNameRoot);
+        protocol = LDLabProtocol.create(protocolId, unwrap(name), unwrap(map((f_8) => f_8(matrix_6)(i_6), protocolDescriptionGetter)), unwrap(map((f_9) => f_9(matrix_6)(i_6), protocolTypeGetter)), undefined, undefined, unwrap(components), undefined, unwrap(map((f_10) => f_10(matrix_6)(i_6), protocolURIGetter)), unwrap(map((f_11) => f_11(matrix_6)(i_6), protocolVersionGetter)));
+        const matchValue_2 = inputGetter_1(matrix_6)(i_6);
+        const matchValue_3 = outputGetter_1(matrix_6)(i_6);
+        const agent = map((f_12) => f_12(matrix_6)(i_6), performerGetter);
+        return LDLabProcess.create(pn, matchValue_2, matchValue_3, undefined, unwrap(agent), unwrap(protocol), unwrap(paramvalues), undefined, unwrap(comments));
+    });
+}
+/**
+ * Groups processes by their name, or by the name of the protocol they execute
+ *
+ * Process names are taken from the Worksheet name and numbered: SheetName_1, SheetName_2, etc.
+ *
+ * This function decomposes this name into a root name and a number, and groups processes by root name.
+ */
+export function ProcessConversion_groupProcesses_Z27F0B586(processes, graph, context) {
+    return List_groupBy((p) => {
+        let protocol, name_1, name_2, protocol_1;
+        const matchValue = LDLabProcess.tryGetNameAsString(p, unwrap(context));
+        const matchValue_1 = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+        let matchResult, name_3, protocol_2, name_4, name_5, protocol_3;
+        if (matchValue != null) {
+            if (ProcessConversion_decomposeProcessName_Z721C83C5(value_4(matchValue))[1] != null) {
+                matchResult = 0;
+                name_3 = value_4(matchValue);
+            }
+            else if (matchValue_1 != null) {
+                if ((protocol = value_4(matchValue_1), LDLabProtocol.tryGetNameAsString(protocol, unwrap(context)) != null)) {
+                    matchResult = 1;
+                    protocol_2 = value_4(matchValue_1);
+                }
+                else if ((name_1 = value_4(matchValue), name_1.indexOf("_") >= 0)) {
+                    matchResult = 2;
+                    name_4 = value_4(matchValue);
+                }
+                else {
+                    matchResult = 3;
+                    name_5 = value_4(matchValue);
+                }
+            }
+            else if ((name_2 = value_4(matchValue), name_2.indexOf("_") >= 0)) {
+                matchResult = 2;
+                name_4 = value_4(matchValue);
+            }
+            else {
+                matchResult = 3;
+                name_5 = value_4(matchValue);
+            }
+        }
+        else if (matchValue_1 != null) {
+            if ((protocol_1 = value_4(matchValue_1), LDLabProtocol.tryGetNameAsString(protocol_1, unwrap(context)) != null)) {
+                matchResult = 1;
+                protocol_2 = value_4(matchValue_1);
+            }
+            else {
+                matchResult = 4;
+                protocol_3 = value_4(matchValue_1);
+            }
+        }
+        else {
+            matchResult = 5;
+        }
+        switch (matchResult) {
+            case 0:
+                return ProcessConversion_decomposeProcessName_Z721C83C5(name_3)[0];
+            case 1:
+                return defaultArg(LDLabProtocol.tryGetNameAsString(protocol_2, unwrap(context)), "");
+            case 2:
+                return remove(name_4, name_4.lastIndexOf("_"));
+            case 3:
+                return name_5;
+            case 4:
+                return protocol_3.Id;
+            default:
+                return createMissingIdentifier();
+        }
+    }, processes, {
+        Equals: (x, y) => (x === y),
+        GetHashCode: stringHash,
+    });
+}
+/**
+ * Merges processes with the same name, protocol and param values
+ */
+export function ProcessConversion_processToRows_Z6839B9E8(p, graph, context) {
+    const pvs = ResizeArray_map((ppv) => [BaseTypes_decomposeParameterValue_Z2F770004(ppv, unwrap(context)), ColumnIndex_tryGetIndex(ppv)], LDLabProcess.getParameterValues(p, unwrap(graph), unwrap(context)));
+    let components;
+    const matchValue = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+    if (matchValue == null) {
+        components = [];
+    }
+    else {
+        const prot = value_4(matchValue);
+        components = ResizeArray_map((ppv_1) => [BaseTypes_decomposeComponent_Z2F770004(ppv_1, unwrap(context)), ColumnIndex_tryGetIndex(ppv_1)], LDLabProtocol.getComponents(prot, unwrap(graph), unwrap(context)));
+    }
+    let protVals;
+    const matchValue_1 = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+    if (matchValue_1 == null) {
+        protVals = empty();
+    }
+    else {
+        const prot_1 = value_4(matchValue_1);
+        protVals = toList(delay(() => {
+            let matchValue_2;
+            return append((matchValue_2 = LDLabProtocol.tryGetNameAsString(prot_1, unwrap(context)), (matchValue_2 == null) ? (empty_1()) : singleton([CompositeHeader_ProtocolREF(), CompositeCell_FreeText(value_4(matchValue_2))])), delay(() => {
+                let matchValue_3;
+                return append((matchValue_3 = LDLabProtocol.tryGetDescriptionAsString(prot_1, unwrap(context)), (matchValue_3 == null) ? (empty_1()) : singleton([CompositeHeader_ProtocolDescription(), CompositeCell_FreeText(value_4(matchValue_3))])), delay(() => {
+                    let matchValue_4;
+                    return append((matchValue_4 = LDLabProtocol.tryGetUrl(prot_1, unwrap(context)), (matchValue_4 == null) ? (empty_1()) : singleton([CompositeHeader_ProtocolUri(), CompositeCell_FreeText(value_4(matchValue_4))])), delay(() => {
+                        let matchValue_5;
+                        return append((matchValue_5 = LDLabProtocol.tryGetVersionAsString(prot_1, unwrap(context)), (matchValue_5 == null) ? (empty_1()) : singleton([CompositeHeader_ProtocolVersion(), CompositeCell_FreeText(value_4(matchValue_5))])), delay(() => {
+                            const matchValue_6 = ProcessConversion_tryGetProtocolType_Z6839B9E8(prot_1, unwrap(graph), unwrap(context));
+                            if (matchValue_6 == null) {
+                                return empty_1();
+                            }
+                            else {
+                                return singleton([CompositeHeader_ProtocolType(), CompositeCell_Term(value_4(matchValue_6))]);
+                            }
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }
+    const comments = ResizeArray_map((c) => {
+        const c_1 = Comment$.fromString(c);
+        return [CompositeHeader_Comment(defaultArg(c_1.Name, "")), CompositeCell_FreeText(defaultArg(c_1.Value, ""))];
+    }, LDLabProcess.getDisambiguatingDescriptionsAsString(p, unwrap(context)));
+    const inputs = LDLabProcess.getObjects(p, unwrap(graph), unwrap(context));
+    const outputs = LDLabProcess.getResults(p, unwrap(graph), unwrap(context));
+    const patternInput = ((inputs.length === 0) && (outputs.length !== 0)) ? [ResizeArray_create(outputs.length, undefined), ResizeArray_map((Value) => Value, outputs)] : (((inputs.length !== 0) && (outputs.length === 0)) ? [ResizeArray_map((Value_1) => Value_1, inputs), ResizeArray_create(inputs.length, undefined)] : [ResizeArray_map((Value_2) => Value_2, inputs), ResizeArray_map((Value_3) => Value_3, outputs)]);
+    const outputs_1 = patternInput[1];
+    const inputs_1 = patternInput[0];
+    if ((inputs_1.length === 0) && (outputs_1.length === 0)) {
+        const vals = map_2((tuple_1) => tuple_1[0], sortBy((arg) => defaultArg(arg[1], 10000), toList(delay(() => append(components, delay(() => pvs)))), {
+            Compare: comparePrimitives,
+        }));
+        return ResizeArray_singleton(toList(delay(() => append(protVals, delay(() => append(vals, delay(() => comments)))))));
+    }
+    else {
+        return ResizeArray_map((tupledArg) => {
+            const i = tupledArg[0];
+            const o = tupledArg[1];
+            let chars;
+            if (i == null) {
+                chars = [];
+            }
+            else {
+                const i_1 = value_4(i);
+                chars = ResizeArray_map((cv) => [BaseTypes_decomposeCharacteristicValue_Z2F770004(cv, unwrap(context)), ColumnIndex_tryGetIndex(cv)], LDSample.getCharacteristics(i_1, unwrap(graph), unwrap(context)));
+            }
+            let factors;
+            if (o == null) {
+                factors = [];
+            }
+            else {
+                const o_1 = value_4(o);
+                factors = ResizeArray_map((fv) => [BaseTypes_decomposeFactorValue_Z2F770004(fv, unwrap(context)), ColumnIndex_tryGetIndex(fv)], LDSample.getFactors(o_1, unwrap(graph), unwrap(context)));
+            }
+            const vals_1 = map_2((tuple_3) => tuple_3[0], sortBy((arg_1) => defaultArg(arg_1[1], 10000), toList(delay(() => append(chars, delay(() => append(components, delay(() => append(pvs, delay(() => factors)))))))), {
+                Compare: comparePrimitives,
+            }));
+            return toList(delay(() => append((i != null) ? singleton(BaseTypes_decomposeProcessInput_Z2F770004(value_4(i), unwrap(context))) : empty_1(), delay(() => append(protVals, delay(() => append(vals_1, delay(() => append(comments, delay(() => ((o != null) ? singleton(BaseTypes_decomposeProcessOutput_Z2F770004(value_4(o), unwrap(context))) : empty_1())))))))))));
+        }, ResizeArray_zip(inputs_1, outputs_1));
+    }
+}
+export function CompositeRow_toProtocol(tableName, row) {
+    return fold((p, hc) => {
+        let matchResult, oa, v, v_1, v_2, v_3;
+        switch (hc[0].tag) {
+            case /* ProtocolType */ 4: {
+                if (hc[1].tag === /* Term */ 0) {
+                    matchResult = 0;
+                    oa = hc[1].fields[0];
+                }
+                else {
+                    matchResult = 6;
+                }
+                break;
+            }
+            case /* ProtocolVersion */ 7: {
+                if (hc[1].tag === /* FreeText */ 1) {
+                    matchResult = 1;
+                    v = hc[1].fields[0];
+                }
+                else {
+                    matchResult = 6;
+                }
+                break;
+            }
+            case /* ProtocolUri */ 6: {
+                if (hc[1].tag === /* FreeText */ 1) {
+                    matchResult = 2;
+                    v_1 = hc[1].fields[0];
+                }
+                else {
+                    matchResult = 6;
+                }
+                break;
+            }
+            case /* ProtocolDescription */ 5: {
+                if (hc[1].tag === /* FreeText */ 1) {
+                    matchResult = 3;
+                    v_2 = hc[1].fields[0];
+                }
+                else {
+                    matchResult = 6;
+                }
+                break;
+            }
+            case /* ProtocolREF */ 8: {
+                if (hc[1].tag === /* FreeText */ 1) {
+                    matchResult = 4;
+                    v_3 = hc[1].fields[0];
+                }
+                else {
+                    matchResult = 6;
+                }
+                break;
+            }
+            case /* Component */ 0: {
+                switch (hc[1].tag) {
+                    case /* Term */ 0:
+                    case /* Unitized */ 2: {
+                        matchResult = 5;
+                        break;
+                    }
+                    default:
+                        matchResult = 6;
+                }
+                break;
+            }
+            default:
+                matchResult = 6;
+        }
+        switch (matchResult) {
+            case 0: {
+                LDLabProtocol.setIntendedUseAsDefinedTerm(p, BaseTypes_composeDefinedTerm_ZDED3A0F(oa));
+                break;
+            }
+            case 1: {
+                LDLabProtocol.setVersionAsString(p, v);
+                break;
+            }
+            case 2: {
+                LDLabProtocol.setUrl(p, v_1);
+                break;
+            }
+            case 3: {
+                LDLabProtocol.setDescriptionAsString(p, v_2);
+                break;
+            }
+            case 4: {
+                LDLabProtocol.setNameAsString(p, v_3);
+                break;
+            }
+            case 5: {
+                const newC = ResizeArray_appendSingleton(BaseTypes_composeComponent(hc[0], hc[1]), LDLabProtocol.getLabEquipments(p));
+                LDLabProtocol.setLabEquipments(p, newC);
+                break;
+            }
+        }
+        return p;
+    }, LDLabProtocol.create(tableName, tableName), row);
+}
+/**
+ * Create a new table from an ISA protocol.
+ *
+ * The table will have at most one row, with the protocol information and the component values
+ */
+export function ARCtrl_ArcTable__ArcTable_fromProtocol_Static_Z6839B9E8(p, graph, context) {
+    const name = LDLabProtocol.getNameAsString(p, unwrap(context));
+    const t = ArcTable.init(name);
+    let enumerator = getEnumerator(LDLabProtocol.getComponents(p, unwrap(graph), unwrap(context)));
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const patternInput = BaseTypes_decomposeComponent_Z2F770004(c, unwrap(context));
+            t.AddColumn(patternInput[0], singleton_1(patternInput[1]), unwrap(ARCtrl_ROCrate_LDNode__LDNode_TryGetColumnIndex(c)));
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    map((d) => {
+        t.AddProtocolDescriptionColumn([d]);
+    }, LDLabProtocol.tryGetDescriptionAsString(p, unwrap(context)));
+    map((d_1) => {
+        t.AddProtocolVersionColumn([d_1]);
+    }, LDLabProtocol.tryGetVersionAsString(p, unwrap(context)));
+    map((d_2) => {
+        t.AddProtocolTypeColumn([d_2]);
+    }, ProcessConversion_tryGetProtocolType_Z6839B9E8(p, undefined, unwrap(context)));
+    map((d_3) => {
+        t.AddProtocolUriColumn([d_3]);
+    }, LDLabProtocol.tryGetUrl(p, unwrap(context)));
+    t.AddProtocolNameColumn([name]);
+    return t;
+}
+/**
+ * Returns the list of protocols executed in this ArcTable
+ */
+export function ARCtrl_ArcTable__ArcTable_GetProtocols(this$) {
+    let source;
+    if (this$.RowCount === 0) {
+        return singleton_2((source = this$.Headers, fold((p, h) => {
+            if (h.tag === /* Component */ 0) {
+                const oa = h.fields[0];
+                const matchValue = oa.NameText;
+                const matchValue_1 = oa.TermAccessionOntobeeUrl;
+                const newC = ResizeArray_appendSingleton(LDPropertyValue.createComponent(matchValue, "Empty Component Value", undefined, matchValue_1), LDLabProtocol.getLabEquipments(p));
+                LDLabProtocol.setLabEquipments(p, newC);
+            }
+            return p;
+        }, LDLabProtocol.create(createMissingIdentifier(), this$.Name), source)));
+    }
+    else {
+        return List_distinct(initialize(this$.RowCount, (i) => {
+            let row;
+            const source_2 = this$.GetRow(i, true);
+            row = zip(this$.Headers, source_2);
+            return CompositeRow_toProtocol(this$.Name, row);
+        }), {
+            Equals: equals,
+            GetHashCode: safeHash,
+        });
+    }
+}
+/**
+ * Returns the list of processes specidified in this ArcTable
+ */
+export function ARCtrl_ArcTable__ArcTable_GetProcesses(this$) {
+    if (this$.RowCount === 0) {
+        return singleton_2(LDLabProcess.create(this$.Name));
+    }
+    else {
+        const getter = ProcessConversion_getProcessGetter(this$.Name, this$.Headers);
+        return toList(delay(() => map_1((i) => getter(this$.Values)(i), rangeDouble(0, 1, this$.RowCount - 1))));
+    }
+}
+/**
+ * Create a new table from a list of processes
+ *
+ * The name will be used as the sheet name
+ *
+ * The processes SHOULD have the same headers, or even execute the same protocol
+ */
+export function ARCtrl_ArcTable__ArcTable_fromProcesses_Static_Z3575FB5F(name, ps, graph, context) {
+    const tupledArg = Unchecked_alignByHeaders(true, collect((p) => ofSeq(ProcessConversion_processToRows_Z6839B9E8(p, unwrap(graph), unwrap(context))), ps));
+    return ArcTable.create(name, tupledArg[0], tupledArg[1]);
+}
+/**
+ * Return a list of all the processes in all the tables.
+ */
+export function ARCtrl_ArcTables__ArcTables_GetProcesses(this$) {
+    return collect(ARCtrl_ArcTable__ArcTable_GetProcesses, toList(this$.Tables));
+}
+/**
+ * Create a collection of tables from a list of processes.
+ *
+ * For this, the processes are grouped by nameroot ("nameroot_1", "nameroot_2" ...) or exectued protocol if no name exists
+ *
+ * Then each group is converted to a table with this nameroot as sheetname
+ */
+export function ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ps, graph, context) {
+    let collection;
+    return new ArcTables((collection = map_2((tupledArg) => {
+        const tupledArg_1 = Unchecked_alignByHeaders(true, collect((p) => ofSeq(ProcessConversion_processToRows_Z6839B9E8(p, unwrap(graph), unwrap(context))), tupledArg[1]));
+        return ArcTable.create(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
+    }, ProcessConversion_groupProcesses_Z27F0B586(ps, unwrap(graph), unwrap(context))), Array.from(collection)));
+}
+export class DatamapConversion {
+    constructor() {
+    }
+}
+export function DatamapConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.DatamapConversion", undefined, DatamapConversion);
+}
+export function DatamapConversion_composeFragmentDescriptors_Z8923FA3(datamap) {
+    return ResizeArray_map(BaseTypes_composeFragmentDescriptor_Z4C0BEF62, DataMap__get_DataContexts(datamap));
+}
+export function DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(fragmentDescriptors, graph, context) {
+    return DataMap_$ctor_4E3220A7(ResizeArray_map((fd) => BaseTypes_decomposeFragmentDescriptor_Z6839B9E8(fd, unwrap(graph), unwrap(context)), fragmentDescriptors));
+}
+export class PersonConversion {
+    constructor() {
+    }
+}
+export function PersonConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.PersonConversion", undefined, PersonConversion);
+}
+export function PersonConversion_get_orcidKey() {
+    return "ORCID";
+}
+export function PersonConversion_composeAffiliation_Z721C83C5(affiliation) {
+    let arg;
+    try {
+        const matchValue = fromString(decoder_1, affiliation);
+        if (matchValue.tag === /* Error */ 1) {
+            throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+        }
+        else {
+            return matchValue.fields[0];
+        }
+    }
+    catch (matchValue_1) {
+        return LDOrganization.create(affiliation);
+    }
+}
+export function PersonConversion_decomposeAffiliation_Z2F770004(affiliation, context) {
+    if (isEmpty(filter((n) => (n !== LDOrganization.name), affiliation.GetPropertyNames(unwrap(context))))) {
+        return LDOrganization.getNameAsString(affiliation, unwrap(context));
+    }
+    else {
+        return toString(0, encoder(affiliation));
+    }
+}
+export function PersonConversion_composeAddress_Z721C83C5(address) {
+    let matchValue;
+    try {
+        return (matchValue = fromString(decoder_1, address), (matchValue.tag === /* Error */ 1) ? (() => {
+            let arg;
+            throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+        })() : matchValue.fields[0]);
+    }
+    catch (matchValue_1) {
+        return address;
+    }
+}
+export function PersonConversion_decomposeAddress_4E60E31B(address) {
+    if (typeof address === "string") {
+        return address;
+    }
+    else if (address instanceof LDNode) {
+        return toString(0, encoder(address));
+    }
+    else {
+        throw new Error("Address must be a string or a Json.LDNode");
+    }
+}
+export function PersonConversion_composePerson_Z64D846DC(person) {
+    let givenName;
+    const matchValue = person.FirstName;
+    if (matchValue == null) {
+        throw new Error("Person must have a given name");
+    }
+    else {
+        givenName = value_4(matchValue);
+    }
+    const jobTitles = Option_fromSeq(ResizeArray_map(BaseTypes_composeDefinedTerm_ZDED3A0F, person.Roles));
+    const disambiguatingDescriptions = Option_fromSeq(ResizeArray_map(toString_1, person.Comments));
+    const address_1 = map(PersonConversion_composeAddress_Z721C83C5, person.Address);
+    const affiliation_1 = map(PersonConversion_composeAffiliation_Z721C83C5, person.Affiliation);
+    return LDPerson.create(givenName, unwrap(person.ORCID), undefined, unwrap(affiliation_1), unwrap(person.EMail), unwrap(person.LastName), undefined, unwrap(jobTitles), unwrap(person.MidInitials), address_1, unwrap(disambiguatingDescriptions), unwrap(person.Fax), unwrap(person.Phone));
+}
+export function PersonConversion_decomposePerson_Z6839B9E8(person, graph, context) {
+    const orcid = tryGetOrcidNumber(person.Id);
+    let address;
+    const matchValue = LDPerson.tryGetAddressAsString(person, unwrap(context));
+    if (matchValue == null) {
+        const matchValue_1 = LDPerson.tryGetAddressAsPostalAddress(person, unwrap(graph), unwrap(context));
+        address = ((matchValue_1 == null) ? undefined : PersonConversion_decomposeAddress_4E60E31B(value_4(matchValue_1)));
+    }
+    else {
+        address = value_4(matchValue);
+    }
+    const roles = ResizeArray_map((r) => BaseTypes_decomposeDefinedTerm_Z2F770004(r, unwrap(context)), LDPerson.getJobTitlesAsDefinedTerm(person, unwrap(graph), unwrap(context)));
+    const comments = ResizeArray_map((s_1) => Comment$.fromString(s_1), LDPerson.getDisambiguatingDescriptionsAsString(person, unwrap(context)));
+    const affiliation = map((a_3) => PersonConversion_decomposeAffiliation_Z2F770004(a_3, unwrap(context)), LDPerson.tryGetAffiliation(person, unwrap(graph), unwrap(context)));
+    return Person.create(unwrap(orcid), unwrap(LDPerson.tryGetFamilyNameAsString(person, unwrap(context))), LDPerson.getGivenNameAsString(person, unwrap(context)), unwrap(LDPerson.tryGetAdditionalNameAsString(person, unwrap(context))), unwrap(LDPerson.tryGetEmailAsString(person, unwrap(context))), unwrap(LDPerson.tryGetTelephoneAsString(person, unwrap(context))), unwrap(LDPerson.tryGetFaxNumberAsString(person, unwrap(context))), unwrap(address), unwrap(affiliation), roles, comments);
+}
+export class ScholarlyArticleConversion {
+    constructor() {
+    }
+}
+export function ScholarlyArticleConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.ScholarlyArticleConversion", undefined, ScholarlyArticleConversion);
+}
+export function ScholarlyArticleConversion_composeAuthor_Z721C83C5(author) {
+    let arg;
+    try {
+        const matchValue = fromString(decoder_1, author);
+        if (matchValue.tag === /* Error */ 1) {
+            throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+        }
+        else {
+            return matchValue.fields[0];
+        }
+    }
+    catch (matchValue_1) {
+        return LDPerson.create(author);
+    }
+}
+export function ScholarlyArticleConversion_splitAuthors_Z721C83C5(a) {
+    let bracketCount = 0;
+    const authors = [];
+    const sb = StringBuilder_$ctor();
+    const enumerator = getEnumerator(a.split(""));
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            switch (c) {
+                case "{": {
+                    bracketCount = ((bracketCount + 1) | 0);
+                    StringBuilder__Append_244C7CD6(sb, c);
+                    break;
+                }
+                case "}": {
+                    bracketCount = ((bracketCount - 1) | 0);
+                    StringBuilder__Append_244C7CD6(sb, c);
+                    break;
+                }
+                default:
+                    if ((c === ",") && (bracketCount === 0)) {
+                        void (authors.push(toString_1(sb)));
+                        StringBuilder__Clear(sb);
+                    }
+                    else {
+                        StringBuilder__Append_244C7CD6(sb, c);
+                    }
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    void (authors.push(toString_1(sb)));
+    return authors;
+}
+export function ScholarlyArticleConversion_composeAuthors_Z721C83C5(authors) {
+    const collection = map_1(ScholarlyArticleConversion_composeAuthor_Z721C83C5, ScholarlyArticleConversion_splitAuthors_Z721C83C5(authors));
+    return Array.from(collection);
+}
+export function ScholarlyArticleConversion_decomposeAuthor_Z2F770004(author, context) {
+    if (isEmpty(filter((n) => (n !== LDPerson.givenName), author.GetPropertyNames(unwrap(context))))) {
+        return LDPerson.getGivenNameAsString(author, unwrap(context));
+    }
+    else {
+        return toString(0, encoder(author));
+    }
+}
+export function ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(authors, context) {
+    return join(",", ResizeArray_map((a) => ScholarlyArticleConversion_decomposeAuthor_Z2F770004(a, unwrap(context)), authors));
+}
+export function ScholarlyArticleConversion_composeScholarlyArticle_D324A6D(publication) {
+    let title;
+    const matchValue = publication.Title;
+    if (matchValue == null) {
+        throw new Error("Publication must have a title");
+    }
+    else {
+        title = value_4(matchValue);
+    }
+    const authors_1 = map(ScholarlyArticleConversion_composeAuthors_Z721C83C5, publication.Authors);
+    const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, publication.Comments));
+    const identifiers = Array.from(toList(delay(() => append(((publication.DOI != null) && (value_4(publication.DOI) !== "")) ? singleton(LDPropertyValue.createDOI(value_4(publication.DOI))) : empty_1(), delay(() => (((publication.PubMedID != null) && (value_4(publication.PubMedID) !== "")) ? singleton(LDPropertyValue.createPubMedID(value_4(publication.PubMedID))) : empty_1()))))));
+    const status = map(BaseTypes_composeDefinedTerm_ZDED3A0F, publication.Status);
+    return LDScholarlyArticle.create(title, identifiers, undefined, unwrap(authors_1), undefined, unwrap(status), unwrap(comments));
+}
+export function ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(sa, graph, context) {
+    const title = LDScholarlyArticle.getHeadlineAsString(sa, unwrap(context));
+    const authors = map((a) => ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(a, unwrap(context)), Option_fromSeq(LDScholarlyArticle.getAuthors(sa, unwrap(graph), unwrap(context))));
+    const comments = ResizeArray_map((c) => BaseTypes_decomposeComment_Z2F770004(c, unwrap(context)), LDScholarlyArticle.getComments(sa, unwrap(graph), unwrap(context)));
+    const status = map((s) => BaseTypes_decomposeDefinedTerm_Z2F770004(s, unwrap(context)), LDScholarlyArticle.tryGetCreativeWorkStatus(sa, unwrap(graph), unwrap(context)));
+    const identifiers = LDScholarlyArticle.getIdentifiersAsPropertyValue(sa, unwrap(graph), unwrap(context));
+    let doi;
+    const _arg = ResizeArray_tryPick((i) => LDPropertyValue.tryGetAsDOI(i, unwrap(context)), identifiers);
+    doi = ((_arg == null) ? LDScholarlyArticle.tryGetSameAsAsString(sa, unwrap(context)) : value_4(_arg));
+    let pubMedID;
+    const _arg_1 = ResizeArray_tryPick((i_1) => LDPropertyValue.tryGetAsPubMedID(i_1, unwrap(context)), identifiers);
+    pubMedID = ((_arg_1 == null) ? LDScholarlyArticle.tryGetUrlAsString(sa, unwrap(context)) : value_4(_arg_1));
+    return Publication.create(unwrap(pubMedID), unwrap(doi), unwrap(authors), title, unwrap(status), comments);
+}
+export class AssayConversion {
+    constructor() {
+    }
+}
+export function AssayConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.AssayConversion", undefined, AssayConversion);
+}
+export function AssayConversion_getDataFilesFromProcesses_6BABD1B0(processes, fragmentDescriptors, graph, context) {
+    const data = ResizeArray_distinct(ResizeArray_append(ResizeArray_choose((df) => LDPropertyValue.tryGetSubjectOf(df, unwrap(graph), unwrap(context)), defaultArg(fragmentDescriptors, [])), ResizeArray_collect((p) => ResizeArray_append(LDLabProcess.getObjectsAsData(p, unwrap(graph), unwrap(context)), LDLabProcess.getResultsAsData(p, unwrap(graph), unwrap(context))), processes)));
+    const files = ResizeArray_filter((d) => (DataAux_pathAndSelectorFromName(d.Id)[1] == null), data);
+    return ResizeArray_append(files, ResizeArray_map((tupledArg) => {
+        const path = tupledArg[0];
+        const fragments = tupledArg[1];
+        let file;
+        const matchValue = ResizeArray_tryFind((d_3) => (d_3.Id === path), files);
+        if (matchValue == null) {
+            const comments = Option_fromSeq(LDFile.getComments(fragments[0], unwrap(graph), unwrap(context)));
+            file = LDFile.create(path, path, unwrap(comments), unwrap(LDFile.tryGetDisambiguatingDescriptionAsString(fragments[0], unwrap(context))), unwrap(LDFile.tryGetEncodingFormatAsString(fragments[0], unwrap(context))), undefined, unwrap(fragments[0].TryGetContext()));
+        }
+        else {
+            file = value_4(matchValue);
+        }
+        LDDataset.setHasParts(file, fragments, unwrap(context));
+        return file;
+    }, ResizeArray_groupBy((d_2) => DataAux_pathAndSelectorFromName(d_2.Id)[0], ResizeArray_filter((d_1) => (DataAux_pathAndSelectorFromName(d_1.Id)[1] != null), data))));
+}
+export function AssayConversion_composeAssay_1501C0F8(assay) {
+    let collection, fds_1, vm_1, fds, vm;
+    const measurementMethod = map(BaseTypes_composeDefinedTerm_ZDED3A0F, assay.TechnologyType);
+    const measurementTechnique = map(BaseTypes_composeDefinedTerm_ZDED3A0F, assay.TechnologyPlatform);
+    const variableMeasured = map(BaseTypes_composePropertyValueFromOA_ZDED3A0F, assay.MeasurementType);
+    const creators = Option_fromSeq(ResizeArray_map(PersonConversion_composePerson_Z64D846DC, assay.Performers));
+    const processSequence = Option_fromSeq((collection = ARCtrl_ArcTables__ArcTables_GetProcesses(new ArcTables(assay.Tables)), Array.from(collection)));
+    const fragmentDescriptors = map(DatamapConversion_composeFragmentDescriptors_Z8923FA3, assay.DataMap);
+    const dataFiles = map((ps) => AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, unwrap(fragmentDescriptors)), processSequence);
+    const variableMeasureds = (variableMeasured == null) ? ((fragmentDescriptors == null) ? undefined : ((fds_1 = value_4(fragmentDescriptors), fds_1))) : ((fragmentDescriptors == null) ? ((vm_1 = value_4(variableMeasured), ResizeArray_singleton(vm_1))) : ((fds = value_4(fragmentDescriptors), (vm = value_4(variableMeasured), ResizeArray_appendSingleton(vm, fds)))));
+    const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, assay.Comments));
+    return LDDataset.createAssay(assay.Identifier, undefined, unwrap(assay.Title), unwrap(assay.Description), unwrap(creators), unwrap(dataFiles), unwrap(measurementMethod), unwrap(measurementTechnique), unwrap(variableMeasureds), unwrap(processSequence), unwrap(comments));
+}
+export function AssayConversion_decomposeAssay_Z6839B9E8(assay, graph, context) {
+    const measurementMethod = map((m) => BaseTypes_decomposeDefinedTerm_Z2F770004(m, unwrap(context)), LDDataset.tryGetMeasurementMethodAsDefinedTerm(assay, unwrap(graph), unwrap(context)));
+    const measurementTechnique = map((m_1) => BaseTypes_decomposeDefinedTerm_Z2F770004(m_1, unwrap(context)), LDDataset.tryGetMeasurementTechniqueAsDefinedTerm(assay, unwrap(graph), unwrap(context)));
+    const variableMeasured = map((v) => BaseTypes_decomposePropertyValueToOA_Z2F770004(v, unwrap(context)), LDDataset.tryGetVariableMeasuredAsMeasurementType(assay, unwrap(graph), unwrap(context)));
+    const perfomers = ResizeArray_map((c) => PersonConversion_decomposePerson_Z6839B9E8(c, unwrap(graph), unwrap(context)), LDDataset.getCreators(assay, unwrap(graph), unwrap(context)));
+    let dataMap;
+    const v_1 = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.getVariableMeasuredAsFragmentDescriptors(assay, unwrap(graph), unwrap(context)), unwrap(graph), unwrap(context));
+    dataMap = Option_fromValueWithDefault(DataMap_init(), v_1);
+    const tables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ofSeq(LDDataset.getAboutsAsLabProcess(assay, unwrap(graph), unwrap(context))), unwrap(graph), unwrap(context));
+    const comments = ResizeArray_map((c_1) => BaseTypes_decomposeComment_Z2F770004(c_1, unwrap(context)), LDDataset.getComments(assay, unwrap(graph), unwrap(context)));
+    return ArcAssay.create(LDDataset.getIdentifierAsString(assay, unwrap(context)), unwrap(LDDataset.tryGetNameAsString(assay, unwrap(context))), unwrap(LDDataset.tryGetDescriptionAsString(assay, unwrap(context))), unwrap(variableMeasured), unwrap(measurementMethod), unwrap(measurementTechnique), tables.Tables, unwrap(dataMap), perfomers, comments);
+}
+export class StudyConversion {
+    constructor() {
+    }
+}
+export function StudyConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.StudyConversion", undefined, StudyConversion);
+}
+export function StudyConversion_composeStudy_1680536E(study) {
+    let collection;
+    const dateCreated = bind(DateTime_tryFromString, study.SubmissionDate);
+    const datePublished = bind(DateTime_tryFromString, study.PublicReleaseDate);
+    const dateModified = now();
+    const publications = Option_fromSeq(ResizeArray_map(ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, study.Publications));
+    const creators = Option_fromSeq(ResizeArray_map(PersonConversion_composePerson_Z64D846DC, study.Contacts));
+    const processSequence = Option_fromSeq((collection = ARCtrl_ArcTables__ArcTables_GetProcesses(new ArcTables(study.Tables)), Array.from(collection)));
+    const fragmentDescriptors = map(DatamapConversion_composeFragmentDescriptors_Z8923FA3, study.DataMap);
+    const dataFiles = map((ps) => AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, unwrap(fragmentDescriptors)), processSequence);
+    const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, study.Comments));
+    return LDDataset.createStudy(study.Identifier, undefined, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), dateModified, unwrap(study.Description), unwrap(dataFiles), unwrap(study.Title), unwrap(publications), unwrap(fragmentDescriptors), unwrap(comments), undefined, unwrap(processSequence));
+}
+export function StudyConversion_decomposeStudy_Z6839B9E8(study, graph, context) {
+    const dateCreated = map(DateTime_toString, LDDataset.tryGetDateCreatedAsDateTime(study, unwrap(context)));
+    const datePublished = map(DateTime_toString, LDDataset.tryGetDatePublishedAsDateTime(study, unwrap(context)));
+    const publications = ResizeArray_map((p) => ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(p, unwrap(graph), unwrap(context)), LDDataset.getCitations(study, unwrap(graph), unwrap(context)));
+    const creators = ResizeArray_map((c) => PersonConversion_decomposePerson_Z6839B9E8(c, unwrap(graph), unwrap(context)), LDDataset.getCreators(study, unwrap(graph), unwrap(context)));
+    let dataMap;
+    const v = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.getVariableMeasuredAsFragmentDescriptors(study, unwrap(graph), unwrap(context)), unwrap(graph), unwrap(context));
+    dataMap = Option_fromValueWithDefault(DataMap_init(), v);
+    const tables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ofSeq(LDDataset.getAboutsAsLabProcess(study, unwrap(graph), unwrap(context))), unwrap(graph), unwrap(context));
+    const comments = ResizeArray_map((c_1) => BaseTypes_decomposeComment_Z2F770004(c_1, unwrap(context)), LDDataset.getComments(study, unwrap(graph), unwrap(context)));
+    return ArcStudy.create(LDDataset.getIdentifierAsString(study, unwrap(context)), unwrap(LDDataset.tryGetNameAsString(study, unwrap(context))), unwrap(LDDataset.tryGetDescriptionAsString(study, unwrap(context))), unwrap(dateCreated), unwrap(datePublished), publications, creators, undefined, tables.Tables, unwrap(dataMap), undefined, comments);
+}
+export class InvestigationConversion {
+    constructor() {
+    }
+}
+export function InvestigationConversion_$reflection() {
+    return class_type("ARCtrl.Conversion.InvestigationConversion", undefined, InvestigationConversion);
+}
+export function InvestigationConversion_composeInvestigation_Z720BD3FF(investigation) {
+    let b;
+    let name;
+    const matchValue = investigation.Title;
+    if (matchValue == null) {
+        throw new Error("Investigation must have a title");
+    }
+    else {
+        name = value_4(matchValue);
+    }
+    const dateCreated = bind(DateTime_tryFromString, investigation.SubmissionDate);
+    const datePublished = defaultArg(bind(DateTime_tryFromString, investigation.PublicReleaseDate), now());
+    const publications = Option_fromSeq(ResizeArray_map(ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, investigation.Publications));
+    const creators = Option_fromSeq(ResizeArray_map(PersonConversion_composePerson_Z64D846DC, investigation.Contacts));
+    const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, investigation.Comments));
+    const hasParts = Option_fromSeq((b = ResizeArray_map(AssayConversion_composeAssay_1501C0F8, investigation.Assays), ResizeArray_append(ResizeArray_map(StudyConversion_composeStudy_1680536E, investigation.Studies), b)));
+    const mentions = Option_fromSeq([]);
+    return LDDataset.createInvestigation(investigation.Identifier, name, undefined, unwrap(creators), unwrap(dateCreated), datePublished, undefined, unwrap(investigation.Description), unwrap(hasParts), unwrap(publications), unwrap(comments), unwrap(mentions));
+}
+export function InvestigationConversion_decomposeInvestigation_Z6839B9E8(investigation, graph, context) {
+    let title;
+    const matchValue = LDDataset.tryGetNameAsString(investigation, unwrap(context));
+    title = ((matchValue == null) ? LDDataset.tryGetHeadlineAsString(investigation, unwrap(context)) : value_4(matchValue));
+    const dateCreated = map(DateTime_toString, LDDataset.tryGetDateCreatedAsDateTime(investigation, unwrap(context)));
+    const datePublished = map(DateTime_toString, LDDataset.tryGetDatePublishedAsDateTime(investigation, unwrap(context)));
+    const publications = ResizeArray_map((p) => ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(p, unwrap(graph), unwrap(context)), LDDataset.getCitations(investigation, unwrap(graph), unwrap(context)));
+    const creators = ResizeArray_map((c) => PersonConversion_decomposePerson_Z6839B9E8(c, unwrap(graph), unwrap(context)), LDDataset.getCreators(investigation, unwrap(graph), unwrap(context)));
+    const datasets = LDDataset.getHasPartsAsDataset(investigation, unwrap(graph), unwrap(context));
+    const studies = ResizeArray_map((d_3) => StudyConversion_decomposeStudy_Z6839B9E8(d_3, unwrap(graph), unwrap(context)), ResizeArray_filter((d_2) => LDDataset.validateStudy(d_2, unwrap(context)), datasets));
+    const assays = ResizeArray_map((d_5) => AssayConversion_decomposeAssay_Z6839B9E8(d_5, unwrap(graph), unwrap(context)), ResizeArray_filter((d_4) => LDDataset.validateAssay(d_4, unwrap(context)), datasets));
+    const comments = ResizeArray_map((c_1) => BaseTypes_decomposeComment_Z2F770004(c_1, unwrap(context)), LDDataset.getComments(investigation, unwrap(graph), unwrap(context)));
+    return ArcInvestigation.create(LDDataset.getIdentifierAsString(investigation, unwrap(context)), unwrap(title), unwrap(LDDataset.tryGetDescriptionAsString(investigation, unwrap(context))), unwrap(dateCreated), unwrap(datePublished), undefined, publications, creators, assays, studies, undefined, undefined, undefined, comments);
+}
+export function ARCtrl_ArcAssay__ArcAssay_ToROCrateAssay(this$) {
+    return AssayConversion_composeAssay_1501C0F8(this$);
+}
+export function ARCtrl_ArcAssay__ArcAssay_fromROCrateAssay_Static_Z6839B9E8(a, graph, context) {
+    return AssayConversion_decomposeAssay_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+export function ARCtrl_ArcStudy__ArcStudy_ToROCrateStudy(this$) {
+    return StudyConversion_composeStudy_1680536E(this$);
+}
+export function ARCtrl_ArcStudy__ArcStudy_fromROCrateStudy_Static_Z6839B9E8(a, graph, context) {
+    return StudyConversion_decomposeStudy_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+export function ARCtrl_ArcInvestigation__ArcInvestigation_ToROCrateInvestigation(this$) {
+    return InvestigationConversion_composeInvestigation_Z720BD3FF(this$);
+}
+export function ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8(a, graph, context) {
+    return InvestigationConversion_decomposeInvestigation_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+export function ARCtrl_ROCrate_Dataset__Dataset_toArcAssay_Static_Z6839B9E8(a, graph, context) {
+    return AssayConversion_decomposeAssay_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+export function ARCtrl_ROCrate_Dataset__Dataset_fromArcAssay_Static_1501C0F8(a) {
+    return AssayConversion_composeAssay_1501C0F8(a);
+}
+export function ARCtrl_ROCrate_Dataset__Dataset_toArcStudy_Static_Z6839B9E8(a, graph, context) {
+    return StudyConversion_decomposeStudy_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+export function ARCtrl_ROCrate_Dataset__Dataset_fromArcStudy_Static_1680536E(a) {
+    return StudyConversion_composeStudy_1680536E(a);
+}
+export function ARCtrl_ROCrate_Dataset__Dataset_toArcInvestigation_Static_Z6839B9E8(a, graph, context) {
+    return InvestigationConversion_decomposeInvestigation_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+export function ARCtrl_ROCrate_Dataset__Dataset_fromArcInvestigation_Static_Z720BD3FF(a) {
+    return InvestigationConversion_composeInvestigation_Z720BD3FF(a);
+}