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

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

@@ -1,70 +1,443 @@
-import { op_UnaryNegation_Int32 } from "@fable-org/fable-library-js/Int32.js";
-import { getItemFromDict, tryGetValue, addToDict } from "@fable-org/fable-library-js/MapUtil.js";
 import { CompositeCell } from "./CompositeCell.js";
-import { numberHash, disposeSafe, getEnumerator, compare, equals, safeHash, comparePrimitives, defaultOf, arrayHash, equalArrays } from "@fable-org/fable-library-js/Util.js";
-import { Dictionary } from "@fable-org/fable-library-js/MutableMap.js";
-import { toString, FSharpRef } from "@fable-org/fable-library-js/Types.js";
-import { value as value_2 } from "@fable-org/fable-library-js/Option.js";
-import { toList, head as head_1, toArray, filter, tryFindIndex, maxBy } from "@fable-org/fable-library-js/Seq.js";
-import { mapIndexed, pick, exists, ofSeq, empty, head, tail as tail_1, isEmpty, cons } from "@fable-org/fable-library-js/List.js";
-import { printf, toConsole } from "@fable-org/fable-library-js/String.js";
-import { max } from "@fable-org/fable-library-js/Double.js";
-import { setItem, item, map, iterateIndexed } from "@fable-org/fable-library-js/Array.js";
-import { tryFind, ofArray } from "@fable-org/fable-library-js/Map.js";
-import { Array_groupBy } from "@fable-org/fable-library-js/Seq2.js";
-import { FSharpSet__Contains, ofArray as ofArray_1 } from "@fable-org/fable-library-js/Set.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 { List_tryPickAndRemove } from "../Helper/Collections.js";
-export function CellDictionary_addOrUpdate(key_, key__1, value, dict) {
-    const key = [key_, key__1];
-    if (dict.has(key)) {
-        dict.set(key, value);
+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 {
-        addToDict(dict, key, value);
+        return CompositeCell.emptyFreeText;
     }
 }
-export function CellDictionary_ofSeq(s) {
-    return new Dictionary(s, {
-        Equals: equalArrays,
-        GetHashCode: arrayHash,
-    });
+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 CellDictionary_tryFind(key_, key__1, dict) {
-    let patternInput;
-    let outArg = defaultOf();
-    patternInput = [tryGetValue(dict, [key_, key__1], new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    if (patternInput[0]) {
-        return patternInput[1];
+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 getColumnCount(headers) {
-    return headers.length;
+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 getRowCount(values) {
-    if (values.size === 0) {
-        return 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 {
-        return (1 + maxBy((tuple) => tuple[1], values.keys(), {
+        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]) | 0;
+        }) - 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 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);
+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$);
     }
-    return hash;
+}
+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) {
@@ -88,7 +461,7 @@ export function $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, input) {
 export function tryFindDuplicateUnique(newHeader, existingHeaders) {
     const activePatternResult = $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, newHeader);
     if (activePatternResult != null) {
-        const index = value_2(activePatternResult) | 0;
+        const index = value_3(activePatternResult) | 0;
         return index;
     }
     else {
@@ -103,10 +476,10 @@ export function tryFindDuplicateUniqueInArray(existingHeaders) {
         loop: while (true) {
             const i = i_mut, duplicateList = duplicateList_mut, headerList = headerList_mut;
             let matchResult, header, tail;
-            if (isEmpty(headerList)) {
+            if (isEmpty_1(headerList)) {
                 matchResult = 0;
             }
-            else if (isEmpty(tail_1(headerList))) {
+            else if (isEmpty_1(tail_1(headerList))) {
                 matchResult = 0;
             }
             else {
@@ -123,7 +496,7 @@ export function tryFindDuplicateUniqueInArray(existingHeaders) {
                     duplicateList_mut = ((hasDuplicate != null) ? cons({
                         HeaderType: header,
                         Index1: i,
-                        Index2: value_2(hasDuplicate),
+                        Index2: value_3(hasDuplicate),
                     }, duplicateList) : duplicateList);
                     headerList_mut = tail;
                     continue loop;
@@ -132,7 +505,7 @@ export function tryFindDuplicateUniqueInArray(existingHeaders) {
             break;
         }
     };
-    return loop(0, empty(), ofSeq(filter((x) => !x.IsTermColumn, existingHeaders)));
+    return loop(0, empty_1(), ofSeq(filter((x) => !x.IsTermColumn, existingHeaders)));
 }
 /**
  * Checks if given column index is valid for given number of columns.
@@ -169,63 +542,261 @@ export function SanityChecks_validateRowIndex(index, rowCount, allowAppend) {
 export function SanityChecks_validateColumn(column) {
     column.Validate(true);
 }
-export function SanityChecks_validate(headers, values, raiseException) {
-    let clo, clo_1;
+export function SanityChecks_validateCellColumns(headers, columns, raiseException) {
+    let clo, clo_1, clo_2;
     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]];
-        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 = toConsole(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 = toConsole(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;
+    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 Unchecked_tryGetCellAt(column, row, cells) {
-    return CellDictionary_tryFind(column, row, cells);
+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, cells) {
-    cells.set([columnIndex, rowIndex], c);
+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));
+    }
 }
-/**
- * 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_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, cells) {
-    const matchValue = CellDictionary_tryFind(fromCol, fromRow, cells);
+export function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, values) {
+    const matchValue = Unchecked_tryGetCellAt(fromCol, fromRow, values);
     if (matchValue == null) {
     }
     else {
-        const c = value_2(matchValue);
-        cells.delete([fromCol, fromRow]);
-        const value_1 = Unchecked_setCellAt(toCol, toRow, c, cells);
+        const cell = value_3(matchValue);
+        Unchecked_removeCellAt(fromCol, fromRow, values);
+        Unchecked_setCellAt(toCol, toRow, cell, values);
     }
 }
 export function Unchecked_removeHeader(index, headers) {
@@ -234,203 +805,263 @@ export function Unchecked_removeHeader(index, headers) {
 /**
  * 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);
-    }
+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(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]);
+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 (col > index) {
-                Unchecked_moveCellTo(col, row, col - 1, row, cells);
+            else if (cI < colIndex) {
+                addToDict(cols, cI, kv[1]);
             }
-        }
+        }, values.Columns);
+        values.Columns = cols;
     }
-}
-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]);
-            }
-        }
+    else {
+        const value = Unchecked_removeColumnCells(colIndex, values);
     }
-    finally {
-        disposeSafe(enumerator);
+}
+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, 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);
+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);
     }
 }
 /**
- * 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.
+ * Remove cells of one Row, change index of cells with higher index to index - 1
  */
-export function Unchecked_getEmptyCellForHeader(header, columCellOption) {
-    const matchValue = header.IsTermColumn;
-    if (matchValue) {
-        let matchResult;
-        if (columCellOption == null) {
-            matchResult = 0;
-        }
-        else {
-            switch (value_2(columCellOption).tag) {
-                case /* Term */ 0: {
-                    matchResult = 0;
-                    break;
+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));
                 }
-                case /* Unitized */ 2: {
-                    matchResult = 1;
-                    break;
+                else {
+                    for (let rowIndex = rowStartIndex; rowIndex <= rowEndIndex; rowIndex++) {
+                        vals.delete(rowIndex);
+                    }
                 }
-                default:
-                    matchResult = 2;
             }
+        }, 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);
         }
-        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 {
+            addToDict(dict_1, key_1, value);
         }
     }
-    else {
-        return CompositeCell.emptyFreeText;
-    }
 }
 /**
- *
+ * Add a new column to the ArcTableValues.
  */
-export function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeaders, headers, values) {
+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_2(hasDuplicateUnique)}\``);
+        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_2(hasDuplicateUnique) | 0);
+        index_1 = (value_3(hasDuplicateUnique) | 0);
     }
-    const matchValue = getColumnCount(headers) | 0;
-    const matchValue_1 = getRowCount(values) | 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(startColCount - 1, 0) | 0;
+        const lastColumnIndex = max_1(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);
-            }
+            Unchecked_moveColumnCellsTo(columnIndex, columnIndex + numberOfNewColumns, values);
         }
     }
     if (!onlyHeaders) {
-        if (hasDuplicateUnique != null) {
-            Unchecked_removeColumnCells(index_1, values);
+        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);
         }
