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

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

@@ -1,103 +1,492 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CellDictionary_addOrUpdate = CellDictionary_addOrUpdate;
-exports.CellDictionary_ofSeq = CellDictionary_ofSeq;
-exports.CellDictionary_tryFind = CellDictionary_tryFind;
-exports.getColumnCount = getColumnCount;
-exports.getRowCount = getRowCount;
-exports.boxHashValues = boxHashValues;
+exports.ArcTableValues = exports.ColumnValueRefs = void 0;
+exports.getEmptyCellForHeader = getEmptyCellForHeader;
+exports.ensureCellHashInValueMap = ensureCellHashInValueMap;
+exports.ColumnValueRefs_Constant = ColumnValueRefs_Constant;
+exports.ColumnValueRefs_Sparse = ColumnValueRefs_Sparse;
+exports.ColumnValueRefs_$reflection = ColumnValueRefs_$reflection;
+exports.ColumnValueRefs__get_RowCount = ColumnValueRefs__get_RowCount;
+exports.ColumnValueRefs__Copy = ColumnValueRefs__Copy;
+exports.ColumnValueRefs__ToSparse_Z524259A4 = ColumnValueRefs__ToSparse_Z524259A4;
+exports.ColumnValueRefs__AsSparse = ColumnValueRefs__AsSparse;
+exports.ColumnValueRefs__AsConstant = ColumnValueRefs__AsConstant;
+exports.ColumnValueRefs_fromCellColumn_14896151 = ColumnValueRefs_fromCellColumn_14896151;
+exports.ColumnValueRefs__ToCellColumn_Z2609C9DD = ColumnValueRefs__ToCellColumn_Z2609C9DD;
+exports.ArcTableValues_$reflection = ArcTableValues_$reflection;
+exports.ArcTableValues_$ctor_39436F7C = ArcTableValues_$ctor_39436F7C;
 exports.$007CIsUniqueExistingHeader$007C_$007C = $007CIsUniqueExistingHeader$007C_$007C;
 exports.tryFindDuplicateUnique = tryFindDuplicateUnique;
 exports.tryFindDuplicateUniqueInArray = tryFindDuplicateUniqueInArray;
 exports.SanityChecks_validateColumnIndex = SanityChecks_validateColumnIndex;
 exports.SanityChecks_validateRowIndex = SanityChecks_validateRowIndex;
 exports.SanityChecks_validateColumn = SanityChecks_validateColumn;
-exports.SanityChecks_validate = SanityChecks_validate;
+exports.SanityChecks_validateCellColumns = SanityChecks_validateCellColumns;
+exports.SanityChecks_validateArcTableValues = SanityChecks_validateArcTableValues;
 exports.Unchecked_tryGetCellAt = Unchecked_tryGetCellAt;
+exports.Unchecked_getCellWithDefault = Unchecked_getCellWithDefault;
 exports.Unchecked_setCellAt = Unchecked_setCellAt;
-exports.Unchecked_addCellAt = Unchecked_addCellAt;
+exports.Unchecked_removeCellAt = Unchecked_removeCellAt;
 exports.Unchecked_moveCellTo = Unchecked_moveCellTo;
 exports.Unchecked_removeHeader = Unchecked_removeHeader;
 exports.Unchecked_removeColumnCells = Unchecked_removeColumnCells;
 exports.Unchecked_removeColumnCells_withIndexChange = Unchecked_removeColumnCells_withIndexChange;
 exports.Unchecked_removeRowCells = Unchecked_removeRowCells;
 exports.Unchecked_removeRowCells_withIndexChange = Unchecked_removeRowCells_withIndexChange;
-exports.Unchecked_getEmptyCellForHeader = Unchecked_getEmptyCellForHeader;
+exports.Unchecked_removeRowRange_withIndexChange = Unchecked_removeRowRange_withIndexChange;
+exports.Unchecked_moveColumnCellsTo = Unchecked_moveColumnCellsTo;
+exports.Unchecked_addRefColumn = Unchecked_addRefColumn;
 exports.Unchecked_addColumn = Unchecked_addColumn;
+exports.Unchecked_addColumnFill = Unchecked_addColumnFill;
 exports.Unchecked_fillMissingCells = Unchecked_fillMissingCells;
-exports.Unchecked_extendToRowCount = Unchecked_extendToRowCount;
+exports.Unchecked_addEmptyRow = Unchecked_addEmptyRow;
 exports.Unchecked_addRow = Unchecked_addRow;
 exports.Unchecked_addRows = Unchecked_addRows;
 exports.Unchecked_compositeHeaderMainColumnEqual = Unchecked_compositeHeaderMainColumnEqual;
 exports.Unchecked_moveColumnTo = Unchecked_moveColumnTo;
 exports.Unchecked_alignByHeaders = Unchecked_alignByHeaders;
-const Int32_js_1 = require("@fable-org/fable-library-js/Int32.js");
-const MapUtil_js_1 = require("@fable-org/fable-library-js/MapUtil.js");
 const CompositeCell_js_1 = require("./CompositeCell.js");
+const Int32_js_1 = require("@fable-org/fable-library-js/Int32.js");
+const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
 const Util_js_1 = require("@fable-org/fable-library-js/Util.js");
-const MutableMap_js_1 = require("@fable-org/fable-library-js/MutableMap.js");
+const MapUtil_js_1 = require("@fable-org/fable-library-js/MapUtil.js");
 const Types_js_1 = require("@fable-org/fable-library-js/Types.js");
-const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
+const Reflection_js_1 = require("@fable-org/fable-library-js/Reflection.js");
 const Seq_js_1 = require("@fable-org/fable-library-js/Seq.js");
-const List_js_1 = require("@fable-org/fable-library-js/List.js");
+const Collections_js_1 = require("../Helper/Collections.js");
 const String_js_1 = require("@fable-org/fable-library-js/String.js");
+const Range_js_1 = require("@fable-org/fable-library-js/Range.js");
+const List_js_1 = require("@fable-org/fable-library-js/List.js");
 const Double_js_1 = require("@fable-org/fable-library-js/Double.js");
 const Array_js_1 = require("@fable-org/fable-library-js/Array.js");
