@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/ts/ts/Conversion.js

@@ -0,0 +1,1247 @@
+import { fromString } from './fable_modules/Thoth.Json.JavaScript.0.4.1/Decode.fs.js';
+import { Decode_datetime } from './Json/Decode.js';
+import { toText, printf, join, toFail } from '../node_modules/@fable-org/fable-library-js/String.js';
+import { unwrap, map, value, bind, defaultArg } from '../node_modules/@fable-org/fable-library-js/Option.js';
+import { toString as toString$1 } from './fable_modules/Thoth.Json.JavaScript.0.4.1/Encode.fs.js';
+import { dateTime } from './Json/Encode.js';
+import { tryParse, parse } from '../node_modules/@fable-org/fable-library-js/Int32.js';
+import { toString, FSharpRef } from '../node_modules/@fable-org/fable-library-js/Types.js';
+import { LDRef, LDNode } from './ROCrate/LDObject.js';
+import { getEnumerator, disposeSafe, int32ToString, comparePrimitives, stringHash } from '../node_modules/@fable-org/fable-library-js/Util.js';
+import { LDComment } from './ROCrate/Generic/Comment.js';
+import { Comment$ } from './Core/Comment.js';
+import { OntologyAnnotation } from './Core/OntologyAnnotation.js';
+import { Option_fromSeq, ResizeArray_map, ResizeArray_singleton, ResizeArray_appendSingleton, Option_fromValueWithDefault, ResizeArray_append, ResizeArray_filter, ResizeArray_distinct, ResizeArray_collect, ResizeArray_choose, ResizeArray_groupBy, ResizeArray_tryFind, ResizeArray_tryPick, ResizeArray_create, ResizeArray_zip } 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_FreeText, CompositeCell_Term, CompositeCell_Unitized, CompositeCell_Data } from './Core/Table/CompositeCell.js';
+import { CompositeHeader_Comment, CompositeHeader_Parameter, CompositeHeader_Component, CompositeHeader_Characteristic, CompositeHeader_Factor, CompositeHeader_ProtocolREF, CompositeHeader_Input, IOType_Source, IOType_Material, IOType_Sample, IOType_Data, IOType_FreeText, CompositeHeader_ProtocolDescription, CompositeHeader_ProtocolUri, CompositeHeader_ProtocolVersion, CompositeHeader_ProtocolType, CompositeHeader_Output } from './Core/Table/CompositeHeader.js';
+import { DataFile__get_AsString, DataFile_fromString_Z721C83C5 } from './Core/DataFile.js';
+import { LDFile } from './ROCrate/Generic/File.js';
+import { LDDataset } from './ROCrate/Generic/Dataset.js';
+import { map as map$3 } from '../node_modules/@fable-org/fable-library-js/Array.js';
+import { combine } from './FileSystem/Path.js';
+import { DataContext__get_Explication, DataContext__get_Unit, DataContext__get_ObjectType, DataContext__get_GeneratedBy, DataContext__get_Description, DataContext__get_Label, DataContext_$ctor_Z780A8A2A } 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 { Unchecked_alignByHeaders, Unchecked_tryGetCellAt, getEmptyCellForHeader } from './Core/Table/ArcTableAux.js';
+import { ArcTable } from './Core/Table/ArcTable.js';
+import { LDPerson } from './ROCrate/Generic/Person.js';
+import { toList, delay, isEmpty, filter, map as map$2, indexed, tryPick, choose as choose$1, append, empty as empty$1, singleton as singleton$1 } from '../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ofSeq, collect, map as map$1, singleton, empty, sortBy, choose, length } from '../node_modules/@fable-org/fable-library-js/List.js';
+import { LDLabProcess } from './ROCrate/Generic/LabProcess.js';
+import { List_groupBy } from '../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { createMissingIdentifier } from './Core/Helper/Identifier.js';
+import { rangeDouble } from '../node_modules/@fable-org/fable-library-js/Range.js';
+import { ArcTables } from './Core/Table/ArcTables.js';
+import { DataMap_init, DataMap__get_DataContexts, DataMap_$ctor_4E3220A7 } from './Core/DataMap.js';
+import { LDOrganization } from './ROCrate/Generic/Organization.js';
+import { decoder, encoder } from './Json/ROCrate/LDNode.js';
+import { Person } from './Core/Person.js';
+import { tryGetOrcidNumber } from './Core/Helper/ORCID.js';
+import { StringBuilder_$ctor, StringBuilder__Clear, StringBuilder__Append_244C7CD6 } from '../node_modules/@fable-org/fable-library-js/System.Text.js';
+import { LDScholarlyArticle } from './ROCrate/Generic/ScholarlyArticle.js';
+import { Publication } from './Core/Publication.js';
+import { ArcAssay, ArcStudy, ArcInvestigation } from './Core/ArcTypes.js';
+import { now } from '../node_modules/@fable-org/fable-library-js/Date.js';
+
+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 void 0;
+  }
+}
+function DateTime_toString(d) {
+  return toString$1(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 void 0;
+  }
+}
+const ColumnIndex_orderName = "columnIndex";
+function ColumnIndex_tryGetIndex(node) {
+  const matchValue = node.TryGetPropertyAsSingleton(ColumnIndex_orderName);
+  let matchResult, ci;
+  if (matchValue != null) {
+    if (typeof value(matchValue) === "string") {
+      matchResult = 0;
+      ci = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return ColumnIndex_tryInt(ci);
+    default:
+      return void 0;
+  }
+}
+function ColumnIndex_setIndex(node, index) {
+  node.SetProperty(ColumnIndex_orderName, int32ToString(index));
+}
+function ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(this$, index) {
+  ColumnIndex_setIndex(this$, index);
+}
+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(matchValue);
+  }
+  return LDComment.create(name, void 0, unwrap(comment.Value));
+}
+function BaseTypes_decomposeComment_Z2F770004(comment, context) {
+  return new Comment$(LDComment.getNameAsString(comment, unwrap(context)), unwrap(LDComment.tryGetTextAsString(comment, unwrap(context))));
+}
+function BaseTypes_ontologyTermFromNameAndID_40457300(name, id) {
+  if (id == null) {
+    return OntologyAnnotation.create(unwrap(name));
+  } else {
+    const t = value(id);
+    return OntologyAnnotation.fromTermAnnotation(t, unwrap(name));
+  }
+}
+function BaseTypes_tryOntologyTermFromNameAndID_40457300(name, id) {
+  if (name == null && id == null) {
+    return void 0;
+  } else {
+    return BaseTypes_ontologyTermFromNameAndID_40457300(unwrap(name), unwrap(id));
+  }
+}
+function BaseTypes_composeDefinedTerm_ZDED3A0F(term) {
+  const tan = Option_fromValueWithDefault("", term.TermAccessionAndOntobeeUrlIfShort);
+  return LDDefinedTerm.create(term.NameText, void 0, unwrap(tan));
+}
+function BaseTypes_decomposeDefinedTerm_Z2F770004(term, context) {
+  return BaseTypes_ontologyTermFromNameAndID_40457300(LDDefinedTerm.getNameAsString(term, unwrap(context)), unwrap(LDDefinedTerm.tryGetTermCodeAsString(term, unwrap(context))));
+}
+function BaseTypes_composePropertyValueFromOA_ZDED3A0F(term) {
+  const tan = Option_fromValueWithDefault("", term.TermAccessionAndOntobeeUrlIfShort);
+  return LDPropertyValue.create(term.NameText, void 0, void 0, unwrap(tan));
+}
+function BaseTypes_decomposePropertyValueToOA_Z2F770004(term, context) {
+  return BaseTypes_ontologyTermFromNameAndID_40457300(LDPropertyValue.getNameAsString(term, unwrap(context)), unwrap(LDPropertyValue.tryGetPropertyIDAsString(term, unwrap(context))));
+}
+function BaseTypes_valuesOfCell_Z436420FE(value) {
+  let term, term_1;
+  switch (value.tag) {
+    case /* Term */
+    0:
+      if (term = value.fields[0], term.isEmpty()) {
+        value.fields[0];
+        return [void 0, void 0, void 0, void 0];
+      } else if (term_1 = value.fields[0], term_1.TANInfo != null) {
+        const term_3 = value.fields[0];
+        return [term_3.Name, term_3.TermAccessionAndOntobeeUrlIfShort, void 0, void 0];
+      } else {
+        const term_4 = value.fields[0];
+        return [term_4.Name, void 0, void 0, void 0];
+      }
+    case /* Unitized */
+    2: {
+      const text_1 = value.fields[0];
+      const unit = value.fields[1];
+      const patternInput = unit.isEmpty() ? [void 0, void 0] : [unit.Name, Option_fromValueWithDefault("", unit.TermAccessionAndOntobeeUrlIfShort)];
+      return [Option_fromValueWithDefault("", text_1), void 0, patternInput[0], patternInput[1]];
+    }
+    case /* Data */
+    3: {
+      value.fields[0];
+      throw new Error("Data cell should not be parsed to isa value");
+    }
+    default:
+      if (value.fields[0] === "") {
+        return [void 0, void 0, void 0, void 0];
+      } else {
+        const text = value.fields[0];
+        return [text, void 0, void 0, void 0];
+      }
+  }
+}
+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 : void 0];
+    default:
+      return toFail(printf("header %O should not be parsed to isa value"))(header);
+  }
+}
+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]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+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]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+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]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+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]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+function BaseTypes_composeFreetextMaterialName(headerFT, name) {
+  return `${headerFT}=${name}`;
+}
+function BaseTypes_composeFile_6CE21C7D(d, fs) {
+  const createFile = () => {
+    const dataType = map(DataFile__get_AsString, d.DataType);
+    return LDFile.create(d.NameText, d.NameText, void 0, unwrap(dataType), unwrap(d.Format), unwrap(d.SelectorFormat));
+  };
+  if (fs == null) {
+    return createFile();
+  } else {
+    const fs_1 = value(fs);
+    const matchValue = fs_1.Tree.TryGetPath(d.NameText);
+    if (matchValue != null) {
+      if (value(matchValue).tag === /* Folder */
+      1) {
+        const fs_2 = value(matchValue);
+        const file = createFile();
+        file.SchemaType = [LDFile.schemaType, LDDataset.schemaType];
+        let subFiles;
+        const collection = map$3((fp) => {
+          const fullPath = combine(d.NameText, fp);
+          return LDFile.create(fullPath, fullPath);
+        }, fs_2.ToFilePaths(true));
+        subFiles = Array.from(collection);
+        LDDataset.setHasParts(file, subFiles);
+        return file;
+      } else {
+        return createFile();
+      }
+    } else {
+      return createFile();
+    }
+  }
+}
+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(void 0, LDFile.getNameAsString(f, unwrap(context)), unwrap(dataType), unwrap(format), unwrap(selectorFormat));
+}
+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)), [void 0, void 0]);
+  const patternInput_1 = defaultArg(map((u) => [u.Name, Option_fromValueWithDefault("", u.TermAccessionAndOntobeeUrlIfShort)], DataContext__get_Unit(dc)), [void 0, void 0]);
+  const disambiguatingDescriptions = Option_fromSeq(ResizeArray_map(toString, dc.Comments));
+  const dataFragment = BaseTypes_composeFile_6CE21C7D(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]), void 0, 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);
+}
+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(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(void 0, name, void 0, 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)));
+}
+function BaseTypes_composeProcessInput(header, value, fs) {
+  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_6CE21C7D(value.fields[0], unwrap(fs));
+          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);
+  }
+}
+function BaseTypes_composeProcessOutput(header, value, fs) {
+  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_6CE21C7D(value.fields[0], unwrap(fs));
+        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);
+  }
+}
+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(matchValue);
+    return OntologyAnnotation.fromTermAnnotation(nRef, n);
+  }
+}
+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(uRef);
+      }
+    } else if (uRef != null) {
+      matchResult = 2;
+      uRef_1 = value(uRef);
+    } else {
+      matchResult = 1;
+      u_1 = value(u);
+    }
+  } else if (u == null) {
+    if (uRef == null) {
+      matchResult = 0;
+      vr = value(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);
+    }
+  }
+}
+function BaseTypes_decomposeComponent_Z2F770004(c, context) {
+  return [CompositeHeader_Component(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeParameterValue_Z2F770004(c, context) {
+  return [CompositeHeader_Parameter(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeFactorValue_Z2F770004(c, context) {
+  return [CompositeHeader_Factor(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeCharacteristicValue_Z2F770004(c, context) {
+  return [CompositeHeader_Characteristic(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+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)))];
+  }
+}
+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)))];
+  }
+}
+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 void 0;
+    } else {
+      const s = value(matchValue_1);
+      return OntologyAnnotation.create(s);
+    }
+  } else {
+    return BaseTypes_decomposeDefinedTerm_Z2F770004(value(matchValue), unwrap(context));
+  }
+}
+function ProcessConversion_composeProcessName(processNameRoot, i) {
+  return `${processNameRoot}_${i}`;
+}
+function ProcessConversion_decomposeProcessName_Z721C83C5(name) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("(?<name>.+)_(?<num>\\d+)", name);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return [r.groups && r.groups.name || "", parse(r.groups && r.groups.num || "", 511, false, 32)];
+  } else {
+    return [name, void 0];
+  }
+}
+function ProcessConversion_tryComponentGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Component */
+  0) {
+    valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const c = BaseTypes_composeComponent(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(c, valueI);
+      return c;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryParameterGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Parameter */
+  3) {
+    valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const p = BaseTypes_composeParameterValue(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(p, valueI);
+      return p;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryFactorGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Factor */
+  2) {
+    valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const f = BaseTypes_composeFactorValue(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(f, valueI);
+      return f;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryCharacteristicGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Characteristic */
+  1) {
+    valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const c = BaseTypes_composeCharacteristicValue(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(c, valueI);
+      return c;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetProtocolTypeGetter(generalI, header) {
+  if (header.tag === /* ProtocolType */
+  4) {
+    return (table) => (i) => {
+      let matchValue, cell;
+      return BaseTypes_composeDefinedTerm_ZDED3A0F((matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? new OntologyAnnotation() : (cell = value(matchValue), cell.AsTerm)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetProtocolREFGetter(generalI, header) {
+  if (header.tag === /* ProtocolREF */
+  8) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetProtocolDescriptionGetter(generalI, header) {
+  if (header.tag === /* ProtocolDescription */
+  5) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetProtocolURIGetter(generalI, header) {
+  if (header.tag === /* ProtocolUri */
+  6) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetProtocolVersionGetter(generalI, header) {
+  if (header.tag === /* ProtocolVersion */
+  7) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetInputGetter(generalI, header, fs) {
+  if (header.tag === /* Input */
+  11) {
+    header.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      return BaseTypes_composeProcessInput(header, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(header, void 0) : value(matchValue)), fs);
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetOutputGetter(generalI, header, fs) {
+  if (header.tag === /* Output */
+  12) {
+    header.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      return BaseTypes_composeProcessOutput(header, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(header, void 0) : value(matchValue)), fs);
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetCommentGetter(generalI, header) {
+  if (header.tag === /* Comment */
+  14) {
+    const c = header.fields[0];
+    return (table) => (i) => {
+      let matchValue, cell;
+      return toString((matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? new Comment$(c) : (cell = value(matchValue), new Comment$(c, cell.AsFreeText))));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetPerformerGetter(generalI, header) {
+  if (header.tag === /* Performer */
+  9) {
+    return (table) => (i) => {
+      let performer;
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        performer = "";
+      } else {
+        const cell = value(matchValue);
+        performer = cell.AsFreeText;
+      }
+      return LDPerson.create(performer);
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_getProcessGetter(assayName, studyName, processNameRoot, headers, fs) {
+  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], fs), headers_1);
+  if (matchValue == null) {
+    inputGetter_1 = length(charGetters) !== 0 ? (table_1) => (i_1) => {
+      let chars_1;
+      const collection_1 = map$2((f_1) => f_1(table_1)(i_1), charGetters);
+      chars_1 = Array.from(collection_1);
+      return ResizeArray_singleton(LDSample.createSample(`${processNameRoot}_Input_${i_1}`, void 0, chars_1));
+    } : (table_2) => (i_2) => [];
+  } else {
+    const inputGetter = value(matchValue);
+    inputGetter_1 = (table) => (i) => {
+      let chars;
+      const collection = map$2((f) => f(table)(i), charGetters);
+      chars = Array.from(collection);
+      const input = inputGetter(table)(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], fs), headers_1);
+  if (matchValue_1 == null) {
+    outputGetter_1 = length(factorValueGetters) !== 0 ? (table_4) => (i_4) => {
+      let factors_1;
+      const collection_3 = map$2((f_3) => f_3(table_4)(i_4), factorValueGetters);
+      factors_1 = Array.from(collection_3);
+      return ResizeArray_singleton(LDSample.createSample(`${processNameRoot}_Output_${i_4}`, void 0, factors_1));
+    } : (table_5) => (i_5) => [];
+  } else {
+    const outputGetter = value(matchValue_1);
+    outputGetter_1 = (table_3) => (i_3) => {
+      let factors;
+      const collection_2 = map$2((f_2) => f_2(table_3)(i_3), factorValueGetters);
+      factors = Array.from(collection_2);
+      const output = outputGetter(table_3)(i_3);
+      if (factors.length > 0) {
+        LDSample.setAdditionalProperties(output, factors);
+      }
+      return ResizeArray_singleton(output);
+    };
+  }
+  return (table_6) => (i_6) => {
+    const pn = table_6.RowCount === 1 ? processNameRoot : ProcessConversion_composeProcessName(processNameRoot, i_6);
+    const paramvalues = map((collection_4) => Array.from(collection_4), Option_fromValueWithDefault(empty(), map$1((f_4) => f_4(table_6)(i_6), parameterValueGetters)));
+    const comments = map((collection_5) => Array.from(collection_5), Option_fromValueWithDefault(empty(), map$1((f_5) => f_5(table_6)(i_6), commentGetters)));
+    const components = map((collection_6) => Array.from(collection_6), Option_fromValueWithDefault(empty(), map$1((f_6) => f_6(table_6)(i_6), componentGetters)));
+    const id = LDLabProcess.genId(processNameRoot, unwrap(assayName), unwrap(studyName)) + `_${i_6}`;
+    let protocol;
+    const name = map((f_7) => f_7(table_6)(i_6), protocolREFGetter);
+    const protocolId = LDLabProtocol.genId(unwrap(name), processNameRoot);
+    protocol = LDLabProtocol.create(protocolId, unwrap(name), unwrap(map((f_8) => f_8(table_6)(i_6), protocolDescriptionGetter)), unwrap(map((f_9) => f_9(table_6)(i_6), protocolTypeGetter)), void 0, void 0, unwrap(components), void 0, unwrap(map((f_10) => f_10(table_6)(i_6), protocolURIGetter)), unwrap(map((f_11) => f_11(table_6)(i_6), protocolVersionGetter)));
+    const matchValue_2 = inputGetter_1(table_6)(i_6);
+    const matchValue_3 = outputGetter_1(table_6)(i_6);
+    const agent = map((f_12) => f_12(table_6)(i_6), performerGetter);
+    return LDLabProcess.create(pn, matchValue_2, matchValue_3, id, unwrap(agent), unwrap(protocol), unwrap(paramvalues), void 0, unwrap(comments));
+  };
+}
+function ProcessConversion_groupProcesses_Z27F0B586(processes, graph, context) {
+  return List_groupBy((p) => {
+    let protocol, protocol_1;
+    const matchValue = LDLabProcess.tryGetNameAsString(p, unwrap(context));
+    const matchValue_1 = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+    let matchResult, name_1, protocol_2, name_2, protocol_3;
+    if (matchValue != null) {
+      if (ProcessConversion_decomposeProcessName_Z721C83C5(value(matchValue))[1] != null) {
+        matchResult = 0;
+        name_1 = value(matchValue);
+      } else if (matchValue_1 != null) {
+        if (protocol = value(matchValue_1), LDLabProtocol.tryGetNameAsString(protocol, unwrap(context)) != null) {
+          matchResult = 1;
+          protocol_2 = value(matchValue_1);
+        } else {
+          matchResult = 2;
+          name_2 = value(matchValue);
+        }
+      } else {
+        matchResult = 2;
+        name_2 = value(matchValue);
+      }
+    } else if (matchValue_1 != null) {
+      if (protocol_1 = value(matchValue_1), LDLabProtocol.tryGetNameAsString(protocol_1, unwrap(context)) != null) {
+        matchResult = 1;
+        protocol_2 = value(matchValue_1);
+      } else {
+        matchResult = 3;
+        protocol_3 = value(matchValue_1);
+      }
+    } else {
+      matchResult = 4;
+    }
+    switch (matchResult) {
+      case 0:
+        return ProcessConversion_decomposeProcessName_Z721C83C5(name_1)[0];
+      case 1:
+        return defaultArg(LDLabProtocol.tryGetNameAsString(protocol_2, unwrap(context)), "");
+      case 2:
+        return name_2;
+      case 3:
+        return protocol_3.Id;
+      default:
+        return createMissingIdentifier();
+    }
+  }, processes, {
+    Equals: (x, y) => x === y,
+    GetHashCode: stringHash
+  });
+}
+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(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(matchValue_1);
+    protVals = toList(delay(() => {
+      let matchValue_2;
+      return append((matchValue_2 = LDLabProtocol.tryGetNameAsString(prot_1, unwrap(context)), matchValue_2 == null ? empty$1() : singleton$1([CompositeHeader_ProtocolREF(), CompositeCell_FreeText(value(matchValue_2))])), delay(() => {
+        let matchValue_3;
+        return append((matchValue_3 = LDLabProtocol.tryGetDescriptionAsString(prot_1, unwrap(context)), matchValue_3 == null ? empty$1() : singleton$1([CompositeHeader_ProtocolDescription(), CompositeCell_FreeText(value(matchValue_3))])), delay(() => {
+          let matchValue_4;
+          return append((matchValue_4 = LDLabProtocol.tryGetUrl(prot_1, unwrap(context)), matchValue_4 == null ? empty$1() : singleton$1([CompositeHeader_ProtocolUri(), CompositeCell_FreeText(value(matchValue_4))])), delay(() => {
+            let matchValue_5;
+            return append((matchValue_5 = LDLabProtocol.tryGetVersionAsString(prot_1, unwrap(context)), matchValue_5 == null ? empty$1() : singleton$1([CompositeHeader_ProtocolVersion(), CompositeCell_FreeText(value(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$1([CompositeHeader_ProtocolType(), CompositeCell_Term(value(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, void 0), ResizeArray_map((Value) => Value, outputs)] : inputs.length !== 0 && outputs.length === 0 ? [ResizeArray_map((Value_1) => Value_1, inputs), ResizeArray_create(inputs.length, void 0)] : [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$1((tuple_1) => tuple_1[0], sortBy((arg) => defaultArg(arg[1], 1e4), 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(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(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$1((tuple_3) => tuple_3[0], sortBy((arg_1) => defaultArg(arg_1[1], 1e4), toList(delay(() => append(chars, delay(() => append(components, delay(() => append(pvs, delay(() => factors)))))))), {
+        Compare: comparePrimitives
+      }));
+      return toList(delay(() => append(i != null ? singleton$1(BaseTypes_decomposeProcessInput_Z2F770004(value(i), unwrap(context))) : empty$1(), delay(() => append(protVals, delay(() => append(vals_1, delay(() => append(comments, delay(() => o != null ? singleton$1(BaseTypes_decomposeProcessOutput_Z2F770004(value(o), unwrap(context))) : empty$1()))))))))));
+    }, ResizeArray_zip(inputs_1, outputs_1));
+  }
+}
+function ARCtrl_ArcTable__ArcTable_GetProcesses_5E660E5C(this$, assayName, studyName, fs) {
+  if (this$.RowCount === 0) {
+    return singleton(LDLabProcess.create(this$.Name));
+  } else {
+    const getter = ProcessConversion_getProcessGetter(assayName, studyName, this$.Name, this$.Headers, fs);
+    return toList(delay(() => map$2((i) => getter(this$)(i), rangeDouble(0, 1, this$.RowCount - 1))));
+  }
+}
+function ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(this$, assayName, studyName, fs) {
+  return collect((t) => ARCtrl_ArcTable__ArcTable_GetProcesses_5E660E5C(t, unwrap(assayName), unwrap(studyName), unwrap(fs)), toList(this$.Tables));
+}
+function ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ps, graph, context) {
+  let collection;
+  return new ArcTables((collection = map$1((tupledArg) => {
+    const tupledArg_1 = Unchecked_alignByHeaders(true, collect((p) => ofSeq(ProcessConversion_processToRows_Z6839B9E8(p, unwrap(graph), unwrap(context))), tupledArg[1]));
+    return ArcTable.fromArcTableValues(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
+  }, ProcessConversion_groupProcesses_Z27F0B586(ps, unwrap(graph), unwrap(context))), Array.from(collection)));
+}
+function DatamapConversion_composeFragmentDescriptors_Z8923FA3(datamap) {
+  return ResizeArray_map(BaseTypes_composeFragmentDescriptor_Z4C0BEF62, DataMap__get_DataContexts(datamap));
+}
+function DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(fragmentDescriptors, graph, context) {
+  return DataMap_$ctor_4E3220A7(ResizeArray_map((fd) => BaseTypes_decomposeFragmentDescriptor_Z6839B9E8(fd, unwrap(graph), unwrap(context)), fragmentDescriptors));
+}
+function PersonConversion_composeAffiliation_Z721C83C5(affiliation) {
+  let arg;
+  try {
+    const matchValue = fromString(decoder, 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);
+  }
+}
+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$1(0, encoder(affiliation));
+  }
+}
+function PersonConversion_composeAddress_Z721C83C5(address) {
+  let matchValue;
+  try {
+    return matchValue = fromString(decoder, 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;
+  }
+}
+function PersonConversion_decomposeAddress_4E60E31B(address) {
+  if (typeof address === "string") {
+    return address;
+  } else if (address instanceof LDNode) {
+    return toString$1(0, encoder(address));
+  } else {
+    throw new Error("Address must be a string or a Json.LDNode");
+  }
+}
+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(matchValue);
+  }
+  const jobTitles = Option_fromSeq(ResizeArray_map(BaseTypes_composeDefinedTerm_ZDED3A0F, person.Roles));
+  const disambiguatingDescriptions = Option_fromSeq(ResizeArray_map(toString, 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), void 0, unwrap(affiliation_1), unwrap(person.EMail), unwrap(person.LastName), void 0, unwrap(jobTitles), unwrap(person.MidInitials), address_1, unwrap(disambiguatingDescriptions), unwrap(person.Fax), unwrap(person.Phone));
+}
+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 ? void 0 : PersonConversion_decomposeAddress_4E60E31B(value(matchValue_1));
+  } else {
+    address = value(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);
+}
+function ScholarlyArticleConversion_composeAuthor_Z721C83C5(author) {
+  let arg;
+  try {
+    const matchValue = fromString(decoder, 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);
+  }
+}
+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(sb));
+            StringBuilder__Clear(sb);
+          } else {
+            StringBuilder__Append_244C7CD6(sb, c);
+          }
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  void authors.push(toString(sb));
+  return authors;
+}
+function ScholarlyArticleConversion_composeAuthors_Z721C83C5(authors) {
+  const collection = map$2(ScholarlyArticleConversion_composeAuthor_Z721C83C5, ScholarlyArticleConversion_splitAuthors_Z721C83C5(authors));
+  return Array.from(collection);
+}
+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$1(0, encoder(author));
+  }
+}
+function ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(authors, context) {
+  return join(",", ResizeArray_map((a) => ScholarlyArticleConversion_decomposeAuthor_Z2F770004(a, unwrap(context)), authors));
+}
+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(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(publication.DOI) !== "" ? singleton$1(LDPropertyValue.createDOI(value(publication.DOI))) : empty$1(), delay(() => publication.PubMedID != null && value(publication.PubMedID) !== "" ? singleton$1(LDPropertyValue.createPubMedID(value(publication.PubMedID))) : empty$1())))));
+  const status = map(BaseTypes_composeDefinedTerm_ZDED3A0F, publication.Status);
+  return LDScholarlyArticle.create(title, identifiers, void 0, unwrap(authors_1), void 0, unwrap(status), unwrap(comments));
+}
+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(_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(_arg_1);
+  return Publication.create(unwrap(pubMedID), unwrap(doi), unwrap(authors), title, unwrap(status), comments);
+}
+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))), void 0, unwrap(fragments[0].TryGetContext()));
+    } else {
+      file = value(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))));
+}
+function AssayConversion_composeAssay_Z5C53FD5C(assay, fs) {
+  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_5E660E5C(new ArcTables(assay.Tables), assay.Identifier, void 0, unwrap(fs)), 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 ? void 0 : (fds_1 = value(fragmentDescriptors), fds_1) : fragmentDescriptors == null ? (vm_1 = value(variableMeasured), ResizeArray_singleton(vm_1)) : (fds = value(fragmentDescriptors), vm = value(variableMeasured), ResizeArray_appendSingleton(vm, fds));
+  const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, assay.Comments));
+  return LDDataset.createAssay(assay.Identifier, void 0, unwrap(assay.Title), unwrap(assay.Description), unwrap(creators), unwrap(dataFiles), unwrap(measurementMethod), unwrap(measurementTechnique), unwrap(variableMeasureds), unwrap(processSequence), unwrap(comments));
+}
+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);
+}
+function StudyConversion_composeStudy_ZFE0E38E(study, fs) {
+  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_5E660E5C(new ArcTables(study.Tables), void 0, study.Identifier, unwrap(fs)), 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, void 0, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), dateModified, unwrap(study.Description), unwrap(dataFiles), unwrap(study.Title), unwrap(publications), unwrap(fragmentDescriptors), unwrap(comments), void 0, unwrap(processSequence));
+}
+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, void 0, tables.Tables, unwrap(dataMap), void 0, comments);
+}
+function InvestigationConversion_composeInvestigation_5AEC717D(investigation, fs) {
+  let b;
+  let name;
+  const matchValue = investigation.Title;
+  if (matchValue == null) {
+    throw new Error("Investigation must have a title");
+  } else {
+    name = value(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((a_3) => AssayConversion_composeAssay_Z5C53FD5C(a_3, unwrap(fs)), investigation.Assays), ResizeArray_append(ResizeArray_map((s_2) => StudyConversion_composeStudy_ZFE0E38E(s_2, unwrap(fs)), investigation.Studies), b)));
+  const mentions = Option_fromSeq([]);
+  return LDDataset.createInvestigation(investigation.Identifier, name, void 0, unwrap(creators), unwrap(dateCreated), datePublished, void 0, unwrap(investigation.Description), unwrap(hasParts), unwrap(publications), unwrap(comments), unwrap(mentions));
+}
+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(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), void 0, publications, creators, assays, studies, void 0, void 0, void 0, comments);
+}
+function ARCtrl_ArcAssay__ArcAssay_ToROCrateAssay_1695DD5C(this$, fs) {
+  return AssayConversion_composeAssay_Z5C53FD5C(this$, unwrap(fs));
+}
+function ARCtrl_ArcAssay__ArcAssay_fromROCrateAssay_Static_Z6839B9E8(a, graph, context) {
+  return AssayConversion_decomposeAssay_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+function ARCtrl_ArcStudy__ArcStudy_ToROCrateStudy_1695DD5C(this$, fs) {
+  return StudyConversion_composeStudy_ZFE0E38E(this$, unwrap(fs));
+}
+function ARCtrl_ArcStudy__ArcStudy_fromROCrateStudy_Static_Z6839B9E8(a, graph, context) {
+  return StudyConversion_decomposeStudy_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+function ARCtrl_ArcInvestigation__ArcInvestigation_ToROCrateInvestigation_1695DD5C(this$, fs) {
+  return InvestigationConversion_composeInvestigation_5AEC717D(this$, unwrap(fs));
+}
+function ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8(a, graph, context) {
+  return InvestigationConversion_decomposeInvestigation_Z6839B9E8(a, unwrap(graph), unwrap(context));
+}
+class TypeExtensions_Conversion {
+  constructor() {
+  }
+  static arcAssayToDataset(a, fs) {
+    return ARCtrl_ArcAssay__ArcAssay_ToROCrateAssay_1695DD5C(a, unwrap(fs));
+  }
+  static datasetToArcAssay(a, graph, context) {
+    return ARCtrl_ArcAssay__ArcAssay_fromROCrateAssay_Static_Z6839B9E8(a, unwrap(graph), unwrap(context));
+  }
+  static arcStudyToDataset(a, fs) {
+    return ARCtrl_ArcStudy__ArcStudy_ToROCrateStudy_1695DD5C(a, unwrap(fs));
+  }
+  static datasetToArcStudy(a, graph, context) {
+    return ARCtrl_ArcStudy__ArcStudy_fromROCrateStudy_Static_Z6839B9E8(a, unwrap(graph), unwrap(context));
+  }
+  static arcInvestigationToDataset(a, fs) {
+    return ARCtrl_ArcInvestigation__ArcInvestigation_ToROCrateInvestigation_1695DD5C(a, unwrap(fs));
+  }
+  static datasetToArcInvestigation(a, graph, context) {
+    return ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8(a, unwrap(graph), unwrap(context));
+  }
+}
+
+export { ARCtrl_ArcAssay__ArcAssay_ToROCrateAssay_1695DD5C, ARCtrl_ArcAssay__ArcAssay_fromROCrateAssay_Static_Z6839B9E8, ARCtrl_ArcInvestigation__ArcInvestigation_ToROCrateInvestigation_1695DD5C, ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8, ARCtrl_ArcStudy__ArcStudy_ToROCrateStudy_1695DD5C, ARCtrl_ArcStudy__ArcStudy_fromROCrateStudy_Static_Z6839B9E8, ARCtrl_ArcTable__ArcTable_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586, ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4, AssayConversion_composeAssay_Z5C53FD5C, AssayConversion_decomposeAssay_Z6839B9E8, AssayConversion_getDataFilesFromProcesses_6BABD1B0, BaseTypes_cellOfPropertyValue_Z2F770004, BaseTypes_composeCharacteristicValue, BaseTypes_composeComment_Z13201A7E, BaseTypes_composeComponent, BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composeFactorValue, BaseTypes_composeFile_6CE21C7D, BaseTypes_composeFragmentDescriptor_Z4C0BEF62, BaseTypes_composeFreetextMaterialName, BaseTypes_composeParameterValue, BaseTypes_composeProcessInput, BaseTypes_composeProcessOutput, BaseTypes_composePropertyValueFromOA_ZDED3A0F, BaseTypes_decomposeCharacteristicValue_Z2F770004, BaseTypes_decomposeComment_Z2F770004, BaseTypes_decomposeComponent_Z2F770004, BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_decomposeFactorValue_Z2F770004, BaseTypes_decomposeFile_Z2F770004, BaseTypes_decomposeFragmentDescriptor_Z6839B9E8, BaseTypes_decomposeParameterValue_Z2F770004, BaseTypes_decomposeProcessInput_Z2F770004, BaseTypes_decomposeProcessOutput_Z2F770004, BaseTypes_decomposePropertyValueToOA_Z2F770004, BaseTypes_headerOntologyOfPropertyValue_Z2F770004, BaseTypes_ontologyTermFromNameAndID_40457300, BaseTypes_termOfHeader_6CAF647B, BaseTypes_tryOntologyTermFromNameAndID_40457300, BaseTypes_valuesOfCell_Z436420FE, ColumnIndex_orderName, ColumnIndex_setIndex, ColumnIndex_tryGetIndex, DatamapConversion_composeFragmentDescriptors_Z8923FA3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F, DateTime_toString, DateTime_tryFromString, InvestigationConversion_composeInvestigation_5AEC717D, InvestigationConversion_decomposeInvestigation_Z6839B9E8, PersonConversion_composeAddress_Z721C83C5, PersonConversion_composeAffiliation_Z721C83C5, PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposeAddress_4E60E31B, PersonConversion_decomposeAffiliation_Z2F770004, PersonConversion_decomposePerson_Z6839B9E8, ProcessConversion_composeProcessName, ProcessConversion_decomposeProcessName_Z721C83C5, ProcessConversion_getProcessGetter, ProcessConversion_groupProcesses_Z27F0B586, ProcessConversion_processToRows_Z6839B9E8, ProcessConversion_tryCharacteristicGetter, ProcessConversion_tryComponentGetter, ProcessConversion_tryFactorGetter, ProcessConversion_tryGetCommentGetter, ProcessConversion_tryGetInputGetter, ProcessConversion_tryGetOutputGetter, ProcessConversion_tryGetPerformerGetter, ProcessConversion_tryGetProtocolDescriptionGetter, ProcessConversion_tryGetProtocolREFGetter, ProcessConversion_tryGetProtocolTypeGetter, ProcessConversion_tryGetProtocolType_Z6839B9E8, ProcessConversion_tryGetProtocolURIGetter, ProcessConversion_tryGetProtocolVersionGetter, ProcessConversion_tryParameterGetter, ScholarlyArticleConversion_composeAuthor_Z721C83C5, ScholarlyArticleConversion_composeAuthors_Z721C83C5, ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, ScholarlyArticleConversion_decomposeAuthor_Z2F770004, ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5, ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8, ScholarlyArticleConversion_splitAuthors_Z721C83C5, StudyConversion_composeStudy_ZFE0E38E, StudyConversion_decomposeStudy_Z6839B9E8, TypeExtensions_Conversion };