-        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_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 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, undefined);
-            for (let rowIndex_1 = 0; rowIndex_1 <= (rowCount - 1); rowIndex_1++) {
-                Unchecked_addCellAt(columnIndex, rowIndex_1, defaultCell_1.Copy(), values);
-            }
-        }
-        else if ((col = value_2(matchValue), col.length === rowCount)) {
-            const col_1 = value_2(matchValue);
-        }
-        else {
-            const col_2 = value_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), {
-                Compare: comparePrimitives,
-            });
-            for (let rowIndex = 0; rowIndex <= (rowCount - 1); rowIndex++) {
-                if (!FSharpSet__Contains(rowKeys, rowIndex)) {
-                    Unchecked_addCellAt(columnIndex, rowIndex, defaultCell.Copy(), 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);
+            }
         }
     }
 }
-/**
- * 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_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 = getRowCount(values) | 0;
-    const columnCount = getColumnCount(headers) | 0;
+    const rowCount = values.RowCount | 0;
+    const columnCount = values.ColumnCount | 0;
     let increaseRowIndices;
     if (index < rowCount) {
-        const lastRowIndex = max(rowCount - 1, 0) | 0;
+        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);
@@ -440,17 +1071,17 @@ export function Unchecked_addRow(index, newCells, headers, values) {
     else {
         increaseRowIndices = undefined;
     }
-    const setNewCells = iterateIndexed((columnIndex_1, cell) => {
+    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 = getRowCount(values) | 0;
-    const columnCount = getColumnCount(headers) | 0;
+    const rowCount = values.RowCount | 0;
+    const columnCount = values.ColumnCount | 0;
     const numNewRows = newRows.length | 0;
     let increaseRowIndices;
     if (index < rowCount) {
-        const lastRowIndex = max(rowCount - 1, 0) | 0;
+        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);
@@ -461,11 +1092,17 @@ export function Unchecked_addRows(index, newRows, headers, values) {
         increaseRowIndices = undefined;
     }
     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);
+    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);
     }
 }
 /**
@@ -479,7 +1116,7 @@ export function Unchecked_compositeHeaderMainColumnEqual(ch1, ch2) {
  *
  * This function moves the column from `fromCol` to `toCol` and shifts all columns in between accordingly
  */
