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

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

@@ -1,15 +1,14 @@
-import { append, toArray, reduce, choose, map as map_1, delay, toList, length, findIndex, tryFindIndex } from "@fable-org/fable-library-js/Seq.js";
+import { append, reduce, choose, map as map_1, delay, toList, length, findIndex, tryFindIndex } from "@fable-org/fable-library-js/Seq.js";
 import { ArcTable } from "./ArcTable.js";
 import { bind, map as map_2, unwrap, defaultArg, value as value_2 } from "@fable-org/fable-library-js/Option.js";
 import { CompositeHeader_ProtocolREF, CompositeHeader_Output, CompositeHeader_Input } from "./CompositeHeader.js";
 import { toIterator, equals, comparePrimitives, stringHash, compare, disposeSafe, getEnumerator } from "@fable-org/fable-library-js/Util.js";
-import { Dictionary_tryFind } from "../Helper/Collections.js";
+import { ResizeArray_collect, ResizeArray_groupBy, ResizeArray_map, ResizeArray_fold, ResizeArray_iter, Dictionary_tryFind } from "../Helper/Collections.js";
 import { addToSet, addToDict } from "@fable-org/fable-library-js/MapUtil.js";
-import { collect, map as map_3, item, insertRangeInPlace, fold } from "@fable-org/fable-library-js/Array.js";
-import { Array_groupBy, distinct } from "@fable-org/fable-library-js/Seq2.js";
+import { distinct } from "@fable-org/fable-library-js/Seq2.js";
 import { FSharpSet__get_IsEmpty, ofSeq, intersect } from "@fable-org/fable-library-js/Set.js";
+import { insertRangeInPlace } from "@fable-org/fable-library-js/Array.js";
 import { tryFind, ofSeq as ofSeq_1 } from "@fable-org/fable-library-js/Map.js";
