@nfdi4plants/arctrl 3.1.1 → 3.2.0

package/dist/ts/ts/fable_modules/{FsSpreadsheet.7.0.0-alpha.1 → FsSpreadsheet.7.0.1}/FsWorksheet.fs.js

@@ -1,19 +1,19 @@
 import { FsCellsCollection } from './Cells/FsCellsCollection.fs.js';
 import { FsTable } from './Tables/FsTable.fs.js';
 import { FsRow } from './FsRow.fs.js';
-import { map, sortBy, head, last, iterate, tryFind, find, exists, filter, maxBy, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { map, sortBy, head, last, iterate, tryFind, find, exists, filter, maxBy, empty } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
 import { FsColumn } from './FsColumn.fs.js';
 import { FsCell } from './Cells/FsCell.fs.js';
-import { comparePrimitives, numberHash, getEnumerator, disposeSafe, safeHash, equals, clear } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { comparePrimitives, numberHash, getEnumerator, disposeSafe, safeHash, equals, clear, Exception } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
 import { FsAddress } from './FsAddress.fs.js';
 import { FsRangeAddress } from './Ranges/FsRangeAddress.fs.js';
-import { groupBy } from '../../../node_modules/@fable-org/fable-library-js/Seq2.js';
-import { defaultArg, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { toFail, printf, toConsole } from '../../../node_modules/@fable-org/fable-library-js/String.js';
-import { removeInPlace, addRangeInPlace } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
-import { ofSeq, tryFind as tryFind$1 } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
-import { iterate as iterate$1 } from '../../../node_modules/@fable-org/fable-library-js/List.js';
-import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { groupBy } from '../../../node_modules/@fable-org/fable-library-ts/Seq2.js';
+import { defaultArg, value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { toFail, printf, toConsole } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { removeInPlace, addRangeInPlace, setItem, item } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { ofSeq, tryFind as tryFind$1 } from '../../../node_modules/@fable-org/fable-library-ts/Map.js';
+import { iterate as iterate$1 } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
 
 class FsWorksheet {
   constructor(name, fsRows, fsTables, fsCellsCollection) {
@@ -23,40 +23,61 @@ class FsWorksheet {
     this._tables = defaultArg(fsTables, []);
     this._cells = defaultArg(fsCellsCollection, new FsCellsCollection());
   }
+  /**
+   * Creates an empty FsWorksheet with the given name.
+   */
   static init(name) {
     return new FsWorksheet(name, [], [], new FsCellsCollection());
   }
+  /**
+   * The name of the FsWorksheet.
+   */
   get Name() {
     const self = this;
     return self._name;
   }
+  /**
+   * The name of the FsWorksheet.
+   */
   set Name(name) {
     const self = this;
     self._name = name;
   }
+  /**
+   * The FsCellCollection of the FsWorksheet.
+   */
   get CellCollection() {
     const self = this;
     return self._cells;
   }
+  /**
+   * The FsTables of the FsWorksheet.
+   */
   get Tables() {
     const self = this;
     return self._tables;
   }
+  /**
+   * The FsRows of the FsWorksheet.
+   */
   get Rows() {
     const self = this;
     return self._rows;
   }
+  /**
+   * The FsColumns of the FsWorksheet.
+   */
   get Columns() {
     const self = this;
     return map((tupledArg) => {
-      let tupledArg_1, cells_1, c_2, c_3;
+      let tupledArg_1 = void 0, cells_1 = void 0, c_2 = void 0, c_3 = void 0;
       const columnIndex = tupledArg[0] | 0;
-      return new FsColumn((tupledArg_1 = (cells_1 = sortBy((c_1) => c_1.RowNumber, tupledArg[1], {
-        Compare: comparePrimitives
+      return new FsColumn((tupledArg_1 = (cells_1 = sortBy((c_1) => c_1.RowNumber | 0, tupledArg[1], {
+        Compare: (x_1, y_1) => comparePrimitives(x_1, y_1) | 0
       }), [new FsAddress((c_2 = head(cells_1), c_2.RowNumber), columnIndex), new FsAddress((c_3 = last(cells_1), c_3.RowNumber), columnIndex)]), new FsRangeAddress(tupledArg_1[0], tupledArg_1[1])), self.CellCollection);
-    }, groupBy((c) => c.ColumnNumber, self._cells.GetCells(), {
+    }, groupBy((c) => c.ColumnNumber | 0, self._cells.GetCells(), {
       Equals: (x, y) => x === y,
-      GetHashCode: numberHash
+      GetHashCode: (x) => numberHash(x) | 0
     }));
   }
   get MaxRowIndex() {
@@ -67,8 +88,11 @@ class FsWorksheet {
     const this$ = this;
     return this$.CellCollection.MaxColumnNumber | 0;
   }
+  /**
+   * Returns a copy of the FsWorksheet.
+   */
   Copy() {
-    let n, n_1;
+    let n = void 0, n_1 = void 0;
     const self = this;
     const fcc = self.CellCollection.Copy();
     return new FsWorksheet(self.Name, (n = [], iterate((r) => {
@@ -79,9 +103,15 @@ class FsWorksheet {
       void n_1.push(item_1);
     }, self.Tables), n_1), fcc);
   }
+  /**
+   * Returns a copy of a given FsWorksheet.
+   */
   static copy(sheet) {
     return sheet.Copy();
   }
+  /**
+   * Returns the FsRow at the given index. If it does not exist, it is created and appended first.
+   */
   Row(rowIndex, SkipSearch) {
     const self = this;
     if (defaultArg(SkipSearch, false)) {
@@ -99,6 +129,9 @@ class FsWorksheet {
       }
     }
   }
+  /**
+   * Returns the FsRow at the given FsRangeAddress. If it does not exist, it is created and appended first.
+   */
   RowWithRange(rangeAddress, SkipSearch) {
     const self = this;
     const skipSearch = defaultArg(SkipSearch, false);
@@ -116,22 +149,40 @@ class FsWorksheet {
       return row_1;
     }
   }
+  /**
+   * Appends an FsRow to an FsWorksheet if the rowIndex is not already taken.
+   */
   static appendRow(row, sheet) {
     sheet.Row(row.Index);
     return sheet;
   }
+  /**
+   * Returns the FsRows of a given FsWorksheet.
+   */
   static getRows(sheet) {
     return sheet.Rows;
   }
+  /**
+   * Returns the FsRow at the given rowIndex of an FsWorksheet.
+   */
   static getRowAt(rowIndex, sheet) {
     return find((arg) => rowIndex === FsRow.getIndex(arg), FsWorksheet.getRows(sheet));
   }
+  /**
+   * Returns the FsRow at the given rowIndex of an FsWorksheet if it exists, else returns None.
+   */
   static tryGetRowAt(rowIndex, sheet) {
     return tryFind((arg) => rowIndex === FsRow.getIndex(arg), sheet.Rows);
   }
+  /**
+   * Returns the FsRow matching or exceeding the given rowIndex if it exists, else returns None.
+   */
   static tryGetRowAfter(rowIndex, sheet) {
     return tryFind((r) => r.Index >= rowIndex, sheet.Rows);
   }
+  /**
+   * Inserts an FsRow into the FsWorksheet before a reference FsRow.
+   */
   InsertBefore(row, refRow) {
     const self = this;
     let enumerator = getEnumerator(self._rows);
@@ -148,19 +199,34 @@ class FsWorksheet {
     self.Row(row.Index);
     return self;
   }
+  /**
+   * Inserts an FsRow into the FsWorksheet before a reference FsRow.
+   */
   static insertBefore(row, refRow, sheet) {
     return sheet.InsertBefore(row, refRow);
   }
+  /**
+   * Returns true if the FsWorksheet contains an FsRow with the given rowIndex.
+   */
   ContainsRowAt(rowIndex) {
     const self = this;
     return exists((t) => t.Index === rowIndex, self.Rows);
   }
+  /**
+   * Returns true if the FsWorksheet contains an FsRow with the given rowIndex.
+   */
   static containsRowAt(rowIndex, sheet) {
     return sheet.ContainsRowAt(rowIndex);
   }
+  /**
+   * Returns the number of FsRows contained in the FsWorksheet.
+   */
   static countRows(sheet) {
-    return sheet.Rows.length;
+    return sheet.Rows.length | 0;
   }
+  /**
+   * Removes the FsRow at the given rowIndex.
+   */
   RemoveRowAt(rowIndex) {
     const self = this;
     const enumerator = getEnumerator(filter((r) => r.Index === rowIndex, self._rows));
@@ -168,17 +234,23 @@ class FsWorksheet {
       while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
         removeInPlace(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), self._rows, {
           Equals: equals,
-          GetHashCode: safeHash
+          GetHashCode: (x) => safeHash(x) | 0
         });
       }
     } finally {
       disposeSafe(enumerator);
     }
   }
+  /**
+   * Removes the FsRow at a given rowIndex of an FsWorksheet.
+   */
   static removeRowAt(rowIndex, sheet) {
     sheet.RemoveRowAt(rowIndex);
     return sheet;
   }
+  /**
+   * Removes the FsRow at a given rowIndex of the FsWorksheet if the FsRow exists.
+   */
   TryRemoveAt(rowIndex) {
     const self = this;
     if (self.ContainsRowAt(rowIndex)) {
@@ -186,60 +258,92 @@ class FsWorksheet {
     }
     return self;
   }
+  /**
+   * Removes the FsRow at a given rowIndex of an FsWorksheet if the FsRow exists.
+   */
   static tryRemoveAt(rowIndex, sheet) {
     if (FsWorksheet.containsRowAt(rowIndex, sheet)) {
       sheet.RemoveRowAt(rowIndex);
     }
   }
+  /**
+   * Sorts the FsRows by their rowIndex.
+   */
   SortRows() {
     const self = this;
-    const sorted = Array.from(sortBy((r) => r.Index, self._rows, {
-      Compare: comparePrimitives
+    const sorted = Array.from(sortBy((r) => r.Index | 0, self._rows, {
+      Compare: (x, y) => comparePrimitives(x, y) | 0
     }));
     clear(self._rows);
     addRangeInPlace(sorted, self._rows);
   }
+  /**
+   * Applies function f to all FsRows and returns the modified FsWorksheet.
+   */
   MapRowsInPlace(f) {
     const self = this;
     for (let i = 0; i <= self._rows.length - 1; i++) {
-      const r = self._rows[i];
-      self._rows[i] = f(r);
+      setItem(self._rows, i, f(item(i, self._rows)));
     }
     return self;
   }
+  /**
+   * Applies function f in a given FsWorksheet to all FsRows and returns the modified FsWorksheet.
+   */
   static mapRowsInPlace(f, sheet) {
     return sheet.MapRowsInPlace(f);
   }
+  /**
+   * Returns the highest index of any FsRow.
+   */
   GetMaxRowIndex() {
     const self = this;
     if (self.Rows.length === 0) {
-      throw new Error("The FsWorksheet has no FsRows.");
+      throw new Exception("The FsWorksheet has no FsRows.");
     }
-    return maxBy((r) => r.Index, self.Rows, {
-      Compare: comparePrimitives
+    return maxBy((r) => r.Index | 0, self.Rows, {
+      Compare: (x, y) => comparePrimitives(x, y) | 0
     });
   }
+  /**
+   * Returns the highest index of any FsRow in a given FsWorksheet.
+   */
   static getMaxRowIndex(sheet) {
     return sheet.GetMaxRowIndex();
   }
+  /**
+   * Gets the string values of the FsRow at the given 1-based rowIndex.
+   */
   GetRowValuesAt(rowIndex) {
     const self = this;
     return self.ContainsRowAt(rowIndex) ? map((c) => c.Value, self.Row(rowIndex).Cells) : empty();
   }
+  /**
+   * Gets the string values of the FsRow at the given 1-based rowIndex of a given FsWorksheet.
+   */
   static getRowValuesAt(rowIndex, sheet) {
     return sheet.GetRowValuesAt(rowIndex);
   }
+  /**
+   * Gets the string values at the given 1-based rowIndex of the FsRow if it exists, else returns None.
+   */
   TryGetRowValuesAt(rowIndex) {
     const self = this;
     return self.ContainsRowAt(rowIndex) ? self.GetRowValuesAt(rowIndex) : void 0;
   }
+  /**
+   * Takes an FsWorksheet and gets the string values at the given 1-based rowIndex of the FsRow if it exists, else returns None.
+   */
   static tryGetRowValuesAt(rowIndex, sheet) {
     return sheet.TryGetRowValuesAt(rowIndex);
   }
+  /**
+   * Checks the cell collection and recreate the whole set of rows, so that all cells are placed in a row
+   */
   RescanRows() {
     const self = this;
     const rows = ofSeq(map((r) => [r.Index, r], self._rows), {
-      Compare: comparePrimitives
+      Compare: (x, y) => comparePrimitives(x, y) | 0
     });
     iterate((tupledArg) => {
       const rowIndex = tupledArg[0] | 0;
@@ -262,15 +366,21 @@ class FsWorksheet {
         const row = value(matchValue);
         row.RangeAddress = newRange;
       }
-    }, groupBy((c) => c.RowNumber, self._cells.GetCells(), {
+    }, groupBy((c) => c.RowNumber | 0, self._cells.GetCells(), {
       Equals: (x_1, y_1) => x_1 === y_1,
-      GetHashCode: numberHash
+      GetHashCode: (x_1) => numberHash(x_1) | 0
     }));
   }
+  /**
+   * Returns the FsColumn at the given index. If it does not exist, it is created and appended first.
+   */
   Column(columnIndex) {
     const self = this;
     return FsColumn.createAt(columnIndex, self.CellCollection);
   }
+  /**
+   * Returns the FsColumn at the given FsRangeAddress. If it does not exist, it is created and appended first.
+   */
   ColumnWithRange(rangeAddress) {
     const self = this;
     if (rangeAddress.FirstAddress.ColumnNumber !== rangeAddress.LastAddress.ColumnNumber) {
@@ -278,15 +388,27 @@ class FsWorksheet {
     }
     self.Column(rangeAddress.FirstAddress.ColumnNumber).RangeAddress = rangeAddress;
   }
+  /**
+   * Returns the FsColumns of a given FsWorksheet.
+   */
   static getColumns(sheet) {
     return sheet.Columns;
   }
+  /**
+   * Returns the FsColumn at the given columnIndex of an FsWorksheet.
+   */
   static getColumnAt(columnIndex, sheet) {
     return find((arg) => columnIndex === FsColumn.getIndex(arg), FsWorksheet.getColumns(sheet));
   }
+  /**
+   * Returns the FsColumn at the given columnIndex of an FsWorksheet if it exists, else returns None.
+   */
   static tryGetColumnAt(columnIndex, sheet) {
     return tryFind((arg) => columnIndex === FsColumn.getIndex(arg), sheet.Columns);
   }
+  /**
+   * Returns the FsTable with the given tableName, rangeAddress, and showHeaderRow parameters. If it does not exist yet, it gets created and appended first.
+   */
   Table(tableName, rangeAddress, showHeaderRow) {
     const self = this;
     const showHeaderRow_1 = defaultArg(showHeaderRow, true);
@@ -299,16 +421,25 @@ class FsWorksheet {
       return value(matchValue);
     }
   }
+  /**
+   * Returns the FsTable of the given name from an FsWorksheet if it exists. Else returns None.
+   */
   static tryGetTableByName(tableName, sheet) {
     return tryFind((t) => t.Name === tableName, sheet.Tables);
   }
+  /**
+   * Returns the FsTable of the given name from an FsWorksheet.
+   */
   static getTableByName(tableName, sheet) {
     try {
       return value(tryFind((t) => t.Name === tableName, sheet.Tables));
     } catch (matchValue) {
-      throw new Error(`FsTable with name ${tableName} is not presen in the FsWorksheet ${sheet.Name}.`);
+      throw new Exception(`FsTable with name ${tableName} is not presen in the FsWorksheet ${sheet.Name}.`);
     }
   }
+  /**
+   * Adds an FsTable to the FsWorksheet if an FsTable with the same name is not already attached.
+   */
   AddTable(table) {
     const self = this;
     if (exists((t) => t.Name === table.Name, self.Tables)) {
@@ -318,9 +449,15 @@ class FsWorksheet {
     }
     return self;
   }
+  /**
+   * Adds an FsTable to the FsWorksheet if an FsTable with the same name is not already attached.
+   */
   static addTable(table, sheet) {
     return sheet.AddTable(table);
   }
+  /**
+   * Adds a list of FsTables to the FsWorksheet. All FsTables with a name already present in the FsWorksheet are not attached.
+   */
   AddTables(tables) {
     const self = this;
     iterate$1((arg) => {
@@ -328,84 +465,152 @@ class FsWorksheet {
     }, tables);
     return self;
   }
+  /**
+   * Adds a list of FsTables to an FsWorksheet. All FsTables with a name already present in the FsWorksheet are not attached.
+   */
   static addTables(tables, sheet) {
     return sheet.AddTables(tables);
   }
+  /**
+   * Returns the FsCell at the given row- and columnIndex if the FsCell exists, else returns None.
+   */
   TryGetCellAt(rowIndex, colIndex) {
     const self = this;
     return self.CellCollection.TryGetCell(rowIndex, colIndex);
   }
+  /**
+   * Returns the FsCell at the given row- and columnIndex of a given FsWorksheet if the FsCell exists, else returns None.
+   */
   static tryGetCellAt(rowIndex, colIndex, sheet) {
     return sheet.TryGetCellAt(rowIndex, colIndex);
   }
+  /**
+   * Returns the FsCell at the given row- and column index. Index is 1 based!
+   */
   GetCellAt(rowIndex, colIndex) {
     const self = this;
     return value(self.TryGetCellAt(rowIndex, colIndex));
   }
+  /**
+   * Returns the FsCell at the given row- and columnIndex of a given FsWorksheet.
+   */
   static getCellAt(rowIndex, colIndex, sheet) {
     return sheet.GetCellAt(rowIndex, colIndex);
   }
+  /**
+   * Adds a FsCell to the FsWorksheet. !Exception if cell address already exists!
+   */
   AddCell(cell) {
     const self = this;
-    const value = self.CellCollection.Add(cell);
+    self.CellCollection.Add(cell);
     return self;
   }
+  /**
+   * Adds a sequence of FsCells to the FsWorksheet. !Exception if cell address already exists!
+   */
   AddCells(cells) {
     const self = this;
-    const value = self.CellCollection.AddMany(cells);
+    self.CellCollection.AddMany(cells);
     return self;
   }
+  /**
+   * Adds a value at the given row- and columnIndex to the FsWorksheet.
+   * 
+   * If a cell exists at the given postion, it is shoved to the right.
+   */
   InsertValueAt(value, rowIndex, colIndex) {
     const self = this;
     const cell = new FsCell(value);
     self.CellCollection.Add(cell, rowIndex, colIndex);
   }
+  /**
+   * Adds a value at the given row- and columnIndex to a given FsWorksheet.
+   * 
+   * If an FsCell exists at the given position, it is shoved to the right.
+   */
   static insertValueAt(value, rowIndex, colIndex, sheet) {
     sheet.InsertValueAt(value, rowIndex, colIndex);
   }
+  /**
+   * Adds a value at the given row- and columnIndex.
+   * 
+   * If an FsCell exists at the given position, overwrites it.
+   */
   SetValueAt(value$1, rowIndex, colIndex) {
     const self = this;
     const matchValue = self.CellCollection.TryGetCell(rowIndex, colIndex);
     if (matchValue == null) {
-      const value_2 = self.CellCollection.Add(value$1, rowIndex, colIndex);
+      self.CellCollection.Add(value$1, rowIndex, colIndex);
       return self;
     } else {
       const c = value(matchValue);
-      const value_1 = c.SetValueAs(value$1);
+      c.SetValueAs(value$1);
       return self;
     }
   }
+  /**
+   * Adds a value at the given row- and columnIndex of a given FsWorksheet.
+   * 
+   * If an FsCell exists at the given position, it is overwritten.
+   */
   static setValueAt(value, rowIndex, colIndex, sheet) {
     return sheet.SetValueAt(value, rowIndex, colIndex);
   }
+  /**
+   * Removes the value at the given row- and columnIndex from the FsWorksheet.
+   */
   RemoveCellAt(rowIndex, colIndex) {
     const self = this;
     self.CellCollection.RemoveCellAt(rowIndex, colIndex);
     return self;
   }
+  /**
+   * Removes the value at the given row- and columnIndex from an FsWorksheet.
+   */
   static removeCellAt(rowIndex, colIndex, sheet) {
     return sheet.RemoveCellAt(rowIndex, colIndex);
   }
+  /**
+   * Removes the value of an FsCell at given row- and columnIndex if it exists from the FsCollection.
+   */
   TryRemoveValueAt(rowIndex, colIndex) {
     const self = this;
     self.CellCollection.TryRemoveValueAt(rowIndex, colIndex);
   }
+  /**
+   * Removes the value of an FsCell at given row- and columnIndex if it exists from the FsCollection of a given FsWorksheet.
+   */
   static tryRemoveValueAt(rowIndex, colIndex, sheet) {
     sheet.TryRemoveValueAt(rowIndex, colIndex);
   }
+  /**
+   * Removes the value of an FsCell at given row- and columnIndex from the FsCollection.
+   */
   RemoveValueAt(rowIndex, colIndex) {
     const self = this;
     self.CellCollection.RemoveValueAt(rowIndex, colIndex);
   }
+  /**
+   * Removes the value of an FsCell at given row- and columnIndex from the FsCollection of a given FsWorksheet.
+   */
   static removeValueAt(rowIndex, colIndex, sheet) {
     sheet.RemoveValueAt(rowIndex, colIndex);
   }
+  /**
+   * Adds a FsCell to the FsWorksheet. !Exception if cell address already exists!
+   */
   static addCell(cell, sheet) {
     return sheet.AddCell(cell);
   }
+  /**
+   * Adds a sequence of FsCells to the FsWorksheet. !Exception if cell address already exists!
+   */
   static addCells(cell, sheet) {
     return sheet.AddCells(cell);
   }
+  /**
+   * Validate the FsWorksheet for writign to xlsx file.
+   */
   static validateForWrite(ws) {
     try {
       iterate((t) => {

package/dist/ts/ts/fable_modules/{FsSpreadsheet.7.0.0-alpha.1 → FsSpreadsheet.7.0.1}/HashCodes.fs.js

@@ -1,11 +1,11 @@
-import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
-import { identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
-import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { fold } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
-import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-ts/Date.js';
+import { identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
 
 function mergeHashes(hash1, hash2) {
-  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
+  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2) | 0;
 }
 function hashDateTime(dt) {
   let acc = 0;
@@ -22,14 +22,14 @@ function hash(obj) {
   return identityHash(copyOfStruct) | 0;
 }
 function boxHashOption(a) {
-  let copyOfStruct, copyOfStruct_1;
+  let copyOfStruct = void 0, copyOfStruct_1 = void 0;
   return a != null ? (copyOfStruct = value(a), identityHash(copyOfStruct)) : (copyOfStruct_1 = 0, numberHash(copyOfStruct_1));
 }
 function boxHashArray(a) {
-  return fold((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+  return fold((acc, o) => mergeHashes(acc, hash(o)) | 0, 0, a);
 }
 function boxHashSeq(a) {
-  return fold$1((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+  return fold$1((acc, o) => mergeHashes(acc, hash(o)) | 0, 0, a);
 }
 
 export { boxHashArray, boxHashOption, boxHashSeq, hash, hashDateTime, mergeHashes };

package/dist/ts/ts/fable_modules/{FsSpreadsheet.7.0.0-alpha.1 → FsSpreadsheet.7.0.1}/Json/Cell.fs.js

@@ -1,8 +1,8 @@
 import { encode, decode } from './Value.fs.js';
-import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
-import { DataType_Empty, FsCell } from '../Cells/FsCell.fs.js';
-import { object, int } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
-import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { map } from '../../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { DataType, FsCell } from '../Cells/FsCell.fs.js';
+import { object, int } from '../../Thoth.Json.Core.0.9.1/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-ts/Option.js';
 import { FsAddress } from '../FsAddress.fs.js';
 
 function encodeNoNumber(cell) {
@@ -15,7 +15,7 @@ function encodeNoNumber(cell) {
   };
 }
 function encodeRows(cell) {
-  let value_1;
+  let value_1 = void 0;
   const values = [["column", (value_1 = cell.ColumnNumber | 0, {
     Encode(helpers) {
       return helpers.encodeSignedIntegralNumber(value_1);
@@ -30,16 +30,16 @@ function encodeRows(cell) {
 }
 function decodeRows(rowNumber) {
   return object((builder) => {
-    let objectArg, objectArg_1;
+    let objectArg = void 0, objectArg_1 = void 0;
     let patternInput;
-    const value_1 = ["", DataType_Empty()];
+    const value_1 = ["", DataType.Empty];
     patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), value_1);
     const c = defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("column", int)), 0) | 0;
     return new FsCell(patternInput[0], patternInput[1], new FsAddress(defaultArg(rowNumber, 0), c));
   });
 }
 function encodeCols(cell) {
-  let value_1;
+  let value_1 = void 0;
   const values = [["row", (value_1 = cell.RowNumber | 0, {
     Encode(helpers) {
       return helpers.encodeSignedIntegralNumber(value_1);
@@ -54,9 +54,9 @@ function encodeCols(cell) {
 }
 function decodeCols(colNumber) {
   return object((builder) => {
-    let objectArg, objectArg_1;
+    let objectArg = void 0, objectArg_1 = void 0;
     let patternInput;
-    const value_1 = ["", DataType_Empty()];
+    const value_1 = ["", DataType.Empty];
     patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), value_1);
     return new FsCell(patternInput[0], patternInput[1], new FsAddress(defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("row", int)), 0), defaultArg(colNumber, 0)));
   });