-export function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values) {
+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;
@@ -496,20 +1133,18 @@ export function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values
         disposeSafe(enumerator);
     }
     setItem(headers, toCol, header);
-    for (let r = 0; r <= (rowCount - 1); r++) {
-        const cell = getItemFromDict(values, [fromCol, r]);
-        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.set([c_1 + shift, r], getItemFromDict(values, [c_1, r]));
-            }
-        }
-        finally {
-            disposeSafe(enumerator_1);
+    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));
         }
-        values.set([toCol, r], cell);
     }
+    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
@@ -522,25 +1157,23 @@ export function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values
  */
 export function Unchecked_alignByHeaders(keepOrder, rows) {
     const headers = [];
-    const values = new Dictionary([], {
-        Equals: equalArrays,
-        GetHashCode: arrayHash,
-    });
+    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(arg), rows_2)) {
+            if (!exists((arg) => !isEmpty_1(arg), rows_2)) {
                 return [headers, values];
             }
             else {
-                const firstElem = pick((l) => (isEmpty(l) ? undefined : head(l)), rows_2)[0];
+                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(l_1)) {
+                        if (!isEmpty_1(l_1)) {
                             if (Unchecked_compositeHeaderMainColumnEqual(head(l_1)[0], firstElem)) {
-                                addToDict(values, [colI, rowI], head(l_1)[1]);
+                                Unchecked_setCellAt(colI, rowI, head(l_1)[1], values);
                                 return tail_1(l_1);
                             }
                             else {
@@ -548,7 +1181,7 @@ export function Unchecked_alignByHeaders(keepOrder, rows) {
                             }
                         }
                         else {
-                            return empty();
+                            return empty_1();
                         }
                     }
                     else {
@@ -566,7 +1199,7 @@ export function Unchecked_alignByHeaders(keepOrder, rows) {
                             return newL;
                         }
                         else {
-                            addToDict(values, [colI, rowI], value_2(firstMatch));
+                            Unchecked_setCellAt(colI, rowI, value_3(firstMatch), values);
                             return newL;
                         }
                     }