@nfdi4plants/arctrl 3.0.0-alpha.4 → 3.0.0-beta.10

package/dist/ts/ts/Core/Table/ArcTable.js

@@ -0,0 +1,898 @@
+import { getEnumerator, disposeSafe, comparePrimitives, equals, safeHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { CompositeCell, CompositeCell_Term, CompositeCell_FreeText } from './CompositeCell.js';
+import { SanityChecks_validateCellColumns, ArcTableValues, SanityChecks_validateArcTableValues, Unchecked_tryGetCellAt, SanityChecks_validateColumnIndex, SanityChecks_validateRowIndex, Unchecked_getCellWithDefault, Unchecked_setCellAt, tryFindDuplicateUnique, SanityChecks_validateColumn, Unchecked_addColumn, Unchecked_addColumnFill, Unchecked_removeHeader, Unchecked_removeColumnCells, tryFindDuplicateUniqueInArray, Unchecked_removeColumnCells_withIndexChange, getEmptyCellForHeader, Unchecked_moveColumnTo, Unchecked_addRow, Unchecked_addEmptyRow, Unchecked_addRows, Unchecked_removeRowCells_withIndexChange, Unchecked_alignByHeaders } from './ArcTableAux.js';
+import { CompositeHeader_ProtocolType, CompositeHeader_ProtocolVersion, CompositeHeader_ProtocolUri, CompositeHeader_ProtocolDescription, CompositeHeader_ProtocolREF } from './CompositeHeader.js';
+import { defaultArg, unwrap, value, map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toArray, delay, map, removeAt, iterate as iterate$1, tryFindIndex, length, collect, singleton, choose, indexed, toList, mapIndexed, append as append$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { CompositeColumn } from './CompositeColumn.js';
+import { rangeDouble } from '../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { ResizeArray_map, ResizeArray_iteri, ResizeArray_singleton, ResizeArray_iter, ResizeArray_init, ResizeArray_choose, ResizeArray_mapi, ResizeArray_groupBy, ResizeArray_indexed } from '../Helper/Collections.js';
+import { isEmpty, iterate, append } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { StringBuilder_$ctor, StringBuilder__AppendLine_Z721C83C5 } from '../../../node_modules/@fable-org/fable-library-js/System.Text.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { sortDescending } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { getItemFromDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { toFail, printf, join } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { boxHashArray, boxHashSeq } from '../Helper/HashCodes.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class ArcTable {
+  constructor(name, headers, columns) {
+    const headers_1 = defaultArg(headers, []);
+    const columns_1 = defaultArg(columns, []);
+    const valid = SanityChecks_validateCellColumns(headers_1, columns_1, true);
+    this._values = ArcTableValues.fromCellColumns(columns_1);
+    this._name = name;
+    this._headers = headers_1;
+  }
+  get ValueMap() {
+    const this$ = this;
+    return this$._values.ValueMap;
+  }
+  set ValueMap(valueMap) {
+    const this$ = this;
+    this$._values.ValueMap = valueMap;
+  }
+  get ColumnRefs() {
+    const this$ = this;
+    return this$._values.Columns;
+  }
+  set ColumnRefs(internalColumnRefs) {
+    const this$ = this;
+    this$._values.Columns = internalColumnRefs;
+  }
+  get Headers() {
+    const this$ = this;
+    return this$._headers;
+  }
+  set Headers(newHeaders) {
+    const this$ = this;
+    SanityChecks_validateArcTableValues(newHeaders, this$._values, true);
+    this$._headers = newHeaders;
+  }
+  get Values() {
+    const this$ = this;
+    return this$._values;
+  }
+  get Name() {
+    const this$ = this;
+    return this$._name;
+  }
+  set Name(newName) {
+    const this$ = this;
+    this$._name = newName;
+  }
+  static create(name, headers, values) {
+    return new ArcTable(name, headers, values);
+  }
+  static init(name) {
+    return new ArcTable(name, [], []);
+  }
+  static fromArcTableValues(name, headers, values) {
+    const t = ArcTable.init(name);
+    t.Headers = headers;
+    t.ValueMap = values.ValueMap;
+    t.ColumnRefs = values.Columns;
+    t.RowCount = values.RowCount | 0;
+    return t;
+  }
+  static createFromRows(name, headers, rows) {
+    const t = new ArcTable(name, headers);
+    t.AddRows(rows);
+    return t;
+  }
+  Validate(raiseException) {
+    const this$ = this;
+    const raiseException_1 = defaultArg(raiseException, true);
+    return SanityChecks_validateArcTableValues(this$.Headers, this$.Values, raiseException_1);
+  }
+  static validate(raiseException) {
+    return (table) => table.Validate(unwrap(raiseException));
+  }
+  get ColumnCount() {
+    const this$ = this;
+    return this$.Headers.length | 0;
+  }
+  static columnCount(table) {
+    return table.ColumnCount;
+  }
+  get RowCount() {
+    const this$ = this;
+    return this$._values.RowCount | 0;
+  }
+  set RowCount(newRowCount) {
+    const this$ = this;
+    this$._values.RowCount = newRowCount | 0;
+  }
+  static rowCount(table) {
+    return table.RowCount;
+  }
+  static setRowCount(newRowCount) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.RowCount = newRowCount | 0;
+      return newTable;
+    };
+  }
+  get Columns() {
+    const this$ = this;
+    return Array.from(toArray(delay(() => map((i) => this$.GetColumn(i), rangeDouble(0, 1, this$.ColumnCount - 1)))));
+  }
+  Copy() {
+    const this$ = this;
+    const nextHeaders = ResizeArray_map((h) => h.Copy(), this$.Headers);
+    const nextValues = this$._values.Copy();
+    return ArcTable.fromArcTableValues(this$.Name, nextHeaders, nextValues);
+  }
+  TryGetCellAt(column, row) {
+    const this$ = this;
+    return Unchecked_tryGetCellAt(column, row, this$._values);
+  }
+  static tryGetCellAt(column, row) {
+    return (table) => table.TryGetCellAt(column, row);
+  }
+  GetCellAt(column, row) {
+    const this$ = this;
+    SanityChecks_validateColumnIndex(column, this$.ColumnCount, false);
+    SanityChecks_validateRowIndex(row, this$.RowCount, false);
+    return Unchecked_getCellWithDefault(column, row, this$._headers, this$._values);
+  }
+  static getCellAt(column, row) {
+    return (table) => table.GetCellAt(column, row);
+  }
+  IterColumns(action) {
+    const this$ = this;
+    for (let columnIndex = 0; columnIndex <= this$.ColumnCount - 1; columnIndex++) {
+      action(this$.GetColumn(columnIndex));
+    }
+  }
+  static iterColumns(action) {
+    return (table) => {
+      const copy = table.Copy();
+      copy.IterColumns(action);
+      return copy;
+    };
+  }
+  IteriColumns(action) {
+    const this$ = this;
+    for (let columnIndex = 0; columnIndex <= this$.ColumnCount - 1; columnIndex++) {
+      action(columnIndex, this$.GetColumn(columnIndex));
+    }
+  }
+  static iteriColumns(action) {
+    return (table) => {
+      const copy = table.Copy();
+      copy.IteriColumns(action);
+      return copy;
+    };
+  }
+  UpdateCellAt(columnIndex, rowIndex, c, skipValidation) {
+    const this$ = this;
+    if (!defaultArg(skipValidation, false)) {
+      SanityChecks_validateColumnIndex(columnIndex, this$.ColumnCount, false);
+      SanityChecks_validateRowIndex(rowIndex, this$.RowCount, false);
+      c.ValidateAgainstHeader(this$.Headers[columnIndex], true);
+    }
+    Unchecked_setCellAt(columnIndex, rowIndex, c, this$._values);
+  }
+  static updateCellAt(columnIndex, rowIndex, cell, skipValidation) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.UpdateCellAt(columnIndex, rowIndex, cell, unwrap(skipValidation));
+      return newTable;
+    };
+  }
+  SetCellAt(columnIndex, rowIndex, c, skipValidation) {
+    const this$ = this;
+    if (!defaultArg(skipValidation, false)) {
+      SanityChecks_validateColumnIndex(columnIndex, this$.ColumnCount, false);
+      c.ValidateAgainstHeader(this$.Headers[columnIndex], true);
+    }
+    Unchecked_setCellAt(columnIndex, rowIndex, c, this$._values);
+  }
+  static setCellAt(columnIndex, rowIndex, cell, skipValidation) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.SetCellAt(columnIndex, rowIndex, cell, unwrap(skipValidation));
+      return newTable;
+    };
+  }
+  UpdateCellsBy(f, skipValidation) {
+    const this$ = this;
+    const skipValidation_1 = defaultArg(skipValidation, false);
+    const enumerator = getEnumerator(this$._values);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const patternInput = kv[0];
+        const ri = patternInput[1] | 0;
+        const ci = patternInput[0] | 0;
+        const newCell = f(ci, ri, kv[1]);
+        if (!skipValidation_1) {
+          newCell.ValidateAgainstHeader(this$.Headers[ci], true);
+        }
+        Unchecked_setCellAt(ci, ri, newCell, this$._values);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  static updateCellsBy(f, skipValidation) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.UpdateCellsBy(f, unwrap(skipValidation));
+    };
+  }
+  UpdateCellBy(columnIndex, rowIndex, f, skipValidation) {
+    const this$ = this;
+    const skipValidation_1 = defaultArg(skipValidation, false);
+    if (!skipValidation_1) {
+      SanityChecks_validateColumnIndex(columnIndex, this$.ColumnCount, false);
+      SanityChecks_validateRowIndex(rowIndex, this$.RowCount, false);
+    }
+    const newCell = f(this$.GetCellAt(columnIndex, rowIndex));
+    if (!skipValidation_1) {
+      newCell.ValidateAgainstHeader(this$.Headers[columnIndex], true);
+    }
+    Unchecked_setCellAt(columnIndex, rowIndex, newCell, this$._values);
+  }
+  static updateCellBy(columnIndex, rowIndex, f, skipValidation) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.UpdateCellBy(columnIndex, rowIndex, f, unwrap(skipValidation));
+    };
+  }
+  UpdateHeader(index, newHeader, forceConvertCells) {
+    const this$ = this;
+    const forceConvertCells_1 = defaultArg(forceConvertCells, false);
+    SanityChecks_validateColumnIndex(index, this$.ColumnCount, false);
+    const header = newHeader;
+    const matchValue = tryFindDuplicateUnique(header, removeAt(index, this$.Headers));
+    if (matchValue != null) {
+      throw new Error(`Invalid input. Tried setting unique header \`${header}\`, but header of same type already exists at index ${value(matchValue)}.`);
+    }
+    const c = new CompositeColumn(newHeader, this$.GetColumn(index).Cells);
+    if (c.Validate()) {
+      let setHeader;
+      setHeader = this$.Headers[index] = newHeader;
+    } else if (forceConvertCells_1) {
+      const convertedCells = newHeader.IsTermColumn ? ResizeArray_map((c_1) => {
+        if (c_1.isFreeText) {
+          return c_1.ToTermCell();
+        } else {
+          return c_1;
+        }
+      }, c.Cells) : ResizeArray_map((c_2) => c_2.ToFreeTextCell(), c.Cells);
+      this$.UpdateColumn(index, newHeader, convertedCells);
+    } else {
+      throw new Error("Tried setting header for column with invalid type of cells. Set `forceConvertCells` flag to automatically convert cells into valid CompositeCell type.");
+    }
+  }
+  static updateHeader(index, header) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.UpdateHeader(index, header);
+      return newTable;
+    };
+  }
+  AddColumn(header, cells, index, forceReplace) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.ColumnCount) | 0;
+    const cells_1 = defaultArg(cells, []);
+    const forceReplace_1 = defaultArg(forceReplace, false);
+    SanityChecks_validateColumnIndex(index_1, this$.ColumnCount, true);
+    SanityChecks_validateColumn(CompositeColumn.create(header, cells_1));
+    Unchecked_addColumn(header, cells_1, index_1, forceReplace_1, false, this$.Headers, this$._values);
+  }
+  static addColumn(header, cells, index, forceReplace) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddColumn(header, unwrap(cells), unwrap(index), unwrap(forceReplace));
+      return newTable;
+    };
+  }
+  AddColumnFill(header, cell, index, forceReplace) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.ColumnCount) | 0;
+    const forceReplace_1 = defaultArg(forceReplace, false);
+    SanityChecks_validateColumnIndex(index_1, this$.ColumnCount, true);
+    SanityChecks_validateColumn(CompositeColumn.create(header, [cell]));
+    Unchecked_addColumnFill(header, cell, index_1, forceReplace_1, false, this$.Headers, this$._values);
+  }
+  static addColumnFill(header, cell, index, forceReplace) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddColumnFill(header, cell, unwrap(index), unwrap(forceReplace));
+      return newTable;
+    };
+  }
+  UpdateColumn(columnIndex, header, cells) {
+    const this$ = this;
+    SanityChecks_validateColumnIndex(columnIndex, this$.ColumnCount, false);
+    const column = CompositeColumn.create(header, unwrap(cells));
+    SanityChecks_validateColumn(column);
+    const header_1 = column.Header;
+    const matchValue = tryFindDuplicateUnique(header_1, removeAt(columnIndex, this$.Headers));
+    if (matchValue != null) {
+      throw new Error(`Invalid input. Tried setting unique header \`${header_1}\`, but header of same type already exists at index ${value(matchValue)}.`);
+    }
+    Unchecked_removeHeader(columnIndex, this$.Headers);
+    Unchecked_removeColumnCells(columnIndex, this$._values);
+    this$.Headers.splice(columnIndex, 0, column.Header);
+    ResizeArray_iteri((rowIndex, v) => {
+      Unchecked_setCellAt(columnIndex, rowIndex, v, this$._values);
+    }, column.Cells);
+  }
+  static updateColumn(columnIndex, header, cells) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.UpdateColumn(columnIndex, header, unwrap(cells));
+      return newTable;
+    };
+  }
+  InsertColumn(index, header, cells) {
+    const this$ = this;
+    this$.AddColumn(header, unwrap(cells), index, false);
+  }
+  static insertColumn(index, header, cells) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.InsertColumn(index, header, unwrap(cells));
+      return newTable;
+    };
+  }
+  AppendColumn(header, cells) {
+    const this$ = this;
+    this$.AddColumn(header, unwrap(cells), this$.ColumnCount, false);
+  }
+  static appendColumn(header, cells) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AppendColumn(header, unwrap(cells));
+      return newTable;
+    };
+  }
+  AddColumns(columns, index, forceReplace) {
+    const this$ = this;
+    let index_1 = defaultArg(index, this$.ColumnCount);
+    const forceReplace_1 = defaultArg(forceReplace, false);
+    SanityChecks_validateColumnIndex(index_1, this$.ColumnCount, true);
+    const duplicates = tryFindDuplicateUniqueInArray(map((x) => x.Header, columns));
+    if (!isEmpty(duplicates)) {
+      const sb = StringBuilder_$ctor();
+      StringBuilder__AppendLine_Z721C83C5(sb, "Found duplicate unique columns in `columns`.");
+      iterate((x_1) => {
+        StringBuilder__AppendLine_Z721C83C5(sb, `Duplicate \`${x_1.HeaderType}\` at index ${x_1.Index1} and ${x_1.Index2}.`);
+      }, duplicates);
+      throw new Error(toString(sb));
+    }
+    iterate$1((x_2) => {
+      SanityChecks_validateColumn(x_2);
+    }, columns);
+    iterate$1((col) => {
+      const prevHeadersCount = this$.Headers.length | 0;
+      Unchecked_addColumn(col.Header, col.Cells, index_1, forceReplace_1, false, this$.Headers, this$._values);
+      if (this$.Headers.length > prevHeadersCount) {
+        index_1 = index_1 + 1 | 0;
+      }
+    }, columns);
+  }
+  static addColumns(columns, index) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddColumns(columns, unwrap(index));
+      return newTable;
+    };
+  }
+  RemoveColumn(index) {
+    const this$ = this;
+    SanityChecks_validateColumnIndex(index, this$.ColumnCount, false);
+    const columnCount = this$.ColumnCount | 0;
+    Unchecked_removeHeader(index, this$.Headers);
+    Unchecked_removeColumnCells_withIndexChange(index, columnCount, this$._values);
+  }
+  static removeColumn(index) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.RemoveColumn(index);
+      return newTable;
+    };
+  }
+  RemoveColumns(indexArr) {
+    const this$ = this;
+    indexArr.forEach((index) => {
+      SanityChecks_validateColumnIndex(index, this$.ColumnCount, false);
+    });
+    const indexArr_1 = sortDescending(indexArr, {
+      Compare: comparePrimitives
+    });
+    indexArr_1.forEach((index_1) => {
+      this$.RemoveColumn(index_1);
+    });
+  }
+  static removeColumns(indexArr) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.RemoveColumns(indexArr);
+      return newTable;
+    };
+  }
+  GetColumn(columnIndex, failOnMissingCell) {
+    const this$ = this;
+    const failOnMissingCell_1 = defaultArg(failOnMissingCell, false);
+    SanityChecks_validateColumnIndex(columnIndex, this$.ColumnCount, false);
+    const h = this$.Headers[columnIndex];
+    const cells = [];
+    if (this$.RowCount !== 0) {
+      const col = getItemFromDict(this$._values.Columns, columnIndex);
+      if (col.tag === /* Sparse */
+      1) {
+        const vals = col.fields[0];
+        const emptyCell = getEmptyCellForHeader(h, void 0);
+        for (let rowIndex = 0; rowIndex <= this$.RowCount - 1; rowIndex++) {
+          if (vals.has(rowIndex)) {
+            void cells.push(getItemFromDict(this$._values.ValueMap, getItemFromDict(vals, rowIndex)));
+          } else if (failOnMissingCell_1) {
+            toFail(printf("Could not return column: Unable to find cell for index: (%i, %i)"))(columnIndex)(rowIndex);
+          } else {
+            void cells.push(emptyCell);
+          }
+        }
+      } else {
+        const valueHash = col.fields[0] | 0;
+        const c = getItemFromDict(this$._values.ValueMap, valueHash);
+        for (let i = 0; i <= this$.RowCount - 1; i++) {
+          void cells.push(c);
+        }
+      }
+    }
+    return CompositeColumn.create(h, cells);
+  }
+  static getColumn(index, failOnMissingCell) {
+    return (table) => table.GetColumn(index, unwrap(failOnMissingCell));
+  }
+  TryGetColumnByHeader(header, failOnMissingCell) {
+    const this$ = this;
+    return map$1((i) => this$.GetColumn(i, unwrap(failOnMissingCell)), tryFindIndex((x) => equals(x, header), this$.Headers));
+  }
+  static tryGetColumnByHeader(header, failOnMissingCell) {
+    return (table) => table.TryGetColumnByHeader(header, unwrap(failOnMissingCell));
+  }
+  TryGetColumnByHeaderBy(headerPredicate, failOnMissingCell) {
+    const this$ = this;
+    return map$1((i) => this$.GetColumn(i, unwrap(failOnMissingCell)), tryFindIndex(headerPredicate, this$.Headers));
+  }
+  static tryGetColumnByHeaderBy(headerPredicate, failOnMissingCell) {
+    return (table) => table.TryGetColumnByHeaderBy(headerPredicate, unwrap(failOnMissingCell));
+  }
+  GetColumnByHeader(header, failOnMissingCell) {
+    const this$ = this;
+    const matchValue = this$.TryGetColumnByHeader(header, unwrap(failOnMissingCell));
+    if (matchValue == null) {
+      const arg = this$.Name;
+      return toFail(printf("Unable to find column with header in table %s: %O"))(arg)(header);
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getColumnByHeader(header, failOnMissingCell) {
+    return (table) => table.GetColumnByHeader(header, unwrap(failOnMissingCell));
+  }
+  TryGetInputColumn() {
+    const this$ = this;
+    return map$1((i) => this$.GetColumn(i), tryFindIndex((x) => x.isInput, this$.Headers));
+  }
+  static tryGetInputColumn() {
+    return (table) => table.TryGetInputColumn();
+  }
+  GetInputColumn() {
+    const this$ = this;
+    const matchValue = this$.TryGetInputColumn();
+    if (matchValue == null) {
+      const arg = this$.Name;
+      return toFail(printf("Unable to find input column in table %s"))(arg);
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getInputColumn() {
+    return (table) => table.GetInputColumn();
+  }
+  TryGetOutputColumn() {
+    const this$ = this;
+    return map$1((i) => this$.GetColumn(i), tryFindIndex((x) => x.isOutput, this$.Headers));
+  }
+  static tryGetOutputColumn() {
+    return (table) => table.TryGetOutputColumn();
+  }
+  GetOutputColumn() {
+    const this$ = this;
+    const matchValue = this$.TryGetOutputColumn();
+    if (matchValue == null) {
+      const arg = this$.Name;
+      return toFail(printf("Unable to find output column in table %s"))(arg);
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getOutputColumn() {
+    return (table) => table.GetOutputColumn();
+  }
+  MoveColumn(startCol, endCol) {
+    const this$ = this;
+    if (startCol === endCol) {
+    } else if (startCol < 0 ? true : startCol >= this$.ColumnCount) {
+      toFail(printf("Cannt move column. Invalid start column index: %i"))(startCol);
+    } else if (endCol < 0 ? true : endCol >= this$.ColumnCount) {
+      toFail(printf("Cannt move column. Invalid end column index: %i"))(endCol);
+    } else {
+      Unchecked_moveColumnTo(startCol, endCol, this$.Headers, this$._values);
+    }
+  }
+  static moveColumn(startCol, endCol) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.MoveColumn(startCol, endCol);
+      return newTable;
+    };
+  }
+  AddRow(cells, index) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.RowCount) | 0;
+    SanityChecks_validateRowIndex(index_1, this$.RowCount, true);
+    if (cells != null) {
+      const cells_1 = value(cells);
+      const newCells = cells_1;
+      const columnCount = this$.ColumnCount | 0;
+      const newCellsCount = length(newCells) | 0;
+      if (columnCount === 0) {
+        throw new Error("Table contains no columns! Cannot add row to empty table!");
+      } else if (newCellsCount !== columnCount) {
+        throw new Error(`Cannot add a new row with ${newCellsCount} cells, as the table has ${columnCount} columns.`);
+      }
+      for (let columnIndex = 0; columnIndex <= this$.ColumnCount - 1; columnIndex++) {
+        const h = this$.Headers[columnIndex];
+        const column = CompositeColumn.create(h, [cells_1[columnIndex]]);
+        cells_1[columnIndex].ValidateAgainstHeader(h, true);
+      }
+      Unchecked_addRow(index_1, cells_1, this$.Headers, this$._values);
+    } else {
+      Unchecked_addEmptyRow(index_1, this$._values);
+    }
+  }
+  static addRow(cells, index) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddRow(unwrap(cells), unwrap(index));
+      return newTable;
+    };
+  }
+  UpdateRow(rowIndex, cells) {
+    const this$ = this;
+    SanityChecks_validateRowIndex(rowIndex, this$.RowCount, false);
+    const newCells = cells;
+    const columnCount = this$.RowCount | 0;
+    const newCellsCount = length(newCells) | 0;
+    if (columnCount === 0) {
+      throw new Error("Table contains no columns! Cannot add row to empty table!");
+    } else if (newCellsCount !== columnCount) {
+      throw new Error(`Cannot add a new row with ${newCellsCount} cells, as the table has ${columnCount} columns.`);
+    }
+    ResizeArray_iteri((i, cell) => {
+      const h = this$.Headers[i];
+      SanityChecks_validateColumn(CompositeColumn.create(h, ResizeArray_singleton(cell)));
+    }, cells);
+    ResizeArray_iteri((columnIndex, cell_1) => {
+      Unchecked_setCellAt(columnIndex, rowIndex, cell_1, this$._values);
+    }, cells);
+  }
+  static updateRow(rowIndex, cells) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.UpdateRow(rowIndex, cells);
+      return newTable;
+    };
+  }
+  AppendRow(cells) {
+    const this$ = this;
+    this$.AddRow(unwrap(cells), this$.RowCount);
+  }
+  static appendRow(cells) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AppendRow(unwrap(cells));
+      return newTable;
+    };
+  }
+  InsertRow(index, cells) {
+    const this$ = this;
+    this$.AddRow(unwrap(cells), index);
+  }
+  static insertRow(index, cells) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddRow(unwrap(cells), index);
+      return newTable;
+    };
+  }
+  AddRows(rows, index) {
+    const this$ = this;
+    let index_1 = defaultArg(index, this$.RowCount);
+    SanityChecks_validateRowIndex(index_1, this$.RowCount, true);
+    ResizeArray_iter((row) => {
+      const newCells = row;
+      const columnCount = this$.ColumnCount | 0;
+      const newCellsCount = length(newCells) | 0;
+      if (columnCount === 0) {
+        throw new Error("Table contains no columns! Cannot add row to empty table!");
+      } else if (newCellsCount !== columnCount) {
+        throw new Error(`Cannot add a new row with ${newCellsCount} cells, as the table has ${columnCount} columns.`);
+      }
+    }, rows);
+    let enumerator = getEnumerator(rows);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const row_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        for (let columnIndex = 0; columnIndex <= this$.ColumnCount - 1; columnIndex++) {
+          const h = this$.Headers[columnIndex];
+          row_1[columnIndex].ValidateAgainstHeader(h, true);
+        }
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    Unchecked_addRows(index_1, rows, this$.Headers, this$._values);
+  }
+  static addRows(rows, index) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddRows(rows, unwrap(index));
+      return newTable;
+    };
+  }
+  AddRowsEmpty(rowCount, index) {
+    const this$ = this;
+    let row;
+    const collection = toArray(delay(() => collect((columnIndex) => singleton(getEmptyCellForHeader(this$.Headers[columnIndex], Unchecked_tryGetCellAt(columnIndex, 0, this$._values))), rangeDouble(0, 1, this$.ColumnCount - 1))));
+    row = Array.from(collection);
+    const rows = ResizeArray_init(rowCount, (_arg) => row);
+    this$.AddRows(rows, unwrap(index));
+  }
+  static addRowsEmpty(rowCount, index) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.AddRowsEmpty(rowCount, unwrap(index));
+      return newTable;
+    };
+  }
+  RemoveRow(index) {
+    const this$ = this;
+    SanityChecks_validateRowIndex(index, this$.RowCount, false);
+    Unchecked_removeRowCells_withIndexChange(index, this$._values);
+  }
+  static removeRow(index) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.RemoveRow(index);
+      return newTable;
+    };
+  }
+  RemoveRows(indexArr) {
+    const this$ = this;
+    indexArr.forEach((index) => {
+      SanityChecks_validateRowIndex(index, this$.RowCount, false);
+    });
+    const indexArr_1 = sortDescending(indexArr, {
+      Compare: comparePrimitives
+    });
+    indexArr_1.forEach((index_1) => {
+      this$.RemoveRow(index_1);
+    });
+  }
+  static removeRows(indexArr) {
+    return (table) => {
+      const newTable = table.Copy();
+      newTable.RemoveColumns(indexArr);
+      return newTable;
+    };
+  }
+  GetRow(rowIndex, SkipValidation) {
+    const this$ = this;
+    if (!equals(SkipValidation, true)) {
+      SanityChecks_validateRowIndex(rowIndex, this$.RowCount, false);
+    }
+    const collection = toArray(delay(() => map((columnIndex) => this$.GetCellAt(columnIndex, rowIndex), rangeDouble(0, 1, this$.ColumnCount - 1))));
+    return Array.from(collection);
+  }
+  static getRow(index) {
+    return (table) => table.GetRow(index);
+  }
+  Join(table, index, joinOptions, forceReplace) {
+    const this$ = this;
+    const joinOptions_1 = defaultArg(joinOptions, "headers");
+    const forceReplace_1 = defaultArg(forceReplace, false);
+    let index_1 = defaultArg(index, this$.ColumnCount);
+    index_1 = (index_1 === -1 ? this$.ColumnCount : index_1) | 0;
+    SanityChecks_validateColumnIndex(index_1, this$.ColumnCount, true);
+    const onlyHeaders = equals(joinOptions_1, "headers");
+    let columns;
+    const pre = table.Columns;
+    columns = joinOptions_1 === "withUnit" ? ResizeArray_map((c_1) => {
+      const unitsOpt = c_1.TryGetColumnUnits();
+      if (unitsOpt == null) {
+        return new CompositeColumn(c_1.Header, []);
+      } else {
+        return new CompositeColumn(c_1.Header, ResizeArray_map((u) => CompositeCell.createUnitized("", u), value(unitsOpt)));
+      }
+    }, pre) : joinOptions_1 === "withValues" ? pre : ResizeArray_map((c) => new CompositeColumn(c.Header, []), pre);
+    const duplicates = tryFindDuplicateUniqueInArray(map((x) => x.Header, columns));
+    if (!isEmpty(duplicates)) {
+      const sb = StringBuilder_$ctor();
+      StringBuilder__AppendLine_Z721C83C5(sb, "Found duplicate unique columns in `columns`.");
+      iterate((x_1) => {
+        StringBuilder__AppendLine_Z721C83C5(sb, `Duplicate \`${x_1.HeaderType}\` at index ${x_1.Index1} and ${x_1.Index2}.`);
+      }, duplicates);
+      throw new Error(toString(sb));
+    }
+    ResizeArray_iter((x_2) => {
+      SanityChecks_validateColumn(x_2);
+    }, columns);
+    ResizeArray_iter((col) => {
+      const prevHeadersCount = this$.Headers.length | 0;
+      Unchecked_addColumn(col.Header, col.Cells, index_1, forceReplace_1, onlyHeaders, this$.Headers, this$._values);
+      if (this$.Headers.length > prevHeadersCount) {
+        index_1 = index_1 + 1 | 0;
+      }
+    }, columns);
+  }
+  static join(table, index, joinOptions, forceReplace) {
+    return (this$) => {
+      const copy = this$.Copy();
+      copy.Join(table, unwrap(index), unwrap(joinOptions), unwrap(forceReplace));
+      return copy;
+    };
+  }
+  AddProtocolTypeColumn(types, index, forceReplace) {
+    const this$ = this;
+    const cells = map$1((a) => ResizeArray_map(CompositeCell_Term, a), types);
+    this$.AddColumn(CompositeHeader_ProtocolType(), unwrap(cells), unwrap(index), unwrap(forceReplace));
+  }
+  AddProtocolVersionColumn(versions, index, forceReplace) {
+    const this$ = this;
+    const cells = map$1((a) => ResizeArray_map(CompositeCell_FreeText, a), versions);
+    this$.AddColumn(CompositeHeader_ProtocolVersion(), unwrap(cells), unwrap(index), unwrap(forceReplace));
+  }
+  AddProtocolUriColumn(uris, index, forceReplace) {
+    const this$ = this;
+    const cells = map$1((a) => ResizeArray_map(CompositeCell_FreeText, a), uris);
+    this$.AddColumn(CompositeHeader_ProtocolUri(), unwrap(cells), unwrap(index), unwrap(forceReplace));
+  }
+  AddProtocolDescriptionColumn(descriptions, index, forceReplace) {
+    const this$ = this;
+    const cells = map$1((a) => ResizeArray_map(CompositeCell_FreeText, a), descriptions);
+    this$.AddColumn(CompositeHeader_ProtocolDescription(), unwrap(cells), unwrap(index), unwrap(forceReplace));
+  }
+  AddProtocolNameColumn(names, index, forceReplace) {
+    const this$ = this;
+    const cells = map$1((a) => ResizeArray_map(CompositeCell_FreeText, a), names);
+    this$.AddColumn(CompositeHeader_ProtocolREF(), unwrap(cells), unwrap(index), unwrap(forceReplace));
+  }
+  GetProtocolTypeColumn() {
+    const this$ = this;
+    return this$.GetColumnByHeader(CompositeHeader_ProtocolType());
+  }
+  GetProtocolVersionColumn() {
+    const this$ = this;
+    return this$.GetColumnByHeader(CompositeHeader_ProtocolVersion());
+  }
+  GetProtocolUriColumn() {
+    const this$ = this;
+    return this$.GetColumnByHeader(CompositeHeader_ProtocolUri());
+  }
+  GetProtocolDescriptionColumn() {
+    const this$ = this;
+    return this$.GetColumnByHeader(CompositeHeader_ProtocolDescription());
+  }
+  GetProtocolNameColumn() {
+    const this$ = this;
+    return this$.GetColumnByHeader(CompositeHeader_ProtocolREF());
+  }
+  TryGetProtocolNameColumn() {
+    const this$ = this;
+    return this$.TryGetColumnByHeader(CompositeHeader_ProtocolREF());
+  }
+  GetComponentColumns() {
+    const this$ = this;
+    return ResizeArray_choose((h) => {
+      if (h.isComponent) {
+        return this$.GetColumnByHeader(h);
+      } else {
+        return void 0;
+      }
+    }, this$.Headers);
+  }
+  RescanValueMap() {
+    const this$ = this;
+    this$._values.RescanValueMap();
+  }
+  static SplitByColumnValues(columnIndex) {
+    return (table) => ResizeArray_mapi((i, indexGroup) => {
+      const headers = table.Headers;
+      const rows = ResizeArray_map((i_1) => table.GetRow(i_1, true), indexGroup);
+      return ArcTable.createFromRows(table.Name, headers, rows);
+    }, ResizeArray_map((tupledArg) => ResizeArray_map((tuple_1) => tuple_1[0], tupledArg[1]), ResizeArray_groupBy((tuple) => tuple[1], ResizeArray_indexed(table.GetColumn(columnIndex).Cells))));
+  }
+  static SplitByColumnValuesByHeader(header) {
+    return (table) => {
+      const index = tryFindIndex((x) => equals(x, header), table.Headers);
+      if (index == null) {
+        return ResizeArray_singleton(table.Copy());
+      } else {
+        const i = value(index) | 0;
+        return ArcTable.SplitByColumnValues(i)(table);
+      }
+    };
+  }
+  static get SplitByProtocolREF() {
+    return (table) => ArcTable.SplitByColumnValuesByHeader(CompositeHeader_ProtocolREF())(table);
+  }
+  static updateReferenceByAnnotationTable(refTable, annotationTable) {
+    const refTable_1 = refTable.Copy();
+    const annotationTable_1 = annotationTable.Copy();
+    const nonProtocolColumns = toArray(choose((tupledArg) => {
+      if (tupledArg[1].isProtocolColumn) {
+        return void 0;
+      } else {
+        return tupledArg[0];
+      }
+    }, indexed(refTable_1.Headers)));
+    refTable_1.RemoveColumns(nonProtocolColumns);
+    refTable_1.RowCount = annotationTable_1.RowCount | 0;
+    let enumerator = getEnumerator(annotationTable_1.Columns);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        refTable_1.AddColumn(c.Header, c.Cells, void 0, true);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    return refTable_1;
+  }
+  static append(table1, table2) {
+    const getList = (t) => toList(delay(() => map((row) => toList(mapIndexed((i, c) => [t.Headers[i], c], t.GetRow(row, true))), rangeDouble(0, 1, t.RowCount - 1))));
+    const patternInput = Unchecked_alignByHeaders(false, append(getList(table1), getList(table2)));
+    return ArcTable.fromArcTableValues(table1.Name, patternInput[0], patternInput[1]);
+  }
+  toString() {
+    const this$ = this;
+    const rowCount = this$.RowCount | 0;
+    return join("\n", toList(delay(() => append$1(singleton(`Table: ${this$.Name}`), delay(() => append$1(singleton("-------------"), delay(() => append$1(singleton(join("	|	", map(toString, this$.Headers))), delay(() => rowCount > 50 ? append$1(map((rowI) => join("	|	", map(toString, this$.GetRow(rowI))), rangeDouble(0, 1, 19)), delay(() => append$1(singleton("..."), delay(() => map((rowI_1) => join("	|	", map(toString, this$.GetRow(rowI_1))), rangeDouble(rowCount - 20, 1, rowCount - 1)))))) : rowCount === 0 ? singleton("No rows") : map((rowI_2) => join("	|	", map(toString, this$.GetRow(rowI_2))), rangeDouble(0, 1, rowCount - 1)))))))))));
+  }
+  StructurallyEquals(other) {
+    const this$ = this;
+    return safeHash(this$) === safeHash(other);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  Equals(other) {
+    let table;
+    const this$ = this;
+    return other instanceof ArcTable && (table = other, this$.StructurallyEquals(table));
+  }
+  GetHashCode() {
+    const this$ = this;
+    const vHash = safeHash(this$._values) | 0;
+    return boxHashArray([this$.Name, boxHashSeq(this$.Headers), vHash]) | 0;
+  }
+}
+function ArcTable_$reflection() {
+  return class_type("ARCtrl.ArcTable", void 0, ArcTable);
+}
+function ArcTable_$ctor_2D310C9B(name, headers, columns) {
+  return new ArcTable(name, headers, columns);
+}
+
+export { ArcTable, ArcTable_$ctor_2D310C9B, ArcTable_$reflection };