-import { Unchecked_fillMissingCells } from "./ArcTableAux.js";
 import { class_type } from "@fable-org/fable-library-js/Reflection.js";
 /**
  * If a table with the given name exists in the TableList, returns it, else returns None.
@@ -57,9 +56,9 @@ export function ArcTablesAux_getIOMap(tables) {
             else {
                 const ic = value_2(matchValue_1);
                 const ioType_1 = value_2(ic.Header.TryInput());
-                ic.Cells.forEach((c) => {
+                ResizeArray_iter((c) => {
                     includeInMap(c.ToFreeTextCell().AsFreeText, ioType_1);
-                });
+                }, ic.Cells);
             }
             const matchValue_2 = table.TryGetOutputColumn();
             if (matchValue_2 == null) {
@@ -67,9 +66,9 @@ export function ArcTablesAux_getIOMap(tables) {
             else {
                 const oc = value_2(matchValue_2);
                 const ioType_2 = value_2(oc.Header.TryOutput());
-                oc.Cells.forEach((c_1) => {
+                ResizeArray_iter((c_1) => {
                     includeInMap(c_1.ToFreeTextCell().AsFreeText, ioType_2);
-                });
+                }, oc.Cells);
             }
         }
     }
@@ -89,7 +88,7 @@ export function ArcTablesAux_applyIOMap(map, tables) {
             else {
                 const ic = value_2(matchValue);
                 const index = findIndex((x) => x.isInput, table.Headers) | 0;
-                const newIOType = fold((io, c) => {
+                const newIOType = ResizeArray_fold((io, c) => {
                     const matchValue_1 = Dictionary_tryFind(c.ToFreeTextCell().AsFreeText, map);
                     if (matchValue_1 == null) {
                         return io;
@@ -107,7 +106,7 @@ export function ArcTablesAux_applyIOMap(map, tables) {
             else {
                 const oc = value_2(matchValue_2);
                 const index_1 = findIndex((x_1) => x_1.isOutput, table.Headers) | 0;
-                const newIOType_1 = fold((io_1, c_1) => {
+                const newIOType_1 = ResizeArray_fold((io_1, c_1) => {
                     const matchValue_3 = Dictionary_tryFind(c_1.ToFreeTextCell().AsFreeText, map);
                     if (matchValue_3 == null) {
                         return io_1;
@@ -408,16 +407,13 @@ export class ArcTables {
         this$.Tables.splice(newIndex, 0, table);
     }
     static updateReferenceTablesBySheets(referenceTables, sheetTables, keepUnusedRefTables) {
-        let collection, s, array;
+        let collection, s, a;
         const keepUnusedRefTables_1 = defaultArg(keepUnusedRefTables, false);
         const usedTables = new Set([]);
-        const referenceTableMap = ofSeq_1(choose((t) => map_2((c) => [item(0, c.Cells).AsFreeText, t], t.TryGetProtocolNameColumn()), referenceTables.Tables), {
+        const referenceTableMap = ofSeq_1(choose((t) => map_2((c) => [c.Cells[0].AsFreeText, t], t.TryGetProtocolNameColumn()), referenceTables.Tables), {
             Compare: comparePrimitives,
         });
-        return new ArcTables((collection = ((s = map_3((t_3) => {
-            Unchecked_fillMissingCells(t_3.Headers, t_3.Values);
-            return t_3;
-        }, map_3((tupledArg) => reduce((table, table_1) => ArcTable.append(table, table_1), tupledArg[1]), Array_groupBy((t_2) => t_2.Name, map_3((t_1) => {
+        return new ArcTables((collection = ((s = ResizeArray_map((tupledArg) => reduce((table, table_1) => ArcTable.append(table, table_1), tupledArg[1]), ResizeArray_groupBy((t_2) => t_2.Name, ResizeArray_map((t_1) => {
             const k = defaultArg(bind((c_1) => {
                 if (c_1.AsFreeText === "") {
                     return undefined;
@@ -434,12 +430,9 @@ export class ArcTables {
                 const rt = value_2(matchValue);
                 addToSet(k, usedTables);
                 const updatedTable = ArcTable.updateReferenceByAnnotationTable(rt, t_1);
-                return ArcTable.create(t_1.Name, updatedTable.Headers, updatedTable.Values);
+                return ArcTable.fromArcTableValues(t_1.Name, updatedTable.Headers, updatedTable.Values);
             }
-        }, (array = toArray(sheetTables.Tables), collect(ArcTable.SplitByProtocolREF, array))), {
-            Equals: (x_2, y_1) => (x_2 === y_1),
-            GetHashCode: stringHash,
-        }))), keepUnusedRefTables_1 ? append(choose((kv) => {
+        }, (a = sheetTables.Tables, ResizeArray_collect(ArcTable.SplitByProtocolREF, a))))), keepUnusedRefTables_1 ? append(choose((kv) => {
             if (usedTables.has(kv[0])) {
                 return undefined;
             }

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

@@ -1,7 +1,7 @@
 import { unwrap, defaultArg } from "@fable-org/fable-library-js/Option.js";
 import { CompositeHeader_$reflection } from "./CompositeHeader.js";
 import { CompositeCell_$reflection, CompositeCell } from "./CompositeCell.js";
-import { fold, empty, singleton, collect, delay, toArray, exists } from "@fable-org/fable-library-js/Seq.js";
+import { fold, isEmpty, empty, singleton, collect, delay, toArray, exists } from "@fable-org/fable-library-js/Seq.js";
 import { Record } from "@fable-org/fable-library-js/Types.js";
 import { record_type, array_type } from "@fable-org/fable-library-js/Reflection.js";
 export class CompositeColumn extends Record {
@@ -19,8 +19,10 @@ export class CompositeColumn extends Record {
     }
     TryGetColumnUnits() {
         const this$ = this;
-        const arr = toArray(delay(() => collect((cell) => (cell.isUnitized ? singleton(cell.AsUnitized[1]) : empty()), this$.Cells)));
-        return (arr.length === 0) ? undefined : arr;
+        let arr;
+        const collection = toArray(delay(() => collect((cell) => (cell.isUnitized ? singleton(cell.AsUnitized[1]) : empty()), this$.Cells)));
+        arr = Array.from(collection);
+        return isEmpty(arr) ? undefined : arr;
     }
     GetDefaultEmptyCell() {
         const this$ = this;

package/dist/ts/esm/ts/FileSystem/DefaultGitattributes.js

@@ -1 +1 @@
-export const dga = "**/dataset/**";
+export const dga = "**/dataset/** filter=lfs diff=lfs merge=lfs -text";

package/dist/ts/esm/ts/Json/Decode.js

@@ -1,14 +1,16 @@
 import { ErrorReason$1_BadOneOf, ErrorReason$1_BadPrimitive, ErrorReason$1_FailMessage } from "../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js";
-import { Getters$2__get_Errors, Getters$2_$ctor_Z4BE6C149, string } from "../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
+import { int, tuple2, Getters$2__get_Errors, Getters$2_$ctor_Z4BE6C149, string } from "../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
 import { Result_Map, FSharpResult$2_Ok, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
 import { printf, toText } from "@fable-org/fable-library-js/String.js";
 import { exists } from "@fable-org/fable-library-js/Seq.js";
 import { ofSeq, contains } from "@fable-org/fable-library-js/Set.js";
-import { int32ToString, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
-import { head, length, isEmpty } from "@fable-org/fable-library-js/List.js";
+import { structuralHash, equals, int32ToString, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { tail, cons, empty, head, length, isEmpty } from "@fable-org/fable-library-js/List.js";
 import { fold } from "@fable-org/fable-library-js/Array.js";
 import { tryParse, minValue } from "@fable-org/fable-library-js/Date.js";
 import { FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { Dictionary } from "@fable-org/fable-library-js/MutableMap.js";
+import { addToDict } from "@fable-org/fable-library-js/MapUtil.js";
 export function Helpers_prependPath(path, err_, err__1) {
     const err = [err_, err__1];
     return [path + err[0], err[1]];
@@ -115,3 +117,103 @@ export const Decode_datetime = {
         }
     },
 };
+export function Decode_dictionary(keyDecoder, valueDecoder) {
+    return {
+        Decode(helpers, value) {
+            if (helpers.isArray(value)) {
+                let errors = empty();
+                const tokens = helpers.asArray(value);
+                const dict = new Dictionary([], {
+                    Equals: equals,
+                    GetHashCode: structuralHash,
+                });
+                const decoder = tuple2(keyDecoder, valueDecoder);
+                return fold((acc, value_1) => {
+                    if (acc.tag === /* Ok */ 0) {
+                        const acc_1 = acc.fields[0];
+                        const matchValue = decoder.Decode(helpers, value_1);
+                        if (matchValue.tag === /* Ok */ 0) {
+                            const tupledArg = matchValue.fields[0];
+                            addToDict(acc_1, tupledArg[0], tupledArg[1]);
+                            return FSharpResult$2_Ok(acc_1);
+                        }
+                        else {
+                            return FSharpResult$2_Error(matchValue.fields[0]);
+                        }
+                    }
+                    else {
+                        return acc;
+                    }
+                }, FSharpResult$2_Ok(dict), tokens);
+            }
+            else {
+                return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+            }
+        },
+    };
+}
+export function Decode_intDictionary(valueDecoder) {
+    return {
+        Decode(helpers, value) {
+            if (helpers.isArray(value)) {
+                let errors = empty();
+                const tokens = helpers.asArray(value);
+                const dict = new Map([]);
+                const decoder = tuple2(int, valueDecoder);
+                return fold((acc, value_1) => {
+                    if (acc.tag === /* Ok */ 0) {
+                        const acc_1 = acc.fields[0];
+                        const matchValue = decoder.Decode(helpers, value_1);
+                        if (matchValue.tag === /* Ok */ 0) {
+                            const tupledArg = matchValue.fields[0];
+                            addToDict(acc_1, tupledArg[0], tupledArg[1]);
+                            return FSharpResult$2_Ok(acc_1);
+                        }
+                        else {
+                            return FSharpResult$2_Error(matchValue.fields[0]);
+                        }
+                    }
+                    else {
+                        return acc;
+                    }
+                }, FSharpResult$2_Ok(dict), tokens);
+            }
+            else {
+                return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+            }
+        },
+    };
+}
+export function Decode_tryOneOf(decoders) {
+    return {
+        Decode(helpers, value) {
+            const loop = (errors_mut, decoders_1_mut) => {
+                loop: while (true) {
+                    const errors = errors_mut, decoders_1 = decoders_1_mut;
+                    if (!isEmpty(decoders_1)) {
+                        let decodingResult;
+                        try {
+                            decodingResult = head(decoders_1).Decode(helpers, value);
+                        }
+                        catch (e) {
+                            decodingResult = FSharpResult$2_Error(["", ErrorReason$1_FailMessage(e.message)]);
+                        }
+                        if (decodingResult.tag === /* Error */ 1) {
+                            errors_mut = cons(decodingResult.fields[0], errors);
+                            decoders_1_mut = tail(decoders_1);
+                            continue loop;
+                        }
+                        else {
+                            return FSharpResult$2_Ok(decodingResult.fields[0]);
+                        }
+                    }
+                    else {
+                        return FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]);
+                    }
+                    break;
+                }
+            };
+            return loop(empty(), decoders);
+        },
+    };
+}

