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

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Cells/FsCellsCollection.fs.js

@@ -0,0 +1,344 @@
+import { getItemFromDict, addToDict, addToSet } from '../../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { some, value } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { comparePrimitives } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { map, iterate, isEmpty, max, collect, delay, min, minBy, empty, singleton } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { FsAddress } from '../FsAddress.fs.js';
+
+function Dictionary_tryGet(k, dict) {
+  if (dict.has(k)) {
+    return some(getItemFromDict(dict, k));
+  } else {
+    return void 0;
+  }
+}
+class FsCellsCollection {
+  constructor() {
+    this._columnsUsed = /* @__PURE__ */ new Map([]);
+    this._deleted = /* @__PURE__ */ new Map([]);
+    this._rowsCollection = /* @__PURE__ */ new Map([]);
+    this._maxColumnUsed = 0;
+    this._maxRowUsed = 0;
+    this._rowsUsed = /* @__PURE__ */ new Map([]);
+    this._count = 0;
+  }
+  get Count() {
+    const this$ = this;
+    return this$._count | 0;
+  }
+  set Count(count) {
+    const this$ = this;
+    this$._count = count | 0;
+  }
+  get MaxRowNumber() {
+    const this$ = this;
+    return this$._maxRowUsed | 0;
+  }
+  get MaxColumnNumber() {
+    const this$ = this;
+    return this$._maxColumnUsed | 0;
+  }
+  Copy() {
+    const this$ = this;
+    const cells = map((c) => c.Copy(), this$.GetCells());
+    return FsCellsCollection.createFromCells(cells);
+  }
+  static copy(cellsCollection) {
+    return cellsCollection.Copy();
+  }
+  static IncrementUsage(dictionary, key) {
+    const matchValue = Dictionary_tryGet(key, dictionary);
+    if (matchValue == null) {
+      addToDict(dictionary, key, 1);
+    } else {
+      const count = value(matchValue) | 0;
+      dictionary.set(key, count + 1);
+    }
+  }
+  static DecrementUsage(dictionary, key) {
+    const matchValue = Dictionary_tryGet(key, dictionary);
+    if (matchValue == null) {
+      return false;
+    } else if (value(matchValue) > 1) {
+      const count_1 = value(matchValue) | 0;
+      dictionary.set(key, count_1 - 1);
+      return false;
+    } else {
+      dictionary.delete(key);
+      return true;
+    }
+  }
+  static createFromCells(cells) {
+    const fcc = new FsCellsCollection();
+    fcc.AddMany(cells);
+    return fcc;
+  }
+  Clear() {
+    const this$ = this;
+    this$._count = 0;
+    this$._rowsUsed.clear();
+    this$._columnsUsed.clear();
+    this$._rowsCollection.clear();
+    this$._maxRowUsed = 0;
+    this$._maxColumnUsed = 0;
+    return this$;
+  }
+  Add(cell, row, column) {
+    let matchValue, columnsCollection_1;
+    const this$ = this;
+    if (row != null) {
+      cell.RowNumber = value(row) | 0;
+    }
+    if (column != null) {
+      cell.ColumnNumber = value(column) | 0;
+    }
+    const row_1 = cell.RowNumber | 0;
+    const column_1 = cell.ColumnNumber | 0;
+    this$._count = this$._count + 1 | 0;
+    FsCellsCollection.IncrementUsage(this$._rowsUsed, row_1);
+    FsCellsCollection.IncrementUsage(this$._columnsUsed, column_1);
+    addToDict((matchValue = Dictionary_tryGet(row_1, this$._rowsCollection), matchValue == null ? (columnsCollection_1 = /* @__PURE__ */ new Map([]), addToDict(this$._rowsCollection, row_1, columnsCollection_1), columnsCollection_1) : value(matchValue)), column_1, cell);
+    if (row_1 > this$._maxRowUsed) {
+      this$._maxRowUsed = row_1 | 0;
+    }
+    if (column_1 > this$._maxColumnUsed) {
+      this$._maxColumnUsed = column_1 | 0;
+    }
+    const matchValue_1 = Dictionary_tryGet(row_1, this$._deleted);
+    if (matchValue_1 == null) ; else {
+      const delHash = value(matchValue_1);
+      delHash.delete(column_1);
+    }
+  }
+  static addCellWithIndeces(rowIndex, colIndex, cell, cellsCollection) {
+    cellsCollection.Add(cell, rowIndex, colIndex);
+  }
+  static addCell(cell, cellsCollection) {
+    cellsCollection.Add(cell);
+    return cellsCollection;
+  }
+  AddMany(cells) {
+    const this$ = this;
+    iterate((arg) => {
+      this$.Add(arg);
+    }, cells);
+  }
+  static addCells(cells, cellsCollection) {
+    cellsCollection.AddMany(cells);
+    return cellsCollection;
+  }
+  ContainsCellAt(rowIndex, colIndex) {
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(rowIndex, this$._rowsCollection);
+    if (matchValue == null) {
+      return false;
+    } else {
+      const colsCollection = value(matchValue);
+      return colsCollection.has(colIndex);
+    }
+  }
+  static containsCellAt(rowIndex, colIndex, cellsCollection) {
+    return cellsCollection.ContainsCellAt(rowIndex, colIndex);
+  }
+  RemoveCellAt(row, column) {
+    let delHash;
+    const this$ = this;
+    this$._count = this$._count - 1 | 0;
+    const rowRemoved = FsCellsCollection.DecrementUsage(this$._rowsUsed, row);
+    const columnRemoved = FsCellsCollection.DecrementUsage(this$._columnsUsed, column);
+    if (rowRemoved && row === this$._maxRowUsed) {
+      this$._maxRowUsed = (!isEmpty(this$._rowsUsed.keys()) ? max(this$._rowsUsed.keys(), {
+        Compare: comparePrimitives
+      }) : 0) | 0;
+    }
+    if (columnRemoved && column === this$._maxColumnUsed) {
+      this$._maxColumnUsed = (!isEmpty(this$._columnsUsed.keys()) ? max(this$._columnsUsed.keys(), {
+        Compare: comparePrimitives
+      }) : 0) | 0;
+    }
+    const matchValue = Dictionary_tryGet(row, this$._deleted);
+    if (matchValue == null) {
+      const delHash_3 = /* @__PURE__ */ new Set([]);
+      addToSet(column, delHash_3);
+      addToDict(this$._deleted, row, delHash_3);
+    } else if (delHash = value(matchValue), delHash.has(column)) {
+      value(matchValue);
+    } else {
+      const delHash_2 = value(matchValue);
+      addToSet(column, delHash_2);
+    }
+    const matchValue_1 = Dictionary_tryGet(row, this$._rowsCollection);
+    if (matchValue_1 == null) ; else {
+      const columnsCollection = value(matchValue_1);
+      columnsCollection.delete(column);
+      if (columnsCollection.size === 0) {
+        this$._rowsCollection.delete(row);
+      }
+    }
+  }
+  static removeCellAt(rowIndex, colIndex, cellsCollection) {
+    cellsCollection.RemoveCellAt(rowIndex, colIndex);
+    return cellsCollection;
+  }
+  TryRemoveValueAt(rowIndex, colIndex) {
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(rowIndex, this$._rowsCollection);
+    if (matchValue == null) ; else {
+      const colsCollection = value(matchValue);
+      try {
+        getItemFromDict(colsCollection, colIndex).Value = "";
+      } catch (matchValue_1) {
+      }
+    }
+  }
+  static tryRemoveValueAt(rowIndex, colIndex, cellsCollection) {
+    cellsCollection.TryRemoveValueAt(rowIndex, colIndex);
+    return cellsCollection;
+  }
+  RemoveValueAt(rowIndex, colIndex) {
+    const this$ = this;
+    getItemFromDict(getItemFromDict(this$._rowsCollection, rowIndex), colIndex).Value = "";
+  }
+  static removeValueAt(rowIndex, colIndex, cellsCollection) {
+    cellsCollection.RemoveValueAt(rowIndex, colIndex);
+    return cellsCollection;
+  }
+  GetCells() {
+    const this$ = this;
+    return collect((columnsCollection) => columnsCollection.values(), this$._rowsCollection.values());
+  }
+  static getCells(cellsCollection) {
+    return cellsCollection.GetCells();
+  }
+  GetCellsInRangeBy(rowStart, columnStart, rowEnd, columnEnd, predicate) {
+    const this$ = this;
+    const finalRow = (rowEnd > this$._maxRowUsed ? this$._maxRowUsed : rowEnd) | 0;
+    const finalColumn = (columnEnd > this$._maxColumnUsed ? this$._maxColumnUsed : columnEnd) | 0;
+    return delay(() => collect((ro) => {
+      const matchValue = Dictionary_tryGet(ro, this$._rowsCollection);
+      if (matchValue == null) {
+        return empty();
+      } else {
+        const columnsCollection = value(matchValue);
+        return collect((co) => {
+          const matchValue_1 = Dictionary_tryGet(co, columnsCollection);
+          let matchResult, cell_1;
+          if (matchValue_1 != null) {
+            if (predicate(value(matchValue_1))) {
+              matchResult = 0;
+              cell_1 = value(matchValue_1);
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+          switch (matchResult) {
+            case 0:
+              return singleton(cell_1);
+            default: {
+              return empty();
+            }
+          }
+        }, rangeDouble(columnStart, 1, finalColumn));
+      }
+    }, rangeDouble(rowStart, 1, finalRow)));
+  }
+  static filterCellsFromTo(rowStart, columnStart, rowEnd, columnEnd, predicate, cellsCollection) {
+    return cellsCollection.GetCellsInRangeBy(rowStart, columnStart, rowEnd, columnEnd, predicate);
+  }
+  GetCellsInStringRangeBy(startAddress, lastAddress, predicate) {
+    const this$ = this;
+    return this$.GetCellsInRangeBy(startAddress.RowNumber, startAddress.ColumnNumber, lastAddress.RowNumber, lastAddress.ColumnNumber, predicate);
+  }
+  static filterCellsFromToAddress(startAddress, lastAddress, predicate, cellsCollection) {
+    return cellsCollection.GetCellsInStringRangeBy(startAddress, lastAddress, predicate);
+  }
+  GetCellsInRange(rowStart, columnStart, rowEnd, columnEnd) {
+    const this$ = this;
+    const finalRow = (rowEnd > this$._maxRowUsed ? this$._maxRowUsed : rowEnd) | 0;
+    const finalColumn = (columnEnd > this$._maxColumnUsed ? this$._maxColumnUsed : columnEnd) | 0;
+    return delay(() => collect((ro) => {
+      const matchValue = Dictionary_tryGet(ro, this$._rowsCollection);
+      if (matchValue == null) {
+        return empty();
+      } else {
+        const columnsCollection = value(matchValue);
+        return collect((co) => {
+          const matchValue_1 = Dictionary_tryGet(co, columnsCollection);
+          if (matchValue_1 != null) {
+            return singleton(value(matchValue_1));
+          } else {
+            return empty();
+          }
+        }, rangeDouble(columnStart, 1, finalColumn));
+      }
+    }, rangeDouble(rowStart, 1, finalRow)));
+  }
+  static getCellsFromTo(rowStart, columnStart, rowEnd, columnEnd, cellsCollection) {
+    return cellsCollection.GetCellsInRange(rowStart, columnStart, rowEnd, columnEnd);
+  }
+  GetCellsInStringRange(startAddress, lastAddress) {
+    const this$ = this;
+    return this$.GetCellsInRange(startAddress.RowNumber, startAddress.ColumnNumber, lastAddress.RowNumber, lastAddress.ColumnNumber);
+  }
+  static getCellsFromToAddress(startAddress, lastAddress, cellsCollection) {
+    return cellsCollection.GetCellsInStringRange(startAddress, lastAddress);
+  }
+  TryGetCell(row, column) {
+    const this$ = this;
+    if (row > this$._maxRowUsed ? true : column > this$._maxColumnUsed) {
+      return void 0;
+    } else {
+      const matchValue = Dictionary_tryGet(row, this$._rowsCollection);
+      if (matchValue == null) {
+        return void 0;
+      } else {
+        const matchValue_1 = Dictionary_tryGet(column, value(matchValue));
+        return matchValue_1 == null ? void 0 : value(matchValue_1);
+      }
+    }
+  }
+  static tryGetCell(rowIndex, colIndex, cellsCollection) {
+    return cellsCollection.TryGetCell(rowIndex, colIndex);
+  }
+  GetCellsInColumn(colIndex) {
+    const this$ = this;
+    return this$.GetCellsInRange(1, colIndex, this$._maxRowUsed, colIndex);
+  }
+  static getCellsInColumn(colIndex, cellsCollection) {
+    return cellsCollection.GetCellsInColumn(colIndex);
+  }
+  GetCellsInRow(rowIndex) {
+    const this$ = this;
+    return this$.GetCellsInRange(rowIndex, 1, rowIndex, this$._maxColumnUsed);
+  }
+  static getCellsInRow(rowIndex, cellsCollection) {
+    return cellsCollection.GetCellsInRow(rowIndex);
+  }
+  GetFirstAddress() {
+    let d_1;
+    const this$ = this;
+    return (isEmpty(this$._rowsCollection) ? true : isEmpty(this$._rowsCollection.keys())) ? new FsAddress(0, 0) : new FsAddress(min(this$._rowsCollection.keys(), {
+      Compare: comparePrimitives
+    }), (d_1 = minBy((d) => min(d.keys(), {
+      Compare: comparePrimitives
+    }), this$._rowsCollection.values(), {
+      Compare: comparePrimitives
+    }), min(d_1.keys(), {
+      Compare: comparePrimitives
+    })));
+  }
+  static getFirstAddress(cells) {
+    return cells.GetFirstAddress();
+  }
+  GetLastAddress() {
+    const this$ = this;
+    return new FsAddress(this$.MaxRowNumber, this$.MaxColumnNumber);
+  }
+  static getLastAddress(cells) {
+    return cells.GetLastAddress();
+  }
+}
+
+export { Dictionary_tryGet, FsCellsCollection };

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

@@ -0,0 +1,154 @@
+import { parse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { toFail, toText, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { StringBuilder_$ctor, StringBuilder__Append_244C7CD6 } from '../../../node_modules/@fable-org/fable-library-js/System.Text.js';
+import { iterate } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { isLetter, isDigit } from '../../../node_modules/@fable-org/fable-library-js/Char.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { value, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { stringHash, identityHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { mergeHashes } from './HashCodes.fs.js';
+
+function CellReference_colAdressToIndex(columnAdress) {
+  const length = columnAdress.length | 0;
+  let sum = 0;
+  for (let i = 0; i <= length - 1; i++) {
+    let c_1;
+    const c = columnAdress[length - 1 - i];
+    c_1 = c.toLocaleUpperCase();
+    let factor;
+    const value = Math.pow(26, i);
+    factor = value >>> 0;
+    sum = sum + ((c_1.charCodeAt(0) >>> 0) - 64) * factor;
+  }
+  return sum;
+}
+function CellReference_indexToColAdress(i) {
+  const loop = (index_mut, acc_mut) => {
+    loop:
+      while (true) {
+        const index = index_mut, acc = acc_mut;
+        if (index === 0) {
+          return acc;
+        } else {
+          const mod26 = (index - 1) % 26;
+          index_mut = ~~((index - 1) / 26);
+          acc_mut = String.fromCharCode(("A".charCodeAt(0) >>> 0) + mod26) + acc;
+          continue loop;
+        }
+      }
+  };
+  return loop(i, "");
+}
+function CellReference_ofIndices(column, row) {
+  const arg = CellReference_indexToColAdress(column);
+  return toText(printf("%s%i"))(arg)(row);
+}
+function CellReference_toIndices(reference) {
+  const charPart = StringBuilder_$ctor();
+  const numPart = StringBuilder_$ctor();
+  iterate((c) => {
+    if (isLetter(c)) {
+      StringBuilder__Append_244C7CD6(charPart, c);
+    } else if (isDigit(c)) {
+      StringBuilder__Append_244C7CD6(numPart, c);
+    } else {
+      toFail(printf("Reference %s does not match Excel A1-style"))(reference);
+    }
+  }, reference.split(""));
+  return [CellReference_colAdressToIndex(toString(charPart)), parse(toString(numPart), 511, true, 32)];
+}
+class FsAddress {
+  constructor(rowNumber, columnNumber, fixedRow, fixedColumn) {
+    this._fixedRow = fixedRow != null && value(fixedRow);
+    this._fixedColumn = fixedColumn != null && value(fixedColumn);
+    this._rowNumber = rowNumber | 0;
+    this._columnNumber = columnNumber | 0;
+    this._trimmedAddress = "";
+  }
+  static fromString(cellAddressString, fixedRow, fixedColumn) {
+    const patternInput = CellReference_toIndices(cellAddressString);
+    return new FsAddress(~~patternInput[1], ~~patternInput[0], unwrap(fixedRow), unwrap(fixedColumn));
+  }
+  get ColumnNumber() {
+    const self = this;
+    return self._columnNumber | 0;
+  }
+  set ColumnNumber(colI) {
+    const self = this;
+    self._columnNumber = colI | 0;
+  }
+  get RowNumber() {
+    const self = this;
+    return self._rowNumber | 0;
+  }
+  set RowNumber(rowI) {
+    const self = this;
+    self._rowNumber = rowI | 0;
+  }
+  get Address() {
+    const self = this;
+    return CellReference_ofIndices(self._columnNumber >>> 0, self._rowNumber >>> 0);
+  }
+  set Address(address) {
+    const self = this;
+    const patternInput = CellReference_toIndices(address);
+    self._rowNumber = ~~patternInput[1] | 0;
+    self._columnNumber = ~~patternInput[0] | 0;
+  }
+  get FixedRow() {
+    return false;
+  }
+  get FixedColumn() {
+    return false;
+  }
+  Copy() {
+    const this$ = this;
+    const colNo = this$.ColumnNumber | 0;
+    return new FsAddress(this$.RowNumber, colNo, this$.FixedRow, this$.FixedColumn);
+  }
+  static copy(address) {
+    return address.Copy();
+  }
+  UpdateIndices(rowIndex, colIndex) {
+    const self = this;
+    self._columnNumber = colIndex | 0;
+    self._rowNumber = rowIndex | 0;
+  }
+  static updateIndices(rowIndex, colIndex, address) {
+    address.UpdateIndices(rowIndex, colIndex);
+    return address;
+  }
+  ToIndices() {
+    const self = this;
+    return [self._rowNumber, self._columnNumber];
+  }
+  static toIndices(address) {
+    return address.ToIndices();
+  }
+  Compare(address) {
+    const self = this;
+    return self.Address === address.Address && self.ColumnNumber === address.ColumnNumber && self.RowNumber === address.RowNumber && self.FixedColumn === address.FixedColumn && self.FixedRow === address.FixedRow;
+  }
+  static compare(address1, address2) {
+    return address1.Compare(address2);
+  }
+  GetHashCode() {
+    let copyOfStruct, copyOfStruct_1;
+    const this$ = this;
+    let hash_7;
+    let hash_5;
+    let hash_3;
+    const hash_1 = stringHash(this$.Address) | 0;
+    hash_3 = mergeHashes(this$.ColumnNumber, hash_1);
+    hash_5 = mergeHashes(this$.RowNumber, hash_3);
+    hash_7 = mergeHashes((copyOfStruct = this$.FixedColumn, identityHash(copyOfStruct)), hash_5);
+    return mergeHashes((copyOfStruct_1 = this$.FixedRow, identityHash(copyOfStruct_1)), hash_7) | 0;
+  }
+  Equals(other) {
+    let other_1;
+    const this$ = this;
+    return other instanceof FsAddress && (other_1 = other, this$.Compare(other_1));
+  }
+}
+
+export { CellReference_colAdressToIndex, CellReference_indexToColAdress, CellReference_ofIndices, CellReference_toIndices, FsAddress };

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

@@ -0,0 +1,116 @@
+import { FsRangeAddress } from './Ranges/FsRangeAddress.fs.js';
+import { FsAddress } from './FsAddress.fs.js';
+import { FsCellsCollection } from './Cells/FsCellsCollection.fs.js';
+import { map, exists, length, minBy, maxBy } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { getEnumerator, toIterator, comparePrimitives } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { FsRangeBase } from './Ranges/FsRangeBase.fs.js';
+
+class FsColumn extends FsRangeBase {
+  constructor(rangeAddress, cells) {
+    super(rangeAddress);
+    this["cells@18"] = cells;
+  }
+  static empty() {
+    return new FsColumn(new FsRangeAddress(new FsAddress(0, 0), new FsAddress(0, 0)), new FsCellsCollection());
+  }
+  static createAt(index, cells) {
+    const getIndexBy = (f) => {
+      if (length(cells.GetCellsInColumn(index)) === 0) {
+        return 1;
+      } else {
+        return f((c) => c.Address.RowNumber)(cells.GetCellsInColumn(index)).Address.RowNumber | 0;
+      }
+    };
+    const minRowIndex = getIndexBy((projection) => (source_1) => minBy(projection, source_1, {
+      Compare: comparePrimitives
+    })) | 0;
+    const maxRowIndex = getIndexBy((projection_1) => (source_2) => maxBy(projection_1, source_2, {
+      Compare: comparePrimitives
+    })) | 0;
+    return new FsColumn(new FsRangeAddress(new FsAddress(minRowIndex, index), new FsAddress(maxRowIndex, index)), cells);
+  }
+  get Cells() {
+    const this$ = this;
+    return super.Cells(this$["cells@18"]);
+  }
+  get Index() {
+    const this$ = this;
+    return this$.RangeAddress.FirstAddress.ColumnNumber | 0;
+  }
+  set Index(i) {
+    const this$ = this;
+    this$.RangeAddress.FirstAddress.ColumnNumber = i | 0;
+    this$.RangeAddress.LastAddress.ColumnNumber = i | 0;
+  }
+  get MinRowIndex() {
+    const this$ = this;
+    return this$.RangeAddress.FirstAddress.RowNumber | 0;
+  }
+  get MaxRowIndex() {
+    const this$ = this;
+    return this$.RangeAddress.LastAddress.RowNumber | 0;
+  }
+  Copy() {
+    const this$ = this;
+    const ra = this$.RangeAddress.Copy();
+    const cells = map((c) => c.Copy(), this$.Cells);
+    const fcc = new FsCellsCollection();
+    fcc.AddMany(cells);
+    return new FsColumn(ra, fcc);
+  }
+  static copy(column) {
+    return column.Copy();
+  }
+  static getIndex(column) {
+    return column.Index;
+  }
+  HasCellAt(rowIndex) {
+    const this$ = this;
+    return exists((c) => c.RowNumber === rowIndex, this$.Cells);
+  }
+  static hasCellAt(rowIndex, column) {
+    return column.HasCellAt(rowIndex);
+  }
+  Item(rowIndex) {
+    const this$ = this;
+    return super.Cell(new FsAddress(rowIndex, 1), this$["cells@18"]);
+  }
+  static item(rowIndex, column) {
+    return column.Item(rowIndex);
+  }
+  TryItem(rowIndex) {
+    const this$ = this;
+    return this$.HasCellAt(rowIndex) ? this$.Item(rowIndex) : void 0;
+  }
+  static tryItem(rowIndex, column) {
+    return column.TryItem(rowIndex);
+  }
+  ToDenseColumn() {
+    const this$ = this;
+    for (let i = this$.MinRowIndex; i <= this$.MaxRowIndex; i++) {
+      this$.Item(i);
+    }
+  }
+  static toDenseColumn(column) {
+    column.ToDenseColumn();
+    return column;
+  }
+  static createDenseColumnOf(column) {
+    const newColumn = column.Copy();
+    newColumn.ToDenseColumn();
+    return newColumn;
+  }
+  GetEnumerator() {
+    const this$ = this;
+    return getEnumerator(this$.Cells);
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const this$ = this;
+    return getEnumerator(this$);
+  }
+}
+
+export { FsColumn };