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

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Json/Value.fs.js

@@ -0,0 +1,25 @@
+import { minValue, tryParse } from '../../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { FSharpRef } from '../../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { FSharpResult$2_Ok, FSharpResult$2_Error } from '../../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { ErrorReason$1_BadPrimitive } from '../../Thoth.Json.Core.0.7.0/Types.fs.js';
+import { oneOf, map, bool, int, float, string } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { DataType_Boolean, DataType_Number, DataType_Date, DataType_String } from '../Cells/FsCell.fs.js';
+import { ofArray } from '../../../../node_modules/@fable-org/fable-library-js/List.js';
+
+const Decode_datetime = {
+  Decode(helpers, value) {
+    if (helpers.isString(value)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse(helpers.asString(value), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value)]);
+    }
+  }
+};
+oneOf(ofArray([map((b) => [b, DataType_Boolean()], bool), map((i) => [i, DataType_Number()], int), map((f) => [f, DataType_Number()], float), map((d_3) => [d_3, DataType_Date()], Decode_datetime), map((s) => [s, DataType_String()], string)]));
+
+export { Decode_datetime };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRange.fs.js

@@ -0,0 +1,28 @@
+import { defaultOf, int32ToString } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { some } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsRangeBase } from './FsRangeBase.fs.js';
+import { toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { FsRangeRow } from './FsRangeRow.fs.js';
+import { FsRangeAddress } from './FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+
+class FsRange extends FsRangeBase {
+  constructor(rangeAddress, styleValue) {
+    super(rangeAddress);
+  }
+  static fromRangeBase(rangeBase) {
+    return new FsRange(rangeBase.RangeAddress, some(defaultOf()));
+  }
+  Row(row) {
+    if (row <= 0 ? true : row + super.RangeAddress.FirstAddress.RowNumber - 1 > 1048576) {
+      throw new Error(int32ToString(row), toText(printf("Row number must be between 1 and %i"))(1048576));
+    }
+    return new FsRangeRow(new FsRangeAddress(new FsAddress(super.RangeAddress.FirstAddress.RowNumber + row - 1, super.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(super.RangeAddress.FirstAddress.RowNumber + row - 1, super.RangeAddress.LastAddress.ColumnNumber)));
+  }
+  FirstRow() {
+    const self = this;
+    return self.Row(1);
+  }
+}
+
+export { FsRange };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeAddress.fs.js

@@ -0,0 +1,82 @@
+import { FsAddress } from '../FsAddress.fs.js';
+import { toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { item } from '../../../../node_modules/@fable-org/fable-library-js/Array.js';
+
+class FsRangeAddress {
+  constructor(firstAddress, lastAddress) {
+    this.firstAddress = firstAddress;
+    this.lastAddress = lastAddress;
+    this._firstAddress = this.firstAddress;
+    this._lastAddress = this.lastAddress;
+  }
+  static fromString(rangeAddress) {
+    const patternInput = Range_toBoundaries(rangeAddress);
+    return new FsRangeAddress(FsAddress.fromString(patternInput[0]), FsAddress.fromString(patternInput[1]));
+  }
+  Copy() {
+    const self = this;
+    return FsRangeAddress.fromString(self.Range);
+  }
+  static copy(rangeAddress) {
+    return rangeAddress.Copy();
+  }
+  Extend(address) {
+    const self = this;
+    if (address.RowNumber < self._firstAddress.RowNumber) {
+      self._firstAddress.RowNumber = address.RowNumber | 0;
+    }
+    if (address.RowNumber > self._lastAddress.RowNumber) {
+      self._lastAddress.RowNumber = address.RowNumber | 0;
+    }
+    if (address.ColumnNumber < self._firstAddress.ColumnNumber) {
+      self._firstAddress.ColumnNumber = address.ColumnNumber | 0;
+    }
+    if (address.ColumnNumber > self._lastAddress.ColumnNumber) {
+      self._lastAddress.ColumnNumber = address.ColumnNumber | 0;
+    }
+  }
+  Normalize() {
+    const self = this;
+    const patternInput = self.firstAddress.RowNumber < self.lastAddress.RowNumber ? [self.firstAddress.RowNumber, self.lastAddress.RowNumber] : [self.lastAddress.RowNumber, self.firstAddress.RowNumber];
+    const patternInput_1 = self.firstAddress.RowNumber < self.lastAddress.RowNumber ? [self.firstAddress.RowNumber, self.lastAddress.RowNumber] : [self.lastAddress.RowNumber, self.firstAddress.RowNumber];
+    self._firstAddress = new FsAddress(patternInput[0], patternInput_1[0]);
+    self._lastAddress = new FsAddress(patternInput[1], patternInput_1[1]);
+  }
+  get Range() {
+    const self = this;
+    return Range_ofBoundaries(self._firstAddress.Address, self._lastAddress.Address);
+  }
+  set Range(address) {
+    const self = this;
+    const patternInput = Range_toBoundaries(address);
+    self._firstAddress = FsAddress.fromString(patternInput[0]);
+    self._lastAddress = FsAddress.fromString(patternInput[1]);
+  }
+  toString() {
+    const self = this;
+    return self.Range;
+  }
+  get FirstAddress() {
+    const self = this;
+    return self._firstAddress;
+  }
+  get LastAddress() {
+    const self = this;
+    return self._lastAddress;
+  }
+  Union(rangeAddress) {
+    const self = this;
+    self.Extend(rangeAddress.FirstAddress);
+    self.Extend(rangeAddress.LastAddress);
+    return self;
+  }
+}
+function Range_ofBoundaries(fromCellReference, toCellReference) {
+  return toText(printf("%s:%s"))(fromCellReference)(toCellReference);
+}
+function Range_toBoundaries(area) {
+  const a = area.split(":");
+  return [item(0, a), item(1, a)];
+}
+
+export { FsRangeAddress, Range_ofBoundaries, Range_toBoundaries };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeBase.fs.js

@@ -0,0 +1,69 @@
+import { FsAddress } from '../FsAddress.fs.js';
+import { defaultOf, equals } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { toFail, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { value } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsCell } from '../Cells/FsCell.fs.js';
+
+class FsRangeBase {
+  constructor(rangeAddress) {
+    this._sortRows = defaultOf();
+    this._sortColumns = defaultOf();
+    this._rangeAddress = rangeAddress;
+    FsRangeBase.IdCounter = FsRangeBase.IdCounter + 1 | 0;
+  }
+  Extend(address) {
+    const this$ = this;
+    this$._rangeAddress.Extend(address);
+  }
+  get RangeAddress() {
+    const this$ = this;
+    return this$._rangeAddress;
+  }
+  set RangeAddress(rangeAdress) {
+    const this$ = this;
+    if (!equals(rangeAdress, this$._rangeAddress)) {
+      this$._rangeAddress;
+      this$._rangeAddress = rangeAdress;
+    }
+  }
+  Cell(cellAddressInRange, cells) {
+    const this$ = this;
+    const absRow = cellAddressInRange.RowNumber + this$.RangeAddress.FirstAddress.RowNumber - 1 | 0;
+    const absColumn = cellAddressInRange.ColumnNumber + this$.RangeAddress.FirstAddress.ColumnNumber - 1 | 0;
+    if (absRow <= 0 ? true : absRow > 1048576) {
+      const arg = cells.MaxRowNumber | 0;
+      toFail(printf("Row number must be between 1 and %i"))(arg);
+    }
+    if (absColumn <= 0 ? true : absColumn > 16384) {
+      const arg_1 = cells.MaxColumnNumber | 0;
+      toFail(printf("Column number must be between 1 and %i"))(arg_1);
+    }
+    const cell = cells.TryGetCell(absRow, absColumn);
+    if (cell == null) {
+      const absoluteAddress = new FsAddress(absRow, absColumn, cellAddressInRange.FixedRow, cellAddressInRange.FixedColumn);
+      const newCell = FsCell.createEmptyWithAdress(absoluteAddress);
+      this$.Extend(absoluteAddress);
+      cells.Add(newCell, absRow, absColumn);
+      return newCell;
+    } else {
+      return value(cell);
+    }
+  }
+  Cells(cells) {
+    const this$ = this;
+    return cells.GetCellsInStringRange(this$.RangeAddress.FirstAddress, this$.RangeAddress.LastAddress);
+  }
+  ColumnCount() {
+    const this$ = this;
+    return this$._rangeAddress.LastAddress.ColumnNumber - this$._rangeAddress.FirstAddress.ColumnNumber + 1 | 0;
+  }
+  RowCount() {
+    const this$ = this;
+    return this$._rangeAddress.LastAddress.RowNumber - this$._rangeAddress.FirstAddress.RowNumber + 1 | 0;
+  }
+}
+(() => {
+  FsRangeBase.IdCounter = 0;
+})();
+
+export { FsRangeBase };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeColumn.fs.js

@@ -0,0 +1,42 @@
+import { FsRangeAddress } from './FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { FsRangeBase } from './FsRangeBase.fs.js';
+
+class FsRangeColumn extends FsRangeBase {
+  constructor(rangeAddress) {
+    super(rangeAddress);
+  }
+  static fromIndex(index) {
+    return new FsRangeColumn(new FsRangeAddress(new FsAddress(0, index), new FsAddress(0, index)));
+  }
+  get Index() {
+    const self = this;
+    return self.RangeAddress.FirstAddress.ColumnNumber | 0;
+  }
+  set Index(i) {
+    const self = this;
+    self.RangeAddress.FirstAddress.ColumnNumber = i | 0;
+    self.RangeAddress.LastAddress.ColumnNumber = i | 0;
+  }
+  Cell(rowIndex, cellsCollection) {
+    return super.Cell(new FsAddress(rowIndex - super.RangeAddress.FirstAddress.RowNumber + 1, 1), cellsCollection);
+  }
+  FirstCell(cells) {
+    return super.Cell(new FsAddress(1, 1), cells);
+  }
+  Cells(cellsCollection) {
+    return super.Cells(cellsCollection);
+  }
+  static fromRangeAddress(rangeAddress) {
+    return new FsRangeColumn(rangeAddress);
+  }
+  Copy() {
+    const self = this;
+    return new FsRangeColumn(self.RangeAddress.Copy());
+  }
+  static copy(rangeColumn) {
+    return rangeColumn.Copy();
+  }
+}
+
+export { FsRangeColumn };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeRow.fs.js

@@ -0,0 +1,29 @@
+import { FsRangeAddress } from './FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { FsRangeBase } from './FsRangeBase.fs.js';
+
+class FsRangeRow extends FsRangeBase {
+  constructor(rangeAddress) {
+    super(rangeAddress);
+  }
+  static fromIndex(index) {
+    return new FsRangeRow(new FsRangeAddress(new FsAddress(index, 0), new FsAddress(index, 0)));
+  }
+  get Index() {
+    const self = this;
+    return self.RangeAddress.FirstAddress.RowNumber | 0;
+  }
+  set Index(i) {
+    const self = this;
+    self.RangeAddress.FirstAddress.RowNumber = i | 0;
+    self.RangeAddress.LastAddress.RowNumber = i | 0;
+  }
+  Cell(columnIndex, cells) {
+    return super.Cell(new FsAddress(1, columnIndex - super.RangeAddress.FirstAddress.ColumnNumber + 1), cells);
+  }
+  Cells(cells) {
+    return super.Cells(cells);
+  }
+}
+
+export { FsRangeRow };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Tables/FsTable.fs.js

@@ -0,0 +1,348 @@
+import { equals, defaultOf, int32ToString, comparePrimitives, getEnumerator, disposeSafe } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { Dictionary_tryGet } from '../Cells/FsCellsCollection.fs.js';
+import { FsTableField } from './FsTableField.fs.js';
+import { length, iterateIndexed, initialize, delay, reduce, map, iterate, max, find, tryFind, tryPick, choose, toList, exists, collect, singleton } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsRange } from '../Ranges/FsRange.fs.js';
+import { FsRow } from '../FsRow.fs.js';
+import { FsRangeAddress } from '../Ranges/FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { defaultArg, value, some } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsColumn } from '../FsColumn.fs.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { replace, toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { addToSet, addToDict, getItemFromDict } from '../../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { FsRangeColumn } from '../Ranges/FsRangeColumn.fs.js';
+import { DataType_String } from '../Cells/FsCell.fs.js';
+import { FsRangeBase } from '../Ranges/FsRangeBase.fs.js';
+
+class FsTable extends FsRangeBase {
+  constructor(name, rangeAddress, showTotalsRow, showHeaderRow, fieldNames) {
+    super(rangeAddress);
+    let fns, dict;
+    this._name = replace(name.trim(), " ", "_");
+    this._lastRangeAddress = rangeAddress;
+    this._showTotalsRow = defaultArg(showTotalsRow, false);
+    this._showHeaderRow = defaultArg(showHeaderRow, true);
+    this._fieldNames = fieldNames == null ? /* @__PURE__ */ new Map([]) : (fns = value(fieldNames), length(fns) !== super.ColumnCount() ? (() => {
+      let arg, arg_1;
+      throw new Error((arg = length(fns) | 0, arg_1 = super.ColumnCount() | 0, toText(printf("The number of field names (%i) must match the number of columns (%i) in the range."))(arg)(arg_1)), "fieldNames");
+    })() : void 0, dict = /* @__PURE__ */ new Map([]), iterateIndexed((i, fn) => {
+      const colI = rangeAddress.FirstAddress.ColumnNumber + i | 0;
+      addToDict(dict, fn, new FsTableField(fn, i, new FsRangeColumn(new FsRangeAddress(new FsAddress(rangeAddress.FirstAddress.RowNumber, colI), new FsAddress(rangeAddress.LastAddress.RowNumber, colI)))));
+    }, fns), dict);
+    this._uniqueNames = /* @__PURE__ */ new Set([]);
+  }
+  get Name() {
+    const this$ = this;
+    return this$._name;
+  }
+  GetFieldNames(cellsCollection) {
+    const this$ = this;
+    if (!equals(this$._fieldNames, defaultOf()) && !equals(this$._lastRangeAddress, defaultOf()) && equals(this$._lastRangeAddress, this$.RangeAddress)) {
+      return this$._fieldNames;
+    } else {
+      this$._lastRangeAddress = this$.RangeAddress;
+      return this$._fieldNames;
+    }
+  }
+  GetFields(cellsCollection) {
+    const this$ = this;
+    return initialize(super.ColumnCount(), (i) => this$.GetFieldAt(i, cellsCollection));
+  }
+  get ShowHeaderRow() {
+    const this$ = this;
+    return this$._showHeaderRow;
+  }
+  set ShowHeaderRow(showHeaderRow) {
+    const this$ = this;
+    this$._showHeaderRow = showHeaderRow;
+  }
+  HeadersRow() {
+    const this$ = this;
+    return !this$.ShowHeaderRow ? defaultOf() : new FsRange(super.RangeAddress).FirstRow();
+  }
+  TryGetHeaderRow(cellsCollection) {
+    const this$ = this;
+    const matchValue = this$.ShowHeaderRow;
+    if (matchValue) {
+      const rowIndex = this$.RangeAddress.FirstAddress.RowNumber | 0;
+      return new FsRow(new FsRangeAddress(new FsAddress(rowIndex, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(rowIndex, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection);
+    } else {
+      return void 0;
+    }
+  }
+  GetHeaderRow(cellsCollection) {
+    const this$ = this;
+    const matchValue = this$.TryGetHeaderRow(cellsCollection);
+    if (matchValue == null) {
+      throw new Error(`Error. Unable to get header row for table "${this$.Name}" as \`ShowHeaderRow\` is set to \`false\`.`);
+    } else {
+      return value(matchValue);
+    }
+  }
+  GetColumns(cellsCollection) {
+    const this$ = this;
+    return delay(() => collect((i) => singleton(new FsColumn(new FsRangeAddress(new FsAddress(this$.RangeAddress.FirstAddress.RowNumber, i), new FsAddress(this$.RangeAddress.LastAddress.RowNumber, i)), cellsCollection)), rangeDouble(this$.RangeAddress.FirstAddress.ColumnNumber, 1, this$.RangeAddress.LastAddress.ColumnNumber)));
+  }
+  GetRows(cellsCollection) {
+    const this$ = this;
+    return delay(() => collect((i) => singleton(new FsRow(new FsRangeAddress(new FsAddress(i, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(i, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection)), rangeDouble(this$.RangeAddress.FirstAddress.RowNumber, 1, this$.RangeAddress.LastAddress.RowNumber)));
+  }
+  GetBodyRows(cellsCollection) {
+    const this$ = this;
+    const firstRowIndex = (this$.ShowHeaderRow ? this$.RangeAddress.FirstAddress.RowNumber + 1 : this$.RangeAddress.FirstAddress.RowNumber) | 0;
+    return delay(() => collect((i) => singleton(new FsRow(new FsRangeAddress(new FsAddress(i, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(i, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection)), rangeDouble(firstRowIndex, 1, this$.RangeAddress.LastAddress.RowNumber)));
+  }
+  GetRowAt(index, cellsCollection) {
+    let arg;
+    const this$ = this;
+    if (index <= 0 ? true : index > super.RowCount()) {
+      throw new Error(int32ToString(index), (arg = super.RowCount() | 0, toText(printf("Row index must be between 1 and %i"))(arg)));
+    }
+    const rowI = this$.RangeAddress.FirstAddress.RowNumber + index - 1 | 0;
+    return new FsRow(new FsRangeAddress(new FsAddress(rowI, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(rowI, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection);
+  }
+  GetBodyRowAt(index, cellsCollection) {
+    const this$ = this;
+    return this$.ShowHeaderRow ? this$.GetRowAt(index + 1, cellsCollection) : this$.GetRowAt(index, cellsCollection);
+  }
+  RescanRange() {
+    const this$ = this;
+    const rangeAddress = reduce((r1, r2) => r1.Union(r2), map((v) => v.Column.RangeAddress, this$._fieldNames.values()));
+    this$.RangeAddress = rangeAddress;
+  }
+  static rescanRange(table) {
+    table.RescanRange();
+    return table;
+  }
+  GetUniqueName(originalName, initialOffset, enforceOffset) {
+    const this$ = this;
+    let name = originalName + (enforceOffset ? int32ToString(initialOffset) : "");
+    if (this$._uniqueNames.has(name)) {
+      let i = initialOffset;
+      name = originalName + int32ToString(i);
+      while (this$._uniqueNames.has(name)) {
+        i = i + 1 | 0;
+        name = originalName + int32ToString(i);
+      }
+    }
+    addToSet(name, this$._uniqueNames);
+    return name;
+  }
+  static getUniqueNames(originalName, initialOffset, enforceOffset, table) {
+    return table.GetUniqueName(originalName, initialOffset, enforceOffset);
+  }
+  InitFields(fieldNames) {
+    const this$ = this;
+    iterateIndexed((i, fn) => {
+      const tableField = new FsTableField(fn, i, FsRangeColumn.fromIndex(i));
+      addToDict(this$._fieldNames, fn, tableField);
+    }, fieldNames);
+  }
+  static initFields(fieldNames, table) {
+    table.InitFields(fieldNames);
+    return table;
+  }
+  AddFields(tableFields) {
+    const this$ = this;
+    iterate((tf) => {
+      addToDict(this$._fieldNames, tf.Name, tf);
+    }, tableFields);
+  }
+  static addFields(tableFields, table) {
+    table.AddFields(tableFields);
+    return table;
+  }
+  Field(name, cellsCollection) {
+    let s, offset;
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(name, this$._fieldNames);
+    if (matchValue == null) {
+      const newField = new FsTableField(name, (s = map((v) => v.Index, this$._fieldNames.values()), length(s) === 0 ? 0 : max(s, {
+        Compare: comparePrimitives
+      })) + 1, new FsRangeColumn((offset = this$._fieldNames.size | 0, new FsRangeAddress(new FsAddress(this$.RangeAddress.FirstAddress.RowNumber, this$.RangeAddress.FirstAddress.ColumnNumber + offset), new FsAddress(this$.RangeAddress.LastAddress.RowNumber, this$.RangeAddress.FirstAddress.ColumnNumber + offset)))), some(defaultOf()), some(defaultOf()));
+      if (this$.ShowHeaderRow) {
+        newField.HeaderCell(cellsCollection, true).SetValueAs(name);
+      }
+      addToDict(this$._fieldNames, name, newField);
+      this$.RescanRange();
+      return newField;
+    } else {
+      return value(matchValue);
+    }
+  }
+  GetField(name, cellsCollection) {
+    const this$ = this;
+    const name_1 = replace(name, "\r\n", "\n");
+    try {
+      return getItemFromDict(this$.GetFieldNames(cellsCollection), name_1);
+    } catch (matchValue) {
+      throw new Error("The header row doesn't contain field name '" + name_1 + "'.");
+    }
+  }
+  static getField(name, cellsCollection, table) {
+    return table.GetField(name, cellsCollection);
+  }
+  GetFieldAt(index, cellsCollection) {
+    const this$ = this;
+    try {
+      return find((ftf) => ftf.Index === index, this$.GetFieldNames(cellsCollection).values());
+    } catch (matchValue) {
+      throw new Error(`FsTableField with index ${index} does not exist in the FsTable.`);
+    }
+  }
+  GetFieldIndex(name, cellsCollection) {
+    const this$ = this;
+    return this$.GetField(name, cellsCollection).Index | 0;
+  }
+  RenameField(oldName, newName) {
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(oldName, this$._fieldNames);
+    if (matchValue == null) {
+      throw new Error("The FsTabelField does not exist in this FsTable", "oldName");
+    } else {
+      const field = value(matchValue);
+      this$._fieldNames.delete(oldName);
+      addToDict(this$._fieldNames, newName, field);
+    }
+  }
+  static renameField(oldName, newName, table) {
+    table.RenameField(oldName, newName);
+    return table;
+  }
+  TryGetHeaderCellOfColumnAt(cellsCollection, colIndex) {
+    const this$ = this;
+    const fstRowIndex = this$.RangeAddress.FirstAddress.RowNumber | 0;
+    return tryFind((c) => c.RowNumber === fstRowIndex, cellsCollection.GetCellsInColumn(colIndex));
+  }
+  static tryGetHeaderCellOfColumnIndexAt(cellsCollection, colIndex, table) {
+    return table.TryGetHeaderCellOfColumnAt(cellsCollection, colIndex);
+  }
+  TryGetHeaderCellOfColumn(cellsCollection, column) {
+    const this$ = this;
+    return this$.TryGetHeaderCellOfColumnAt(cellsCollection, column.Index);
+  }
+  static tryGetHeaderCellOfColumn(cellsCollection, column, table) {
+    return table.TryGetHeaderCellOfColumn(cellsCollection, column);
+  }
+  GetHeaderCellOfColumnAt(cellsCollection, colIndex) {
+    const this$ = this;
+    return value(this$.TryGetHeaderCellOfColumnAt(cellsCollection, colIndex));
+  }
+  static getHeaderCellOfColumnIndexAt(cellsCollection, colIndex, table) {
+    return table.GetHeaderCellOfColumnAt(cellsCollection, colIndex);
+  }
+  GetHeaderCellOfColumn(cellsCollection, column) {
+    const this$ = this;
+    return value(this$.TryGetHeaderCellOfColumn(cellsCollection, column));
+  }
+  static getHeaderCellOfColumn(cellsCollection, column, table) {
+    return table.GetHeaderCellOfColumn(cellsCollection, column);
+  }
+  GetHeaderCellOfTableField(cellsCollection, tableField) {
+    const this$ = this;
+    return tableField.HeaderCell(cellsCollection, this$.ShowHeaderRow);
+  }
+  static getHeaderCellOfTableField(cellsCollection, tableField, table) {
+    return table.GetHeaderCellOfTableField(cellsCollection, tableField);
+  }
+  TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex) {
+    const this$ = this;
+    return tryPick((tf) => {
+      if (tf.Index === tableFieldIndex) {
+        return tf.HeaderCell(cellsCollection, this$.ShowHeaderRow);
+      } else {
+        return void 0;
+      }
+    }, this$._fieldNames.values());
+  }
+  static tryGetHeaderCellOfTableFieldIndexAt(cellsCollection, tableFieldIndex, table) {
+    return table.TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex);
+  }
+  GetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex) {
+    const this$ = this;
+    return value(this$.TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex));
+  }
+  static getHeaderCellOfTableFieldIndexAt(cellsCollection, tableFieldIndex, table) {
+    return table.GetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex);
+  }
+  TryGetHeaderCellByFieldName(cellsCollection, fieldName) {
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(fieldName, this$._fieldNames);
+    if (matchValue == null) {
+      return void 0;
+    } else {
+      const tf = value(matchValue);
+      return tf.HeaderCell(cellsCollection, this$.ShowHeaderRow);
+    }
+  }
+  static tryGetHeaderCellByFieldName(cellsCollection, fieldName, table) {
+    return table.TryGetHeaderCellByFieldName(cellsCollection, fieldName);
+  }
+  GetDataCellsOfColumnAt(cellsCollection, colIndex) {
+    const this$ = this;
+    return choose((ri) => cellsCollection.TryGetCell(ri, colIndex), toList(rangeDouble(this$.RangeAddress.FirstAddress.RowNumber + 1, 1, this$.RangeAddress.LastAddress.RowNumber)));
+  }
+  static getDataCellsOfColumnIndexAt(cellsCollection, colIndex, table) {
+    return table.GetDataCellsOfColumnAt(cellsCollection, colIndex);
+  }
+  Copy() {
+    const this$ = this;
+    const ra = this$.RangeAddress.Copy();
+    return new FsTable(this$.Name, ra, false, this$.ShowHeaderRow);
+  }
+  static copy(table) {
+    return table.Copy();
+  }
+  static validateForWrite(table, cellsCollection) {
+    let arg;
+    if (length(table.GetBodyRows(cellsCollection)) === 0) {
+      throw new Error((arg = table.Name, toText(printf("The table '%s' must contain at least one body row."))(arg)), "table");
+    }
+  }
+  RescanFieldNames(cellsCollection) {
+    const this$ = this;
+    if (this$.ShowHeaderRow) {
+      const oldFieldNames = this$._fieldNames;
+      this$._fieldNames = /* @__PURE__ */ new Map([]);
+      let cellPos = 0;
+      const enumerator = getEnumerator(this$.GetHeaderRow(cellsCollection));
+      try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+          const cell = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          let name = cell.ValueAsString();
+          const matchValue = Dictionary_tryGet(name, oldFieldNames);
+          if (matchValue == null) {
+            if (name === defaultOf() !== (name === "")) {
+              name = this$.GetUniqueName("Column", cellPos + 1, true);
+              const value = cell.SetValueAs(name);
+              cell.DataType = DataType_String();
+            }
+            if (this$._fieldNames.has(name)) {
+              throw new Error("The header row contains more than one field name '" + name + "'.");
+            }
+            addToDict(this$._fieldNames, name, new FsTableField(name, cellPos));
+            cellPos = cellPos + 1 | 0;
+          } else {
+            const tableField = value(matchValue);
+            tableField.Index = cellPos | 0;
+            addToDict(this$._fieldNames, name, tableField);
+            cellPos = cellPos + 1 | 0;
+          }
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+    } else {
+      const colCount = super.ColumnCount() | 0;
+      for (let i = 1; i <= colCount; i++) {
+        if (!exists((v) => v.Index === i - 1, this$._fieldNames.values())) {
+          const name_1 = "Column" + int32ToString(i);
+          addToDict(this$._fieldNames, name_1, new FsTableField(name_1, i - 1));
+        }
+      }
+    }
+  }
+}
+
+export { FsTable };