package/dist/ts/esm/ts/Json/Encode.js

@@ -1,10 +1,12 @@
 import { defaultArg, value as value_2, map } from "@fable-org/fable-library-js/Option.js";
 import { Json_Object } from "../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js";
-import { append, map as map_1, isEmpty } from "@fable-org/fable-library-js/Seq.js";
-import { list as list_1, seq } from "../fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js";
+import { toArray, append, map as map_1, isEmpty } from "@fable-org/fable-library-js/Seq.js";
+import { tuple2, list as list_1, seq } from "../fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js";
 import { item, map as map_2 } from "@fable-org/fable-library-js/Array.js";
 import { map as map_3, isEmpty as isEmpty_1 } from "@fable-org/fable-library-js/List.js";
 import { toString } from "@fable-org/fable-library-js/Date.js";
+import { count } from "@fable-org/fable-library-js/CollectionUtil.js";
+import { printf, toFail } from "@fable-org/fable-library-js/String.js";
 /**
  * Try to encode the given object using the given encoder, or return Encode.nil if the object is null
  */
@@ -61,3 +63,41 @@ export function resizeArrayOrSingleton(encoder, values) {
         return seq(map_1(encoder, values));
     }
 }
+export function dictionary(keyEncoder, valueEncoder, values) {
+    if (count(values) === 0) {
+        return {
+            Encode(helpers) {
+                return helpers.encodeNull();
+            },
+        };
+    }
+    else {
+        return seq(toArray(map_1((_arg) => {
+            const activePatternResult = _arg;
+            return tuple2(keyEncoder, valueEncoder, activePatternResult[0], activePatternResult[1]);
+        }, values)));
+    }
+}
+export function intDictionary(valueEncoder, values) {
+    if (count(values) === 0) {
+        return {
+            Encode(helpers) {
+                return helpers.encodeNull();
+            },
+        };
+    }
+    else {
+        return seq(toArray(map_1((_arg) => {
+            const activePatternResult = _arg;
+            const k = activePatternResult[0] | 0;
+            if ((k > 2147483647) ? true : (k < -2147483648)) {
+                toFail(printf("Key %d is out of bounds for Int32"))(k);
+            }
+            return tuple2((value) => ({
+                Encode(helpers_1) {
+                    return helpers_1.encodeSignedIntegralNumber(value);
+                },
+            }), valueEncoder, k, activePatternResult[1]);
+        }, values)));
+    }
+}

