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

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

@@ -1,1213 +0,0 @@
-import { CompositeCell } from "./CompositeCell.js";
-import { op_UnaryNegation_Int32 } from "@fable-org/fable-library-js/Int32.js";
-import { bind, value as value_3 } from "@fable-org/fable-library-js/Option.js";
-import { compare, equals, toIterator, defaultOf, disposeSafe, getEnumerator, comparePrimitives, safeHash } from "@fable-org/fable-library-js/Util.js";
-import { tryGetValue, getItemFromDict, addToDict } from "@fable-org/fable-library-js/MapUtil.js";
-import { toString, FSharpRef, Union } from "@fable-org/fable-library-js/Types.js";
-import { union_type, class_type, int32_type } from "@fable-org/fable-library-js/Reflection.js";
-import { filter, tryFindIndex, map, empty, singleton, collect, delay, toList, isEmpty, max, iterateIndexed, item, length, iterate, maxBy } from "@fable-org/fable-library-js/Seq.js";
-import { List_tryPickAndRemove, ResizeArray_iteri, ResizeArray_map, ResizeArray_create, ResizeArray_init } from "../Helper/Collections.js";
-import { toConsole, printf, toFail } from "@fable-org/fable-library-js/String.js";
-import { rangeDouble } from "@fable-org/fable-library-js/Range.js";
-import { mapIndexed, pick, exists, length as length_1, ofSeq, empty as empty_1, head, tail as tail_1, isEmpty as isEmpty_1, cons } from "@fable-org/fable-library-js/List.js";
-import { max as max_1 } from "@fable-org/fable-library-js/Double.js";
-import { setItem } from "@fable-org/fable-library-js/Array.js";
-/**
- * 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 getEmptyCellForHeader(header, columCellOption) {
-    const matchValue = header.IsTermColumn;
-    if (matchValue) {
-        let matchResult;
-        if (columCellOption == null) {
-            matchResult = 0;
-        }
-        else {
-            switch (value_3(columCellOption).tag) {
-                case /* Term */ 0: {
-                    matchResult = 0;
-                    break;
-                }
-                case /* Unitized */ 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 ensureCellHashInValueMap(value, valueMap) {
-    const hash = safeHash(value) | 0;
-    if (valueMap.has(hash)) {
-        return hash | 0;
-    }
-    else {
-        addToDict(valueMap, hash, value);
-        return hash | 0;
-    }
-}
-export function ColumnValueRefs_Constant(Item) {
-    return new ColumnValueRefs(0, [Item]);
-}
-export function ColumnValueRefs_Sparse(Item) {
-    return new ColumnValueRefs(1, [Item]);
-}
-export class ColumnValueRefs extends Union {
-    constructor(tag, fields) {
-        super();
-        this.tag = tag;
-        this.fields = fields;
-    }
-    cases() {
-        return ["Constant", "Sparse"];
-    }
-}
-export function ColumnValueRefs_$reflection() {
-    return union_type("ARCtrl.ArcTableAux.ColumnValueRefs", [], ColumnValueRefs, () => [[["Item", int32_type]], [["Item", class_type("System.Collections.Generic.Dictionary`2", [int32_type, int32_type])]]]);
-}
-export function ColumnValueRefs__get_RowCount(this$) {
-    if (this$.tag === /* Sparse */ 1) {
-        return maxBy((kv) => kv[0], this$.fields[0], {
-            Compare: comparePrimitives,
-        });
-    }
-    else {
-        return undefined;
-    }
-}
-export function ColumnValueRefs__Copy(this$) {
-    if (this$.tag === /* Sparse */ 1) {
-        const values = this$.fields[0];
-        const d = new Map([]);
-        iterate((v) => {
-            addToDict(d, v[0], v[1]);
-        }, values);
-        return ColumnValueRefs_Sparse(d);
-    }
-    else {
-        return ColumnValueRefs_Constant(this$.fields[0]);
-    }
-}
-export function ColumnValueRefs__ToSparse_Z524259A4(this$, rowCount) {
-    if (this$.tag === /* Sparse */ 1) {
-        return ColumnValueRefs_Sparse(this$.fields[0]);
-    }
-    else {
-        const valueHash = this$.fields[0] | 0;
-        const d = new Map([]);
-        for (let i = 0; i <= (rowCount - 1); i++) {
-            addToDict(d, i, valueHash);
-        }
-        return ColumnValueRefs_Sparse(d);
-    }
-}
-export function ColumnValueRefs__AsSparse(this$) {
-    if (this$.tag === /* Sparse */ 1) {
-        return this$.fields[0];
-    }
-    else {
-        const valueHash = this$.fields[0] | 0;
-        throw new Error("Cannot convert a constant column to sparse. Use ToSparse first.");
-    }
-}
-export function ColumnValueRefs__AsConstant(this$) {
-    if (this$.tag === /* Sparse */ 1) {
-        throw new Error("Cannot convert a sparse column to constant. Use ToSparse first.");
-    }
-    else {
-        return this$.fields[0] | 0;
-    }
-}
-export function ColumnValueRefs_fromCellColumn_14896151(column, previousRowCount, valueMap) {
-    const l = length(column) | 0;
-    const cells = new Map([]);
-    if (l === 0) {
-        return ColumnValueRefs_Sparse(cells);
-    }
-    else {
-        let current;
-        const hash = ensureCellHashInValueMap(item(0, column), valueMap) | 0;
-        if (l >= previousRowCount) {
-            current = ColumnValueRefs_Constant(hash);
-        }
-        else {
-            addToDict(cells, 0, hash);
-            current = ColumnValueRefs_Sparse(cells);
-        }
-        iterateIndexed((i, cell) => {
-            const hash_1 = ensureCellHashInValueMap(cell, valueMap) | 0;
-            if (current.tag === /* Sparse */ 1) {
-                const cells_2 = current.fields[0];
-                cells_2.set(i, hash_1);
-            }
-            else if (current.fields[0] === hash_1) {
-                const cellHash_1 = current.fields[0] | 0;
-            }
-            else {
-                const cellHash_2 = current.fields[0] | 0;
-                const cells_1 = new Map([]);
-                for (let j = 0; j <= (i - 1); j++) {
-                    cells_1.set(j, cellHash_2);
-                }
-                cells_1.set(i, hash_1);
-                current = ColumnValueRefs_Sparse(cells_1);
-            }
-        }, column);
-        return current;
-    }
-}
-export function ColumnValueRefs__ToCellColumn_Z2609C9DD(this$, valueMap, rowCount, header) {
-    if (this$.tag === /* Sparse */ 1) {
-        const values = this$.fields[0];
-        const defaultCell = (values.size === 0) ? getEmptyCellForHeader(header, undefined) : getEmptyCellForHeader(header, getItemFromDict(valueMap, getItemFromDict(values, max(values.keys(), {
-            Compare: comparePrimitives,
-        }) - 1)));
-        return ResizeArray_init(rowCount, (i_1) => (values.has(i_1) ? getItemFromDict(valueMap, getItemFromDict(values, i_1)) : defaultCell));
-    }
-    else {
-        return ResizeArray_create(rowCount, getItemFromDict(valueMap, this$.fields[0]));
-    }
-}
-export class ArcTableValues {
-    constructor(cols, valueMap, rowCount) {
-        this._columns = cols;
-        this._valueMap = valueMap;
-        this._rowCount = (rowCount | 0);
-    }
-    get Columns() {
-        const this$ = this;
-        return this$._columns;
-    }
-    set Columns(columns) {
-        const this$ = this;
-        this$._columns = columns;
-    }
-    get ColumnCount() {
-        const this$ = this;
-        return (isEmpty(this$._columns) ? 0 : (1 + max(this$._columns.keys(), {
-            Compare: comparePrimitives,
-        }))) | 0;
-    }
-    get ValueMap() {
-        const this$ = this;
-        return this$._valueMap;
-    }
-    set ValueMap(valueMap) {
-        const this$ = this;
-        this$._valueMap = valueMap;
-    }
-    get RowCount() {
-        const this$ = this;
-        return this$._rowCount | 0;
-    }
-    set RowCount(rowCount) {
-        const this$ = this;
-        if ((rowCount > 0) && (rowCount < this$._rowCount)) {
-            let enumerator = getEnumerator(this$._columns);
-            try {
-                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                    const matchValue = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()[1];
-                    if (matchValue.tag === /* Sparse */ 1) {
-                        const values = matchValue.fields[0];
-                        const enumerator_1 = getEnumerator(toList(values.keys()));
-                        try {
-                            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
-                                const key = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
-                                if (key >= rowCount) {
-                                    values.delete(key);
-                                }
-                            }
-                        }
-                        finally {
-                            disposeSafe(enumerator_1);
-                        }
-                    }
-                }
-            }
-            finally {
-                disposeSafe(enumerator);
-            }
-        }
-        this$._rowCount = (rowCount | 0);
-    }
-    static fromCellColumns(columns) {
-        const rowCount = ((columns.length === 0) ? 0 : max(ResizeArray_map((c) => c.length, columns), {
-            Compare: comparePrimitives,
-        })) | 0;
-        const valueMap = new Map([]);
-        const parsedColumns = new Map([]);
-        iterateIndexed((i, column) => {
-            addToDict(parsedColumns, i, ColumnValueRefs_fromCellColumn_14896151(column, rowCount, valueMap));
-        }, columns);
-        return new ArcTableValues(parsedColumns, valueMap, rowCount);
-    }
-    static fromRefColumns(columns, valueMap, rowCount) {
-        const parsedColumns = new Map([]);
-        iterateIndexed((i, column) => {
-            addToDict(parsedColumns, i, column);
-        }, columns);
-        return new ArcTableValues(parsedColumns, valueMap, rowCount);
-    }
-    static init() {
-        const valueMap = new Map([]);
-        return new ArcTableValues(new Map([]), valueMap, 0);
-    }
-    ToCellColumns(headers) {
-        const this$ = this;
-        return ResizeArray_init(headers.length, (i) => {
-            const header = headers[i];
-            return ColumnValueRefs__ToCellColumn_Z2609C9DD(getItemFromDict(this$._columns, i), this$._valueMap, this$._rowCount, header);
-        });
-    }
-    RescanValueMap() {
-        const this$ = this;
-        const newValueMap = new Map([]);
-        let enumerator = getEnumerator(this$._columns);
-        try {
-            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                const matchValue = kv[1];
-                if (matchValue.tag === /* Sparse */ 1) {
-                    const values = matchValue.fields[0];
-                    let enumerator_1 = getEnumerator(values);
-                    try {
-                        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
-                            const ckv = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                            const hash_1 = ensureCellHashInValueMap(getItemFromDict(this$._valueMap, ckv[1]), newValueMap) | 0;
-                            values.set(ckv[0], hash_1);
-                        }
-                    }
-                    finally {
-                        disposeSafe(enumerator_1);
-                    }
-                }
-                else {
-                    const valueHash = matchValue.fields[0] | 0;
-                    const hash = ensureCellHashInValueMap(getItemFromDict(this$._valueMap, valueHash), newValueMap) | 0;
-                    this$._columns.set(kv[0], ColumnValueRefs_Constant(hash));
-                }
-            }
-        }
-        finally {
-            disposeSafe(enumerator);
-        }
-        this$._valueMap = newValueMap;
-    }
-    Copy() {
-        const this$ = this;
-        const nextValueMap = new Map([]);
-        iterate((kv) => {
-            addToDict(nextValueMap, kv[0], kv[1].Copy());
-        }, this$._valueMap);
-        const nextColumns = new Map([]);
-        iterate((kv_1) => {
-            addToDict(nextColumns, kv_1[0], ColumnValueRefs__Copy(kv_1[1]));
-        }, this$._columns);
-        return new ArcTableValues(nextColumns, nextValueMap, this$._rowCount);
-    }
-    GetHashCode() {
-        const this$ = this;
-        let hash = 0;
-        for (let i = 0; i <= (this$.ColumnCount - 1); i++) {
-            let matchValue;
-            const dict = this$._columns;
-            let patternInput;
-            let outArg = defaultOf();
-            patternInput = [tryGetValue(dict, i, new FSharpRef(() => outArg, (v) => {
-                    outArg = v;
-                })), outArg];
-            matchValue = (patternInput[0] ? patternInput[1] : undefined);
-            if (matchValue != null) {
-                if (value_3(matchValue).tag === /* Sparse */ 1) {
-                    const values = value_3(matchValue).fields[0];
-                    let enumerator = getEnumerator(values);
-                    try {
-                        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                            const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                            hash = ((((-1640531527 + kv[0]) + (hash << 6)) + (hash >> 2)) | 0);
-                            hash = ((((-1640531527 + kv[1]) + (hash << 6)) + (hash >> 2)) | 0);
-                        }
-                    }
-                    finally {
-                        disposeSafe(enumerator);
-                    }
-                }
-                else {
-                    const valueHash = value_3(matchValue).fields[0] | 0;
-                    for (let i_1 = 0; i_1 <= (this$._rowCount - 1); i_1++) {
-                        hash = ((((-1640531527 + i_1) + (hash << 6)) + (hash >> 2)) | 0);
-                        hash = ((((-1640531527 + valueHash) + (hash << 6)) + (hash >> 2)) | 0);
-                    }
-                }
-            }
-        }
-        return hash | 0;
-    }
-    Equals(other) {
-        let other_1;
-        const this$ = this;
-        return (other instanceof ArcTableValues) && ((other_1 = other, safeHash(this$) === safeHash(other_1)));
-    }
-    Item(crIndices) {
-        const this$ = this;
-        const row = crIndices[1] | 0;
-        const col = crIndices[0] | 0;
-        if (row > (this$.RowCount - 1)) {
-            const arg_1 = this$.RowCount | 0;
-            toFail(printf("Row index %d is out of bounds for ArcTableValues with row count %d."))(row)(arg_1);
-        }
-        if (col > (this$.ColumnCount - 1)) {
-            const arg_3 = this$.ColumnCount | 0;
-            toFail(printf("Column index %d is out of bounds for ArcTableValues with column count %d."))(col)(arg_3);
-        }
-        let matchValue;
-        const dict = this$._columns;
-        let patternInput;
-        let outArg = defaultOf();
-        patternInput = [tryGetValue(dict, col, new FSharpRef(() => outArg, (v) => {
-                outArg = v;
-            })), outArg];
-        matchValue = (patternInput[0] ? patternInput[1] : undefined);
-        if (matchValue != null) {
-            const colValueRefs = value_3(matchValue);
-            if (colValueRefs.tag === /* Sparse */ 1) {
-                const values = colValueRefs.fields[0];
-                return values.has(row) ? getItemFromDict(this$._valueMap, getItemFromDict(values, row)) : toFail(printf("Row value for index %d does not exist in column %d of ArcTableValues."))(row)(col);
-            }
-            else {
-                const valueHash = colValueRefs.fields[0] | 0;
-                return getItemFromDict(this$._valueMap, valueHash);
-            }
-        }
-        else {
-            return toFail(printf("Column %d does not exist in ArcTableValues."))(col);
-        }
-    }
-    GetEnumerator() {
-        const this$ = this;
-        return getEnumerator(delay(() => collect((colI) => {
-            let matchValue;
-            const dict = this$._columns;
-            let patternInput;
-            let outArg = defaultOf();
-            patternInput = [tryGetValue(dict, colI, new FSharpRef(() => outArg, (v) => {
-                    outArg = v;
-                })), outArg];
-            matchValue = (patternInput[0] ? patternInput[1] : undefined);
-            if (matchValue != null) {
-                const matchValue_1 = value_3(matchValue);
-                if (matchValue_1.tag === /* Sparse */ 1) {
-                    const values = matchValue_1.fields[0];
-                    return collect((rowI_1) => (values.has(rowI_1) ? singleton([[colI, rowI_1], getItemFromDict(this$._valueMap, getItemFromDict(values, rowI_1))]) : empty()), rangeDouble(0, 1, this$._rowCount - 1));
-                }
-                else {
-                    const valueHash = matchValue_1.fields[0] | 0;
-                    return map((rowI) => [[colI, rowI], getItemFromDict(this$._valueMap, valueHash)], rangeDouble(0, 1, this$._rowCount - 1));
-                }
-            }
-            else {
-                return empty();
-            }
-        }, rangeDouble(0, 1, this$.ColumnCount - 1))));
-    }
-    [Symbol.iterator]() {
-        return toIterator(getEnumerator(this));
-    }
-    "System.Collections.IEnumerable.GetEnumerator"() {
-        const this$ = this;
-        return getEnumerator(this$);
-    }
-}
-export function ArcTableValues_$reflection() {
-    return class_type("ARCtrl.ArcTableAux.ArcTableValues", undefined, ArcTableValues);
-}
-export function ArcTableValues_$ctor_39436F7C(cols, valueMap, rowCount) {
-    return new ArcTableValues(cols, valueMap, rowCount);
-}
-export 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 tryFindIndex((h) => (h.tag === /* Output */ 12), existingHeaders);
-        case /* Input */ 11:
-            return tryFindIndex((h_1) => (h_1.tag === /* Input */ 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 = value_3(activePatternResult) | 0;
-        return index;
-    }
-    else {
-        return undefined;
-    }
-}
-/**
- * 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_1(headerList)) {
-                matchResult = 0;
-            }
-            else if (isEmpty_1(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_3(hasDuplicate),
-                    }, duplicateList) : duplicateList);
-                    headerList_mut = tail;
-                    continue loop;
-                }
-            }
-            break;
-        }
-    };
-    return loop(0, empty_1(), 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_validateCellColumns(headers, columns, raiseException) {
-    let clo, clo_1, clo_2;
-    let isValid = true;
-    let en = getEnumerator(headers);
-    let colIndex = 0;
-    if ((headers.length !== columns.length) && (columns.length !== 0)) {
-        (raiseException ? ((message) => {
-            throw new Error(message);
-        }) : ((clo = toConsole(printf("%s")), (arg) => {
-            clo(arg);
-        })))(`Invalid table. Number of headers (${headers.length}) does not match number of columns (${columns.length}).`);
-        isValid = false;
-    }
-    while ((isValid && en["System.Collections.IEnumerator.MoveNext"]()) && (columns.length !== 0)) {
-        const header = en["System.Collections.Generic.IEnumerator`1.get_Current"]();
-        let colEn = getEnumerator(columns[colIndex]);
-        colIndex = ((colIndex + 1) | 0);
-        while (isValid && colEn["System.Collections.IEnumerator.MoveNext"]()) {
-            const cell = colEn["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            const headerIsData = header.IsDataColumn;
-            const headerIsFreetext = !header.IsTermColumn && !header.IsDataColumn;
-            const cellIsNotFreetext = !cell.isFreeText;
-            if (headerIsData && (!cell.isData && cellIsNotFreetext)) {
-                (raiseException ? ((message_1) => {
-                    throw new Error(message_1);
-                }) : ((clo_1 = toConsole(printf("%s")), (arg_1) => {
-                    clo_1(arg_1);
-                })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Data header should contain either Data or Freetext cells.`);
-                isValid = false;
-            }
-            if (headerIsFreetext && cellIsNotFreetext) {
-                (raiseException ? ((message_2) => {
-                    throw new Error(message_2);
-                }) : ((clo_2 = toConsole(printf("%s")), (arg_2) => {
-                    clo_2(arg_2);
-                })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Freetext header should not contain non-freetext cells.`);
-                isValid = false;
-            }
-        }
-    }
-    return isValid;
-}
-export function SanityChecks_validateArcTableValues(headers, values, raiseException) {
-    let clo;
-    let isValid = true;
-    let colIndex = 0;
-    if ((headers.length !== values.ColumnCount) && (values.ColumnCount !== 0)) {
-        (raiseException ? ((message) => {
-            throw new Error(message);
-        }) : ((clo = toConsole(printf("%s")), (arg) => {
-            clo(arg);
-        })))(`Invalid table. Number of headers (${headers.length}) does not match number of columns (${values.ColumnCount}).`);
-        isValid = false;
-    }
-    if ((values.RowCount !== 0) && (values.ColumnCount !== 0)) {
-        while (isValid && (colIndex < values.ColumnCount)) {
-            const header = headers[colIndex];
-            let matchValue;
-            const key = colIndex | 0;
-            const dict = values.Columns;
-            let patternInput;
-            let outArg = defaultOf();
-            patternInput = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {
-                    outArg = v;
-                })), outArg];
-            matchValue = (patternInput[0] ? patternInput[1] : undefined);
-            if (matchValue != null) {
-                if (value_3(matchValue).tag === /* Sparse */ 1) {
-                    const column = value_3(matchValue).fields[0];
-                    let enumerator = getEnumerator(column);
-                    try {
-                        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                            const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                            const cell_1 = getItemFromDict(values.ValueMap, kv[1]);
-                            if (!cell_1.ValidateAgainstHeader(header, raiseException)) {
-                                isValid = false;
-                            }
-                        }
-                    }
-                    finally {
-                        disposeSafe(enumerator);
-                    }
-                }
-                else {
-                    const hash = value_3(matchValue).fields[0] | 0;
-                    const cell = getItemFromDict(values.ValueMap, hash);
-                    if (!cell.ValidateAgainstHeader(header, raiseException)) {
-                        isValid = false;
-                    }
-                }
-            }
-            colIndex = ((colIndex + 1) | 0);
-        }
-    }
-    return isValid;
-}
-export function Unchecked_tryGetCellAt(column, row, values) {
-    let dict, patternInput, outArg;
-    return bind((col) => {
-        if (col.tag === /* Sparse */ 1) {
-            const vals = col.fields[0];
-            if (vals.has(row)) {
-                return getItemFromDict(values.ValueMap, getItemFromDict(vals, row));
-            }
-            else {
-                return undefined;
-            }
-        }
-        else {
-            const valueHash = col.fields[0] | 0;
-            return getItemFromDict(values.ValueMap, valueHash);
-        }
-    }, (dict = values.Columns, (patternInput = ((outArg = defaultOf(), [tryGetValue(dict, column, new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg])), patternInput[0] ? patternInput[1] : undefined)));
-}
-export function Unchecked_getCellWithDefault(column, row, headers, values) {
-    if (headers.length <= column) {
-        const arg_1 = headers.length | 0;
-        toFail(printf("Column index %d is out of bounds for ArcTableValues with column count %d."))(column)(arg_1);
-    }
-    let matchValue;
-    const dict = values.Columns;
-    let patternInput;
-    let outArg = defaultOf();
-    patternInput = [tryGetValue(dict, column, new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    matchValue = (patternInput[0] ? patternInput[1] : undefined);
-    if (matchValue == null) {
-        if (row < values.RowCount) {
-            return CompositeCell.emptyFreeText;
-        }
-        else {
-            return getEmptyCellForHeader(headers[column], undefined);
-        }
-    }
-    else {
-        const col = value_3(matchValue);
-        if (col.tag === /* Sparse */ 1) {
-            const vals = col.fields[0];
-            if (vals.has(row)) {
-                return getItemFromDict(values.ValueMap, getItemFromDict(vals, row));
-            }
-            else if (vals.size === 0) {
-                return getEmptyCellForHeader(headers[column], undefined);
-            }
-            else {
-                const header_1 = headers[column];
-                const maxI = max(vals.keys(), {
-                    Compare: comparePrimitives,
-                }) | 0;
-                return getEmptyCellForHeader(header_1, getItemFromDict(values.ValueMap, getItemFromDict(vals, maxI)));
-            }
-        }
-        else {
-            const valueHash = col.fields[0] | 0;
-            return getItemFromDict(values.ValueMap, valueHash);
-        }
-    }
-}
-/**
- * Add or update a cell in the dictionary.
- */
-export function Unchecked_setCellAt(columnIndex, rowIndex, c, values) {
-    if ((rowIndex + 1) > values.RowCount) {
-        values.RowCount = ((rowIndex + 1) | 0);
-    }
-    let matchValue;
-    const dict = values.Columns;
-    let patternInput;
-    let outArg = defaultOf();
-    patternInput = [tryGetValue(dict, columnIndex, new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    matchValue = (patternInput[0] ? patternInput[1] : undefined);
-    if (matchValue != null) {
-        const col = value_3(matchValue);
-        if (col.tag === /* Sparse */ 1) {
-            const vals = col.fields[0];
-            const key_1 = rowIndex | 0;
-            const value = ensureCellHashInValueMap(c, values.ValueMap) | 0;
-            const dict_1 = vals;
-            if (dict_1.has(key_1)) {
-                dict_1.set(key_1, value);
-            }
-            else {
-                addToDict(dict_1, key_1, value);
-            }
-        }
-        else {
-            const valueHash = col.fields[0] | 0;
-            const hash_2 = ensureCellHashInValueMap(c, values.ValueMap) | 0;
-            if (hash_2 === valueHash) {
-            }
-            else {
-                const d = new Map([]);
-                for (let i = 0; i <= (values.RowCount - 1); i++) {
-                    if (i === rowIndex) {
-                        addToDict(d, i, hash_2);
-                    }
-                    else {
-                        addToDict(d, i, valueHash);
-                    }
-                }
-                values.Columns.set(columnIndex, ColumnValueRefs_Sparse(d));
-            }
-        }
-    }
-    else if ((values.RowCount <= 1) && (rowIndex === 0)) {
-        const hash = ensureCellHashInValueMap(c, values.ValueMap) | 0;
-        addToDict(values.Columns, columnIndex, ColumnValueRefs_Constant(hash));
-    }
-    else {
-        const newColumn = new Map([]);
-        addToDict(newColumn, rowIndex, ensureCellHashInValueMap(c, values.ValueMap));
-        addToDict(values.Columns, columnIndex, ColumnValueRefs_Sparse(newColumn));
-    }
-}
-export function Unchecked_removeCellAt(columnIndex, rowIndex, values) {
-    let matchValue;
-    const dict = values.Columns;
-    let patternInput;
-    let outArg = defaultOf();
-    patternInput = [tryGetValue(dict, columnIndex, new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    matchValue = (patternInput[0] ? patternInput[1] : undefined);
-    if (matchValue != null) {
-        const col = value_3(matchValue);
-        if (col.tag === /* Sparse */ 1) {
-            const vals = col.fields[0];
-            if (vals.has(rowIndex)) {
-                vals.delete(rowIndex);
-                if (vals.size === 0) {
-                    values.Columns.delete(columnIndex);
-                }
-            }
-        }
-        else {
-            const valueHash = col.fields[0] | 0;
-            if ((rowIndex === 0) && (values.RowCount === 1)) {
-                values.Columns.delete(columnIndex);
-            }
-        }
-    }
-}
-export function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, values) {
-    const matchValue = Unchecked_tryGetCellAt(fromCol, fromRow, values);
-    if (matchValue == null) {
-    }
-    else {
-        const cell = value_3(matchValue);
-        Unchecked_removeCellAt(fromCol, fromRow, values);
-        Unchecked_setCellAt(toCol, toRow, cell, values);
-    }
-}
-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(colIndex, values) {
-    values.Columns.delete(colIndex);
-}
-/**
- * Remove cells of one Column, change index of cells with higher index to index - 1
- */
-export function Unchecked_removeColumnCells_withIndexChange(colIndex, columnCount, values) {
-    if (colIndex < (columnCount - 1)) {
-        const cols = new Map([]);
-        iterate((kv) => {
-            const cI = kv[0] | 0;
-            if (cI > colIndex) {
-                addToDict(cols, cI - 1, kv[1]);
-            }
-            else if (cI < colIndex) {
-                addToDict(cols, cI, kv[1]);
-            }
-        }, values.Columns);
-        values.Columns = cols;
-    }
-    else {
-        const value = Unchecked_removeColumnCells(colIndex, values);
-    }
-}
-export function Unchecked_removeRowCells(rowIndex, columnCount, values) {
-    for (let c = 0; c <= (columnCount - 1); c++) {
-        Unchecked_removeCellAt(c, rowIndex, values);
-    }
-}
-/**
- * Remove cells of one Row, change index of cells with higher index to index - 1
- */
-export function Unchecked_removeRowCells_withIndexChange(rowIndex, values) {
-    if ((rowIndex === 0) && (values.RowCount === 1)) {
-        values.RowCount = 0;
-        values.Columns = (new Map([]));
-    }
-    else {
-        iterate((kv) => {
-            const matchValue = kv[1];
-            if (matchValue.tag === /* Sparse */ 1) {
-                const vals = matchValue.fields[0];
-                if (rowIndex < (values.RowCount - 1)) {
-                    const col = new Map([]);
-                    iterate((kv_1) => {
-                        const rI = kv_1[0] | 0;
-                        if (rI > rowIndex) {
-                            addToDict(col, rI - 1, kv_1[1]);
-                        }
-                        else if (rI < rowIndex) {
-                            addToDict(col, rI, kv_1[1]);
-                        }
-                    }, vals);
-                    values.Columns.set(kv[0], ColumnValueRefs_Sparse(col));
-                }
-                else {
-                    vals.delete(rowIndex);
-                }
-            }
-        }, values.Columns);
-        values.RowCount = ((values.RowCount - 1) | 0);
-    }
-}
-/**
- * Remove cells of one Row, change index of cells with higher index to index - 1
- */
-export function Unchecked_removeRowRange_withIndexChange(rowStartIndex, rowEndIndex, values) {
-    if ((rowStartIndex === 0) && (values.RowCount === rowEndIndex)) {
-        values.RowCount = 0;
-        values.Columns = (new Map([]));
-    }
-    else {
-        iterate((kv) => {
-            const matchValue = kv[1];
-            if (matchValue.tag === /* Sparse */ 1) {
-                const vals = matchValue.fields[0];
-                const range = ((rowEndIndex - rowStartIndex) + 1) | 0;
-                if (rowEndIndex < (values.RowCount - 1)) {
-                    const col = new Map([]);
-                    iterate((kv_1) => {
-                        const rI = kv_1[0] | 0;
-                        if (rI > rowEndIndex) {
-                            addToDict(col, rI - range, kv_1[1]);
-                        }
-                        else if (rI < rowStartIndex) {
-                            addToDict(col, rI, kv_1[1]);
-                        }
-                    }, vals);
-                    values.Columns.set(kv[0], ColumnValueRefs_Sparse(col));
-                }
-                else {
-                    for (let rowIndex = rowStartIndex; rowIndex <= rowEndIndex; rowIndex++) {
-                        vals.delete(rowIndex);
-                    }
-                }
-            }
-        }, values.Columns);
-        values.RowCount = ((values.RowCount - ((rowEndIndex - rowStartIndex) + 1)) | 0);
-    }
-}
-export function Unchecked_moveColumnCellsTo(fromCol, toCol, values) {
-    let matchValue;
-    const dict = values.Columns;
-    let patternInput;
-    let outArg = defaultOf();
-    patternInput = [tryGetValue(dict, fromCol, new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    matchValue = (patternInput[0] ? patternInput[1] : undefined);
-    if (matchValue != null) {
-        const col = value_3(matchValue);
-        Unchecked_removeColumnCells(fromCol, values);
-        const key_1 = toCol | 0;
-        const value = col;
-        const dict_1 = values.Columns;
-        if (dict_1.has(key_1)) {
-            dict_1.set(key_1, value);
-        }
-        else {
-            addToDict(dict_1, key_1, value);
-        }
-    }
-}
-/**
- * Add a new column to the ArcTableValues.
- */
-export function Unchecked_addRefColumn(newHeader, newCol, rowCount, 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_3(hasDuplicateUnique)}\``);
-    }
-    if (rowCount > values.RowCount) {
-        values.RowCount = (rowCount | 0);
-        let enumerator = getEnumerator(values.Columns);
-        try {
-            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                values.Columns.set(kv[0], ColumnValueRefs__ToSparse_Z524259A4(kv[1], values.RowCount));
-            }
-        }
-        finally {
-            disposeSafe(enumerator);
-        }
-    }
-    if ((((rowCount < values.RowCount) && (hasDuplicateUnique != null)) && forceReplace) && (values.Columns.size === 1)) {
-        values.RowCount = (rowCount | 0);
-    }
-    if (hasDuplicateUnique != null) {
-        numberOfNewColumns = 0;
-        index_1 = (value_3(hasDuplicateUnique) | 0);
-    }
-    const matchValue = headers.length | 0;
-    const matchValue_1 = values.RowCount | 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_1(startColCount - 1, 0) | 0;
-        for (let columnIndex = lastColumnIndex; columnIndex >= index_1; columnIndex--) {
-            Unchecked_moveColumnCellsTo(columnIndex, columnIndex + numberOfNewColumns, values);
-        }
-    }
-    if (!onlyHeaders) {
-        const key = index_1 | 0;
-        const value = newCol;
-        const dict = values.Columns;
-        if (dict.has(key)) {
-            dict.set(key, value);
-        }
-        else {
-            addToDict(dict, key, value);
-        }
-    }
-}
-export function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeaders, headers, values) {
-    Unchecked_addRefColumn(newHeader, ColumnValueRefs_fromCellColumn_14896151(newCells, values.RowCount, values.ValueMap), length(newCells), index, forceReplace, onlyHeaders, headers, values);
-}
-export function Unchecked_addColumnFill(newHeader, newCell, index, forceReplace, onlyHeaders, headers, values) {
-    Unchecked_addRefColumn(newHeader, ColumnValueRefs_Constant(ensureCellHashInValueMap(newCell, values.ValueMap)), 1, index, forceReplace, onlyHeaders, headers, values);
-}
-export function Unchecked_fillMissingCells(headers, values) {
-    let i_1;
-    if (values.RowCount === 0) {
-    }
-    else {
-        for (let i = 0; i <= (values.ColumnCount - 1); i++) {
-            let matchValue;
-            const dict = values.Columns;
-            let patternInput;
-            let outArg = defaultOf();
-            patternInput = [tryGetValue(dict, i, new FSharpRef(() => outArg, (v) => {
-                    outArg = v;
-                })), outArg];
-            matchValue = (patternInput[0] ? patternInput[1] : undefined);
-            if (matchValue != null) {
-                if (value_3(matchValue).tag === /* Sparse */ 1) {
-                    const vals = value_3(matchValue).fields[0];
-                    if (vals.size < values.RowCount) {
-                        const header = headers[i];
-                        const defaultHash = ensureCellHashInValueMap((vals.size === 0) ? getEmptyCellForHeader(header, undefined) : ((i_1 = (max(vals.keys(), {
-                            Compare: comparePrimitives,
-                        }) | 0), getEmptyCellForHeader(header, getItemFromDict(values.ValueMap, getItemFromDict(vals, i_1))))), values.ValueMap) | 0;
-                        for (let j = vals.size; j <= (values.RowCount - 1); j++) {
-                            if (!vals.has(j)) {
-                                addToDict(vals, j, defaultHash);
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                const col = ColumnValueRefs_Constant(ensureCellHashInValueMap(getEmptyCellForHeader(headers[i], undefined), values.ValueMap));
-                const value = addToDict(values.Columns, i, col);
-            }
-        }
-    }
-}
-export function Unchecked_addEmptyRow(index, values) {
-    if ((index < values.RowCount) && (values.ColumnCount !== 0)) {
-        let enumerator = getEnumerator(values.Columns);
-        try {
-            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-                const matchValue = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()[1];
-                if (matchValue.tag === /* Sparse */ 1) {
-                    const dict = matchValue.fields[0];
-                    const maxIndex = max(dict.keys(), {
-                        Compare: comparePrimitives,
-                    }) | 0;
-                    for (let i = maxIndex; i >= ((index + 1) - 1); i--) {
-                        if (dict.has(i)) {
-                            const v = getItemFromDict(dict, i) | 0;
-                            dict.delete(i);
-                            addToDict(dict, i + 1, v);
-                        }
-                    }
-                }
-                else {
-                    const valueHash = matchValue.fields[0] | 0;
-                }
-            }
-        }
-        finally {
-            disposeSafe(enumerator);
-        }
-    }
-    values.RowCount = ((values.RowCount + 1) | 0);
-}
-export function Unchecked_addRow(index, newCells, headers, values) {
-    const rowCount = values.RowCount | 0;
-    const columnCount = values.ColumnCount | 0;
-    let increaseRowIndices;
-    if (index < rowCount) {
-        const lastRowIndex = max_1(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 = ResizeArray_iteri((columnIndex_1, cell) => {
-        Unchecked_setCellAt(columnIndex_1, index, cell, values);
-    }, newCells);
-}
-export function Unchecked_addRows(index, newRows, headers, values) {
-    const rowCount = values.RowCount | 0;
-    const columnCount = values.ColumnCount | 0;
-    const numNewRows = newRows.length | 0;
-    let increaseRowIndices;
-    if (index < rowCount) {
-        const lastRowIndex = max_1(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;
-    let enumerator = getEnumerator(newRows);
-    try {
-        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            const setNewCells = ResizeArray_iteri((columnIndex_1, cell) => {
-                Unchecked_setCellAt(columnIndex_1, currentRowIndex, cell, values);
-            }, enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
-            currentRowIndex = ((currentRowIndex + 1) | 0);
-        }
-    }
-    finally {
-        disposeSafe(enumerator);
-    }
-}
-/**
- * Returns true, if two composite headers share the same main header string
- */
-export function Unchecked_compositeHeaderMainColumnEqual(ch1, ch2) {
-    return toString(ch1) === 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
- */
-export function Unchecked_moveColumnTo(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 = getEnumerator(toList(rangeDouble(shiftStart, op_UnaryNegation_Int32(shift), shiftEnd)));
-    try {
-        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
-            setItem(headers, c + shift, headers[c]);
-        }
-    }
-    finally {
-        disposeSafe(enumerator);
-    }
-    setItem(headers, toCol, header);
-    const col = getItemFromDict(values.Columns, fromCol);
-    const enumerator_1 = getEnumerator(toList(rangeDouble(shiftStart, 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.Columns.set(c_1 + shift, getItemFromDict(values.Columns, c_1));
-        }
-    }
-    finally {
-        disposeSafe(enumerator_1);
-    }
-    values.Columns.set(toCol, col);
-}
-/**
- * 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 = ArcTableValues.init();
-    values.RowCount = (length_1(rows) | 0);
-    const loop = (colI_mut, rows_2_mut) => {
-        loop: while (true) {
-            const colI = colI_mut, rows_2 = rows_2_mut;
-            if (!exists((arg) => !isEmpty_1(arg), rows_2)) {
-                return [headers, values];
-            }
-            else {
-                const firstElem = pick((l) => (isEmpty_1(l) ? undefined : head(l)), rows_2)[0];
-                void (headers.push(firstElem));
-                colI_mut = (colI + 1);
-                rows_2_mut = mapIndexed((rowI, l_1) => {
-                    if (keepOrder) {
-                        if (!isEmpty_1(l_1)) {
-                            if (Unchecked_compositeHeaderMainColumnEqual(head(l_1)[0], firstElem)) {
-                                Unchecked_setCellAt(colI, rowI, head(l_1)[1], values);
-                                return tail_1(l_1);
-                            }
-                            else {
-                                return l_1;
-                            }
-                        }
-                        else {
-                            return empty_1();
-                        }
-                    }
-                    else {
-                        const patternInput = 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 {
-                            Unchecked_setCellAt(colI, rowI, value_3(firstMatch), values);
-                            return newL;
-                        }
-                    }
-                }, rows_2);
-                continue loop;
-            }
-            break;
-        }
-    };
-    return loop(0, rows);
-}