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

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

@@ -0,0 +1,993 @@
+import { CompositeCell } from './CompositeCell.js';
+import { op_UnaryNegation_Int32 } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { value, bind } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { safeHash, getEnumerator, disposeSafe, defaultOf, toIterator, compare, comparePrimitives, equals } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { addToDict, getItemFromDict, tryGetValue } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { Union, FSharpRef, toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { isEmpty, max, toList, iterateIndexed, iterate, delay, length, filter, tryFindIndex, item, collect, singleton, empty as empty$1, map } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ResizeArray_map, ResizeArray_init, ResizeArray_iteri, ResizeArray_create, List_tryPickAndRemove } from '../Helper/Collections.js';
+import { toFail, toConsole, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { rangeDouble } from '../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { ofSeq, empty, length as length$1, isEmpty as isEmpty$1, tail, head, cons, exists, pick, mapIndexed } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { max as max$1 } from '../../../node_modules/@fable-org/fable-library-js/Double.js';
+import { setItem } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+
+function getEmptyCellForHeader(header, columCellOption) {
+  const matchValue = header.IsTermColumn;
+  if (matchValue) {
+    let matchResult;
+    if (columCellOption == null) {
+      matchResult = 0;
+    } else {
+      switch (value(columCellOption).tag) {
+        case /* Term */
+        0: {
+          matchResult = 0;
+          break;
+        }
+        case /* Unitized */
+        2: {
+          matchResult = 1;
+          break;
+        }
+        default:
+          matchResult = 2;
+      }
+    }
+    switch (matchResult) {
+      case 0:
+        return CompositeCell.emptyTerm;
+      case 1:
+        return CompositeCell.emptyUnitized;
+      default:
+        throw new Error("[extendBodyCells] This should never happen, IsTermColumn header must be paired with either term or unitized cell.");
+    }
+  } else {
+    return CompositeCell.emptyFreeText;
+  }
+}
+function ensureCellHashInValueMap(value, valueMap) {
+  const hash = safeHash(value) | 0;
+  if (valueMap.has(hash)) {
+    return hash | 0;
+  } else {
+    addToDict(valueMap, hash, value);
+    return hash | 0;
+  }
+}
+function ColumnValueRefs_Constant(Item) {
+  return new ColumnValueRefs(0, [Item]);
+}
+function ColumnValueRefs_Sparse(Item) {
+  return new ColumnValueRefs(1, [Item]);
+}
+class ColumnValueRefs extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Constant", "Sparse"];
+  }
+}
+function ColumnValueRefs__Copy(this$) {
+  if (this$.tag === /* Sparse */
+  1) {
+    const values = this$.fields[0];
+    const d = /* @__PURE__ */ new Map([]);
+    iterate((v) => {
+      addToDict(d, v[0], v[1]);
+    }, values);
+    return ColumnValueRefs_Sparse(d);
+  } else {
+    return ColumnValueRefs_Constant(this$.fields[0]);
+  }
+}
+function ColumnValueRefs__ToSparse_Z524259A4(this$, rowCount) {
+  if (this$.tag === /* Sparse */
+  1) {
+    return ColumnValueRefs_Sparse(this$.fields[0]);
+  } else {
+    const valueHash = this$.fields[0] | 0;
+    const d = /* @__PURE__ */ new Map([]);
+    for (let i = 0; i <= rowCount - 1; i++) {
+      addToDict(d, i, valueHash);
+    }
+    return ColumnValueRefs_Sparse(d);
+  }
+}
+function ColumnValueRefs_fromCellColumn_14896151(column, previousRowCount, valueMap) {
+  const l = length(column) | 0;
+  const cells = /* @__PURE__ */ new Map([]);
+  if (l === 0) {
+    return ColumnValueRefs_Sparse(cells);
+  } else {
+    let current;
+    const hash = ensureCellHashInValueMap(item(0, column), valueMap) | 0;
+    if (l >= previousRowCount) {
+      current = ColumnValueRefs_Constant(hash);
+    } else {
+      addToDict(cells, 0, hash);
+      current = ColumnValueRefs_Sparse(cells);
+    }
+    iterateIndexed((i, cell) => {
+      const hash_1 = ensureCellHashInValueMap(cell, valueMap) | 0;
+      if (current.tag === /* Sparse */
+      1) {
+        const cells_2 = current.fields[0];
+        cells_2.set(i, hash_1);
+      } else if (current.fields[0] === hash_1) {
+        current.fields[0] | 0;
+      } else {
+        const cellHash_2 = current.fields[0] | 0;
+        const cells_1 = /* @__PURE__ */ 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, void 0) : getEmptyCellForHeader(header, getItemFromDict(valueMap, getItemFromDict(values, max(values.keys(), {
+      Compare: comparePrimitives
+    }) - 1)));
+    return ResizeArray_init(rowCount, (i_1) => values.has(i_1) ? getItemFromDict(valueMap, getItemFromDict(values, i_1)) : defaultCell);
+  } else {
+    return ResizeArray_create(rowCount, getItemFromDict(valueMap, this$.fields[0]));
+  }
+}
+class ArcTableValues {
+  constructor(cols, valueMap, rowCount) {
+    this._columns = cols;
+    this._valueMap = valueMap;
+    this._rowCount = rowCount | 0;
+  }
+  get Columns() {
+    const this$ = this;
+    return this$._columns;
+  }
+  set Columns(columns) {
+    const this$ = this;
+    this$._columns = columns;
+  }
+  get ColumnCount() {
+    const this$ = this;
+    return (isEmpty(this$._columns) ? 0 : 1 + max(this$._columns.keys(), {
+      Compare: comparePrimitives
+    })) | 0;
+  }
+  get ValueMap() {
+    const this$ = this;
+    return this$._valueMap;
+  }
+  set ValueMap(valueMap) {
+    const this$ = this;
+    this$._valueMap = valueMap;
+  }
+  get RowCount() {
+    const this$ = this;
+    return this$._rowCount | 0;
+  }
+  set RowCount(rowCount) {
+    const this$ = this;
+    if (rowCount > 0 && rowCount < this$._rowCount) {
+      let enumerator = getEnumerator(this$._columns);
+      try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+          const matchValue = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()[1];
+          if (matchValue.tag === /* Sparse */
+          1) {
+            const values = matchValue.fields[0];
+            const enumerator_1 = getEnumerator(toList(values.keys()));
+            try {
+              while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                const key = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
+                if (key >= rowCount) {
+                  values.delete(key);
+                }
+              }
+            } finally {
+              disposeSafe(enumerator_1);
+            }
+          }
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+    }
+    this$._rowCount = rowCount | 0;
+  }
+  static fromCellColumns(columns) {
+    const rowCount = (columns.length === 0 ? 0 : max(ResizeArray_map((c) => c.length, columns), {
+      Compare: comparePrimitives
+    })) | 0;
+    const valueMap = /* @__PURE__ */ new Map([]);
+    const parsedColumns = /* @__PURE__ */ new Map([]);
+    iterateIndexed((i, column) => {
+      addToDict(parsedColumns, i, ColumnValueRefs_fromCellColumn_14896151(column, rowCount, valueMap));
+    }, columns);
+    return new ArcTableValues(parsedColumns, valueMap, rowCount);
+  }
+  static fromRefColumns(columns, valueMap, rowCount) {
+    const parsedColumns = /* @__PURE__ */ new Map([]);
+    iterateIndexed((i, column) => {
+      addToDict(parsedColumns, i, column);
+    }, columns);
+    return new ArcTableValues(parsedColumns, valueMap, rowCount);
+  }
+  static init() {
+    const valueMap = /* @__PURE__ */ new Map([]);
+    return new ArcTableValues(/* @__PURE__ */ new Map([]), valueMap, 0);
+  }
+  ToCellColumns(headers) {
+    const this$ = this;
+    return ResizeArray_init(headers.length, (i) => {
+      const header = headers[i];
+      return ColumnValueRefs__ToCellColumn_Z2609C9DD(getItemFromDict(this$._columns, i), this$._valueMap, this$._rowCount, header);
+    });
+  }
+  RescanValueMap() {
+    const this$ = this;
+    const newValueMap = /* @__PURE__ */ new Map([]);
+    let enumerator = getEnumerator(this$._columns);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const matchValue = kv[1];
+        if (matchValue.tag === /* Sparse */
+        1) {
+          const values = matchValue.fields[0];
+          let enumerator_1 = getEnumerator(values);
+          try {
+            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+              const ckv = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              const hash_1 = ensureCellHashInValueMap(getItemFromDict(this$._valueMap, ckv[1]), newValueMap) | 0;
+              values.set(ckv[0], hash_1);
+            }
+          } finally {
+            disposeSafe(enumerator_1);
+          }
+        } else {
+          const valueHash = matchValue.fields[0] | 0;
+          const hash = ensureCellHashInValueMap(getItemFromDict(this$._valueMap, valueHash), newValueMap) | 0;
+          this$._columns.set(kv[0], ColumnValueRefs_Constant(hash));
+        }
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    this$._valueMap = newValueMap;
+  }
+  Copy() {
+    const this$ = this;
+    const nextValueMap = /* @__PURE__ */ new Map([]);
+    iterate((kv) => {
+      addToDict(nextValueMap, kv[0], kv[1].Copy());
+    }, this$._valueMap);
+    const nextColumns = /* @__PURE__ */ new Map([]);
+    iterate((kv_1) => {
+      addToDict(nextColumns, kv_1[0], ColumnValueRefs__Copy(kv_1[1]));
+    }, this$._columns);
+    return new ArcTableValues(nextColumns, nextValueMap, this$._rowCount);
+  }
+  GetHashCode() {
+    const this$ = this;
+    let hash = 0;
+    for (let i = 0; i <= this$.ColumnCount - 1; i++) {
+      let matchValue;
+      const dict = this$._columns;
+      let patternInput;
+      let outArg = defaultOf();
+      patternInput = [tryGetValue(dict, i, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      matchValue = patternInput[0] ? patternInput[1] : void 0;
+      if (matchValue != null) {
+        if (value(matchValue).tag === /* Sparse */
+        1) {
+          const values = value(matchValue).fields[0];
+          let enumerator = getEnumerator(values);
+          try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+              const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              hash = -1640531527 + kv[0] + (hash << 6) + (hash >> 2) | 0;
+              hash = -1640531527 + kv[1] + (hash << 6) + (hash >> 2) | 0;
+            }
+          } finally {
+            disposeSafe(enumerator);
+          }
+        } else {
+          const valueHash = value(matchValue).fields[0] | 0;
+          for (let i_1 = 0; i_1 <= this$._rowCount - 1; i_1++) {
+            hash = -1640531527 + i_1 + (hash << 6) + (hash >> 2) | 0;
+            hash = -1640531527 + valueHash + (hash << 6) + (hash >> 2) | 0;
+          }
+        }
+      }
+    }
+    return hash | 0;
+  }
+  Equals(other) {
+    let other_1;
+    const this$ = this;
+    return other instanceof ArcTableValues && (other_1 = other, safeHash(this$) === safeHash(other_1));
+  }
+  Item(crIndices) {
+    const this$ = this;
+    const row = crIndices[1] | 0;
+    const col = crIndices[0] | 0;
+    if (row > this$.RowCount - 1) {
+      const arg_1 = this$.RowCount | 0;
+      toFail(printf("Row index %d is out of bounds for ArcTableValues with row count %d."))(row)(arg_1);
+    }
+    if (col > this$.ColumnCount - 1) {
+      const arg_3 = this$.ColumnCount | 0;
+      toFail(printf("Column index %d is out of bounds for ArcTableValues with column count %d."))(col)(arg_3);
+    }
+    let matchValue;
+    const dict = this$._columns;
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(dict, col, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg];
+    matchValue = patternInput[0] ? patternInput[1] : void 0;
+    if (matchValue != null) {
+      const colValueRefs = value(matchValue);
+      if (colValueRefs.tag === /* Sparse */
+      1) {
+        const values = colValueRefs.fields[0];
+        return values.has(row) ? getItemFromDict(this$._valueMap, getItemFromDict(values, row)) : toFail(printf("Row value for index %d does not exist in column %d of ArcTableValues."))(row)(col);
+      } else {
+        const valueHash = colValueRefs.fields[0] | 0;
+        return getItemFromDict(this$._valueMap, valueHash);
+      }
+    } else {
+      return toFail(printf("Column %d does not exist in ArcTableValues."))(col);
+    }
+  }
+  GetEnumerator() {
+    const this$ = this;
+    return getEnumerator(delay(() => collect((colI) => {
+      let matchValue;
+      const dict = this$._columns;
+      let patternInput;
+      let outArg = defaultOf();
+      patternInput = [tryGetValue(dict, colI, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      matchValue = patternInput[0] ? patternInput[1] : void 0;
+      if (matchValue != null) {
+        const matchValue_1 = value(matchValue);
+        if (matchValue_1.tag === /* Sparse */
+        1) {
+          const values = matchValue_1.fields[0];
+          return collect((rowI_1) => values.has(rowI_1) ? singleton([[colI, rowI_1], getItemFromDict(this$._valueMap, getItemFromDict(values, rowI_1))]) : empty$1(), rangeDouble(0, 1, this$._rowCount - 1));
+        } else {
+          const valueHash = matchValue_1.fields[0] | 0;
+          return map((rowI) => [[colI, rowI], getItemFromDict(this$._valueMap, valueHash)], rangeDouble(0, 1, this$._rowCount - 1));
+        }
+      } else {
+        return empty$1();
+      }
+    }, rangeDouble(0, 1, this$.ColumnCount - 1))));
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const this$ = this;
+    return getEnumerator(this$);
+  }
+}
+function $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, input) {
+  switch (input.tag) {
+    case /* Parameter */
+    3:
+    case /* Factor */
+    2:
+    case /* Characteristic */
+    1:
+    case /* Component */
+    0:
+    case /* FreeText */
+    13:
+      return void 0;
+    case /* Output */
+    12:
+      return tryFindIndex((h) => h.tag === /* Output */
+      12, existingHeaders);
+    case /* Input */
+    11:
+      return tryFindIndex((h_1) => h_1.tag === /* Input */
+      11, existingHeaders);
+    default:
+      return tryFindIndex((h_2) => equals(h_2, input), existingHeaders);
+  }
+}
+function tryFindDuplicateUnique(newHeader, existingHeaders) {
+  const activePatternResult = $007CIsUniqueExistingHeader$007C_$007C(existingHeaders, newHeader);
+  if (activePatternResult != null) {
+    const index = value(activePatternResult) | 0;
+    return index;
+  } else {
+    return void 0;
+  }
+}
+function tryFindDuplicateUniqueInArray(existingHeaders) {
+  const loop = (i_mut, duplicateList_mut, headerList_mut) => {
+    loop:
+      while (true) {
+        const i = i_mut, duplicateList = duplicateList_mut, headerList = headerList_mut;
+        let matchResult, header, tail$1;
+        if (isEmpty$1(headerList)) {
+          matchResult = 0;
+        } else if (isEmpty$1(tail(headerList))) {
+          matchResult = 0;
+        } else {
+          matchResult = 1;
+          header = head(headerList);
+          tail$1 = tail(headerList);
+        }
+        switch (matchResult) {
+          case 0:
+            return duplicateList;
+          default: {
+            const hasDuplicate = tryFindDuplicateUnique(header, tail$1);
+            i_mut = i + 1;
+            duplicateList_mut = hasDuplicate != null ? cons({
+              HeaderType: header,
+              Index1: i,
+              Index2: value(hasDuplicate)
+            }, duplicateList) : duplicateList;
+            headerList_mut = tail$1;
+            continue loop;
+          }
+        }
+      }
+  };
+  return loop(0, empty(), ofSeq(filter((x) => !x.IsTermColumn, existingHeaders)));
+}
+function SanityChecks_validateColumnIndex(index, columnCount, allowAppend) {
+  let x, y;
+  if (index < 0) {
+    throw new Error("Cannot insert CompositeColumn at index < 0.");
+  }
+  if (x = index | 0, y = columnCount | 0, allowAppend ? compare(x, y) > 0 : compare(x, y) >= 0) {
+    throw new Error(`Specified index is out of table range! Table contains only ${columnCount} columns.`);
+  }
+}
+function SanityChecks_validateRowIndex(index, rowCount, allowAppend) {
+  let x, y;
+  if (index < 0) {
+    throw new Error("Cannot insert CompositeColumn at index < 0.");
+  }
+  if (x = index | 0, y = rowCount | 0, allowAppend ? compare(x, y) > 0 : compare(x, y) >= 0) {
+    throw new Error(`Specified index is out of table range! Table contains only ${rowCount} rows.`);
+  }
+}
+function SanityChecks_validateColumn(column) {
+  column.Validate(true);
+}
+function SanityChecks_validateCellColumns(headers, columns, raiseException) {
+  let isValid = true;
+  let en = getEnumerator(headers);
+  let colIndex = 0;
+  if (headers.length !== columns.length && columns.length !== 0) {
+    ((message) => {
+      throw new Error(message);
+    } )(`Invalid table. Number of headers (${headers.length}) does not match number of columns (${columns.length}).`);
+    isValid = false;
+  }
+  while (isValid && en["System.Collections.IEnumerator.MoveNext"]() && columns.length !== 0) {
+    const header = en["System.Collections.Generic.IEnumerator`1.get_Current"]();
+    let colEn = getEnumerator(columns[colIndex]);
+    colIndex = colIndex + 1 | 0;
+    while (isValid && colEn["System.Collections.IEnumerator.MoveNext"]()) {
+      const cell = colEn["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const headerIsData = header.IsDataColumn;
+      const headerIsFreetext = !header.IsTermColumn && !header.IsDataColumn;
+      const cellIsNotFreetext = !cell.isFreeText;
+      if (headerIsData && (!cell.isData && cellIsNotFreetext)) {
+        ((message_1) => {
+          throw new Error(message_1);
+        } )(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Data header should contain either Data or Freetext cells.`);
+        isValid = false;
+      }
+      if (headerIsFreetext && cellIsNotFreetext) {
+        ((message_2) => {
+          throw new Error(message_2);
+        } )(`Invalid combination of header \`${header}\` and cell \`${cell}\`. Freetext header should not contain non-freetext cells.`);
+        isValid = false;
+      }
+    }
+  }
+  return isValid;
+}
+function SanityChecks_validateArcTableValues(headers, values, raiseException) {
+  let clo;
+  let isValid = true;
+  let colIndex = 0;
+  if (headers.length !== values.ColumnCount && values.ColumnCount !== 0) {
+    (raiseException ? (message) => {
+      throw new Error(message);
+    } : (clo = toConsole(printf("%s")), (arg) => {
+      clo(arg);
+    }))(`Invalid table. Number of headers (${headers.length}) does not match number of columns (${values.ColumnCount}).`);
+    isValid = false;
+  }
+  if (values.RowCount !== 0 && values.ColumnCount !== 0) {
+    while (isValid && colIndex < values.ColumnCount) {
+      const header = headers[colIndex];
+      let matchValue;
+      const key = colIndex | 0;
+      const dict = values.Columns;
+      let patternInput;
+      let outArg = defaultOf();
+      patternInput = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      matchValue = patternInput[0] ? patternInput[1] : void 0;
+      if (matchValue != null) {
+        if (value(matchValue).tag === /* Sparse */
+        1) {
+          const column = value(matchValue).fields[0];
+          let enumerator = getEnumerator(column);
+          try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+              const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              const cell_1 = getItemFromDict(values.ValueMap, kv[1]);
+              if (!cell_1.ValidateAgainstHeader(header, raiseException)) {
+                isValid = false;
+              }
+            }
+          } finally {
+            disposeSafe(enumerator);
+          }
+        } else {
+          const hash = value(matchValue).fields[0] | 0;
+          const cell = 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 bind((col) => {
+    if (col.tag === /* Sparse */
+    1) {
+      const vals = col.fields[0];
+      if (vals.has(row)) {
+        return getItemFromDict(values.ValueMap, getItemFromDict(vals, row));
+      } else {
+        return void 0;
+      }
+    } else {
+      const valueHash = col.fields[0] | 0;
+      return getItemFromDict(values.ValueMap, valueHash);
+    }
+  }, (dict = values.Columns, patternInput = (outArg = defaultOf(), [tryGetValue(dict, column, new FSharpRef(() => outArg, (v) => {
+    outArg = v;
+  })), outArg]), patternInput[0] ? patternInput[1] : void 0));
+}
+function Unchecked_getCellWithDefault(column, row, headers, values) {
+  if (headers.length <= column) {
+    const arg_1 = headers.length | 0;
+    toFail(printf("Column index %d is out of bounds for ArcTableValues with column count %d."))(column)(arg_1);
+  }
+  let matchValue;
+  const dict = values.Columns;
+  let patternInput;
+  let outArg = defaultOf();
+  patternInput = [tryGetValue(dict, column, new FSharpRef(() => outArg, (v) => {
+    outArg = v;
+  })), outArg];
+  matchValue = patternInput[0] ? patternInput[1] : void 0;
+  if (matchValue == null) {
+    if (row < values.RowCount) {
+      return CompositeCell.emptyFreeText;
+    } else {
+      return getEmptyCellForHeader(headers[column], void 0);
+    }
+  } else {
+    const col = value(matchValue);
+    if (col.tag === /* Sparse */
+    1) {
+      const vals = col.fields[0];
+      if (vals.has(row)) {
+        return getItemFromDict(values.ValueMap, getItemFromDict(vals, row));
+      } else if (vals.size === 0) {
+        return getEmptyCellForHeader(headers[column], void 0);
+      } else {
+        const header_1 = headers[column];
+        const maxI = max(vals.keys(), {
+          Compare: comparePrimitives
+        }) | 0;
+        return getEmptyCellForHeader(header_1, getItemFromDict(values.ValueMap, getItemFromDict(vals, maxI)));
+      }
+    } else {
+      const valueHash = col.fields[0] | 0;
+      return getItemFromDict(values.ValueMap, valueHash);
+    }
+  }
+}
+function Unchecked_setCellAt(columnIndex, rowIndex, c, values) {
+  if (rowIndex + 1 > values.RowCount) {
+    values.RowCount = rowIndex + 1 | 0;
+  }
+  let matchValue;
+  const dict = values.Columns;
+  let patternInput;
+  let outArg = defaultOf();
+  patternInput = [tryGetValue(dict, columnIndex, new FSharpRef(() => outArg, (v) => {
+    outArg = v;
+  })), outArg];
+  matchValue = patternInput[0] ? patternInput[1] : void 0;
+  if (matchValue != null) {
+    const col = 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 {
+        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 = /* @__PURE__ */ new Map([]);
+        for (let i = 0; i <= values.RowCount - 1; i++) {
+          if (i === rowIndex) {
+            addToDict(d, i, hash_2);
+          } else {
+            addToDict(d, i, valueHash);
+          }
+        }
+        values.Columns.set(columnIndex, ColumnValueRefs_Sparse(d));
+      }
+    }
+  } else if (values.RowCount <= 1 && rowIndex === 0) {
+    const hash = ensureCellHashInValueMap(c, values.ValueMap) | 0;
+    addToDict(values.Columns, columnIndex, ColumnValueRefs_Constant(hash));
+  } else {
+    const newColumn = /* @__PURE__ */ new Map([]);
+    addToDict(newColumn, rowIndex, ensureCellHashInValueMap(c, values.ValueMap));
+    addToDict(values.Columns, columnIndex, ColumnValueRefs_Sparse(newColumn));
+  }
+}
+function Unchecked_removeCellAt(columnIndex, rowIndex, values) {
+  let matchValue;
+  const dict = values.Columns;
+  let patternInput;
+  let outArg = defaultOf();
+  patternInput = [tryGetValue(dict, columnIndex, new FSharpRef(() => outArg, (v) => {
+    outArg = v;
+  })), outArg];
+  matchValue = patternInput[0] ? patternInput[1] : void 0;
+  if (matchValue != null) {
+    const col = 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 {
+      col.fields[0] | 0;
+      if (rowIndex === 0 && values.RowCount === 1) {
+        values.Columns.delete(columnIndex);
+      }
+    }
+  }
+}
+function Unchecked_moveCellTo(fromCol, fromRow, toCol, toRow, values) {
+  const matchValue = Unchecked_tryGetCellAt(fromCol, fromRow, values);
+  if (matchValue == null) ; else {
+    const cell = value(matchValue);
+    Unchecked_removeCellAt(fromCol, fromRow, values);
+    Unchecked_setCellAt(toCol, toRow, cell, values);
+  }
+}
+function Unchecked_removeHeader(index, headers) {
+  headers.splice(index, 1);
+}
+function Unchecked_removeColumnCells(colIndex, values) {
+  values.Columns.delete(colIndex);
+}
+function Unchecked_removeColumnCells_withIndexChange(colIndex, columnCount, values) {
+  if (colIndex < columnCount - 1) {
+    const cols = /* @__PURE__ */ new Map([]);
+    iterate((kv) => {
+      const cI = kv[0] | 0;
+      if (cI > colIndex) {
+        addToDict(cols, cI - 1, kv[1]);
+      } else if (cI < colIndex) {
+        addToDict(cols, cI, kv[1]);
+      }
+    }, values.Columns);
+    values.Columns = cols;
+  } else {
+    Unchecked_removeColumnCells(colIndex, values);
+  }
+}
+function Unchecked_removeRowCells_withIndexChange(rowIndex, values) {
+  if (rowIndex === 0 && values.RowCount === 1) {
+    values.RowCount = 0;
+    values.Columns = /* @__PURE__ */ new Map([]);
+  } else {
+    iterate((kv) => {
+      const matchValue = kv[1];
+      if (matchValue.tag === /* Sparse */
+      1) {
+        const vals = matchValue.fields[0];
+        if (rowIndex < values.RowCount - 1) {
+          const col = /* @__PURE__ */ new Map([]);
+          iterate((kv_1) => {
+            const rI = kv_1[0] | 0;
+            if (rI > rowIndex) {
+              addToDict(col, rI - 1, kv_1[1]);
+            } else if (rI < rowIndex) {
+              addToDict(col, rI, kv_1[1]);
+            }
+          }, vals);
+          values.Columns.set(kv[0], ColumnValueRefs_Sparse(col));
+        } else {
+          vals.delete(rowIndex);
+        }
+      }
+    }, values.Columns);
+    values.RowCount = values.RowCount - 1 | 0;
+  }
+}
+function Unchecked_moveColumnCellsTo(fromCol, toCol, values) {
+  let matchValue;
+  const dict = values.Columns;
+  let patternInput;
+  let outArg = defaultOf();
+  patternInput = [tryGetValue(dict, fromCol, new FSharpRef(() => outArg, (v) => {
+    outArg = v;
+  })), outArg];
+  matchValue = patternInput[0] ? patternInput[1] : void 0;
+  if (matchValue != null) {
+    const col = value(matchValue);
+    Unchecked_removeColumnCells(fromCol, values);
+    const key_1 = toCol | 0;
+    const value$1 = col;
+    const dict_1 = values.Columns;
+    if (dict_1.has(key_1)) {
+      dict_1.set(key_1, value$1);
+    } else {
+      addToDict(dict_1, key_1, value$1);
+    }
+  }
+}
+function Unchecked_addRefColumn(newHeader, newCol, rowCount, index, forceReplace, onlyHeaders, headers, values) {
+  let numberOfNewColumns = 1;
+  let index_1 = index;
+  const hasDuplicateUnique = tryFindDuplicateUnique(newHeader, headers);
+  if (!forceReplace && hasDuplicateUnique != null) {
+    throw new Error(`Invalid new column \`${newHeader}\`. Table already contains header of the same type on index \`${value(hasDuplicateUnique)}\``);
+  }
+  if (rowCount > values.RowCount) {
+    values.RowCount = rowCount | 0;
+    let enumerator = getEnumerator(values.Columns);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        values.Columns.set(kv[0], ColumnValueRefs__ToSparse_Z524259A4(kv[1], values.RowCount));
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  if (rowCount < values.RowCount && hasDuplicateUnique != null && forceReplace && values.Columns.size === 1) {
+    values.RowCount = rowCount | 0;
+  }
+  if (hasDuplicateUnique != null) {
+    numberOfNewColumns = 0;
+    index_1 = value(hasDuplicateUnique) | 0;
+  }
+  const matchValue = headers.length | 0;
+  values.RowCount | 0;
+  const startColCount = matchValue | 0;
+  if (hasDuplicateUnique != null) {
+    Unchecked_removeHeader(index_1, headers);
+  }
+  headers.splice(index_1, 0, newHeader);
+  if (index_1 < startColCount && hasDuplicateUnique == null) {
+    const lastColumnIndex = max$1(startColCount - 1, 0) | 0;
+    for (let columnIndex = lastColumnIndex; columnIndex >= index_1; columnIndex--) {
+      Unchecked_moveColumnCellsTo(columnIndex, columnIndex + numberOfNewColumns, values);
+    }
+  }
+  if (!onlyHeaders) {
+    const key = index_1 | 0;
+    const value = newCol;
+    const dict = values.Columns;
+    if (dict.has(key)) {
+      dict.set(key, value);
+    } else {
+      addToDict(dict, key, value);
+    }
+  }
+}
+function Unchecked_addColumn(newHeader, newCells, index, forceReplace, onlyHeaders, headers, values) {
+  Unchecked_addRefColumn(newHeader, ColumnValueRefs_fromCellColumn_14896151(newCells, values.RowCount, values.ValueMap), length(newCells), index, forceReplace, onlyHeaders, headers, values);
+}
+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_addEmptyRow(index, values) {
+  if (index < values.RowCount && values.ColumnCount !== 0) {
+    let enumerator = getEnumerator(values.Columns);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const matchValue = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()[1];
+        if (matchValue.tag === /* Sparse */
+        1) {
+          const dict = matchValue.fields[0];
+          const maxIndex = max(dict.keys(), {
+            Compare: comparePrimitives
+          }) | 0;
+          for (let i = maxIndex; i >= index + 1 - 1; i--) {
+            if (dict.has(i)) {
+              const v = getItemFromDict(dict, i) | 0;
+              dict.delete(i);
+              addToDict(dict, i + 1, v);
+            }
+          }
+        } else {
+          const valueHash = matchValue.fields[0] | 0;
+        }
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  values.RowCount = values.RowCount + 1 | 0;
+}
+function Unchecked_addRow(index, newCells, headers, values) {
+  const rowCount = values.RowCount | 0;
+  const columnCount = values.ColumnCount | 0;
+  if (index < rowCount) {
+    const lastRowIndex = max$1(rowCount - 1, 0) | 0;
+    for (let rowIndex = lastRowIndex; rowIndex >= index; rowIndex--) {
+      for (let columnIndex = 0; columnIndex <= columnCount - 1; columnIndex++) {
+        Unchecked_moveCellTo(columnIndex, rowIndex, columnIndex, rowIndex + 1, values);
+      }
+    }
+  }
+  ResizeArray_iteri((columnIndex_1, cell) => {
+    Unchecked_setCellAt(columnIndex_1, index, cell, values);
+  }, newCells);
+}
+function Unchecked_addRows(index, newRows, headers, values) {
+  const rowCount = values.RowCount | 0;
+  const columnCount = values.ColumnCount | 0;
+  const numNewRows = newRows.length | 0;
+  if (index < rowCount) {
+    const lastRowIndex = max$1(rowCount - 1, 0) | 0;
+    for (let rowIndex = lastRowIndex; rowIndex >= index; rowIndex--) {
+      for (let columnIndex = 0; columnIndex <= columnCount - 1; columnIndex++) {
+        Unchecked_moveCellTo(columnIndex, rowIndex, columnIndex, rowIndex + numNewRows, values);
+      }
+    }
+  }
+  let currentRowIndex = index;
+  let enumerator = getEnumerator(newRows);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const setNewCells = ResizeArray_iteri((columnIndex_1, cell) => {
+        Unchecked_setCellAt(columnIndex_1, currentRowIndex, cell, values);
+      }, enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      currentRowIndex = currentRowIndex + 1 | 0;
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+function Unchecked_compositeHeaderMainColumnEqual(ch1, ch2) {
+  return toString(ch1) === toString(ch2);
+}
+function Unchecked_moveColumnTo(fromCol, toCol, headers, values) {
+  const patternInput = fromCol < toCol ? [-1, fromCol + 1, toCol] : [1, fromCol - 1, toCol];
+  const shiftStart = patternInput[1] | 0;
+  const shiftEnd = patternInput[2] | 0;
+  const shift = patternInput[0] | 0;
+  const header = headers[fromCol];
+  const enumerator = getEnumerator(toList(rangeDouble(shiftStart, op_UnaryNegation_Int32(shift), shiftEnd)));
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
+      setItem(headers, c + shift, headers[c]);
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  setItem(headers, toCol, header);
+  const col = getItemFromDict(values.Columns, fromCol);
+  const enumerator_1 = getEnumerator(toList(rangeDouble(shiftStart, op_UnaryNegation_Int32(shift), shiftEnd)));
+  try {
+    while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+      const c_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]() | 0;
+      values.Columns.set(c_1 + shift, getItemFromDict(values.Columns, c_1));
+    }
+  } finally {
+    disposeSafe(enumerator_1);
+  }
+  values.Columns.set(toCol, col);
+}
+function Unchecked_alignByHeaders(keepOrder, rows) {
+  const headers = [];
+  const values = ArcTableValues.init();
+  values.RowCount = length$1(rows) | 0;
+  const loop = (colI_mut, rows_2_mut) => {
+    loop:
+      while (true) {
+        const colI = colI_mut, rows_2 = rows_2_mut;
+        if (!exists((arg) => !isEmpty$1(arg), rows_2)) {
+          return [headers, values];
+        } else {
+          const firstElem = pick((l) => isEmpty$1(l) ? void 0 : head(l), rows_2)[0];
+          void headers.push(firstElem);
+          colI_mut = colI + 1;
+          rows_2_mut = mapIndexed((rowI, l_1) => {
+            if (keepOrder) {
+              if (!isEmpty$1(l_1)) {
+                if (Unchecked_compositeHeaderMainColumnEqual(head(l_1)[0], firstElem)) {
+                  Unchecked_setCellAt(colI, rowI, head(l_1)[1], values);
+                  return tail(l_1);
+                } else {
+                  return l_1;
+                }
+              } else {
+                return empty();
+              }
+            } else {
+              const patternInput = List_tryPickAndRemove((tupledArg) => {
+                if (Unchecked_compositeHeaderMainColumnEqual(tupledArg[0], firstElem)) {
+                  return tupledArg[1];
+                } else {
+                  return void 0;
+                }
+              }, l_1);
+              const newL = patternInput[1];
+              const firstMatch = patternInput[0];
+              if (firstMatch == null) {
+                return newL;
+              } else {
+                Unchecked_setCellAt(colI, rowI, value(firstMatch), values);
+                return newL;
+              }
+            }
+          }, rows_2);
+          continue loop;
+        }
+      }
+  };
+  return loop(0, rows);
+}
+
+export { $007CIsUniqueExistingHeader$007C_$007C, ArcTableValues, ColumnValueRefs, ColumnValueRefs_Constant, ColumnValueRefs_Sparse, ColumnValueRefs__Copy, ColumnValueRefs__ToCellColumn_Z2609C9DD, ColumnValueRefs__ToSparse_Z524259A4, ColumnValueRefs_fromCellColumn_14896151, SanityChecks_validateArcTableValues, SanityChecks_validateCellColumns, SanityChecks_validateColumn, SanityChecks_validateColumnIndex, SanityChecks_validateRowIndex, Unchecked_addColumn, Unchecked_addColumnFill, Unchecked_addEmptyRow, Unchecked_addRefColumn, Unchecked_addRow, Unchecked_addRows, Unchecked_alignByHeaders, Unchecked_compositeHeaderMainColumnEqual, Unchecked_getCellWithDefault, Unchecked_moveCellTo, Unchecked_moveColumnCellsTo, Unchecked_moveColumnTo, Unchecked_removeCellAt, Unchecked_removeColumnCells, Unchecked_removeColumnCells_withIndexChange, Unchecked_removeHeader, Unchecked_removeRowCells_withIndexChange, Unchecked_setCellAt, Unchecked_tryGetCellAt, ensureCellHashInValueMap, getEmptyCellForHeader, tryFindDuplicateUnique, tryFindDuplicateUniqueInArray };