-const Map_js_1 = require("@fable-org/fable-library-js/Map.js");
-const Seq2_js_1 = require("@fable-org/fable-library-js/Seq2.js");
-const Set_js_1 = require("@fable-org/fable-library-js/Set.js");
-const Range_js_1 = require("@fable-org/fable-library-js/Range.js");
-const Collections_js_1 = require("../Helper/Collections.js");
-function CellDictionary_addOrUpdate(key_, key__1, value, dict) {
-    const key = [key_, key__1];
-    if (dict.has(key)) {
-        dict.set(key, value);
+/**
+ * Get an empty cell fitting for related column header.
+ *
+ * `columCellOption` is used to decide between `CompositeCell.Term` or `CompositeCell.Unitized`. `columCellOption` can be any other cell in the same column, preferably the first one.
+ */
+function getEmptyCellForHeader(header, columCellOption) {
+    const matchValue = header.IsTermColumn;
+    if (matchValue) {
+        let matchResult;
+        if (columCellOption == null) {
+            matchResult = 0;
+        }
+        else {
+            switch ((0, Option_js_1.value)(columCellOption).tag) {
+                case /* Term */ 0: {
+                    matchResult = 0;
+                    break;
+                }
+                case /* Unitized */ 2: {
+                    matchResult = 1;
+                    break;
+                }
+                default:
+                    matchResult = 2;
+            }
+        }
+        switch (matchResult) {
+            case 0:
+                return CompositeCell_js_1.CompositeCell.emptyTerm;
+            case 1:
+                return CompositeCell_js_1.CompositeCell.emptyUnitized;
+            default:
+                throw new Error("[extendBodyCells] This should never happen, IsTermColumn header must be paired with either term or unitized cell.");
+        }
     }
     else {
-        (0, MapUtil_js_1.addToDict)(dict, key, value);
+        return CompositeCell_js_1.CompositeCell.emptyFreeText;
     }
 }
-function CellDictionary_ofSeq(s) {
-    return new MutableMap_js_1.Dictionary(s, {
-        Equals: Util_js_1.equalArrays,
-        GetHashCode: Util_js_1.arrayHash,
-    });
+function ensureCellHashInValueMap(value, valueMap) {
+    const hash = (0, Util_js_1.safeHash)(value) | 0;
+    if (valueMap.has(hash)) {
+        return hash | 0;
+    }
+    else {
+        (0, MapUtil_js_1.addToDict)(valueMap, hash, value);
+        return hash | 0;
+    }
 }
-function CellDictionary_tryFind(key_, key__1, dict) {
-    let patternInput;
-    let outArg = (0, Util_js_1.defaultOf)();
-    patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, [key_, key__1], new Types_js_1.FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    if (patternInput[0]) {
-        return patternInput[1];
+function ColumnValueRefs_Constant(Item) {
+    return new ColumnValueRefs(0, [Item]);
+}
+function ColumnValueRefs_Sparse(Item) {
+    return new ColumnValueRefs(1, [Item]);
+}
+class ColumnValueRefs extends Types_js_1.Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Constant", "Sparse"];
+    }
+}
+exports.ColumnValueRefs = ColumnValueRefs;
+function ColumnValueRefs_$reflection() {
+    return (0, Reflection_js_1.union_type)("ARCtrl.ArcTableAux.ColumnValueRefs", [], ColumnValueRefs, () => [[["Item", Reflection_js_1.int32_type]], [["Item", (0, Reflection_js_1.class_type)("System.Collections.Generic.Dictionary`2", [Reflection_js_1.int32_type, Reflection_js_1.int32_type])]]]);
+}
+function ColumnValueRefs__get_RowCount(this$) {
+    if (this$.tag === /* Sparse */ 1) {
+        return (0, Seq_js_1.maxBy)((kv) => kv[0], this$.fields[0], {
+            Compare: Util_js_1.comparePrimitives,
+        });
     }
     else {
         return undefined;
     }
 }
-function getColumnCount(headers) {
-    return headers.length;
+function ColumnValueRefs__Copy(this$) {
+    if (this$.tag === /* Sparse */ 1) {
+        const values = this$.fields[0];
+        const d = new Map([]);
+        (0, Seq_js_1.iterate)((v) => {
+            (0, MapUtil_js_1.addToDict)(d, v[0], v[1]);
+        }, values);
+        return ColumnValueRefs_Sparse(d);
+    }
+    else {
+        return ColumnValueRefs_Constant(this$.fields[0]);
+    }
 }
-function getRowCount(values) {
-    if (values.size === 0) {
-        return 0;
+function ColumnValueRefs__ToSparse_Z524259A4(this$, rowCount) {
+    if (this$.tag === /* Sparse */ 1) {
+        return ColumnValueRefs_Sparse(this$.fields[0]);
     }
     else {
-        return (1 + (0, Seq_js_1.maxBy)((tuple) => tuple[1], values.keys(), {
+        const valueHash = this$.fields[0] | 0;
+        const d = new Map([]);
+        for (let i = 0; i <= (rowCount - 1); i++) {
+            (0, MapUtil_js_1.addToDict)(d, i, valueHash);
+        }
+        return ColumnValueRefs_Sparse(d);
+    }
+}
+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.");
+    }
+}
+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;
+    }
+}
+function ColumnValueRefs_fromCellColumn_14896151(column, previousRowCount, valueMap) {
+    const l = (0, Seq_js_1.length)(column) | 0;
+    const cells = new Map([]);
+    if (l === 0) {
+        return ColumnValueRefs_Sparse(cells);
+    }
+    else {
+        let current;
+        const hash = ensureCellHashInValueMap((0, Seq_js_1.item)(0, column), valueMap) | 0;
+        if (l >= previousRowCount) {
+            current = ColumnValueRefs_Constant(hash);
+        }
+        else {
+            (0, MapUtil_js_1.addToDict)(cells, 0, hash);
+            current = ColumnValueRefs_Sparse(cells);
+        }
+        (0, Seq_js_1.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;
+    }
+}
+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, (0, MapUtil_js_1.getItemFromDict)(valueMap, (0, MapUtil_js_1.getItemFromDict)(values, (0, Seq_js_1.max)(values.keys(), {
             Compare: Util_js_1.comparePrimitives,
-        })[1]) | 0;
+        }) - 1)));
+        return (0, Collections_js_1.ResizeArray_init)(rowCount, (i_1) => (values.has(i_1) ? (0, MapUtil_js_1.getItemFromDict)(valueMap, (0, MapUtil_js_1.getItemFromDict)(values, i_1)) : defaultCell));
+    }
+    else {
+        return (0, Collections_js_1.ResizeArray_create)(rowCount, (0, MapUtil_js_1.getItemFromDict)(valueMap, this$.fields[0]));
     }
 }