package/dist/ts/esm/ts/Json/Table/ArcTable.js

@@ -1,126 +1,99 @@
-import { toArray, collect, empty, map, singleton, append, delay, toList } from "@fable-org/fable-library-js/Seq.js";
+import { int32ToString, disposeSafe, getEnumerator, arrayHash, equalArrays, compareArrays } from "@fable-org/fable-library-js/Util.js";
+import { decoder as decoder_3, encoder as encoder_1 } from "./CompositeCell.js";
+import { getItemFromDict } from "@fable-org/fable-library-js/MapUtil.js";
 import { ErrorReason$1_BadPrimitive } from "../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js";
-import { tuple2, map as map_1, list } from "../../fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js";
-import { decoder as decoder_1, encoder as encoder_1 } from "./CompositeHeader.js";
-import { decoder as decoder_2, encoder as encoder_2 } from "./CompositeCell.js";
-import { empty as empty_2, ofSeq } from "@fable-org/fable-library-js/Map.js";
-import { int32ToString, equals, arrayHash, equalArrays, compareArrays } from "@fable-org/fable-library-js/Util.js";
+import { empty, map, singleton, append, delay, toList } from "@fable-org/fable-library-js/Seq.js";
+import { list } from "../../fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js";
+import { decoder as decoder_2, encoder as encoder_2 } from "./CompositeHeader.js";
+import { intDictionary } from "../Encode.js";
+import { Unchecked_setCellAt, ArcTableValues, ColumnValueRefs_Sparse, ColumnValueRefs_Constant, ensureCellHashInValueMap } from "../../Core/Table/ArcTableAux.js";
 import { ArcTable } from "../../Core/Table/ArcTable.js";
