@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/cjs/ts/Core/Table/ArcTableAux.js

@@ -0,0 +1,582 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnCount = getColumnCount;
+exports.getRowCount = getRowCount;
+exports.boxHashValues = boxHashValues;
+exports.$007CIsUniqueExistingHeader$007C_$007C = $007CIsUniqueExistingHeader$007C_$007C;
+exports.tryFindDuplicateUnique = tryFindDuplicateUnique;
+exports.tryFindDuplicateUniqueInArray = tryFindDuplicateUniqueInArray;
+exports.SanityChecks_validateColumnIndex = SanityChecks_validateColumnIndex;
+exports.SanityChecks_validateRowIndex = SanityChecks_validateRowIndex;
+exports.SanityChecks_validateColumn = SanityChecks_validateColumn;
+exports.SanityChecks_validate = SanityChecks_validate;
+exports.Unchecked_tryGetCellAt = Unchecked_tryGetCellAt;
+exports.Unchecked_setCellAt = Unchecked_setCellAt;
+exports.Unchecked_addCellAt = Unchecked_addCellAt;
+exports.Unchecked_moveCellTo = Unchecked_moveCellTo;
+exports.Unchecked_removeHeader = Unchecked_removeHeader;
+exports.Unchecked_removeColumnCells = Unchecked_removeColumnCells;
+exports.Unchecked_removeColumnCells_withIndexChange = Unchecked_removeColumnCells_withIndexChange;
+exports.Unchecked_removeRowCells = Unchecked_removeRowCells;
+exports.Unchecked_removeRowCells_withIndexChange = Unchecked_removeRowCells_withIndexChange;
+exports.Unchecked_getEmptyCellForHeader = Unchecked_getEmptyCellForHeader;
+exports.Unchecked_addColumn = Unchecked_addColumn;
+exports.Unchecked_fillMissingCells = Unchecked_fillMissingCells;
+exports.Unchecked_extendToRowCount = Unchecked_extendToRowCount;
+exports.Unchecked_addRow = Unchecked_addRow;
+exports.Unchecked_addRows = Unchecked_addRows;
+exports.Unchecked_compositeHeaderMainColumnEqual = Unchecked_compositeHeaderMainColumnEqual;
+exports.Unchecked_moveColumnTo = Unchecked_moveColumnTo;
+exports.Unchecked_alignByHeaders = Unchecked_alignByHeaders;
+const Int32_js_1 = require("@fable-org/fable-library-js/Int32.js");
+const Seq_js_1 = require("@fable-org/fable-library-js/Seq.js");
+const Util_js_1 = require("@fable-org/fable-library-js/Util.js");
+const CompositeCell_js_1 = require("./CompositeCell.js");
+const MapUtil_js_1 = require("@fable-org/fable-library-js/MapUtil.js");
+const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
+const List_js_1 = require("@fable-org/fable-library-js/List.js");
+const String_js_1 = require("@fable-org/fable-library-js/String.js");
+const Collections_js_1 = require("../Helper/Collections.js");
+const Double_js_1 = require("@fable-org/fable-library-js/Double.js");
+const Array_js_1 = require("@fable-org/fable-library-js/Array.js");
+const Map_js_1 = require("@fable-org/fable-library-js/Map.js");
+const Seq2_js_1 = require("@fable-org/fable-library-js/Seq2.js");
+const Set_js_1 = require("@fable-org/fable-library-js/Set.js");
+const Types_js_1 = require("@fable-org/fable-library-js/Types.js");
+const Range_js_1 = require("@fable-org/fable-library-js/Range.js");
+const MutableMap_js_1 = require("@fable-org/fable-library-js/MutableMap.js");
+function getColumnCount(headers) {
+    return headers.length;
+}
+function getRowCount(values) {
+    if (values.size === 0) {
+        return 0;
+    }
+    else {
+        return (1 + (0, Seq_js_1.maxBy)((tuple) => tuple[1], values.keys(), {
+            Compare: Util_js_1.comparePrimitives,
+        })[1]) | 0;
+    }
+}
+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 + (0, Util_js_1.safeHash)((0, MapUtil_js_1.getItemFromDict)(values, [col, row]))) + (hash << 6)) + (hash >> 2)) | 0);
+        }
+    }
+    return hash;
+}
+function $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, input) {
+    switch (input.tag) {
+        case /* Parameter */ 3:
+        case /* Factor */ 2:
+        case /* Characteristic */ 1:
+        case /* Component */ 0:
+        case /* FreeText */ 13:
+            return undefined;
+        case /* Output */ 12:
+            return (0, Seq_js_1.tryFindIndex)((h) => (h.tag === /* Output */ 12), existingHeaders);
+        case /* Input */ 11:
+            return (0, Seq_js_1.tryFindIndex)((h_1) => (h_1.tag === /* Input */ 11), existingHeaders);
+        default:
+            return (0, Seq_js_1.tryFindIndex)((h_2) => (0, Util_js_1.equals)(h_2, input), existingHeaders);
+    }
+}
+/**
+ * Returns the column index of the duplicate unique column in `existingHeaders`.
+ */
+function tryFindDuplicateUnique(newHeader, existingHeaders) {
+    const activePatternResult = $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, newHeader);
+    if (activePatternResult != null) {
+        const index = (0, Option_js_1.value)(activePatternResult) | 0;
+        return index;
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * Returns the column index of the duplicate unique column in `existingHeaders`.
+ */
+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 ((0, List_js_1.isEmpty)(headerList)) {
+                matchResult = 0;
+            }
+            else if ((0, List_js_1.isEmpty)((0, List_js_1.tail)(headerList))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+                header = (0, List_js_1.head)(headerList);
+                tail = (0, List_js_1.tail)(headerList);
+            }
+            switch (matchResult) {
+                case 0:
+                    return duplicateList;
+                default: {
+                    const hasDuplicate = tryFindDuplicateUnique(header, tail);
+                    i_mut = (i + 1);
+                    duplicateList_mut = ((hasDuplicate != null) ? (0, List_js_1.cons)({
+                        HeaderType: header,
+                        Index1: i,
+                        Index2: (0, Option_js_1.value)(hasDuplicate),
+                    }, duplicateList) : duplicateList);
+                    headerList_mut = tail;
+                    continue loop;
+                }
+            }
+            break;
+        }
+    };
+    return loop(0, (0, List_js_1.empty)(), (0, List_js_1.ofSeq)((0, Seq_js_1.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`
+ */
+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 ? ((0, Util_js_1.compare)(x, y) > 0) : ((0, Util_js_1.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`
+ */
+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 ? ((0, Util_js_1.compare)(x, y) > 0) : ((0, Util_js_1.compare)(x, y) >= 0)))) {
+        throw new Error(`Specified index is out of table range! Table contains only ${rowCount} rows.`);
+    }
+}
+function SanityChecks_validateColumn(column) {
+    column.Validate(true);
+}
+function SanityChecks_validate(headers, values, raiseException) {
+    let clo, clo_1;
+    let isValid = true;
+    let en = (0, Util_js_1.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]];
+        const headerIsData = header.IsDataColumn;
+        const headerIsFreetext = !header.IsTermColumn && !header.IsDataColumn;
+        const cellIsNotFreetext = !cell.isFreeText;
+        if (headerIsData && (!cell.isData && cellIsNotFreetext)) {
+            (raiseException ? ((message) => {
+                throw new Error(message);
+            }) : ((clo = (0, String_js_1.toConsole)((0, String_js_1.printf)("%s")), (arg) => {
+                clo(arg);
+            })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Data header should contain either Data or Freetext cells.`);
+            isValid = false;
+        }
+        if (headerIsFreetext && cellIsNotFreetext) {
+            (raiseException ? ((message_1) => {
+                throw new Error(message_1);
+            }) : ((clo_1 = (0, String_js_1.toConsole)((0, String_js_1.printf)("%s")), (arg_1) => {
+                clo_1(arg_1);
+            })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Freetext header should not contain non-freetext cells.`);
+            isValid = false;
+        }
+    }
+    return isValid;
+}
+function Unchecked_tryGetCellAt(column, row, cells) {
+    return (0, Collections_js_1.Dictionary_tryFind)([column, row], cells);
+}
+/**
+ * Add or update a cell in the dictionary.
+ */
+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.
+ */
+function Unchecked_addCellAt(columnIndex, rowIndex, c, cells) {
+    (0, MapUtil_js_1.addToDict)(cells, [columnIndex, rowIndex], c);
+}
+function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, cells) {
+    const matchValue = (0, Collections_js_1.Dictionary_tryFind)([fromCol, fromRow], cells);
+    if (matchValue == null) {
+    }
+    else {
+        const c = (0, Option_js_1.value)(matchValue);
+        cells.delete([fromCol, fromRow]);
+        const value_1 = Unchecked_setCellAt(toCol, toRow, c, cells);
+    }
+}
+function Unchecked_removeHeader(index, headers) {
+    headers.splice(index, 1);
+}
+/**
+ * Remove cells of one Column, change index of cells with higher index to index - 1
+ */
+function Unchecked_removeColumnCells(index, cells) {
+    let enumerator = (0, Util_js_1.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 {
+        (0, Util_js_1.disposeSafe)(enumerator);
+    }
+}
+/**
+ * Remove cells of one Column, change index of cells with higher index to index - 1
+ */
+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);
+            }
+        }
+    }
+}
+function Unchecked_removeRowCells(rowIndex, cells) {
+    let enumerator = (0, Util_js_1.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 {
+        (0, Util_js_1.disposeSafe)(enumerator);
+    }
+}
+/**
+ * Remove cells of one Row, change index of cells with higher index to index - 1
+ */
+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.
+ */
+function Unchecked_getEmptyCellForHeader(header, columCellOption) {
+    const matchValue = header.IsTermColumn;
+    if (matchValue) {
+        let matchResult;
+        if (columCellOption == null) {
+            matchResult = 0;
+        }
+        else {
+            switch ((0, Option_js_1.value)(columCellOption).tag) {
+                case /* Term */ 0: {
+                    matchResult = 0;
+                    break;
+                }
+                case /* Unitized */ 2: {
+                    matchResult = 1;
+                    break;
+                }
+                default:
+                    matchResult = 2;
+            }
+        }
+        switch (matchResult) {
+            case 0:
+                return CompositeCell_js_1.CompositeCell.emptyTerm;
+            case 1:
+                return CompositeCell_js_1.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_js_1.CompositeCell.emptyFreeText;
+    }
+}
+/**
+ *
+ */
+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 \`${(0, Option_js_1.value)(hasDuplicateUnique)}\``);
+    }
+    if (hasDuplicateUnique != null) {
+        numberOfNewColumns = 0;
+        index_1 = ((0, Option_js_1.value)(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 = (0, Double_js_1.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 = (0, MapUtil_js_1.addToDict)(values_1, [tupledArg[0], tupledArg[1]], tupledArg[2]);
+        })) : ((tupledArg_1) => ((cells) => {
+            Unchecked_setCellAt(tupledArg_1[0], tupledArg_1[1], tupledArg_1[2], cells);
+        }));
+        (0, Array_js_1.iterateIndexed)((rowIndex_3, cell_1) => {
+            f([index_1, rowIndex_3, cell_1])(values);
+        }, newCells);
+    }
+}
+function Unchecked_fillMissingCells(headers, values) {
+    let col;
+    const rowCount = getRowCount(values) | 0;
+    const columnCount = getColumnCount(headers) | 0;
+    const columnKeyGroups = (0, Map_js_1.ofArray)((0, Seq2_js_1.Array_groupBy)((tuple) => tuple[0], (0, Seq_js_1.toArray)(values.keys()), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: Util_js_1.numberHash,
+    }), {
+        Compare: Util_js_1.comparePrimitives,
+    });
+    for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
+        const header = headers[columnIndex];
+        const matchValue = (0, Map_js_1.tryFind)(columnIndex, columnKeyGroups);
+        if (matchValue == null) {
+            const defaultCell_1 = Unchecked_getEmptyCellForHeader(header, undefined);
+            for (let rowIndex_1 = 0; rowIndex_1 <= (rowCount - 1); rowIndex_1++) {
+                Unchecked_addCellAt(columnIndex, rowIndex_1, defaultCell_1.Copy(), values);
+            }
+        }
+        else if ((col = (0, Option_js_1.value)(matchValue), col.length === rowCount)) {
+            const col_1 = (0, Option_js_1.value)(matchValue);
+        }
+        else {
+            const col_2 = (0, Option_js_1.value)(matchValue);
+            const defaultCell = Unchecked_getEmptyCellForHeader(header, (0, MapUtil_js_1.getItemFromDict)(values, (0, Seq_js_1.head)(col_2)));
+            const rowKeys = (0, Set_js_1.ofArray)((0, Array_js_1.map)((tuple_1) => tuple_1[1], col_2), {
+                Compare: Util_js_1.comparePrimitives,
+            });
+            for (let rowIndex = 0; rowIndex <= (rowCount - 1); rowIndex++) {
+                if (!(0, Set_js_1.FSharpSet__Contains)(rowKeys, rowIndex)) {
+                    Unchecked_addCellAt(columnIndex, rowIndex, defaultCell.Copy(), values);
+                }
+            }
+        }
+    }
+}
+/**
+ * Increases the table size to the given new row count and fills the new rows with the last value of the column
+ */
+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 = (0, MapUtil_js_1.getItemFromDict)(values, [columnIndex, previousRowCount - 1]);
+        for (let rowIndex = previousRowCount - 1; rowIndex <= (rowCount - 1); rowIndex++) {
+            Unchecked_setCellAt(columnIndex, rowIndex, lastValue, values);
+        }
+    }
+}
+function Unchecked_addRow(index, newCells, headers, values) {
+    const rowCount = getRowCount(values) | 0;
+    const columnCount = getColumnCount(headers) | 0;
+    let increaseRowIndices;
+    if (index < rowCount) {
+        const lastRowIndex = (0, Double_js_1.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 = undefined;
+    }
+    const setNewCells = (0, Array_js_1.iterateIndexed)((columnIndex_1, cell) => {
+        Unchecked_setCellAt(columnIndex_1, index, cell, values);
+    }, newCells);
+}
+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 = (0, Double_js_1.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 = undefined;
+    }
+    let currentRowIndex = index;
+    for (let idx = 0; idx <= (newRows.length - 1); idx++) {
+        const setNewCells = (0, Array_js_1.iterateIndexed)((columnIndex_1, cell) => {
+            Unchecked_setCellAt(columnIndex_1, currentRowIndex, cell, values);
+        }, (0, Array_js_1.item)(idx, newRows));
+        currentRowIndex = ((currentRowIndex + 1) | 0);
+    }
+}
+/**
+ * Returns true, if two composite headers share the same main header string
+ */
+function Unchecked_compositeHeaderMainColumnEqual(ch1, ch2) {
+    return (0, Types_js_1.toString)(ch1) === (0, Types_js_1.toString)(ch2);
+}
+/**
+ * Moves a column from one position to another
+ *
+ * This function moves the column from `fromCol` to `toCol` and shifts all columns in between accordingly
+ */
+function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values) {
+    const patternInput = (fromCol < toCol) ? [-1, fromCol + 1, toCol] : [1, fromCol - 1, toCol];
+    const shiftStart = patternInput[1] | 0;
+    const shiftEnd = patternInput[2] | 0;
+    const shift = patternInput[0] | 0;
+    const header = headers[fromCol];
+    const enumerator = (0, Util_js_1.getEnumerator)((0, Seq_js_1.toList)((0, Range_js_1.rangeDouble)(shiftStart, (0, Int32_js_1.op_UnaryNegation_Int32)(shift), shiftEnd)));
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
+            (0, Array_js_1.setItem)(headers, c + shift, headers[c]);
+        }
+    }
+    finally {
+        (0, Util_js_1.disposeSafe)(enumerator);
+    }
+    (0, Array_js_1.setItem)(headers, toCol, header);
+    for (let r = 0; r <= (rowCount - 1); r++) {
+        const cell = (0, MapUtil_js_1.getItemFromDict)(values, [fromCol, r]);
+        const enumerator_1 = (0, Util_js_1.getEnumerator)((0, Seq_js_1.toList)((0, Range_js_1.rangeDouble)(shiftStart, (0, Int32_js_1.op_UnaryNegation_Int32)(shift), shiftEnd)));
+        try {
+            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                const c_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
+                values.set([c_1 + shift, r], (0, MapUtil_js_1.getItemFromDict)(values, [c_1, r]));
+            }
+        }
+        finally {
+            (0, Util_js_1.disposeSafe)(enumerator_1);
+        }
+        values.set([toCol, r], cell);
+    }
+}
+/**
+ * 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
+ */
+function Unchecked_alignByHeaders(keepOrder, rows) {
+    const headers = [];
+    const values = new MutableMap_js_1.Dictionary([], {
+        Equals: Util_js_1.equalArrays,
+        GetHashCode: Util_js_1.arrayHash,
+    });
+    const loop = (colI_mut, rows_2_mut) => {
+        loop: while (true) {
+            const colI = colI_mut, rows_2 = rows_2_mut;
+            if (!(0, List_js_1.exists)((arg) => !(0, List_js_1.isEmpty)(arg), rows_2)) {
+                return [headers, values];
+            }
+            else {
+                const firstElem = (0, List_js_1.pick)((l) => ((0, List_js_1.isEmpty)(l) ? undefined : (0, List_js_1.head)(l)), rows_2)[0];
+                void (headers.push(firstElem));
+                colI_mut = (colI + 1);
+                rows_2_mut = (0, List_js_1.mapIndexed)((rowI, l_1) => {
+                    if (keepOrder) {
+                        if (!(0, List_js_1.isEmpty)(l_1)) {
+                            if (Unchecked_compositeHeaderMainColumnEqual((0, List_js_1.head)(l_1)[0], firstElem)) {
+                                (0, MapUtil_js_1.addToDict)(values, [colI, rowI], (0, List_js_1.head)(l_1)[1]);
+                                return (0, List_js_1.tail)(l_1);
+                            }
+                            else {
+                                return l_1;
+                            }
+                        }
+                        else {
+                            return (0, List_js_1.empty)();
+                        }
+                    }
+                    else {
+                        const patternInput = (0, Collections_js_1.List_tryPickAndRemove)((tupledArg) => {
+                            if (Unchecked_compositeHeaderMainColumnEqual(tupledArg[0], firstElem)) {
+                                return tupledArg[1];
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }, l_1);
+                        const newL = patternInput[1];
+                        const firstMatch = patternInput[0];
+                        if (firstMatch == null) {
+                            return newL;
+                        }
+                        else {
+                            (0, MapUtil_js_1.addToDict)(values, [colI, rowI], (0, Option_js_1.value)(firstMatch));
+                            return newL;
+                        }
+                    }
+                }, rows_2);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(0, rows);
+}