@nfdi4plants/arctrl 1.2.0 → 2.0.0-alpha.2

package/Core/Table/ArcTableAux.js

@@ -0,0 +1,532 @@
+import { head as head_1, toArray, filter, tryFindIndex, maxBy } from "../../fable_modules/fable-library-js.4.16.0/Seq.js";
+import { arrayHash, equalArrays, numberHash, disposeSafe, getEnumerator, compare, equals, safeHash, comparePrimitives } from "../../fable_modules/fable-library-js.4.16.0/Util.js";
+import { addToDict, getItemFromDict } from "../../fable_modules/fable-library-js.4.16.0/MapUtil.js";
+import { value as value_2 } from "../../fable_modules/fable-library-js.4.16.0/Option.js";
+import { mapIndexed, pick, exists, ofSeq, empty, head, tail as tail_1, isEmpty, cons } from "../../fable_modules/fable-library-js.4.16.0/List.js";
+import { printf, toConsole } from "../../fable_modules/fable-library-js.4.16.0/String.js";
+import { List_tryPickAndRemove, Dictionary_tryFind } from "../Helper/Collections.js";
+import { CompositeCell } from "./CompositeCell.js";
+import { max } from "../../fable_modules/fable-library-js.4.16.0/Double.js";
+import { item, map, iterateIndexed } from "../../fable_modules/fable-library-js.4.16.0/Array.js";
+import { tryFind, ofArray } from "../../fable_modules/fable-library-js.4.16.0/Map.js";
+import { Array_groupBy } from "../../fable_modules/fable-library-js.4.16.0/Seq2.js";
+import { FSharpSet__Contains, ofArray as ofArray_1 } from "../../fable_modules/fable-library-js.4.16.0/Set.js";
+import { toString } from "../../fable_modules/fable-library-js.4.16.0/Types.js";
+import { Dictionary } from "../../fable_modules/fable-library-js.4.16.0/MutableMap.js";
+
+export function getColumnCount(headers) {
+    return headers.length;
+}
+
+export function getRowCount(values) {
+    if (values.size === 0) {
+        return 0;
+    }
+    else {
+        return (1 + maxBy((tuple) => tuple[1], values.keys(), {
+            Compare: comparePrimitives,
+        })[1]) | 0;
+    }
+}
+
+export function boxHashValues(colCount, values) {
+    let hash = 0;
+    const rowCount = getRowCount(values) | 0;
+    for (let col = 0; col <= (colCount - 1); col++) {
+        for (let row = 0; row <= (rowCount - 1); row++) {
+            hash = ((((-1640531527 + safeHash(getItemFromDict(values, [col, row]))) + (hash << 6)) + (hash >> 2)) | 0);
+        }
+    }
+    return hash;
+}
+
+export function $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, input) {
+    switch (input.tag) {
+        case 3:
+        case 2:
+        case 1:
+        case 0:
+        case 13:
+            return void 0;
+        case 12:
+            return tryFindIndex((h) => (h.tag === 12), existingHeaders);
+        case 11:
+            return tryFindIndex((h_1) => (h_1.tag === 11), existingHeaders);
+        default:
+            return tryFindIndex((h_2) => equals(h_2, input), existingHeaders);
+    }
+}
+
+/**
+ * Returns the column index of the duplicate unique column in `existingHeaders`.
+ */
+export function tryFindDuplicateUnique(newHeader, existingHeaders) {
+    const activePatternResult = $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, newHeader);
+    if (activePatternResult != null) {
+        const index = activePatternResult | 0;
+        return index;
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * Returns the column index of the duplicate unique column in `existingHeaders`.
+ */
+export function tryFindDuplicateUniqueInArray(existingHeaders) {
+    const loop = (i_mut, duplicateList_mut, headerList_mut) => {
+        loop:
+        while (true) {
+            const i = i_mut, duplicateList = duplicateList_mut, headerList = headerList_mut;
+            let matchResult, header, tail;
+            if (isEmpty(headerList)) {
+                matchResult = 0;
+            }
+            else if (isEmpty(tail_1(headerList))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+                header = head(headerList);
+                tail = tail_1(headerList);
+            }
+            switch (matchResult) {
+                case 0:
+                    return duplicateList;
+                default: {
+                    const hasDuplicate = tryFindDuplicateUnique(header, tail);
+                    i_mut = (i + 1);
+                    duplicateList_mut = ((hasDuplicate != null) ? cons({
+                        HeaderType: header,
+                        Index1: i,
+                        Index2: value_2(hasDuplicate),
+                    }, duplicateList) : duplicateList);
+                    headerList_mut = tail;
+                    continue loop;
+                }
+            }
+            break;
+        }
+    };
+    return loop(0, empty(), ofSeq(filter((x) => !x.IsTermColumn, existingHeaders)));
+}
+
+/**
+ * Checks if given column index is valid for given number of columns.
+ * 
+ * if `allowAppend` = true => `0 < index <= columnCount`
+ * 
+ * if `allowAppend` = false => `0 < index < columnCount`
+ */
+export function SanityChecks_validateColumnIndex(index, columnCount, allowAppend) {
+    let x, y;
+    if (index < 0) {
+        throw new Error("Cannot insert CompositeColumn at index < 0.");
+    }
+    if ((x = (index | 0), (y = (columnCount | 0), allowAppend ? (compare(x, y) > 0) : (compare(x, y) >= 0)))) {
+        throw new Error(`Specified index is out of table range! Table contains only ${columnCount} columns.`);
+    }
+}
+
+/**
+ * Checks if given index is valid for given number of rows.
+ * 
+ * if `allowAppend` = true => `0 < index <= rowCount`
+ * 
+ * if `allowAppend` = false => `0 < index < rowCount`
+ */
+export function SanityChecks_validateRowIndex(index, rowCount, allowAppend) {
+    let x, y;
+    if (index < 0) {
+        throw new Error("Cannot insert CompositeColumn at index < 0.");
+    }
+    if ((x = (index | 0), (y = (rowCount | 0), allowAppend ? (compare(x, y) > 0) : (compare(x, y) >= 0)))) {
+        throw new Error(`Specified index is out of table range! Table contains only ${rowCount} rows.`);
+    }
+}
+
+export function SanityChecks_validateColumn(column) {
+    column.Validate(true);
+}
+
+export function SanityChecks_validate(headers, values, raiseException) {
+    let clo;
+    let isValid = true;
+    let en = getEnumerator(values);
+    while (isValid && en["System.Collections.IEnumerator.MoveNext"]()) {
+        let matchValue;
+        let copyOfStruct = en["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        matchValue = copyOfStruct[0];
+        let cell;
+        let copyOfStruct_1 = en["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        cell = copyOfStruct_1[1];
+        const header = headers[matchValue[0]];
+        if (!header.IsTermColumn && !cell.isFreeText) {
+            (raiseException ? ((message) => {
+                throw new Error(message);
+            }) : ((clo = toConsole(printf("%s")), (arg) => {
+                clo(arg);
+            })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`.`);
+            isValid = false;
+        }
+    }
+    return isValid;
+}
+
+export function Unchecked_tryGetCellAt(column, row, cells) {
+    return Dictionary_tryFind([column, row], cells);
+}
+
+/**
+ * Add or update a cell in the dictionary.
+ */
+export function Unchecked_setCellAt(columnIndex, rowIndex, c, cells) {
+    cells.set([columnIndex, rowIndex], c);
+}
+
+/**
+ * Add a cell to the dictionary. If a cell already exists at the given position, it fails.
+ */
+export function Unchecked_addCellAt(columnIndex, rowIndex, c, cells) {
+    addToDict(cells, [columnIndex, rowIndex], c);
+}
+
+export function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, cells) {
+    const matchValue = Dictionary_tryFind([fromCol, fromRow], cells);
+    if (matchValue == null) {
+    }
+    else {
+        const c = matchValue;
+        cells.delete([fromCol, fromRow]);
+        const value_1 = Unchecked_setCellAt(toCol, toRow, c, cells);
+    }
+}
+
+export function Unchecked_removeHeader(index, headers) {
+    headers.splice(index, 1);
+}
+
+/**
+ * Remove cells of one Column, change index of cells with higher index to index - 1
+ */
+export function Unchecked_removeColumnCells(index, cells) {
+    let enumerator = getEnumerator(cells);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const c = activePatternResult[0][0] | 0;
+            if (c === index) {
+                cells.delete([c, activePatternResult[0][1]]);
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+
+/**
+ * Remove cells of one Column, change index of cells with higher index to index - 1
+ */
+export function Unchecked_removeColumnCells_withIndexChange(index, columnCount, rowCount, cells) {
+    for (let col = index; col <= (columnCount - 1); col++) {
+        for (let row = 0; row <= (rowCount - 1); row++) {
+            if (col === index) {
+                cells.delete([col, row]);
+            }
+            else if (col > index) {
+                Unchecked_moveCellTo(col, row, col - 1, row, cells);
+            }
+        }
+    }
+}
+
+export function Unchecked_removeRowCells(rowIndex, cells) {
+    let enumerator = getEnumerator(cells);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const r = activePatternResult[0][1] | 0;
+            if (r === rowIndex) {
+                cells.delete([activePatternResult[0][0], r]);
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+
+/**
+ * Remove cells of one Row, change index of cells with higher index to index - 1
+ */
+export function Unchecked_removeRowCells_withIndexChange(rowIndex, columnCount, rowCount, cells) {
+    for (let row = rowIndex; row <= (rowCount - 1); row++) {
+        for (let col = 0; col <= (columnCount - 1); col++) {
+            if (row === rowIndex) {
+                cells.delete([col, row]);
+            }
+            else if (row > rowIndex) {
+                Unchecked_moveCellTo(col, row, col, row - 1, cells);
+            }
+        }
+    }
+}
+
+/**
+ * Get an empty cell fitting for related column header.
+ * 
+ * `columCellOption` is used to decide between `CompositeCell.Term` or `CompositeCell.Unitized`. `columCellOption` can be any other cell in the same column, preferably the first one.
+ */
+export function Unchecked_getEmptyCellForHeader(header, columCellOption) {
+    const matchValue = header.IsTermColumn;
+    if (matchValue) {
+        let matchResult;
+        if (columCellOption == null) {
+            matchResult = 0;
+        }
+        else {
+            switch (columCellOption.tag) {
+                case 0: {
+                    matchResult = 0;
+                    break;
+                }
+                case 2: {
+                    matchResult = 1;
+                    break;
+                }
+                default:
+                    matchResult = 2;
+            }
+        }
+        switch (matchResult) {
+            case 0:
+                return CompositeCell.emptyTerm;
+            case 1:
+                return CompositeCell.emptyUnitized;
+            default:
+                throw new Error("[extendBodyCells] This should never happen, IsTermColumn header must be paired with either term or unitized cell.");
+        }
+    }
+    else {
+        return CompositeCell.emptyFreeText;
+    }
+}
+
+/**
+ * 
+ */
+export function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeaders, headers, values) {
+    let numberOfNewColumns = 1;
+    let index_1 = index;
+    const hasDuplicateUnique = tryFindDuplicateUnique(newHeader, headers);
+    if (!forceReplace && (hasDuplicateUnique != null)) {
+        throw new Error(`Invalid new column \`${newHeader}\`. Table already contains header of the same type on index \`${value_2(hasDuplicateUnique)}\``);
+    }
+    if (hasDuplicateUnique != null) {
+        numberOfNewColumns = 0;
+        index_1 = (value_2(hasDuplicateUnique) | 0);
+    }
+    const matchValue = getColumnCount(headers) | 0;
+    const matchValue_1 = getRowCount(values) | 0;
+    const startColCount = matchValue | 0;
+    if (hasDuplicateUnique != null) {
+        Unchecked_removeHeader(index_1, headers);
+    }
+    headers.splice(index_1, 0, newHeader);
+    if ((index_1 < startColCount) && (hasDuplicateUnique == null)) {
+        const lastColumnIndex = max(startColCount - 1, 0) | 0;
+        for (let columnIndex = lastColumnIndex; columnIndex >= index_1; columnIndex--) {
+            for (let rowIndex = 0; rowIndex <= matchValue_1; rowIndex++) {
+                Unchecked_moveCellTo(columnIndex, rowIndex, columnIndex + numberOfNewColumns, rowIndex, values);
+            }
+        }
+    }
+    if (!onlyHeaders) {
+        if (hasDuplicateUnique != null) {
+            Unchecked_removeColumnCells(index_1, values);
+        }
+        const f = (index_1 >= startColCount) ? ((tupledArg) => ((values_1) => {
+            const value = addToDict(values_1, [tupledArg[0], tupledArg[1]], tupledArg[2]);
+        })) : ((tupledArg_1) => ((cells) => {
+            Unchecked_setCellAt(tupledArg_1[0], tupledArg_1[1], tupledArg_1[2], cells);
+        }));
+        iterateIndexed((rowIndex_3, cell_1) => {
+            f([index_1, rowIndex_3, cell_1])(values);
+        }, newCells);
+    }
+}
+
+export function Unchecked_fillMissingCells(headers, values) {
+    let col;
+    const rowCount = getRowCount(values) | 0;
+    const columnCount = getColumnCount(headers) | 0;
+    const columnKeyGroups = ofArray(Array_groupBy((tuple) => tuple[0], toArray(values.keys()), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: numberHash,
+    }), {
+        Compare: comparePrimitives,
+    });
+    for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
+        const header = headers[columnIndex];
+        const matchValue = tryFind(columnIndex, columnKeyGroups);
+        if (matchValue == null) {
+            const defaultCell_1 = Unchecked_getEmptyCellForHeader(header, void 0);
+            for (let rowIndex_1 = 0; rowIndex_1 <= (rowCount - 1); rowIndex_1++) {
+                Unchecked_addCellAt(columnIndex, rowIndex_1, defaultCell_1, values);
+            }
+        }
+        else if ((col = matchValue, col.length === rowCount)) {
+            const col_1 = matchValue;
+        }
+        else {
+            const col_2 = matchValue;
+            const defaultCell = Unchecked_getEmptyCellForHeader(header, getItemFromDict(values, head_1(col_2)));
+            const rowKeys = ofArray_1(map((tuple_1) => tuple_1[1], col_2, Int32Array), {
+                Compare: comparePrimitives,
+            });
+            for (let rowIndex = 0; rowIndex <= (rowCount - 1); rowIndex++) {
+                if (!FSharpSet__Contains(rowKeys, rowIndex)) {
+                    Unchecked_addCellAt(columnIndex, rowIndex, defaultCell, values);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Increases the table size to the given new row count and fills the new rows with the last value of the column
+ */
+export function Unchecked_extendToRowCount(rowCount, headers, values) {
+    const columnCount = getColumnCount(headers) | 0;
+    const previousRowCount = getRowCount(values) | 0;
+    for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
+        const lastValue = getItemFromDict(values, [columnIndex, previousRowCount - 1]);
+        for (let rowIndex = previousRowCount - 1; rowIndex <= (rowCount - 1); rowIndex++) {
+            Unchecked_setCellAt(columnIndex, rowIndex, lastValue, values);
+        }
+    }
+}
+
+export function Unchecked_addRow(index, newCells, headers, values) {
+    const rowCount = getRowCount(values) | 0;
+    const columnCount = getColumnCount(headers) | 0;
+    let increaseRowIndices;
+    if (index < rowCount) {
+        const lastRowIndex = max(rowCount - 1, 0) | 0;
+        for (let rowIndex = lastRowIndex; rowIndex >= index; rowIndex--) {
+            for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
+                Unchecked_moveCellTo(columnIndex, rowIndex, columnIndex, rowIndex + 1, values);
+            }
+        }
+    }
+    else {
+        increaseRowIndices = void 0;
+    }
+    const setNewCells = iterateIndexed((columnIndex_1, cell) => {
+        Unchecked_setCellAt(columnIndex_1, index, cell, values);
+    }, newCells);
+}
+
+export function Unchecked_addRows(index, newRows, headers, values) {
+    const rowCount = getRowCount(values) | 0;
+    const columnCount = getColumnCount(headers) | 0;
+    const numNewRows = newRows.length | 0;
+    let increaseRowIndices;
+    if (index < rowCount) {
+        const lastRowIndex = max(rowCount - 1, 0) | 0;
+        for (let rowIndex = lastRowIndex; rowIndex >= index; rowIndex--) {
+            for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
+                Unchecked_moveCellTo(columnIndex, rowIndex, columnIndex, rowIndex + numNewRows, values);
+            }
+        }
+    }
+    else {
+        increaseRowIndices = void 0;
+    }
+    let currentRowIndex = index;
+    for (let idx = 0; idx <= (newRows.length - 1); idx++) {
+        const setNewCells = iterateIndexed((columnIndex_1, cell) => {
+            Unchecked_setCellAt(columnIndex_1, currentRowIndex, cell, values);
+        }, item(idx, newRows));
+        currentRowIndex = ((currentRowIndex + 1) | 0);
+    }
+}
+
+/**
+ * Returns true, if two composite headers share the same main header string
+ */
+export function Unchecked_compositeHeaderMainColumnEqual(ch1, ch2) {
+    return toString(ch1) === toString(ch2);
+}
+
+/**
+ * From a list of rows consisting of headers and values, creates a list of combined headers and the values as a sparse matrix
+ * 
+ * The values cant be directly taken as they are, as there is no guarantee that the headers are aligned
+ * 
+ * This function aligns the headers and values by the main header string
+ * 
+ * If keepOrder is true, the order of values per row is kept intact, otherwise the values are allowed to be reordered
+ */
+export function Unchecked_alignByHeaders(keepOrder, rows) {
+    const headers = [];
+    const values = new Dictionary([], {
+        Equals: equalArrays,
+        GetHashCode: arrayHash,
+    });
+    const loop = (colI_mut, rows_2_mut) => {
+        loop:
+        while (true) {
+            const colI = colI_mut, rows_2 = rows_2_mut;
+            if (!exists((arg) => !isEmpty(arg), rows_2)) {
+                return [headers, values];
+            }
+            else {
+                const firstElem = pick((l) => (isEmpty(l) ? void 0 : head(l)), rows_2)[0];
+                void (headers.push(firstElem));
+                colI_mut = (colI + 1);
+                rows_2_mut = mapIndexed((rowI, l_1) => {
+                    if (keepOrder) {
+                        if (!isEmpty(l_1)) {
+                            if (Unchecked_compositeHeaderMainColumnEqual(head(l_1)[0], firstElem)) {
+                                addToDict(values, [colI, rowI], head(l_1)[1]);
+                                return tail_1(l_1);
+                            }
+                            else {
+                                return l_1;
+                            }
+                        }
+                        else {
+                            return empty();
+                        }
+                    }
+                    else {
+                        const patternInput = List_tryPickAndRemove((tupledArg) => {
+                            if (Unchecked_compositeHeaderMainColumnEqual(tupledArg[0], firstElem)) {
+                                return tupledArg[1];
+                            }
+                            else {
+                                return void 0;
+                            }
+                        }, l_1);
+                        const newL = patternInput[1];
+                        const firstMatch = patternInput[0];
+                        if (firstMatch == null) {
+                            return newL;
+                        }
+                        else {
+                            addToDict(values, [colI, rowI], firstMatch);
+                            return newL;
+                        }
+                    }
+                }, rows_2);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(0, rows);
+}
+

package/{ISA/ISA/ArcTypes → Core/Table}/ArcTables.js

@@ -1,17 +1,16 @@
-import { append, toArray, reduce, choose, map as map_1, delay, toList, length, findIndex, tryFindIndex } from "../../../fable_modules/fable-library-js.4.13.0/Seq.js";
-import { Dict_tryFind } from "../Helper.js";
-import { addToSet, addToDict } from "../../../fable_modules/fable-library-js.4.13.0/MapUtil.js";
-import { toIterator, equals, comparePrimitives, stringHash, compare, disposeSafe, getEnumerator } from "../../../fable_modules/fable-library-js.4.13.0/Util.js";
-import { bind, map as map_3, unwrap, defaultArg, value as value_2 } from "../../../fable_modules/fable-library-js.4.13.0/Option.js";
-import { collect as collect_1, map as map_4, item, insertRangeInPlace, fold } from "../../../fable_modules/fable-library-js.4.13.0/Array.js";
+import { append, toArray, reduce, choose, map as map_1, delay, toList, length, findIndex, tryFindIndex } from "../../fable_modules/fable-library-js.4.16.0/Seq.js";
+import { Dictionary_tryFind } from "../Helper/Collections.js";
+import { addToSet, addToDict } from "../../fable_modules/fable-library-js.4.16.0/MapUtil.js";
+import { toIterator, equals, comparePrimitives, stringHash, compare, disposeSafe, getEnumerator } from "../../fable_modules/fable-library-js.4.16.0/Util.js";
+import { bind, map as map_2, unwrap, defaultArg, value as value_2 } from "../../fable_modules/fable-library-js.4.16.0/Option.js";
+import { collect, map as map_3, item, insertRangeInPlace, fold } from "../../fable_modules/fable-library-js.4.16.0/Array.js";
 import { CompositeHeader } from "./CompositeHeader.js";
-import { Array_groupBy, distinct } from "../../../fable_modules/fable-library-js.4.13.0/Seq2.js";
-import { FSharpSet__get_IsEmpty, ofSeq, intersect } from "../../../fable_modules/fable-library-js.4.13.0/Set.js";
+import { Array_groupBy, distinct } from "../../fable_modules/fable-library-js.4.16.0/Seq2.js";
+import { FSharpSet__get_IsEmpty, ofSeq, intersect } from "../../fable_modules/fable-library-js.4.16.0/Set.js";
 import { ArcTable } from "./ArcTable.js";
-import { map as map_2, collect } from "../../../fable_modules/fable-library-js.4.13.0/List.js";
-import { Unchecked_fillMissingCells, ProcessParsing_groupProcesses, ProcessParsing_processToRows, ProcessParsing_alignByHeaders } from "./ArcTableAux.js";
-import { tryFind, ofSeq as ofSeq_1 } from "../../../fable_modules/fable-library-js.4.13.0/Map.js";
-import { class_type } from "../../../fable_modules/fable-library-js.4.13.0/Reflection.js";
+import { tryFind, ofSeq as ofSeq_1 } from "../../fable_modules/fable-library-js.4.16.0/Map.js";
+import { Unchecked_fillMissingCells } from "./ArcTableAux.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.16.0/Reflection.js";
 
 /**
  * If a table with the given name exists in the TableList, returns it, else returns None.
@@ -40,7 +39,7 @@ export function ArcTablesAux_getIOMap(tables) {
     const mappings = new Map([]);
     const includeInMap = (name, ioType) => {
         if (name !== "") {
-            const matchValue = Dict_tryFind(name, mappings);
+            const matchValue = Dictionary_tryFind(name, mappings);
             if (matchValue == null) {
                 addToDict(mappings, name, ioType);
             }
@@ -95,7 +94,7 @@ export function ArcTablesAux_applyIOMap(map, tables) {
                 const ic = matchValue;
                 const index = findIndex((x) => x.isInput, table.Headers) | 0;
                 const newIOType = fold((io, c) => {
-                    const matchValue_1 = Dict_tryFind(c.ToFreeTextCell().AsFreeText, map);
+                    const matchValue_1 = Dictionary_tryFind(c.ToFreeTextCell().AsFreeText, map);
                     if (matchValue_1 == null) {
                         return io;
                     }
@@ -113,7 +112,7 @@ export function ArcTablesAux_applyIOMap(map, tables) {
                 const oc = matchValue_2;
                 const index_1 = findIndex((x_1) => x_1.isOutput, table.Headers) | 0;
                 const newIOType_1 = fold((io_1, c_1) => {
-                    const matchValue_3 = Dict_tryFind(c_1.ToFreeTextCell().AsFreeText, map);
+                    const matchValue_3 = Dictionary_tryFind(c_1.ToFreeTextCell().AsFreeText, map);
                     if (matchValue_3 == null) {
                         return io_1;
                     }
@@ -409,10 +408,6 @@ export class ArcTables {
         const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex];
         return this$.GetRowAt(tupledArg[0], tupledArg[1]);
     }
-    GetProcesses() {
-        const this$ = this;
-        return collect((t) => t.GetProcesses(), toList(this$.Tables));
-    }
     static ofSeq(tables) {
         return new ArcTables(Array.from(tables));
     }
@@ -422,24 +417,17 @@ export class ArcTables {
         this$.Tables.splice(oldIndex, 1);
         this$.Tables.splice(newIndex, 0, table);
     }
-    static fromProcesses(ps) {
-        let collection;
-        return new ArcTables((collection = map_2((tupledArg) => {
-            const tupledArg_1 = ProcessParsing_alignByHeaders(true, collect(ProcessParsing_processToRows, tupledArg[1]));
-            return ArcTable.create(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
-        }, ProcessParsing_groupProcesses(ps)), Array.from(collection)));
-    }
     static updateReferenceTablesBySheets(referenceTables, sheetTables, keepUnusedRefTables) {
         let collection, s, array;
         const keepUnusedRefTables_1 = defaultArg(keepUnusedRefTables, false);
         const usedTables = new Set([]);
-        const referenceTableMap = ofSeq_1(choose((t) => map_3((c) => [item(0, c.Cells).AsFreeText, t], t.TryGetProtocolNameColumn()), referenceTables.Tables), {
+        const referenceTableMap = ofSeq_1(choose((t) => map_2((c) => [item(0, c.Cells).AsFreeText, t], t.TryGetProtocolNameColumn()), referenceTables.Tables), {
             Compare: comparePrimitives,
         });
-        return new ArcTables((collection = ((s = map_4((t_3) => {
+        return new ArcTables((collection = ((s = map_3((t_3) => {
             Unchecked_fillMissingCells(t_3.Headers, t_3.Values);
             return t_3;
-        }, map_4((tupledArg) => reduce((table, table_1) => ArcTable.append(table, table_1), tupledArg[1]), Array_groupBy((t_2) => t_2.Name, map_4((t_1) => {
+        }, map_3((tupledArg) => reduce((table, table_1) => ArcTable.append(table, table_1), tupledArg[1]), Array_groupBy((t_2) => t_2.Name, map_3((t_1) => {
             const k = defaultArg(bind((c_1) => {
                 if (c_1.AsFreeText === "") {
                     return void 0;
@@ -458,7 +446,7 @@ export class ArcTables {
                 const updatedTable = ArcTable.updateReferenceByAnnotationTable(rt, t_1);
                 return ArcTable.create(t_1.Name, updatedTable.Headers, updatedTable.Values);
             }
-        }, (array = toArray(sheetTables.Tables), collect_1(ArcTable.SplitByProtocolREF, array))), {
+        }, (array = toArray(sheetTables.Tables), collect(ArcTable.SplitByProtocolREF, array))), {
             Equals: (x_2, y_1) => (x_2 === y_1),
             GetHashCode: stringHash,
         }))), keepUnusedRefTables_1 ? append(choose((kv) => {
@@ -484,10 +472,10 @@ export class ArcTables {
 }
 
 export function ArcTables_$reflection() {
-    return class_type("ARCtrl.ISA.ArcTables", void 0, ArcTables);
+    return class_type("ARCtrl.ArcTables", void 0, ArcTables);
 }
 
-export function ArcTables_$ctor_Z18C2F36D(initTables) {
+export function ArcTables_$ctor_Z420F2E1A(initTables) {
     return new ArcTables(initTables);
 }