-function boxHashValues(colCount, values) {
-    let hash = 0;
-    const rowCount = getRowCount(values) | 0;
-    for (let col = 0; col <= (colCount - 1); col++) {
-        for (let row = 0; row <= (rowCount - 1); row++) {
-            hash = ((((-1640531527 + (0, Util_js_1.safeHash)((0, MapUtil_js_1.getItemFromDict)(values, [col, row]))) + (hash << 6)) + (hash >> 2)) | 0);
+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 ((0, Seq_js_1.isEmpty)(this$._columns) ? 0 : (1 + (0, Seq_js_1.max)(this$._columns.keys(), {
+            Compare: Util_js_1.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 = (0, Util_js_1.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 = (0, Util_js_1.getEnumerator)((0, Seq_js_1.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 {
+                            (0, Util_js_1.disposeSafe)(enumerator_1);
+                        }
+                    }
+                }
+            }
+            finally {
+                (0, Util_js_1.disposeSafe)(enumerator);
+            }
+        }
+        this$._rowCount = (rowCount | 0);
+    }
+    static fromCellColumns(columns) {
+        const rowCount = ((columns.length === 0) ? 0 : (0, Seq_js_1.max)((0, Collections_js_1.ResizeArray_map)((c) => c.length, columns), {
+            Compare: Util_js_1.comparePrimitives,
+        })) | 0;
+        const valueMap = new Map([]);
+        const parsedColumns = new Map([]);
+        (0, Seq_js_1.iterateIndexed)((i, column) => {
+            (0, MapUtil_js_1.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([]);
+        (0, Seq_js_1.iterateIndexed)((i, column) => {
+            (0, MapUtil_js_1.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 (0, Collections_js_1.ResizeArray_init)(headers.length, (i) => {
+            const header = headers[i];
+            return ColumnValueRefs__ToCellColumn_Z2609C9DD((0, MapUtil_js_1.getItemFromDict)(this$._columns, i), this$._valueMap, this$._rowCount, header);
+        });
+    }
+    RescanValueMap() {
+        const this$ = this;
+        const newValueMap = new Map([]);
+        let enumerator = (0, Util_js_1.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 = (0, Util_js_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((0, MapUtil_js_1.getItemFromDict)(this$._valueMap, ckv[1]), newValueMap) | 0;
+                            values.set(ckv[0], hash_1);
+                        }
+                    }
+                    finally {
+                        (0, Util_js_1.disposeSafe)(enumerator_1);
+                    }
+                }
+                else {
+                    const valueHash = matchValue.fields[0] | 0;
+                    const hash = ensureCellHashInValueMap((0, MapUtil_js_1.getItemFromDict)(this$._valueMap, valueHash), newValueMap) | 0;
+                    this$._columns.set(kv[0], ColumnValueRefs_Constant(hash));
+                }
+            }
+        }
+        finally {
+            (0, Util_js_1.disposeSafe)(enumerator);
+        }
+        this$._valueMap = newValueMap;
+    }
+    Copy() {
+        const this$ = this;
+        const nextValueMap = new Map([]);
+        (0, Seq_js_1.iterate)((kv) => {
+            (0, MapUtil_js_1.addToDict)(nextValueMap, kv[0], kv[1].Copy());
+        }, this$._valueMap);
+        const nextColumns = new Map([]);
+        (0, Seq_js_1.iterate)((kv_1) => {
+            (0, MapUtil_js_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 = (0, Util_js_1.defaultOf)();
+            patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, i, new Types_js_1.FSharpRef(() => outArg, (v) => {
+                    outArg = v;
+                })), outArg];
+            matchValue = (patternInput[0] ? patternInput[1] : undefined);
+            if (matchValue != null) {
+                if ((0, Option_js_1.value)(matchValue).tag === /* Sparse */ 1) {
+                    const values = (0, Option_js_1.value)(matchValue).fields[0];
+                    let enumerator = (0, Util_js_1.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 {
+                        (0, Util_js_1.disposeSafe)(enumerator);
+                    }
+                }
+                else {
+                    const valueHash = (0, Option_js_1.value)(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, (0, Util_js_1.safeHash)(this$) === (0, Util_js_1.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;
+            (0, String_js_1.toFail)((0, String_js_1.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;
+            (0, String_js_1.toFail)((0, String_js_1.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 = (0, Util_js_1.defaultOf)();
+        patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, col, new Types_js_1.FSharpRef(() => outArg, (v) => {
+                outArg = v;
+            })), outArg];
+        matchValue = (patternInput[0] ? patternInput[1] : undefined);
+        if (matchValue != null) {
+            const colValueRefs = (0, Option_js_1.value)(matchValue);
+            if (colValueRefs.tag === /* Sparse */ 1) {
+                const values = colValueRefs.fields[0];
+                return values.has(row) ? (0, MapUtil_js_1.getItemFromDict)(this$._valueMap, (0, MapUtil_js_1.getItemFromDict)(values, row)) : (0, String_js_1.toFail)((0, String_js_1.printf)("Row value for index %d does not exist in column %d of ArcTableValues."))(row)(col);
+            }
+            else {
+                const valueHash = colValueRefs.fields[0] | 0;
+                return (0, MapUtil_js_1.getItemFromDict)(this$._valueMap, valueHash);
+            }
+        }
+        else {
+            return (0, String_js_1.toFail)((0, String_js_1.printf)("Column %d does not exist in ArcTableValues."))(col);
+        }
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return (0, Util_js_1.getEnumerator)((0, Seq_js_1.delay)(() => (0, Seq_js_1.collect)((colI) => {
+            let matchValue;
+            const dict = this$._columns;
+            let patternInput;
+            let outArg = (0, Util_js_1.defaultOf)();
+            patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, colI, new Types_js_1.FSharpRef(() => outArg, (v) => {
+                    outArg = v;
+                })), outArg];
+            matchValue = (patternInput[0] ? patternInput[1] : undefined);
+            if (matchValue != null) {
+                const matchValue_1 = (0, Option_js_1.value)(matchValue);
+                if (matchValue_1.tag === /* Sparse */ 1) {
+                    const values = matchValue_1.fields[0];
+                    return (0, Seq_js_1.collect)((rowI_1) => (values.has(rowI_1) ? (0, Seq_js_1.singleton)([[colI, rowI_1], (0, MapUtil_js_1.getItemFromDict)(this$._valueMap, (0, MapUtil_js_1.getItemFromDict)(values, rowI_1))]) : (0, Seq_js_1.empty)()), (0, Range_js_1.rangeDouble)(0, 1, this$._rowCount - 1));
+                }
+                else {
+                    const valueHash = matchValue_1.fields[0] | 0;
+                    return (0, Seq_js_1.map)((rowI) => [[colI, rowI], (0, MapUtil_js_1.getItemFromDict)(this$._valueMap, valueHash)], (0, Range_js_1.rangeDouble)(0, 1, this$._rowCount - 1));
+                }
+            }
+            else {
+                return (0, Seq_js_1.empty)();
+            }
+        }, (0, Range_js_1.rangeDouble)(0, 1, this$.ColumnCount - 1))));
+    }
+    [Symbol.iterator]() {
+        return (0, Util_js_1.toIterator)((0, Util_js_1.getEnumerator)(this));
     }
-    return hash;
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return (0, Util_js_1.getEnumerator)(this$);
+    }
+}
+exports.ArcTableValues = ArcTableValues;
+function ArcTableValues_$reflection() {
+    return (0, Reflection_js_1.class_type)("ARCtrl.ArcTableAux.ArcTableValues", undefined, ArcTableValues);
+}
+function ArcTableValues_$ctor_39436F7C(cols, valueMap, rowCount) {
+    return new ArcTableValues(cols, valueMap, rowCount);
 }
 function $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, input) {
     switch (input.tag) {
@@ -202,63 +591,261 @@ function SanityChecks_validateRowIndex(index, rowCount, allowAppend) {
 function SanityChecks_validateColumn(column) {
     column.Validate(true);
 }
-function SanityChecks_validate(headers, values, raiseException) {
-    let clo, clo_1;
+function SanityChecks_validateCellColumns(headers, columns, raiseException) {
+    let clo, clo_1, clo_2;
     let isValid = true;
-    let en = (0, Util_js_1.getEnumerator)(values);
-    while (isValid && en["System.Collections.IEnumerator.MoveNext"]()) {
-        let matchValue;
-        let copyOfStruct = en["System.Collections.Generic.IEnumerator`1.get_Current"]();
-        matchValue = copyOfStruct[0];
-        let cell;
-        let copyOfStruct_1 = en["System.Collections.Generic.IEnumerator`1.get_Current"]();
-        cell = copyOfStruct_1[1];
-        const header = headers[matchValue[0]];
-        const headerIsData = header.IsDataColumn;
-        const headerIsFreetext = !header.IsTermColumn && !header.IsDataColumn;
-        const cellIsNotFreetext = !cell.isFreeText;
-        if (headerIsData && (!cell.isData && cellIsNotFreetext)) {
-            (raiseException ? ((message) => {
-                throw new Error(message);
-            }) : ((clo = (0, String_js_1.toConsole)((0, String_js_1.printf)("%s")), (arg) => {
-                clo(arg);
-            })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Data header should contain either Data or Freetext cells.`);
-            isValid = false;
-        }
-        if (headerIsFreetext && cellIsNotFreetext) {
-            (raiseException ? ((message_1) => {
-                throw new Error(message_1);
-            }) : ((clo_1 = (0, String_js_1.toConsole)((0, String_js_1.printf)("%s")), (arg_1) => {
-                clo_1(arg_1);
-            })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Freetext header should not contain non-freetext cells.`);
-            isValid = false;
+    let en = (0, Util_js_1.getEnumerator)(headers);
+    let colIndex = 0;
+    if ((headers.length !== columns.length) && (columns.length !== 0)) {
+        (raiseException ? ((message) => {
+            throw new Error(message);
+        }) : ((clo = (0, String_js_1.toConsole)((0, String_js_1.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 = (0, Util_js_1.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 = (0, String_js_1.toConsole)((0, String_js_1.printf)("%s")), (arg_1) => {
+                    clo_1(arg_1);
+                })))(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Data header should contain either Data or Freetext cells.`);
+                isValid = false;
+            }
+            if (headerIsFreetext && cellIsNotFreetext) {
+                (raiseException ? ((message_2) => {
+                    throw new Error(message_2);
+                }) : ((clo_2 = (0, String_js_1.toConsole)((0, String_js_1.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;
 }
-function Unchecked_tryGetCellAt(column, row, cells) {
-    return CellDictionary_tryFind(column, row, cells);
+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 = (0, String_js_1.toConsole)((0, String_js_1.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 = (0, Util_js_1.defaultOf)();
+            patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, key, new Types_js_1.FSharpRef(() => outArg, (v) => {
+                    outArg = v;
+                })), outArg];
+            matchValue = (patternInput[0] ? patternInput[1] : undefined);
+            if (matchValue != null) {
+                if ((0, Option_js_1.value)(matchValue).tag === /* Sparse */ 1) {
+                    const column = (0, Option_js_1.value)(matchValue).fields[0];
+                    let enumerator = (0, Util_js_1.getEnumerator)(column);
+                    try {
+                        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                            const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                            const cell_1 = (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, kv[1]);
+                            if (!cell_1.ValidateAgainstHeader(header, raiseException)) {
+                                isValid = false;
+                            }
+                        }
+                    }
+                    finally {
+                        (0, Util_js_1.disposeSafe)(enumerator);
+                    }
+                }
+                else {
+                    const hash = (0, Option_js_1.value)(matchValue).fields[0] | 0;
+                    const cell = (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, hash);
+                    if (!cell.ValidateAgainstHeader(header, raiseException)) {
+                        isValid = false;
+                    }
+                }
+            }
+            colIndex = ((colIndex + 1) | 0);
+        }
+    }
+    return isValid;
+}
+function Unchecked_tryGetCellAt(column, row, values) {
+    let dict, patternInput, outArg;
+    return (0, Option_js_1.bind)((col) => {
+        if (col.tag === /* Sparse */ 1) {
+            const vals = col.fields[0];
+            if (vals.has(row)) {
+                return (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, (0, MapUtil_js_1.getItemFromDict)(vals, row));
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            const valueHash = col.fields[0] | 0;
+            return (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, valueHash);
+        }
+    }, (dict = values.Columns, (patternInput = ((outArg = (0, Util_js_1.defaultOf)(), [(0, MapUtil_js_1.tryGetValue)(dict, column, new Types_js_1.FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg])), patternInput[0] ? patternInput[1] : undefined)));
+}
+function Unchecked_getCellWithDefault(column, row, headers, values) {
+    if (headers.length <= column) {
+        const arg_1 = headers.length | 0;
+        (0, String_js_1.toFail)((0, String_js_1.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 = (0, Util_js_1.defaultOf)();
+    patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, column, new Types_js_1.FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    matchValue = (patternInput[0] ? patternInput[1] : undefined);
+    if (matchValue == null) {
+        if (row < values.RowCount) {
+            return CompositeCell_js_1.CompositeCell.emptyFreeText;
+        }
+        else {
+            return getEmptyCellForHeader(headers[column], undefined);
+        }
+    }
+    else {
+        const col = (0, Option_js_1.value)(matchValue);
+        if (col.tag === /* Sparse */ 1) {
+            const vals = col.fields[0];
+            if (vals.has(row)) {
+                return (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, (0, MapUtil_js_1.getItemFromDict)(vals, row));
+            }
+            else if (vals.size === 0) {
+                return getEmptyCellForHeader(headers[column], undefined);
+            }
+            else {
+                const header_1 = headers[column];
+                const maxI = (0, Seq_js_1.max)(vals.keys(), {
+                    Compare: Util_js_1.comparePrimitives,
+                }) | 0;
+                return getEmptyCellForHeader(header_1, (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, (0, MapUtil_js_1.getItemFromDict)(vals, maxI)));
+            }
+        }
+        else {
+            const valueHash = col.fields[0] | 0;
+            return (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, valueHash);
+        }
+    }
 }
 /**
  * Add or update a cell in the dictionary.
  */
-function Unchecked_setCellAt(columnIndex, rowIndex, c, cells) {
-    cells.set([columnIndex, rowIndex], c);
+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 = (0, Util_js_1.defaultOf)();
+    patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, columnIndex, new Types_js_1.FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    matchValue = (patternInput[0] ? patternInput[1] : undefined);
+    if (matchValue != null) {
+        const col = (0, Option_js_1.value)(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 {
+                (0, MapUtil_js_1.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) {
+                        (0, MapUtil_js_1.addToDict)(d, i, hash_2);
+                    }
+                    else {
+                        (0, MapUtil_js_1.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;
+        (0, MapUtil_js_1.addToDict)(values.Columns, columnIndex, ColumnValueRefs_Constant(hash));
+    }
+    else {
+        const newColumn = new Map([]);
+        (0, MapUtil_js_1.addToDict)(newColumn, rowIndex, ensureCellHashInValueMap(c, values.ValueMap));
+        (0, MapUtil_js_1.addToDict)(values.Columns, columnIndex, ColumnValueRefs_Sparse(newColumn));
+    }
 }
-/**
- * Add a cell to the dictionary. If a cell already exists at the given position, it fails.
- */
-function Unchecked_addCellAt(columnIndex, rowIndex, c, cells) {
-    (0, MapUtil_js_1.addToDict)(cells, [columnIndex, rowIndex], c);
+function Unchecked_removeCellAt(columnIndex, rowIndex, values) {
+    let matchValue;
+    const dict = values.Columns;
+    let patternInput;
+    let outArg = (0, Util_js_1.defaultOf)();
+    patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, columnIndex, new Types_js_1.FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    matchValue = (patternInput[0] ? patternInput[1] : undefined);
+    if (matchValue != null) {
+        const col = (0, Option_js_1.value)(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);
+            }
+        }
+    }
 }
-function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, cells) {
-    const matchValue = CellDictionary_tryFind(fromCol, fromRow, cells);
+function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, values) {
+    const matchValue = Unchecked_tryGetCellAt(fromCol, fromRow, values);
     if (matchValue == null) {
     }
     else {
-        const c = (0, Option_js_1.value)(matchValue);
-        cells.delete([fromCol, fromRow]);
-        const value_1 = Unchecked_setCellAt(toCol, toRow, c, cells);
+        const cell = (0, Option_js_1.value)(matchValue);
+        Unchecked_removeCellAt(fromCol, fromRow, values);
+        Unchecked_setCellAt(toCol, toRow, cell, values);
     }
 }
 function Unchecked_removeHeader(index, headers) {
@@ -267,121 +854,161 @@ function Unchecked_removeHeader(index, headers) {
 /**
  * Remove cells of one Column, change index of cells with higher index to index - 1
  */
-function Unchecked_removeColumnCells(index, cells) {
-    let enumerator = (0, Util_js_1.getEnumerator)(cells);
-    try {
-        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            const c = activePatternResult[0][0] | 0;
-            if (c === index) {
-                cells.delete([c, activePatternResult[0][1]]);
-            }
-        }
-    }
-    finally {
-        (0, Util_js_1.disposeSafe)(enumerator);
-    }
+function Unchecked_removeColumnCells(colIndex, values) {
+    values.Columns.delete(colIndex);
 }
 /**
  * Remove cells of one Column, change index of cells with higher index to index - 1
  */
-function Unchecked_removeColumnCells_withIndexChange(index, columnCount, rowCount, cells) {
-    for (let col = index; col <= (columnCount - 1); col++) {
-        for (let row = 0; row <= (rowCount - 1); row++) {
-            if (col === index) {
-                cells.delete([col, row]);
+function Unchecked_removeColumnCells_withIndexChange(colIndex, columnCount, values) {
+    if (colIndex < (columnCount - 1)) {
+        const cols = new Map([]);
+        (0, Seq_js_1.iterate)((kv) => {
+            const cI = kv[0] | 0;
+            if (cI > colIndex) {
+                (0, MapUtil_js_1.addToDict)(cols, cI - 1, kv[1]);
             }
-            else if (col > index) {
-                Unchecked_moveCellTo(col, row, col - 1, row, cells);
+            else if (cI < colIndex) {
+                (0, MapUtil_js_1.addToDict)(cols, cI, kv[1]);
             }
-        }
+        }, values.Columns);
+        values.Columns = cols;
     }
-}
-function Unchecked_removeRowCells(rowIndex, cells) {
-    let enumerator = (0, Util_js_1.getEnumerator)(cells);
-    try {
-        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            const r = activePatternResult[0][1] | 0;
-            if (r === rowIndex) {
-                cells.delete([activePatternResult[0][0], r]);
-            }
-        }
+    else {
+        const value = Unchecked_removeColumnCells(colIndex, values);
     }
-    finally {
-        (0, Util_js_1.disposeSafe)(enumerator);
+}
+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
  */
-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);
+function Unchecked_removeRowCells_withIndexChange(rowIndex, values) {
+    if ((rowIndex === 0) && (values.RowCount === 1)) {
+        values.RowCount = 0;
+        values.Columns = (new Map([]));
+    }
+    else {
+        (0, Seq_js_1.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([]);
+                    (0, Seq_js_1.iterate)((kv_1) => {
+                        const rI = kv_1[0] | 0;
+                        if (rI > rowIndex) {
+                            (0, MapUtil_js_1.addToDict)(col, rI - 1, kv_1[1]);
+                        }
+                        else if (rI < rowIndex) {
+                            (0, MapUtil_js_1.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
  */
-function Unchecked_getEmptyCellForHeader(header, columCellOption) {
-    const matchValue = header.IsTermColumn;
-    if (matchValue) {
-        let matchResult;
-        if (columCellOption == null) {
-            matchResult = 0;
-        }
-        else {
-            switch ((0, Option_js_1.value)(columCellOption).tag) {
-                case /* Term */ 0: {
-                    matchResult = 0;
-                    break;
+function Unchecked_removeRowRange_withIndexChange(rowStartIndex, rowEndIndex, values) {
+    if ((rowStartIndex === 0) && (values.RowCount === rowEndIndex)) {
+        values.RowCount = 0;
+        values.Columns = (new Map([]));
+    }
+    else {
+        (0, Seq_js_1.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([]);
+                    (0, Seq_js_1.iterate)((kv_1) => {
+                        const rI = kv_1[0] | 0;
+                        if (rI > rowEndIndex) {
+                            (0, MapUtil_js_1.addToDict)(col, rI - range, kv_1[1]);
+                        }
+                        else if (rI < rowStartIndex) {
+                            (0, MapUtil_js_1.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);
+    }
+}
+function Unchecked_moveColumnCellsTo(fromCol, toCol, values) {
+    let matchValue;
+    const dict = values.Columns;
+    let patternInput;
+    let outArg = (0, Util_js_1.defaultOf)();
+    patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, fromCol, new Types_js_1.FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    matchValue = (patternInput[0] ? patternInput[1] : undefined);
+    if (matchValue != null) {
+        const col = (0, Option_js_1.value)(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_js_1.CompositeCell.emptyTerm;
-            case 1:
-                return CompositeCell_js_1.CompositeCell.emptyUnitized;
-            default:
-                throw new Error("[extendBodyCells] This should never happen, IsTermColumn header must be paired with either term or unitized cell.");
+        else {
+            (0, MapUtil_js_1.addToDict)(dict_1, key_1, value);
         }
     }
-    else {
-        return CompositeCell_js_1.CompositeCell.emptyFreeText;
-    }
 }
 /**
- *
+ * Add a new column to the ArcTableValues.
  */
-function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeaders, headers, values) {
+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 \`${(0, Option_js_1.value)(hasDuplicateUnique)}\``);
     }
+    if (rowCount > values.RowCount) {
+        values.RowCount = (rowCount | 0);
+        let enumerator = (0, Util_js_1.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 {
+            (0, Util_js_1.disposeSafe)(enumerator);
+        }
+    }
+    if ((((rowCount < values.RowCount) && (hasDuplicateUnique != null)) && forceReplace) && (values.Columns.size === 1)) {
+        values.RowCount = (rowCount | 0);
+    }
     if (hasDuplicateUnique != null) {
         numberOfNewColumns = 0;
         index_1 = ((0, Option_js_1.value)(hasDuplicateUnique) | 0);
     }
-    const matchValue = getColumnCount(headers) | 0;
-    const matchValue_1 = getRowCount(values) | 0;
+    const matchValue = headers.length | 0;
+    const matchValue_1 = values.RowCount | 0;
     const startColCount = matchValue | 0;
     if (hasDuplicateUnique != null) {
         Unchecked_removeHeader(index_1, headers);
@@ -390,77 +1017,97 @@ function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeade
     if ((index_1 < startColCount) && (hasDuplicateUnique == null)) {
         const lastColumnIndex = (0, Double_js_1.max)(startColCount - 1, 0) | 0;
         for (let columnIndex = lastColumnIndex; columnIndex >= index_1; columnIndex--) {
-            for (let rowIndex = 0; rowIndex <= matchValue_1; rowIndex++) {
-                Unchecked_moveCellTo(columnIndex, rowIndex, columnIndex + numberOfNewColumns, rowIndex, values);
-            }
+            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 {
+            (0, MapUtil_js_1.addToDict)(dict, key, value);
         }
-        const f = (index_1 >= startColCount) ? ((tupledArg) => ((values_1) => {
-            const value = (0, MapUtil_js_1.addToDict)(values_1, [tupledArg[0], tupledArg[1]], tupledArg[2]);
-        })) : ((tupledArg_1) => ((cells) => {
-            Unchecked_setCellAt(tupledArg_1[0], tupledArg_1[1], tupledArg_1[2], cells);
-        }));
-        (0, Array_js_1.iterateIndexed)((rowIndex_3, cell_1) => {
-            f([index_1, rowIndex_3, cell_1])(values);
-        }, newCells);
     }
 }
+function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeaders, headers, values) {
+    Unchecked_addRefColumn(newHeader, ColumnValueRefs_fromCellColumn_14896151(newCells, values.RowCount, values.ValueMap), (0, Seq_js_1.length)(newCells), index, forceReplace, onlyHeaders, headers, values);
+}
+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);
+}
 function Unchecked_fillMissingCells(headers, values) {
-    let col;
-    const rowCount = getRowCount(values) | 0;
-    const columnCount = getColumnCount(headers) | 0;
-    const columnKeyGroups = (0, Map_js_1.ofArray)((0, Seq2_js_1.Array_groupBy)((tuple) => tuple[0], (0, Seq_js_1.toArray)(values.keys()), {
-        Equals: (x, y) => (x === y),
-        GetHashCode: Util_js_1.numberHash,
-    }), {
-        Compare: Util_js_1.comparePrimitives,
-    });
-    for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
-        const header = headers[columnIndex];
-        const matchValue = (0, Map_js_1.tryFind)(columnIndex, columnKeyGroups);
-        if (matchValue == null) {
-            const defaultCell_1 = Unchecked_getEmptyCellForHeader(header, undefined);
-            for (let rowIndex_1 = 0; rowIndex_1 <= (rowCount - 1); rowIndex_1++) {
-                Unchecked_addCellAt(columnIndex, rowIndex_1, defaultCell_1.Copy(), values);
-            }
-        }
-        else if ((col = (0, Option_js_1.value)(matchValue), col.length === rowCount)) {
-            const col_1 = (0, Option_js_1.value)(matchValue);
-        }
-        else {
-            const col_2 = (0, Option_js_1.value)(matchValue);
-            const defaultCell = Unchecked_getEmptyCellForHeader(header, (0, MapUtil_js_1.getItemFromDict)(values, (0, Seq_js_1.head)(col_2)));
-            const rowKeys = (0, Set_js_1.ofArray)((0, Array_js_1.map)((tuple_1) => tuple_1[1], col_2), {
-                Compare: Util_js_1.comparePrimitives,
-            });
-            for (let rowIndex = 0; rowIndex <= (rowCount - 1); rowIndex++) {
-                if (!(0, Set_js_1.FSharpSet__Contains)(rowKeys, rowIndex)) {
-                    Unchecked_addCellAt(columnIndex, rowIndex, defaultCell.Copy(), values);
+    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 = (0, Util_js_1.defaultOf)();
+            patternInput = [(0, MapUtil_js_1.tryGetValue)(dict, i, new Types_js_1.FSharpRef(() => outArg, (v) => {
+                    outArg = v;
+                })), outArg];
+            matchValue = (patternInput[0] ? patternInput[1] : undefined);
+            if (matchValue != null) {
+                if ((0, Option_js_1.value)(matchValue).tag === /* Sparse */ 1) {
+                    const vals = (0, Option_js_1.value)(matchValue).fields[0];
+                    if (vals.size < values.RowCount) {
+                        const header = headers[i];
+                        const defaultHash = ensureCellHashInValueMap((vals.size === 0) ? getEmptyCellForHeader(header, undefined) : ((i_1 = ((0, Seq_js_1.max)(vals.keys(), {
+                            Compare: Util_js_1.comparePrimitives,
+                        }) | 0), getEmptyCellForHeader(header, (0, MapUtil_js_1.getItemFromDict)(values.ValueMap, (0, MapUtil_js_1.getItemFromDict)(vals, i_1))))), values.ValueMap) | 0;
+                        for (let j = vals.size; j <= (values.RowCount - 1); j++) {
+                            if (!vals.has(j)) {
+                                (0, MapUtil_js_1.addToDict)(vals, j, defaultHash);
+                            }
+                        }
+                    }
                 }
             }
+            else {
+                const col = ColumnValueRefs_Constant(ensureCellHashInValueMap(getEmptyCellForHeader(headers[i], undefined), values.ValueMap));
+                const value = (0, MapUtil_js_1.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
- */
-function Unchecked_extendToRowCount(rowCount, headers, values) {
-    const columnCount = getColumnCount(headers) | 0;
-    const previousRowCount = getRowCount(values) | 0;
-    for (let columnIndex = 0; columnIndex <= (columnCount - 1); columnIndex++) {
-        const lastValue = (0, MapUtil_js_1.getItemFromDict)(values, [columnIndex, previousRowCount - 1]);
-        for (let rowIndex = previousRowCount - 1; rowIndex <= (rowCount - 1); rowIndex++) {
-            Unchecked_setCellAt(columnIndex, rowIndex, lastValue, values);
+function Unchecked_addEmptyRow(index, values) {
+    if ((index < values.RowCount) && (values.ColumnCount !== 0)) {
+        let enumerator = (0, Util_js_1.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 = (0, Seq_js_1.max)(dict.keys(), {
+                        Compare: Util_js_1.comparePrimitives,
+                    }) | 0;
+                    for (let i = maxIndex; i >= ((index + 1) - 1); i--) {
+                        if (dict.has(i)) {
+                            const v = (0, MapUtil_js_1.getItemFromDict)(dict, i) | 0;
+                            dict.delete(i);
+                            (0, MapUtil_js_1.addToDict)(dict, i + 1, v);
+                        }
+                    }
+                }
+                else {
+                    const valueHash = matchValue.fields[0] | 0;
+                }
+            }
+        }
+        finally {
+            (0, Util_js_1.disposeSafe)(enumerator);
         }
     }
+    values.RowCount = ((values.RowCount + 1) | 0);
 }
 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 = (0, Double_js_1.max)(rowCount - 1, 0) | 0;
@@ -473,13 +1120,13 @@ function Unchecked_addRow(index, newCells, headers, values) {
     else {
         increaseRowIndices = undefined;
     }
-    const setNewCells = (0, Array_js_1.iterateIndexed)((columnIndex_1, cell) => {
+    const setNewCells = (0, Collections_js_1.ResizeArray_iteri)((columnIndex_1, cell) => {
         Unchecked_setCellAt(columnIndex_1, index, cell, values);
     }, newCells);
 }
 function Unchecked_addRows(index, newRows, headers, values) {
-    const rowCount = getRowCount(values) | 0;
-    const columnCount = getColumnCount(headers) | 0;
+    const rowCount = values.RowCount | 0;
+    const columnCount = values.ColumnCount | 0;
     const numNewRows = newRows.length | 0;
     let increaseRowIndices;
     if (index < rowCount) {
@@ -494,11 +1141,17 @@ function Unchecked_addRows(index, newRows, headers, values) {
         increaseRowIndices = undefined;
     }
     let currentRowIndex = index;
-    for (let idx = 0; idx <= (newRows.length - 1); idx++) {
-        const setNewCells = (0, Array_js_1.iterateIndexed)((columnIndex_1, cell) => {
-            Unchecked_setCellAt(columnIndex_1, currentRowIndex, cell, values);
-        }, (0, Array_js_1.item)(idx, newRows));
-        currentRowIndex = ((currentRowIndex + 1) | 0);
+    let enumerator = (0, Util_js_1.getEnumerator)(newRows);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const setNewCells = (0, Collections_js_1.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 {
+        (0, Util_js_1.disposeSafe)(enumerator);
     }
 }
 /**
@@ -512,7 +1165,7 @@ function Unchecked_compositeHeaderMainColumnEqual(ch1, ch2) {
  *
  * This function moves the column from `fromCol` to `toCol` and shifts all columns in between accordingly
  */
-function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values) {
+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;
@@ -529,20 +1182,18 @@ function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values) {
         (0, Util_js_1.disposeSafe)(enumerator);
     }
     (0, Array_js_1.setItem)(headers, toCol, header);
-    for (let r = 0; r <= (rowCount - 1); r++) {
-        const cell = (0, MapUtil_js_1.getItemFromDict)(values, [fromCol, r]);
-        const enumerator_1 = (0, Util_js_1.getEnumerator)((0, Seq_js_1.toList)((0, Range_js_1.rangeDouble)(shiftStart, (0, Int32_js_1.op_UnaryNegation_Int32)(shift), shiftEnd)));
-        try {
-            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
-                const c_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
-                values.set([c_1 + shift, r], (0, MapUtil_js_1.getItemFromDict)(values, [c_1, r]));
-            }
-        }
-        finally {
-            (0, Util_js_1.disposeSafe)(enumerator_1);
+    const col = (0, MapUtil_js_1.getItemFromDict)(values.Columns, fromCol);
+    const enumerator_1 = (0, Util_js_1.getEnumerator)((0, Seq_js_1.toList)((0, Range_js_1.rangeDouble)(shiftStart, (0, Int32_js_1.op_UnaryNegation_Int32)(shift), shiftEnd)));
+    try {
+        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const c_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
+            values.Columns.set(c_1 + shift, (0, MapUtil_js_1.getItemFromDict)(values.Columns, c_1));
         }
-        values.set([toCol, r], cell);
     }
+    finally {
+        (0, Util_js_1.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
@@ -555,10 +1206,8 @@ function Unchecked_moveColumnTo(rowCount, fromCol, toCol, headers, values) {
  */
 function Unchecked_alignByHeaders(keepOrder, rows) {
     const headers = [];
-    const values = new MutableMap_js_1.Dictionary([], {
-        Equals: Util_js_1.equalArrays,
-        GetHashCode: Util_js_1.arrayHash,
-    });
+    const values = ArcTableValues.init();
+    values.RowCount = ((0, List_js_1.length)(rows) | 0);
     const loop = (colI_mut, rows_2_mut) => {
         loop: while (true) {
             const colI = colI_mut, rows_2 = rows_2_mut;
@@ -573,7 +1222,7 @@ function Unchecked_alignByHeaders(keepOrder, rows) {
                     if (keepOrder) {
                         if (!(0, List_js_1.isEmpty)(l_1)) {
                             if (Unchecked_compositeHeaderMainColumnEqual((0, List_js_1.head)(l_1)[0], firstElem)) {
-                                (0, MapUtil_js_1.addToDict)(values, [colI, rowI], (0, List_js_1.head)(l_1)[1]);
+                                Unchecked_setCellAt(colI, rowI, (0, List_js_1.head)(l_1)[1], values);
                                 return (0, List_js_1.tail)(l_1);
                             }
                             else {
@@ -599,7 +1248,7 @@ function Unchecked_alignByHeaders(keepOrder, rows) {
                             return newL;
                         }
                         else {
-                            (0, MapUtil_js_1.addToDict)(values, [colI, rowI], (0, Option_js_1.value)(firstMatch));
+                            Unchecked_setCellAt(colI, rowI, (0, Option_js_1.value)(firstMatch), values);
                             return newL;
                         }
                     }