-import { Helpers_prependPath, array as array_2, string, int, tuple2 as tuple2_1, map$0027, list as list_1, object } from "../../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
+import { Helpers_prependPath, array as array_1, resizeArray, map as map_1, string, int, tuple2, map$0027, list as list_1, object } from "../../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
 import { defaultArg } from "@fable-org/fable-library-js/Option.js";
-import { empty as empty_1 } from "@fable-org/fable-library-js/List.js";
+import { ofArray, empty as empty_1 } from "@fable-org/fable-library-js/List.js";
 import { Dictionary } from "@fable-org/fable-library-js/MutableMap.js";
-import { decodeCell, encodeCell } from "./CellTable.js";
-import { addToDict, getItemFromDict } from "@fable-org/fable-library-js/MapUtil.js";
-import { rangeDouble } from "@fable-org/fable-library-js/Range.js";
-import { fill, setItem, fold, iterateIndexed, map as map_2 } from "@fable-org/fable-library-js/Array.js";
+import { empty as empty_2 } from "@fable-org/fable-library-js/Map.js";
+import { Decode_dictionary, Decode_intDictionary, Decode_tryOneOf } from "../Decode.js";
 import { FSharpResult$2_Ok, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
+import { encodeCell, decodeCell } from "./CellTable.js";
+import { item, fill, setItem, fold, iterateIndexed } from "@fable-org/fable-library-js/Array.js";
 import { decodeString, encodeString } from "../StringTable.js";
 export function encoder(table) {
+    const valueMap = table.Values.ValueMap;
+    const cellEncoder = (hash) => encoder_1(getItemFromDict(valueMap, hash));
     const values = toList(delay(() => {
-        let value_4;
-        return append(singleton(["name", (value_4 = table.Name, {
-                Encode(helpers_2) {
-                    return helpers_2.encodeString(value_4);
-                },
-            })]), delay(() => append((table.Headers.length !== 0) ? singleton(["header", list(toList(delay(() => map(encoder_1, table.Headers))))]) : empty(), delay(() => ((table.Values.size !== 0) ? singleton(["values", map_1((tupledArg) => tuple2((value) => ({
+        let value;
+        return append(singleton(["name", (value = table.Name, {
                 Encode(helpers) {
-                    return helpers.encodeSignedIntegralNumber(value);
+                    return helpers.encodeString(value);
                 },
-            }), (value_2) => ({
-                Encode(helpers_1) {
-                    return helpers_1.encodeSignedIntegralNumber(value_2);
-                },
-            }), tupledArg[0], tupledArg[1]), encoder_2, ofSeq(toList(delay(() => collect((matchValue) => {
-                const activePatternResult = matchValue;
-                return singleton([activePatternResult[0], activePatternResult[1]]);
-            }, table.Values))), {
-                Compare: compareArrays,
-            }))]) : empty())))));
+            })]), delay(() => append((table.Headers.length !== 0) ? singleton(["headers", list(toList(delay(() => map(encoder_2, table.Headers))))]) : empty(), delay(() => ((table.Values.RowCount !== 0) ? append(singleton(["columns", intDictionary((col) => {
+                if (col.tag === /* Sparse */ 1) {
+                    return intDictionary(cellEncoder, col.fields[0]);
+                }
+                else {
+                    return cellEncoder(col.fields[0]);
+                }
+            }, table.Values.Columns)]), delay(() => {
+            let value_1;
+            return singleton(["rowCount", (value_1 = (table.RowCount | 0), {
+                    Encode(helpers_1) {
+                        return helpers_1.encodeSignedIntegralNumber(value_1);
+                    },
+                })]);
+        })) : empty())))));
     }));
     return {
-        Encode(helpers_3) {
-            const arg = map((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_3)], values);
-            return helpers_3.encodeObject(arg);
+        Encode(helpers_2) {
+            const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_2)], values);
+            return helpers_2.encodeObject(arg);
         },
     };
 }
-export const decoder = object((get$) => {
+export const decoderV2Deprecated = object((get$) => {
     let arg_1, objectArg, arg_3, objectArg_1, objectArg_2;
     let decodedHeader;
-    const collection = defaultArg((arg_1 = list_1(decoder_1), (objectArg = get$.Optional, objectArg.Field("header", arg_1))), empty_1());
+    const collection = defaultArg((arg_1 = list_1(decoder_2), (objectArg = get$.Optional, objectArg.Field("header", arg_1))), empty_1());
     decodedHeader = Array.from(collection);
-    const decodedValues = new Dictionary(defaultArg((arg_3 = map$0027(tuple2_1(int, int), decoder_2), (objectArg_1 = get$.Optional, objectArg_1.Field("values", arg_3))), empty_2({
+    const decodedValues = new Dictionary(defaultArg((arg_3 = map$0027(tuple2(int, int), decoder_3), (objectArg_1 = get$.Optional, objectArg_1.Field("values", arg_3))), empty_2({
         Compare: compareArrays,
     })), {
         Equals: equalArrays,
         GetHashCode: arrayHash,
     });
-    return ArcTable.create((objectArg_2 = get$.Required, objectArg_2.Field("name", string)), decodedHeader, decodedValues);
-});
-export function encoderCompressedColumn(columnIndex, rowCount, cellTable, table) {
-    if (table.Headers[columnIndex].IsIOType ? true : (rowCount < 100)) {
-        const values = toArray(delay(() => map((r) => encodeCell(cellTable, getItemFromDict(table.Values, [columnIndex, r])), rangeDouble(0, 1, rowCount - 1))));
-        return {
-            Encode(helpers) {
-                const arg = map_2((v) => v.Encode(helpers), values);
-                return helpers.encodeArray(arg);
-            },
-        };
+    const t = ArcTable.create((objectArg_2 = get$.Required, objectArg_2.Field("name", string)), decodedHeader, []);
+    let enumerator = getEnumerator(decodedValues);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            t.SetCellAt(activePatternResult[0][0], activePatternResult[0][1], activePatternResult[1]);
+        }
     }
-    else {
-        let current = getItemFromDict(table.Values, [columnIndex, 0]);
-        let from = 0;
-        const values_3 = toArray(delay(() => append(collect((i) => {
-            let values_1, value, value_1;
-            const next = getItemFromDict(table.Values, [columnIndex, i]);
-            return !equals(next, current) ? append(singleton((values_1 = [["f", (value = (from | 0), {
-                        Encode(helpers_1) {
-                            return helpers_1.encodeSignedIntegralNumber(value);
-                        },
-                    })], ["t", (value_1 = ((i - 1) | 0), {
-                        Encode(helpers_2) {
-                            return helpers_2.encodeSignedIntegralNumber(value_1);
-                        },
-                    })], ["v", encodeCell(cellTable, current)]], {
-                Encode(helpers_3) {
-                    const arg_1 = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_3)], values_1);
-                    return helpers_3.encodeObject(arg_1);
-                },
-            })), delay(() => {
-                current = next;
-                from = (i | 0);
-                return empty();
-            })) : empty();
-        }, rangeDouble(1, 1, rowCount - 1)), delay(() => {
-            let values_2, value_2, value_3;
-            return singleton((values_2 = [["f", (value_2 = (from | 0), {
-                        Encode(helpers_4) {
-                            return helpers_4.encodeSignedIntegralNumber(value_2);
-                        },
-                    })], ["t", (value_3 = ((rowCount - 1) | 0), {
-                        Encode(helpers_5) {
-                            return helpers_5.encodeSignedIntegralNumber(value_3);
-                        },
-                    })], ["v", encodeCell(cellTable, current)]], {
-                Encode(helpers_6) {
-                    const arg_2 = map((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_6)], values_2);
-                    return helpers_6.encodeObject(arg_2);
-                },
-            }));
-        }))));
-        return {
-            Encode(helpers_7) {
-                const arg_3 = map_2((v_3) => v_3.Encode(helpers_7), values_3);
-                return helpers_7.encodeArray(arg_3);
-            },
-        };
+    finally {
+        disposeSafe(enumerator);
     }
-}
+    return t;
+});
+export const decoder = (() => {
+    const valueMap = new Map([]);
+    const cellDecoder = map_1((cell) => ensureCellHashInValueMap(cell, valueMap), decoder_3);
+    const columnDecoder = Decode_tryOneOf(ofArray([map_1(ColumnValueRefs_Constant, cellDecoder), map_1(ColumnValueRefs_Sparse, Decode_intDictionary(cellDecoder))]));
+    const decoder_1 = object((get$) => {
+        let arg_1, objectArg, arg_3, objectArg_1, objectArg_2, objectArg_3;
+        const decodedHeader = defaultArg((arg_1 = resizeArray(decoder_2), (objectArg = get$.Optional, objectArg.Field("headers", arg_1))), []);
+        const values = new ArcTableValues(defaultArg((arg_3 = Decode_dictionary(int, columnDecoder), (objectArg_1 = get$.Optional, objectArg_1.Field("columns", arg_3))), new Map([])), valueMap, defaultArg((objectArg_2 = get$.Optional, objectArg_2.Field("rowCount", int)), 0));
+        return ArcTable.fromArcTableValues((objectArg_3 = get$.Required, objectArg_3.Field("name", string)), decodedHeader, values);
+    });
+    return {
+        Decode(helper, column) {
+            return helper.hasProperty("values", column) ? decoderV2Deprecated.Decode(helper, column) : decoder_1.Decode(helper, column);
+        },
+    };
+})();
 export function decoderCompressedColumn(cellTable, table, columnIndex) {
     return {
         Decode(helper, column) {
-            const matchValue = array_2(decodeCell(cellTable)).Decode(helper, column);
+            const matchValue = array_1(decodeCell(cellTable)).Decode(helper, column);
             if (matchValue.tag === /* Error */ 1) {
                 const err = matchValue.fields[0];
                 const rangeDecoder = object((get$) => {
@@ -135,15 +108,15 @@ export function decoderCompressedColumn(cellTable, table, columnIndex) {
                     const objectArg_2 = get$.Required;
                     value = objectArg_2.Field("v", arg_5);
                     for (let i = from; i <= to_; i++) {
-                        addToDict(table.Values, [columnIndex, i], value);
+                        Unchecked_setCellAt(columnIndex, i, value, table.Values);
                     }
                 });
-                const matchValue_1 = array_2(rangeDecoder).Decode(helper, column);
+                const matchValue_1 = array_1(rangeDecoder).Decode(helper, column);
                 return (matchValue_1.tag === /* Error */ 1) ? FSharpResult$2_Error(matchValue_1.fields[0]) : FSharpResult$2_Ok(undefined);
             }
             else {
                 iterateIndexed((r, cell) => {
-                    addToDict(table.Values, [columnIndex, r], cell);
+                    Unchecked_setCellAt(columnIndex, r, cell, table.Values);
                 }, matchValue.fields[0]);
                 return FSharpResult$2_Ok(undefined);
             }
@@ -183,39 +156,53 @@ export function arrayi(decoderi) {
     };
 }
 export function encoderCompressed(stringTable, oaTable, cellTable, table) {
-    const values_1 = toList(delay(() => append(singleton(["n", encodeString(stringTable, table.Name)]), delay(() => append((table.Headers.length !== 0) ? singleton(["h", list(toList(delay(() => map(encoder_1, table.Headers))))]) : empty(), delay(() => {
-        if (table.Values.size !== 0) {
-            const rowCount = table.RowCount | 0;
-            const columns = toArray(delay(() => map((c) => encoderCompressedColumn(c, rowCount, cellTable, table), rangeDouble(0, 1, table.ColumnCount - 1))));
-            return singleton(["c", {
-                    Encode(helpers) {
-                        const arg = map_2((v) => v.Encode(helpers), columns);
-                        return helpers.encodeArray(arg);
-                    },
-                }]);
-        }
-        else {
-            return empty();
-        }
-    }))))));
+    const cellEncoder = (hash) => encodeCell(cellTable, getItemFromDict(table.Values.ValueMap, hash));
+    const values = toList(delay(() => append(singleton(["n", encodeString(stringTable, table.Name)]), delay(() => append((table.Headers.length !== 0) ? singleton(["h", list(toList(delay(() => map(encoder_2, table.Headers))))]) : empty(), delay(() => ((table.Values.RowCount !== 0) ? append(singleton(["c", intDictionary((col) => {
+            if (col.tag === /* Sparse */ 1) {
+                return intDictionary(cellEncoder, col.fields[0]);
+            }
+            else {
+                return cellEncoder(col.fields[0]);
+            }
+        }, table.Values.Columns)]), delay(() => {
+        let value;
+        return singleton(["r", (value = (table.RowCount | 0), {
+                Encode(helpers) {
+                    return helpers.encodeSignedIntegralNumber(value);
+                },
+            })]);
+    })) : empty())))))));
     return {
         Encode(helpers_1) {
-            const arg_1 = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
-            return helpers_1.encodeObject(arg_1);
+            const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+            return helpers_1.encodeObject(arg);
         },
     };
 }
-export function decoderCompressed(stringTable, oaTable, cellTable) {
+export function decoderCompressedV2Deprecated(stringTable, oaTable, cellTable) {
     return object((get$) => {
         let arg_1, objectArg, arg_3, objectArg_1, arg_5, objectArg_2;
         let decodedHeader;
-        const collection = defaultArg((arg_1 = list_1(decoder_1), (objectArg = get$.Optional, objectArg.Field("h", arg_1))), empty_1());
+        const collection = defaultArg((arg_1 = list_1(decoder_2), (objectArg = get$.Optional, objectArg.Field("h", arg_1))), empty_1());
         decodedHeader = Array.from(collection);
-        const table = ArcTable.create((arg_3 = decodeString(stringTable), (objectArg_1 = get$.Required, objectArg_1.Field("n", arg_3))), decodedHeader, new Dictionary([], {
-            Equals: equalArrays,
-            GetHashCode: arrayHash,
-        }));
+        const table = ArcTable.create((arg_3 = decodeString(stringTable), (objectArg_1 = get$.Required, objectArg_1.Field("n", arg_3))), decodedHeader, []);
         (arg_5 = arrayi((columnIndex) => decoderCompressedColumn(cellTable, table, columnIndex)), (objectArg_2 = get$.Optional, objectArg_2.Field("c", arg_5)));
         return table;
     });
 }
+export function decoderCompressed(stringTable, oaTable, cellTable) {
+    const valueMap = new Map([]);
+    const cellDecoder = map_1((i) => ensureCellHashInValueMap(item(i, cellTable), valueMap), int);
+    const columnDecoder = Decode_tryOneOf(ofArray([map_1(ColumnValueRefs_Constant, cellDecoder), map_1(ColumnValueRefs_Sparse, Decode_intDictionary(cellDecoder))]));
+    const decoder_1 = object((get$) => {
+        let arg_1, objectArg, arg_3, objectArg_1, objectArg_2, arg_7, objectArg_3;
+        const decodedHeader = defaultArg((arg_1 = resizeArray(decoder_2), (objectArg = get$.Optional, objectArg.Field("h", arg_1))), []);
+        const values = new ArcTableValues(defaultArg((arg_3 = Decode_dictionary(int, columnDecoder), (objectArg_1 = get$.Optional, objectArg_1.Field("c", arg_3))), new Map([])), valueMap, defaultArg((objectArg_2 = get$.Optional, objectArg_2.Field("r", int)), 0));
+        return ArcTable.fromArcTableValues((arg_7 = decodeString(stringTable), (objectArg_3 = get$.Required, objectArg_3.Field("n", arg_7))), decodedHeader, values);
+    });
+    return {
+        Decode(helper, column) {
+            return !helper.hasProperty("r", column) ? decoderCompressedV2Deprecated(stringTable, oaTable, cellTable).Decode(helper, column) : decoder_1.Decode(helper, column);
+        },
+    };
+}