update: add leftbar to app

.github/workflows/pypi.yml

@@ -117,7 +117,7 @@ jobs:
           MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
         with:
           command: upload
-          args: "--skip-existing **/*.whl **/*.tar.gz"
+          args: "--skip-existing **/*.whl"
           working-directory: bindings/python
 
   publish-pypi:
@@ -137,5 +137,5 @@ jobs:
           MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
         with:
           command: upload
-          args: "--skip-existing **/*.whl **/*.tar.gz"
+          args: "--skip-existing **/*.whl"
           working-directory: bindings/python

Cargo.lock

@@ -437,6 +437,7 @@ dependencies = [
  "chrono-tz",
  "csv",
  "js-sys",
+ "once_cell",
  "rand",
  "regex",
  "regex-lite",
@@ -720,10 +721,11 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.25.0"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
+checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
 dependencies = [
+ "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -737,9 +739,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.25.0"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
+checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -747,9 +749,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.25.0"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
+checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -757,9 +759,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.25.0"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
+checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -769,9 +771,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.0"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
+checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -782,9 +784,8 @@ dependencies = [
 
 [[package]]
 name = "pyroncalc"
-version = "0.5.7"
+version = "0.5.0"
 dependencies = [
- "bitcode",
  "ironcalc",
  "pyo3",
  "serde",
@@ -984,9 +985,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.2"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "thiserror"

Makefile

@@ -31,12 +31,7 @@ clean: remove-artifacts
 	rm -r -f base/target
 	rm -r -f xlsx/target
 	rm -r -f bindings/python/target
-	rm -r -f bindings/wasm/target
-	rm -r -f bindings/wasm/pkg
-	rm -r -f webapp/IronCalc/node_modules
-	rm -r -f webapp/IronCalc/dist
-	rm -r -f webapp/app.ironcalc.com/frontend/node_modules
-	rm -r -f webapp/app.ironcalc.com/frontend/dist
+	rm -r -f bindings/wasm/targets
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*

base/CALC.md

@@ -1,61 +0,0 @@
-# Evaluation Strategy
-
-
-We have a list of the spill cells:
-
-```
-// Checks if the array starting at cell will cover cells whose values
-// has been requested
-def CheckSpill(cell, array):
-    for c in cell+array:
-        support CellHasBeenRequested(c):
-        if support is not empty:
-            return support
-    return []
-
-// Fills cells with the result (an array)
-def FillCells(cell, result):
-
-
-def EvaluateNodeInContext(node, context):
-    match node:
-        case OP(left, right, op):
-            l = EvaluateNodeInContext(left, context)?
-            r = EvaluateNodeInContext(left, context)?
-            return op(l, r)
-        case FUNCTION(args, fn):
-            ...
-        case CELL(cell):
-            EvaluateCell(cell)
-        case RANGE(start, end):
-            ...
-
-
-
-def EvaluateCell(cell):
-    if IsCellEvaluating(cell):
-        return CIRC
-    MarkEvaluating(cell)
-    result = EvaluateNodeInContext(cell.formula, cell)
-    if isSpill(result):
-        CheckSpill(cell, array)?
-        FillCells(result)
-
-
-def EvaluateWorkbook():
-    spill_cells = [cell_1, ...., cell_n];
-
-
-    for cell in spill_cells:
-        result = evaluate(cell)
-```   
-
-
-
-
-
-
-
-# When updating a cell value
-
-If it was a spill cell we nee

base/Cargo.toml

@@ -17,6 +17,7 @@ chrono = "0.4"
 chrono-tz = "0.10"
 regex = { version = "1.0", optional = true}
 regex-lite = { version = "0.1.6", optional = true}
+once_cell = "1.16.0"
 bitcode = "0.6.3"
 csv = "1.3.0"
 

base/src/actions.rs

@@ -22,7 +22,7 @@ impl Model {
             .cell(row, column)
             .and_then(|c| c.get_formula())
         {
-            let node = &self.parsed_formulas[sheet as usize][f as usize].0.clone();
+            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
             let cell_reference = CellReferenceRC {
                 sheet: self.workbook.worksheets[sheet as usize].get_name(),
                 row,
@@ -212,12 +212,6 @@ impl Model {
         if column_count <= 0 {
             return Err("Please use insert columns instead".to_string());
         }
-        if !(1..=LAST_COLUMN).contains(&column) {
-            return Err(format!("Column number '{column}' is not valid."));
-        }
-        if column + column_count - 1 > LAST_COLUMN {
-            return Err("Cannot delete columns beyond the last column of the sheet".to_string());
-        }
 
         // first column being deleted
         let column_start = column;
@@ -390,13 +384,6 @@ impl Model {
         if row_count <= 0 {
             return Err("Please use insert rows instead".to_string());
         }
-        if !(1..=LAST_ROW).contains(&row) {
-            return Err(format!("Row number '{row}' is not valid."));
-        }
-        if row + row_count - 1 > LAST_ROW {
-            return Err("Cannot delete rows beyond the last row of the sheet".to_string());
-        }
-
         // Move cells
         let worksheet = &self.workbook.worksheet(sheet)?;
         let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -457,7 +444,7 @@ impl Model {
     ///    * Column is one of the extremes of the range. The new extreme would be target_column.
     ///      Range is then normalized
     ///    * Any other case, range is left unchanged.
-    ///      NOTE: This moves the data and column styles along with the formulas
+    ///      NOTE: This does NOT move the data in the columns or move the colum styles
     pub fn move_column_action(
         &mut self,
         sheet: u32,
@@ -473,70 +460,7 @@ impl Model {
             return Err("Initial column out of boundaries".to_string());
         }
 
-        if delta == 0 {
-            return Ok(());
-        }
-
-        // Preserve cell contents, width and style of the column being moved
-        let original_refs = self
-            .workbook
-            .worksheet(sheet)?
-            .column_cell_references(column)?;
-        let mut original_cells = Vec::new();
-        for r in &original_refs {
-            let cell = self
-                .workbook
-                .worksheet(sheet)?
-                .cell(r.row, column)
-                .ok_or("Expected Cell to exist")?;
-            let style_idx = cell.get_style();
-            let formula_or_value = self
-                .get_cell_formula(sheet, r.row, column)?
-                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
-            original_cells.push((r.row, formula_or_value, style_idx));
-            self.cell_clear_all(sheet, r.row, column)?;
-        }
-
-        let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
-        let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
-
-        if delta > 0 {
-            for c in column + 1..=target_column {
-                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
-                for r in refs {
-                    self.move_cell(sheet, r.row, c, r.row, c - 1)?;
-                }
-
-                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
-                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .set_column_width_and_style(c - 1, w, s)?;
-            }
-        } else {
-            for c in (target_column..=column - 1).rev() {
-                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
-                for r in refs {
-                    self.move_cell(sheet, r.row, c, r.row, c + 1)?;
-                }
-
-                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
-                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .set_column_width_and_style(c + 1, w, s)?;
-            }
-        }
-
-        for (r, value, style_idx) in original_cells {
-            self.set_user_input(sheet, r, target_column, value)?;
-            self.workbook
-                .worksheet_mut(sheet)?
-                .set_cell_style(r, target_column, style_idx)?;
-        }
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_column_width_and_style(target_column, width, style)?;
+        // TODO: Add the actual displacement of data and styles
 
         // Update all formulas in the workbook
         self.displace_cells(
@@ -549,88 +473,4 @@ impl Model {
 
         Ok(())
     }
-
-    /// Displaces cells due to a move row action
-    /// from initial_row to target_row = initial_row + row_delta
-    /// References will be updated following the same rules as move_column_action
-    /// NOTE: This moves the data and row styles along with the formulas
-    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
-        // Check boundaries
-        let target_row = row + delta;
-        if !(1..=LAST_ROW).contains(&target_row) {
-            return Err("Target row out of boundaries".to_string());
-        }
-        if !(1..=LAST_ROW).contains(&row) {
-            return Err("Initial row out of boundaries".to_string());
-        }
-
-        if delta == 0 {
-            return Ok(());
-        }
-
-        let original_cols = self.get_columns_for_row(sheet, row, false)?;
-        let mut original_cells = Vec::new();
-        for c in &original_cols {
-            let cell = self
-                .workbook
-                .worksheet(sheet)?
-                .cell(row, *c)
-                .ok_or("Expected Cell to exist")?;
-            let style_idx = cell.get_style();
-            let formula_or_value = self
-                .get_cell_formula(sheet, row, *c)?
-                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
-            original_cells.push((*c, formula_or_value, style_idx));
-            self.cell_clear_all(sheet, row, *c)?;
-        }
-
-        if delta > 0 {
-            for r in row + 1..=target_row {
-                let cols = self.get_columns_for_row(sheet, r, false)?;
-                for c in cols {
-                    self.move_cell(sheet, r, c, r - 1, c)?;
-                }
-            }
-        } else {
-            for r in (target_row..=row - 1).rev() {
-                let cols = self.get_columns_for_row(sheet, r, false)?;
-                for c in cols {
-                    self.move_cell(sheet, r, c, r + 1, c)?;
-                }
-            }
-        }
-
-        for (c, value, style_idx) in original_cells {
-            self.set_user_input(sheet, target_row, c, value)?;
-            self.workbook
-                .worksheet_mut(sheet)?
-                .set_cell_style(target_row, c, style_idx)?;
-        }
-
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-        let mut new_rows = Vec::new();
-        for r in worksheet.rows.iter() {
-            if r.r == row {
-                let mut nr = r.clone();
-                nr.r = target_row;
-                new_rows.push(nr);
-            } else if delta > 0 && r.r > row && r.r <= target_row {
-                let mut nr = r.clone();
-                nr.r -= 1;
-                new_rows.push(nr);
-            } else if delta < 0 && r.r < row && r.r >= target_row {
-                let mut nr = r.clone();
-                nr.r += 1;
-                new_rows.push(nr);
-            } else {
-                new_rows.push(r.clone());
-            }
-        }
-        worksheet.rows = new_rows;
-
-        // Update all formulas in the workbook
-        self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
-
-        Ok(())
-    }
 }

base/src/arithmetic.rs

@@ -77,6 +77,8 @@ impl Model {
                         match to_f64(&node) {
                             Ok(f2) => match op(f1, f2) {
                                 Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
                                 Err(e) => data_row.push(ArrayNode::Error(e)),
                             },
                             Err(err) => data_row.push(ArrayNode::Error(err)),
@@ -98,6 +100,8 @@ impl Model {
                         match to_f64(&node) {
                             Ok(f1) => match op(f1, f2) {
                                 Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
                                 Err(e) => data_row.push(ArrayNode::Error(e)),
                             },
                             Err(err) => data_row.push(ArrayNode::Error(err)),
@@ -133,6 +137,10 @@ impl Model {
                             (Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
                                 (Ok(f1), Ok(f2)) => match op(f1, f2) {
                                     Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                    Err(Error::VALUE) => {
+                                        data_row.push(ArrayNode::Error(Error::VALUE))
+                                    }
                                     Err(e) => data_row.push(ArrayNode::Error(e)),
                                 },
                                 (Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),

base/src/cell.rs

@@ -64,50 +64,12 @@ impl Cell {
     /// Returns the formula of a cell if any.
     pub fn get_formula(&self) -> Option<i32> {
         match self {
-            Cell::CellFormula { f, .. }
-            | Cell::CellFormulaBoolean { f, .. }
-            | Cell::CellFormulaNumber { f, .. }
-            | Cell::CellFormulaString { f, .. }
-            | Cell::CellFormulaError { f, .. }
-            | Cell::DynamicCellFormula { f, .. }
-            | Cell::DynamicCellFormulaBoolean { f, .. }
-            | Cell::DynamicCellFormulaNumber { f, .. }
-            | Cell::DynamicCellFormulaString { f, .. }
-            | Cell::DynamicCellFormulaError { f, .. } => Some(*f),
-            Cell::EmptyCell { .. }
-            | Cell::BooleanCell { .. }
-            | Cell::NumberCell { .. }
-            | Cell::ErrorCell { .. }
-            | Cell::SharedString { .. }
-            | Cell::SpillNumberCell { .. }
-            | Cell::SpillBooleanCell { .. }
-            | Cell::SpillErrorCell { .. }
-            | Cell::SpillStringCell { .. } => None,
-        }
-    }
-
-    /// Returns the dynamic range of a cell if any.
-    pub fn get_dynamic_range(&self) -> Option<(i32, i32)> {
-        match self {
-            Cell::DynamicCellFormula { r, .. } => Some(*r),
-            Cell::DynamicCellFormulaBoolean { r, .. } => Some(*r),
-            Cell::DynamicCellFormulaNumber { r, .. } => Some(*r),
-            Cell::DynamicCellFormulaString { r, .. } => Some(*r),
-            Cell::DynamicCellFormulaError { r, .. } => Some(*r),
-            Cell::EmptyCell { .. }
-            | Cell::BooleanCell { .. }
-            | Cell::NumberCell { .. }
-            | Cell::ErrorCell { .. }
-            | Cell::SharedString { .. }
-            | Cell::CellFormula { .. }
-            | Cell::CellFormulaBoolean { .. }
-            | Cell::CellFormulaNumber { .. }
-            | Cell::CellFormulaString { .. }
-            | Cell::CellFormulaError { .. }
-            | Cell::SpillNumberCell { .. }
-            | Cell::SpillBooleanCell { .. }
-            | Cell::SpillErrorCell { .. }
-            | Cell::SpillStringCell { .. } => None,
+            Cell::CellFormula { f, .. } => Some(*f),
+            Cell::CellFormulaBoolean { f, .. } => Some(*f),
+            Cell::CellFormulaNumber { f, .. } => Some(*f),
+            Cell::CellFormulaString { f, .. } => Some(*f),
+            Cell::CellFormulaError { f, .. } => Some(*f),
+            _ => None,
         }
     }
 
@@ -127,15 +89,6 @@ impl Cell {
             Cell::CellFormulaNumber { s, .. } => *s = style,
             Cell::CellFormulaString { s, .. } => *s = style,
             Cell::CellFormulaError { s, .. } => *s = style,
-            Cell::SpillBooleanCell { s, .. } => *s = style,
-            Cell::SpillNumberCell { s, .. } => *s = style,
-            Cell::SpillStringCell { s, .. } => *s = style,
-            Cell::SpillErrorCell { s, .. } => *s = style,
-            Cell::DynamicCellFormula { s, .. } => *s = style,
-            Cell::DynamicCellFormulaBoolean { s, .. } => *s = style,
-            Cell::DynamicCellFormulaNumber { s, .. } => *s = style,
-            Cell::DynamicCellFormulaString { s, .. } => *s = style,
-            Cell::DynamicCellFormulaError { s, .. } => *s = style,
         };
     }
 
@@ -151,15 +104,6 @@ impl Cell {
             Cell::CellFormulaNumber { s, .. } => *s,
             Cell::CellFormulaString { s, .. } => *s,
             Cell::CellFormulaError { s, .. } => *s,
-            Cell::SpillBooleanCell { s, .. } => *s,
-            Cell::SpillNumberCell { s, .. } => *s,
-            Cell::SpillStringCell { s, .. } => *s,
-            Cell::SpillErrorCell { s, .. } => *s,
-            Cell::DynamicCellFormula { s, .. } => *s,
-            Cell::DynamicCellFormulaBoolean { s, .. } => *s,
-            Cell::DynamicCellFormulaNumber { s, .. } => *s,
-            Cell::DynamicCellFormulaString { s, .. } => *s,
-            Cell::DynamicCellFormulaError { s, .. } => *s,
         }
     }
 
@@ -175,15 +119,6 @@ impl Cell {
             Cell::CellFormulaNumber { .. } => CellType::Number,
             Cell::CellFormulaString { .. } => CellType::Text,
             Cell::CellFormulaError { .. } => CellType::ErrorValue,
-            Cell::SpillBooleanCell { .. } => CellType::LogicalValue,
-            Cell::SpillNumberCell { .. } => CellType::Number,
-            Cell::SpillStringCell { .. } => CellType::Text,
-            Cell::SpillErrorCell { .. } => CellType::ErrorValue,
-            Cell::DynamicCellFormula { .. } => CellType::Number,
-            Cell::DynamicCellFormulaBoolean { .. } => CellType::LogicalValue,
-            Cell::DynamicCellFormulaNumber { .. } => CellType::Number,
-            Cell::DynamicCellFormulaString { .. } => CellType::Text,
-            Cell::DynamicCellFormulaError { .. } => CellType::ErrorValue,
         }
     }
 
@@ -201,7 +136,7 @@ impl Cell {
             Cell::EmptyCell { .. } => CellValue::None,
             Cell::BooleanCell { v, s: _ } => CellValue::Boolean(*v),
             Cell::NumberCell { v, s: _ } => CellValue::Number(*v),
-            Cell::ErrorCell { ei, .. } | Cell::SpillErrorCell { ei, .. } => {
+            Cell::ErrorCell { ei, .. } => {
                 let v = ei.to_localized_error_string(language);
                 CellValue::String(v)
             }
@@ -213,25 +148,14 @@ impl Cell {
                 };
                 CellValue::String(v)
             }
-            Cell::DynamicCellFormula { .. } | Cell::CellFormula { .. } => {
-                CellValue::String("#ERROR!".to_string())
-            }
-            Cell::DynamicCellFormulaBoolean { v, .. } | Cell::CellFormulaBoolean { v, .. } => {
-                CellValue::Boolean(*v)
-            }
-            Cell::DynamicCellFormulaNumber { v, .. } | Cell::CellFormulaNumber { v, .. } => {
-                CellValue::Number(*v)
-            }
-            Cell::DynamicCellFormulaString { v, .. } | Cell::CellFormulaString { v, .. } => {
-                CellValue::String(v.clone())
-            }
-            Cell::DynamicCellFormulaError { ei, .. } | Cell::CellFormulaError { ei, .. } => {
+            Cell::CellFormula { .. } => CellValue::String("#ERROR!".to_string()),
+            Cell::CellFormulaBoolean { v, .. } => CellValue::Boolean(*v),
+            Cell::CellFormulaNumber { v, .. } => CellValue::Number(*v),
+            Cell::CellFormulaString { v, .. } => CellValue::String(v.clone()),
+            Cell::CellFormulaError { ei, .. } => {
                 let v = ei.to_localized_error_string(language);
                 CellValue::String(v)
             }
-            Cell::SpillBooleanCell { v, .. } => CellValue::Boolean(*v),
-            Cell::SpillNumberCell { v, .. } => CellValue::Number(*v),
-            Cell::SpillStringCell { v, .. } => CellValue::String(v.clone()),
         }
     }
 

base/src/expressions/lexer/mod.rs

@@ -314,9 +314,6 @@ impl Lexer {
                             } else if name_upper == self.language.booleans.r#false {
                                 return TokenType::Boolean(false);
                             }
-                            if self.peek_char() == Some('(') {
-                                return TokenType::Ident(name);
-                            }
                             if self.mode == LexerMode::A1 {
                                 let parsed_reference = utils::parse_reference_a1(&name_upper);
                                 if parsed_reference.is_some()

base/src/expressions/lexer/test/test_common.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;
 
@@ -686,29 +685,3 @@ fn test_comparisons() {
     assert_eq!(lx.next_token(), Number(7.0));
     assert_eq!(lx.next_token(), EOF);
 }
-
-#[test]
-fn test_log10_is_cell_reference() {
-    let mut lx = new_lexer("LOG10", true);
-    assert_eq!(
-        lx.next_token(),
-        Reference {
-            sheet: None,
-            column: column_to_number("LOG").unwrap(),
-            row: 10,
-            absolute_column: false,
-            absolute_row: false,
-        }
-    );
-    assert_eq!(lx.next_token(), EOF);
-}
-
-#[test]
-fn test_log10_is_function() {
-    let mut lx = new_lexer("LOG10(100)", true);
-    assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
-    assert_eq!(lx.next_token(), LeftParenthesis);
-    assert_eq!(lx.next_token(), Number(100.0));
-    assert_eq!(lx.next_token(), RightParenthesis);
-    assert_eq!(lx.next_token(), EOF);
-}

base/src/expressions/parser/mod.rs

@@ -717,7 +717,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: format!("sheet not found: {}", context.sheet),
+                            message: "sheet not found".to_string(),
                         };
                     }
                 };
@@ -850,7 +850,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: format!("sheet not found: {}", context.sheet),
+                            message: "sheet not found".to_string(),
                         };
                     }
                 };
@@ -878,7 +878,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: format!("table sheet not found: {}", table.sheet_name),
+                            message: "sheet not found".to_string(),
                         };
                     }
                 };

base/src/expressions/parser/static_analysis.rs

@@ -2,19 +2,15 @@ use crate::functions::Function;
 
 use super::Node;
 
+use once_cell::sync::Lazy;
 use regex::Regex;
-use std::sync::OnceLock;
-
-static RANGE_REFERENCE_REGEX: OnceLock<Regex> = OnceLock::new();
 
 #[allow(clippy::expect_used)]
-fn get_re() -> &'static Regex {
-    RANGE_REFERENCE_REGEX
-        .get_or_init(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"))
-}
+static RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"));
 
 fn is_range_reference(s: &str) -> bool {
-    get_re().is_match(s)
+    RE.is_match(s)
 }
 
 /*
@@ -186,8 +182,7 @@ pub fn add_implicit_intersection(node: &mut Node, add: bool) {
     };
 }
 
-#[derive(Clone)]
-pub enum StaticResult {
+pub(crate) enum StaticResult {
     Scalar,
     Array(i32, i32),
     Range(i32, i32),
@@ -223,7 +218,7 @@ fn static_analysis_op_nodes(left: &Node, right: &Node) -> StaticResult {
 //  * Array(a, b) if we know it will be an a x b array.
 //  * Range(a, b) if we know it will be a a x b range.
 //  * Unknown if we cannot guaranty either
-pub(crate) fn run_static_analysis_on_node(node: &Node) -> StaticResult {
+fn run_static_analysis_on_node(node: &Node) -> StaticResult {
     match node {
         Node::BooleanKind(_)
         | Node::NumberKind(_)
@@ -610,9 +605,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Choose => vec![Signature::Scalar; arg_count],
         Function::Column => args_signature_row(arg_count),
         Function::Columns => args_signature_one_vector(arg_count),
-        Function::Ln => args_signature_scalars(arg_count, 1, 0),
-        Function::Log => args_signature_scalars(arg_count, 1, 1),
-        Function::Log10 => args_signature_scalars(arg_count, 1, 0),
         Function::Cos => args_signature_scalars(arg_count, 1, 0),
         Function::Cosh => args_signature_scalars(arg_count, 1, 0),
         Function::Max => vec![Signature::Vector; arg_count],
@@ -824,9 +816,6 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Round => scalar_arguments(args),
         Function::Rounddown => scalar_arguments(args),
         Function::Roundup => scalar_arguments(args),
-        Function::Ln => scalar_arguments(args),
-        Function::Log => scalar_arguments(args),
-        Function::Log10 => scalar_arguments(args),
         Function::Sin => scalar_arguments(args),
         Function::Sinh => scalar_arguments(args),
         Function::Sqrt => scalar_arguments(args),

base/src/expressions/parser/stringify.rs

@@ -2,7 +2,7 @@ use super::{super::utils::quote_name, Node, Reference};
 use crate::constants::{LAST_COLUMN, LAST_ROW};
 use crate::expressions::parser::move_formula::to_string_array_node;
 use crate::expressions::parser::static_analysis::add_implicit_intersection;
-use crate::expressions::token::{OpSum, OpUnary};
+use crate::expressions::token::OpUnary;
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -28,11 +28,6 @@ pub enum DisplaceData {
         column: i32,
         delta: i32,
     },
-    RowMove {
-        sheet: u32,
-        row: i32,
-        delta: i32,
-    },
     ColumnMove {
         sheet: u32,
         column: i32,
@@ -164,29 +159,6 @@ pub(crate) fn stringify_reference(
                         }
                     }
                 }
-                DisplaceData::RowMove {
-                    sheet,
-                    row: move_row,
-                    delta,
-                } => {
-                    if sheet_index == *sheet {
-                        if row == *move_row {
-                            row += *delta;
-                        } else if *delta > 0 {
-                            // Moving the row downwards
-                            if row > *move_row && row <= *move_row + *delta {
-                                // Intermediate rows move up by one position
-                                row -= 1;
-                            }
-                        } else if *delta < 0 {
-                            // Moving the row upwards
-                            if row < *move_row && row >= *move_row + *delta {
-                                // Intermediate rows move down by one position
-                                row += 1;
-                            }
-                        }
-                    }
-                }
                 DisplaceData::ColumnMove {
                     sheet,
                     column: move_column,
@@ -195,18 +167,14 @@ pub(crate) fn stringify_reference(
                     if sheet_index == *sheet {
                         if column == *move_column {
                             column += *delta;
-                        } else if *delta > 0 {
-                            // Moving the column to the right
-                            if column > *move_column && column <= *move_column + *delta {
-                                // Intermediate columns move left by one position
-                                column -= 1;
-                            }
-                        } else if *delta < 0 {
-                            // Moving the column to the left
-                            if column < *move_column && column >= *move_column + *delta {
-                                // Intermediate columns move right by one position
-                                column += 1;
-                            }
+                        } else if (*delta > 0
+                            && column > *move_column
+                            && column <= *move_column + *delta)
+                            || (*delta < 0
+                                && column < *move_column
+                                && column >= *move_column + *delta)
+                        {
+                            column -= *delta;
                         }
                     }
                 }
@@ -483,32 +451,34 @@ fn stringify(
             kind,
             stringify(right, context, displace_data, export_to_excel)
         ),
-        OpSumKind { kind, left, right } => {
-            let left_str = stringify(left, context, displace_data, export_to_excel);
-            // if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
-            let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
-                | matches!(**right, CompareKind { .. })
-            {
-                format!(
-                    "({})",
-                    stringify(right, context, displace_data, export_to_excel)
-                )
-            } else {
-                stringify(right, context, displace_data, export_to_excel)
-            };
-
-            format!("{left_str}{kind}{right_str}")
-        }
+        OpSumKind { kind, left, right } => format!(
+            "{}{}{}",
+            stringify(left, context, displace_data, export_to_excel),
+            kind,
+            stringify(right, context, displace_data, export_to_excel)
+        ),
         OpProductKind { kind, left, right } => {
             let x = match **left {
-                OpSumKind { .. } | CompareKind { .. } => format!(
+                OpSumKind { .. } => format!(
+                    "({})",
+                    stringify(left, context, displace_data, export_to_excel)
+                ),
+                CompareKind { .. } => format!(
                     "({})",
                     stringify(left, context, displace_data, export_to_excel)
                 ),
                 _ => stringify(left, context, displace_data, export_to_excel),
             };
             let y = match **right {
-                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
+                OpSumKind { .. } => format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                ),
+                CompareKind { .. } => format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                ),
+                OpProductKind { .. } => format!(
                     "({})",
                     stringify(right, context, displace_data, export_to_excel)
                 ),
@@ -619,43 +589,10 @@ fn stringify(
         WrongVariableKind(name) => name.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
-                let needs_parentheses = match **right {
-                    BooleanKind(_)
-                    | NumberKind(_)
-                    | StringKind(_)
-                    | ReferenceKind { .. }
-                    | RangeKind { .. }
-                    | WrongReferenceKind { .. }
-                    | WrongRangeKind { .. }
-                    | OpRangeKind { .. }
-                    | OpConcatenateKind { .. }
-                    | OpProductKind { .. }
-                    | OpPowerKind { .. }
-                    | FunctionKind { .. }
-                    | InvalidFunctionKind { .. }
-                    | ArrayKind(_)
-                    | DefinedNameKind(_)
-                    | TableNameKind(_)
-                    | WrongVariableKind(_)
-                    | ImplicitIntersection { .. }
-                    | CompareKind { .. }
-                    | ErrorKind(_)
-                    | ParseErrorKind { .. }
-                    | EmptyArgKind => false,
-
-                    OpSumKind { .. } | UnaryKind { .. } => true,
-                };
-                if needs_parentheses {
-                    format!(
-                        "-({})",
-                        stringify(right, context, displace_data, export_to_excel)
-                    )
-                } else {
-                    format!(
-                        "-{}",
-                        stringify(right, context, displace_data, export_to_excel)
-                    )
-                }
+                format!(
+                    "-{}",
+                    stringify(right, context, displace_data, export_to_excel)
+                )
             }
             OpUnary::Percentage => {
                 format!(

base/src/expressions/parser/tests/test_stringify.rs

@@ -32,39 +32,3 @@ fn exp_order() {
     let t = parser.parse("(5)^(4)", &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "5^4");
 }
-
-#[test]
-fn correct_parenthesis() {
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 1,
-        column: 1,
-    };
-
-    let t = parser.parse("-(1 + 1)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
-
-    let t = parser.parse("1 - (3 + 4)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
-
-    let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
-    assert_eq!(
-        to_string(&t, &cell_reference),
-        "-(1.05*(0.0284+0.0046)-0.0284)"
-    );
-
-    let t = parser.parse("1 + (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1+3+5");
-
-    let t = parser.parse("1 - (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
-
-    let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
-
-    let t = parser.parse("1 + (3<5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
-}

base/src/expressions/utils/test.rs

@@ -211,6 +211,4 @@ fn test_names() {
     assert!(!is_valid_identifier("test€"));
     assert!(!is_valid_identifier("truñe"));
     assert!(!is_valid_identifier("tr&ue"));
-
-    assert!(!is_valid_identifier("LOG10"));
 }

base/src/functions/logical.rs

@@ -246,7 +246,7 @@ impl Model {
         }
         // None of the cases matched so we return the default
         // If there is an even number of args is the last one otherwise is #N/A
-        if args_count.is_multiple_of(2) {
+        if args_count % 2 == 0 {
             return self.evaluate_node_in_context(&args[args_count - 1], cell);
         }
         CalcResult::Error {
@@ -262,7 +262,7 @@ impl Model {
         if args_count < 2 {
             return CalcResult::new_args_number_error(cell);
         }
-        if !args_count.is_multiple_of(2) {
+        if args_count % 2 != 0 {
             // Missing value for last condition
             return CalcResult::new_args_number_error(cell);
         }

base/src/functions/mathematical.rs

@@ -2,7 +2,6 @@ use crate::cast::NumberOrArray;
 use crate::constants::{LAST_COLUMN, LAST_ROW};
 use crate::expressions::parser::ArrayNode;
 use crate::expressions::types::CellReferenceIndex;
-use crate::number_format::to_precision;
 use crate::single_number_fn;
 use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
@@ -312,7 +311,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => to_precision(f, 15),
+            Ok(f) => f,
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -328,13 +327,12 @@ impl Model {
         let scale = 10.0_f64.powf(number_of_digits);
         CalcResult::Number((value * scale).round() / scale)
     }
-
     pub(crate) fn fn_roundup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => to_precision(f, 15),
+            Ok(f) => f,
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -354,13 +352,12 @@ impl Model {
             CalcResult::Number((value * scale).floor() / scale)
         }
     }
-
     pub(crate) fn fn_rounddown(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => to_precision(f, 15),
+            Ok(f) => f,
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -381,16 +378,6 @@ impl Model {
         }
     }
 
-    single_number_fn!(fn_log10, |f| if f <= 0.0 {
-        Err(Error::NUM)
-    } else {
-        Ok(f64::log10(f))
-    });
-    single_number_fn!(fn_ln, |f| if f <= 0.0 {
-        Err(Error::NUM)
-    } else {
-        Ok(f64::ln(f))
-    });
     single_number_fn!(fn_sin, |f| Ok(f64::sin(f)));
     single_number_fn!(fn_cos, |f| Ok(f64::cos(f)));
     single_number_fn!(fn_tan, |f| Ok(f64::tan(f)));
@@ -444,47 +431,6 @@ impl Model {
         CalcResult::Number(f64::atan2(y, x))
     }
 
-    pub(crate) fn fn_log(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let n_args = args.len();
-        if !(1..=2).contains(&n_args) {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let x = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let y = if n_args == 1 {
-            10.0
-        } else {
-            match self.get_number(&args[1], cell) {
-                Ok(f) => f,
-                Err(s) => return s,
-            }
-        };
-        if x <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Number must be positive".to_string(),
-            };
-        }
-        if y == 1.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Logarithm base cannot be 1".to_string(),
-            };
-        }
-        if y <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Logarithm base must be positive".to_string(),
-            };
-        }
-        CalcResult::Number(f64::log(x, y))
-    }
-
     pub(crate) fn fn_power(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/mod.rs

@@ -54,9 +54,6 @@ pub enum Function {
     Columns,
     Cos,
     Cosh,
-    Log,
-    Log10,
-    Ln,
     Max,
     Min,
     Pi,
@@ -253,7 +250,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 198> {
+    pub fn into_iter() -> IntoIter<Function, 195> {
         [
             Function::And,
             Function::False,
@@ -280,9 +277,6 @@ impl Function {
             Function::Atanh,
             Function::Abs,
             Function::Pi,
-            Function::Ln,
-            Function::Log,
-            Function::Log10,
             Function::Sqrt,
             Function::Sqrtpi,
             Function::Atan2,
@@ -540,10 +534,6 @@ impl Function {
             "POWER" => Some(Function::Power),
             "ATAN2" => Some(Function::Atan2),
 
-            "LN" => Some(Function::Ln),
-            "LOG" => Some(Function::Log),
-            "LOG10" => Some(Function::Log10),
-
             "MAX" => Some(Function::Max),
             "MIN" => Some(Function::Min),
             "PRODUCT" => Some(Function::Product),
@@ -744,9 +734,6 @@ impl fmt::Display for Function {
             Function::Switch => write!(f, "SWITCH"),
             Function::True => write!(f, "TRUE"),
             Function::Xor => write!(f, "XOR"),
-            Function::Log => write!(f, "LOG"),
-            Function::Log10 => write!(f, "LOG10"),
-            Function::Ln => write!(f, "LN"),
             Function::Sin => write!(f, "SIN"),
             Function::Cos => write!(f, "COS"),
             Function::Tan => write!(f, "TAN"),
@@ -974,9 +961,6 @@ impl Model {
             Function::True => self.fn_true(args, cell),
             Function::Xor => self.fn_xor(args, cell),
             // Math and trigonometry
-            Function::Log => self.fn_log(args, cell),
-            Function::Log10 => self.fn_log10(args, cell),
-            Function::Ln => self.fn_ln(args, cell),
             Function::Sin => self.fn_sin(args, cell),
             Function::Cos => self.fn_cos(args, cell),
             Function::Tan => self.fn_tan(args, cell),

base/src/functions/statistical.rs

@@ -350,7 +350,7 @@ impl Model {
     // FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
     pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let args_count = args.len();
-        if args_count < 2 || !args_count.is_multiple_of(2) {
+        if args_count < 2 || args_count % 2 == 1 {
             return CalcResult::new_args_number_error(cell);
         }
 
@@ -476,7 +476,7 @@ impl Model {
         F: FnMut(f64),
     {
         let args_count = args.len();
-        if args_count < 3 || args_count.is_multiple_of(2) {
+        if args_count < 3 || args_count % 2 == 0 {
             return Err(CalcResult::new_args_number_error(cell));
         }
         let arg_0 = self.evaluate_node_in_context(&args[0], cell);

base/src/functions/subtotal.rs

@@ -96,7 +96,7 @@ impl Model {
 
         match cell.get_formula() {
             Some(f) => {
-                let node = &self.parsed_formulas[sheet_index as usize][f as usize].0;
+                let node = &self.parsed_formulas[sheet_index as usize][f as usize];
                 matches!(
                     node,
                     Node::FunctionKind {

base/src/language/mod.rs

@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::OnceLock};
+use std::collections::HashMap;
 
 use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
 
 #[derive(Encode, Decode, Clone)]
 pub struct Booleans {
@@ -30,17 +31,14 @@ pub struct Language {
     pub errors: Errors,
 }
 
-static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
-
 #[allow(clippy::expect_used)]
-fn get_languages() -> &'static HashMap<String, Language> {
-    LANGUAGES.get_or_init(|| {
-        bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
-    })
-}
+static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
+    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
+});
 
 pub fn get_language(id: &str) -> Result<&Language, String> {
-    get_languages()
+    let language = LANGUAGES
         .get(id)
-        .ok_or_else(|| format!("Language is not supported: '{id}'"))
+        .ok_or(format!("Language is not supported: '{id}'"))?;
+    Ok(language)
 }

base/src/locale/mod.rs

@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::OnceLock};
-
 use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
+
+use std::collections::HashMap;
 
 #[derive(Encode, Decode, Clone)]
 pub struct Locale {
@@ -64,17 +65,12 @@ pub struct DecimalFormats {
     pub standard: String,
 }
 
-static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
-
 #[allow(clippy::expect_used)]
-fn get_locales() -> &'static HashMap<String, Locale> {
-    LOCALES.get_or_init(|| {
-        bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
-    })
-}
+static LOCALES: Lazy<HashMap<String, Locale>> =
+    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
 
 pub fn get_locale(id: &str) -> Result<&Locale, String> {
-    get_locales()
-        .get(id)
-        .ok_or_else(|| format!("Invalid locale: '{id}'"))
+    // TODO: pass the locale once we implement locales in Rust
+    let locale = LOCALES.get(id).ok_or("Invalid locale")?;
+    Ok(locale)
 }

base/src/model.rs

@@ -11,9 +11,8 @@ use crate::{
         lexer::LexerMode,
         parser::{
             move_formula::{move_formula, MoveContext},
-            static_analysis::{run_static_analysis_on_node, StaticResult},
             stringify::{rename_defined_name_in_node, to_rc_format, to_string},
-            ArrayNode, Node, Parser,
+            Node, Parser,
         },
         token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
         types::*,
@@ -84,24 +83,6 @@ pub(crate) enum ParsedDefinedName {
     InvalidDefinedNameFormula,
 }
 
-/// A support node is either a cell or a range of cells
-pub(crate) enum SupportNode {
-    /// (sheet, row, column)
-    Cell((u32, i32, i32)),
-    /// (sheet, row, column, height, width)
-    Range((u32, i32, i32, u32, u32))
-}
-
-/// The state of the computation
-pub(crate) enum EvaluationState {
-    /// the model is ready for a new evaluation
-    Ready,
-    /// the model is evaluating cells that might spill
-    EvaluatingSpills,
-    /// the model is evaluating cells normally
-    Evaluating
-}
-
 /// A dynamical IronCalc model.
 ///
 /// Its is composed of a `Workbook`. Everything else are dynamical quantities:
@@ -118,13 +99,15 @@ pub struct Model {
     /// A Rust internal representation of an Excel workbook
     pub workbook: Workbook,
     /// A list of parsed formulas
-    pub parsed_formulas: Vec<Vec<(Node, StaticResult)>>,
+    pub parsed_formulas: Vec<Vec<Node>>,
     /// A list of parsed defined names
     pub(crate) parsed_defined_names: HashMap<(Option<u32>, String), ParsedDefinedName>,
     /// An optimization to lookup strings faster
     pub(crate) shared_strings: HashMap<String, usize>,
     /// An instance of the parser
     pub(crate) parser: Parser,
+    /// The list of cells with formulas that are evaluated or being evaluated
+    pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
     /// The locale of the model
     pub(crate) locale: Locale,
     /// The language used
@@ -133,16 +116,6 @@ pub struct Model {
     pub(crate) tz: Tz,
     /// The view id. A view consists of a selected sheet and ranges.
     pub(crate) view_id: u32,
-    /// ** Runtime ***
-    /// The list of cells with formulas that are evaluated or being evaluated
-    pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
-    /// The support graph. For a given cell (sheet, row, column) the list of cells and ranges that were requested
-    pub(crate) support_graph: HashMap<(u32, i32, i32), Vec<SupportNode>>,
-    /// If the model is in a switch state then spill cells in the indices should be switched and recalculation redone
-    pub(crate) switch_cells: Option<(i32, i32)>,
-    /// Stack of cells being evaluated
-    pub(crate) stack: Vec<(u32, i32, i32)>,
-    pub(crate) state: EvaluationState,
 }
 
 // FIXME: Maybe this should be the same as CellReference
@@ -549,203 +522,14 @@ impl Model {
         }
         Ok(format!("{}!{}{}", sheet.name, column, cell_reference.row))
     }
-
-    /// Sets sheet, target_row, target_column, (width, height), &v
-    #[allow(clippy::too_many_arguments)]
-    fn set_spill_cell_with_formula_value(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-        r: (i32, i32),
-        v: &CalcResult,
-        s: i32,
-        f: i32,
-    ) -> Result<(), String> {
-        let new_cell = match v {
-            CalcResult::EmptyCell => Cell::DynamicCellFormulaNumber {
-                f,
-                v: 0.0,
-                s,
-                r,
-                a: false,
-            },
-            CalcResult::String(v) => Cell::DynamicCellFormulaString {
-                f,
-                v: v.clone(),
-                s,
-                r,
-                a: false,
-            },
-            CalcResult::Number(v) => Cell::DynamicCellFormulaNumber {
-                v: *v,
-                s,
-                r,
-                f,
-                a: false,
-            },
-            CalcResult::Boolean(b) => Cell::DynamicCellFormulaBoolean {
-                v: *b,
-                s,
-                r,
-                f,
-                a: false,
-            },
-            CalcResult::Error { error, .. } => Cell::DynamicCellFormulaError {
-                ei: error.clone(),
-                s,
-                r,
-                f,
-                a: false,
-                o: "".to_string(),
-                m: "".to_string(),
-            },
-
-            // These cannot happen
-            // FIXME: Maybe the type of get_cell_value should be different
-            CalcResult::Range { .. } | CalcResult::EmptyArg | CalcResult::Array(_) => {
-                Cell::DynamicCellFormulaError {
-                    ei: Error::ERROR,
-                    s,
-                    r,
-                    f,
-                    a: false,
-                    o: "".to_string(),
-                    m: "".to_string(),
-                }
-            }
-        };
-        let sheet_data = &mut self.workbook.worksheet_mut(sheet)?.sheet_data;
-
-        match sheet_data.get_mut(&row) {
-            Some(column_data) => match column_data.get(&column) {
-                Some(_cell) => {
-                    column_data.insert(column, new_cell);
-                }
-                None => {
-                    column_data.insert(column, new_cell);
-                }
-            },
-            None => {
-                let mut column_data = HashMap::new();
-                column_data.insert(column, new_cell);
-                sheet_data.insert(row, column_data);
-            }
-        }
-        Ok(())
-    }
-
-    /// Sets a cell with a "spill" value
-    fn set_spill_cell_with_value(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-        m: (i32, i32),
-        v: &CalcResult,
-    ) -> Result<(), String> {
-        let style_index = self.get_cell_style_index(sheet, row, column)?;
-        let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
-            self.workbook
-                .styles
-                .get_style_without_quote_prefix(style_index)?
-        } else {
-            style_index
-        };
-        let new_cell = match v {
-            CalcResult::EmptyCell => Cell::SpillNumberCell {
-                v: 0.0,
-                s: style_index,
-                m,
-            },
-            CalcResult::String(s) => Cell::SpillStringCell {
-                v: s.clone(),
-                s: new_style_index,
-                m,
-            },
-            CalcResult::Number(f) => Cell::SpillNumberCell {
-                v: *f,
-                s: new_style_index,
-                m,
-            },
-            CalcResult::Boolean(b) => Cell::SpillBooleanCell {
-                v: *b,
-                s: new_style_index,
-                m,
-            },
-            CalcResult::Error { error, .. } => Cell::SpillErrorCell {
-                ei: error.clone(),
-                s: style_index,
-                m,
-            },
-
-            // These cannot happen
-            // FIXME: Maybe the type of get_cell_value should be different
-            CalcResult::Range { .. } | CalcResult::EmptyArg | CalcResult::Array(_) => {
-                Cell::SpillErrorCell {
-                    ei: Error::ERROR,
-                    s: style_index,
-                    m,
-                }
-            }
-        };
-        let sheet_data = &mut self.workbook.worksheet_mut(sheet)?.sheet_data;
-
-        match sheet_data.get_mut(&row) {
-            Some(column_data) => match column_data.get(&column) {
-                Some(_cell) => {
-                    column_data.insert(column, new_cell);
-                }
-                None => {
-                    column_data.insert(column, new_cell);
-                }
-            },
-            None => {
-                let mut column_data = HashMap::new();
-                column_data.insert(column, new_cell);
-                sheet_data.insert(row, column_data);
-            }
-        }
-        Ok(())
-    }
-
-    /// Returns `None` if no cell has called this cell, otherwise returns the dependent cell
-    fn get_support_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Option<&Cell>, String> {
-        self.workbook.supporting_cells.get(&(sheet, row, column)).map(|c| Some(c)).ok_or_else(|| "Cell not found".into())
-    }
-
     /// Sets `result` in the cell given by `sheet` sheet index, row and column
     /// Note that will panic if the cell does not exist
     /// It will do nothing if the cell does not have a formula
-    /// If the cell is an array or a range it will check if it is possible to spill to other cells
-    /// if it is not it will return an error.
-    /// Then it will check if any of the cells has been requested before.
     #[allow(clippy::expect_used)]
-    fn set_cell_value(
-        &mut self,
-        cell_reference: CellReferenceIndex,
-        result: &CalcResult,
-    ) -> Result<(), String> {
+    fn set_cell_value(&mut self, cell_reference: CellReferenceIndex, result: &CalcResult) {
         let CellReferenceIndex { sheet, column, row } = cell_reference;
-        let cell = self
-            .workbook
-            .worksheet(sheet)?
-            .cell(row, column)
-            .cloned()
-            .unwrap_or_default();
+        let cell = &self.workbook.worksheets[sheet as usize].sheet_data[&row][&column];
         let s = cell.get_style();
-        // If the cell is a dynamic cell we need to delete all the cells in the range
-        if let Some((width, height)) = cell.get_dynamic_range() {
-            for r in row..row + height {
-                for c in column..column + width {
-                    // skip the "mother" cell
-                    if r == row && c == column {
-                        continue;
-                    }
-                    self.cell_clear_contents(sheet, r, c)?;
-                }
-            }
-        }
         if let Some(f) = cell.get_formula() {
             match result {
                 CalcResult::Number(value) => {
@@ -810,145 +594,19 @@ impl Model {
                         ei: error.clone(),
                     };
                 }
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {
-                    *self.workbook.worksheets[sheet as usize]
-                        .sheet_data
-                        .get_mut(&row)
-                        .expect("expected a row")
-                        .get_mut(&column)
-                        .expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
-                }
                 CalcResult::Range { left, right } => {
                     if left.sheet == right.sheet
                         && left.row == right.row
                         && left.column == right.column
                     {
-                        // There is only one cell
-                        let single_cell = CellReferenceIndex {
+                        let intersection_cell = CellReferenceIndex {
                             sheet: left.sheet,
                             column: left.column,
                             row: left.row,
                         };
-                        let v = self.evaluate_cell(single_cell);
-                        self.set_cell_value(cell_reference, &v)?;
+                        let v = self.evaluate_cell(intersection_cell);
+                        self.set_cell_value(cell_reference, &v);
                     } else {
-                        // We need to check if all the cells are empty, otherwise we mark the cell as #SPILL!
-                        let mut all_empty = true;
-                        for r in row..=row + right.row - left.row {
-                            for c in column..=column + right.column - left.column {
-                                if r == row && c == column {
-                                    // skip the "mother" cell
-                                    continue;
-                                }
-                                if !self.is_empty_cell(sheet, r, c).unwrap_or(false) {
-                                    all_empty = false;
-                                    break;
-                                }
-                                if let Some(support) = self.get_support_cell(sheet, r, c) {
-                                    all_empty = false;
-                                }
-                            }
-                            if !all_empty {
-                                break;
-                            }
-                        }
-                        if !all_empty {
-                            let o = match self.cell_reference_to_string(&cell_reference) {
-                                Ok(s) => s,
-                                Err(_) => "".to_string(),
-                            };
-                            *self.workbook.worksheets[sheet as usize]
-                                .sheet_data
-                                .get_mut(&row)
-                                .expect("expected a row")
-                                .get_mut(&column)
-                                .expect("expected a column") = Cell::DynamicCellFormulaError {
-                                f,
-                                s,
-                                o,
-                                m: "Result would spill to non empty cells".to_string(),
-                                ei: Error::SPILL,
-                                r: (1, 1),
-                                a: false,
-                            };
-                            return Ok(());
-                        }
-                        // evaluate all the cells in that range
-                        for r in left.row..=right.row {
-                            for c in left.column..=right.column {
-                                let cell_reference = CellReferenceIndex {
-                                    sheet: left.sheet,
-                                    row: r,
-                                    column: c,
-                                };
-                                // FIXME: We ned to return an error
-                                self.evaluate_cell(cell_reference);
-                            }
-                        }
-                        // now write the result in the target
-                        for r in left.row..=right.row {
-                            let row_delta = r - left.row;
-                            for c in left.column..=right.column {
-                                let column_delta = c - left.column;
-                                // We need to put whatever is in (left.sheet, r, c) in
-                                // (sheet, row + row_delta, column + column_delta)
-                                // But we need to preserve the style
-                                let target_row = row + row_delta;
-                                let target_column = column + column_delta;
-                                let cell = self
-                                    .workbook
-                                    .worksheet(left.sheet)?
-                                    .cell(r, c)
-                                    .cloned()
-                                    .unwrap_or_default();
-                                let cell_reference = CellReferenceIndex {
-                                    sheet: left.sheet,
-                                    row: r,
-                                    column: c,
-                                };
-                                let v = self.get_cell_value(&cell, cell_reference);
-                                if row == target_row && column == target_column {
-                                    // let cell_reference = CellReferenceIndex { sheet, row, column };
-                                    // self.set_cell_value(cell_reference, &v);
-                                    self.set_spill_cell_with_formula_value(
-                                        sheet,
-                                        target_row,
-                                        target_column,
-                                        (right.column - left.column + 1, right.row - left.row + 1),
-                                        &v,
-                                        s,
-                                        f,
-                                    )?;
-                                    continue;
-                                }
-                                self.set_spill_cell_with_value(
-                                    sheet,
-                                    target_row,
-                                    target_column,
-                                    (row, column),
-                                    &v,
-                                )?;
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    let width = array[0].len() as i32;
-                    let height = array.len() as i32;
-                    // First we check that we don't spill:
-                    let mut all_empty = true;
-                    for r in row..row + height {
-                        for c in column..column + width {
-                            if r == row && c == column {
-                                continue;
-                            }
-                            if !self.is_empty_cell(sheet, r, c).unwrap_or(false) {
-                                all_empty = false;
-                                break;
-                            }
-                        }
-                    }
-                    if !all_empty {
                         let o = match self.cell_reference_to_string(&cell_reference) {
                             Ok(s) => s,
                             Err(_) => "".to_string(),
@@ -962,65 +620,57 @@ impl Model {
                             f,
                             s,
                             o,
-                            m: "Result would spill to non empty cells".to_string(),
-                            ei: Error::SPILL,
+                            m: "Implicit Intersection not implemented".to_string(),
+                            ei: Error::NIMPL,
                         };
-                        return Ok(());
-                    }
-                    let mut target_row = row;
-                    for data_row in array {
-                        let mut target_column = column;
-                        for value in data_row {
-                            if row == target_row && column == target_column {
-                                // This is the root cell of the dynamic array
-                                let cell_reference = CellReferenceIndex { sheet, row, column };
-                                let v = match value {
-                                    ArrayNode::Boolean(b) => CalcResult::Boolean(*b),
-                                    ArrayNode::Number(f) => CalcResult::Number(*f),
-                                    ArrayNode::String(s) => CalcResult::String(s.clone()),
-                                    ArrayNode::Error(error) => CalcResult::new_error(
-                                        error.clone(),
-                                        cell_reference,
-                                        error.to_localized_error_string(&self.language),
-                                    ),
-                                };
-                                self.set_spill_cell_with_formula_value(
-                                    sheet,
-                                    target_row,
-                                    target_column,
-                                    (width, height),
-                                    &v,
-                                    s,
-                                    f,
-                                )?;
-                                target_column += 1;
-                                continue;
-                            }
-                            let v = match value {
-                                ArrayNode::Boolean(b) => CalcResult::Boolean(*b),
-                                ArrayNode::Number(f) => CalcResult::Number(*f),
-                                ArrayNode::String(s) => CalcResult::String(s.clone()),
-                                ArrayNode::Error(error) => CalcResult::new_error(
-                                    error.clone(),
-                                    cell_reference,
-                                    error.to_localized_error_string(&self.language),
-                                ),
-                            };
-                            self.set_spill_cell_with_value(
-                                sheet,
-                                target_row,
-                                target_column,
-                                (row, column),
-                                &v,
-                            )?;
-                            target_column += 1;
-                        }
-                        target_row += 1;
                     }
+                    // if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
+                    // {
+                    //     let v = self.evaluate_cell(intersection_cell);
+                    //     self.set_cell_value(cell_reference, &v);
+                    // } else {
+                    //     let o = match self.cell_reference_to_string(&cell_reference) {
+                    //         Ok(s) => s,
+                    //         Err(_) => "".to_string(),
+                    //     };
+                    //     *self.workbook.worksheets[sheet as usize]
+                    //         .sheet_data
+                    //         .get_mut(&row)
+                    //         .expect("expected a row")
+                    //         .get_mut(&column)
+                    //         .expect("expected a column") = Cell::CellFormulaError {
+                    //         f,
+                    //         s,
+                    //         o,
+                    //         m: "Invalid reference".to_string(),
+                    //         ei: Error::VALUE,
+                    //     };
+                    // }
+                }
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {
+                    *self.workbook.worksheets[sheet as usize]
+                        .sheet_data
+                        .get_mut(&row)
+                        .expect("expected a row")
+                        .get_mut(&column)
+                        .expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
+                }
+                CalcResult::Array(_) => {
+                    *self.workbook.worksheets[sheet as usize]
+                        .sheet_data
+                        .get_mut(&row)
+                        .expect("expected a row")
+                        .get_mut(&column)
+                        .expect("expected a column") = Cell::CellFormulaError {
+                        f,
+                        s,
+                        o: "".to_string(),
+                        m: "Arrays not supported yet".to_string(),
+                        ei: Error::NIMPL,
+                    };
                 }
             }
         }
-        Ok(())
     }
 
     /// Sets the color of the sheet tab.
@@ -1064,18 +714,16 @@ impl Model {
         Ok(())
     }
 
-    // EmptyCell, Boolean, Number, String, Error
     fn get_cell_value(&self, cell: &Cell, cell_reference: CellReferenceIndex) -> CalcResult {
         use Cell::*;
         match cell {
             EmptyCell { .. } => CalcResult::EmptyCell,
-            BooleanCell { v, .. } | SpillBooleanCell { v, .. } => CalcResult::Boolean(*v),
-            NumberCell { v, .. } | SpillNumberCell { v, .. } => CalcResult::Number(*v),
-            ErrorCell { ei, .. } | SpillErrorCell { ei, .. } => {
+            BooleanCell { v, .. } => CalcResult::Boolean(*v),
+            NumberCell { v, .. } => CalcResult::Number(*v),
+            ErrorCell { ei, .. } => {
                 let message = ei.to_localized_error_string(&self.language);
                 CalcResult::new_error(ei.clone(), cell_reference, message)
             }
-            SpillStringCell { v, .. } => CalcResult::String(v.clone()),
             SharedString { si, .. } => {
                 if let Some(s) = self.workbook.shared_strings.get(*si as usize) {
                     CalcResult::String(s.clone())
@@ -1084,21 +732,15 @@ impl Model {
                     CalcResult::new_error(Error::ERROR, cell_reference, message)
                 }
             }
-            DynamicCellFormula { .. } | CellFormula { .. } => CalcResult::Error {
+            CellFormula { .. } => CalcResult::Error {
                 error: Error::ERROR,
                 origin: cell_reference,
                 message: "Unevaluated formula".to_string(),
             },
-            DynamicCellFormulaBoolean { v, .. } | CellFormulaBoolean { v, .. } => {
-                CalcResult::Boolean(*v)
-            }
-            DynamicCellFormulaNumber { v, .. } | CellFormulaNumber { v, .. } => {
-                CalcResult::Number(*v)
-            }
-            DynamicCellFormulaString { v, .. } | CellFormulaString { v, .. } => {
-                CalcResult::String(v.clone())
-            }
-            DynamicCellFormulaError { ei, o, m, .. } | CellFormulaError { ei, o, m, .. } => {
+            CellFormulaBoolean { v, .. } => CalcResult::Boolean(*v),
+            CellFormulaNumber { v, .. } => CalcResult::Number(*v),
+            CellFormulaString { v, .. } => CalcResult::String(v.clone()),
+            CellFormulaError { ei, o, m, .. } => {
                 if let Some(cell_reference) = self.parse_reference(o) {
                     CalcResult::new_error(ei.clone(), cell_reference, m.clone())
                 } else {
@@ -1130,8 +772,6 @@ impl Model {
         self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
     }
 
-    /// Evaluates the cell. After the evaluation is done puts the value in the cell and other cells if it spills.
-    /// If when writing a spill cell encounter a cell whose value has been requested marks the model as "dirty"
     pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
         let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
             .sheet_data
@@ -1170,10 +810,9 @@ impl Model {
                         self.cells.insert(key, CellState::Evaluating);
                     }
                 }
-                let (node, _static_result) =
-                    &self.parsed_formulas[cell_reference.sheet as usize][f as usize];
-                let result = self.evaluate_node_in_context(&node.clone(), cell_reference);
-                let _ = self.set_cell_value(cell_reference, &result);
+                let node = &self.parsed_formulas[cell_reference.sheet as usize][f as usize].clone();
+                let result = self.evaluate_node_in_context(node, cell_reference);
+                self.set_cell_value(cell_reference, &result);
                 // mark cell as evaluated
                 self.cells.insert(key, CellState::Evaluated);
                 result
@@ -1283,10 +922,6 @@ impl Model {
             locale,
             tz,
             view_id: 0,
-            support_graph: HashMap::new(),
-            switch_cells: None,
-            stack: Vec::new(),
-            state: EvaluationState::Ready,
         };
 
         model.parse_formulas();
@@ -1465,8 +1100,7 @@ impl Model {
             Some(cell) => match cell.get_formula() {
                 None => cell.get_text(&self.workbook.shared_strings, &self.language),
                 Some(i) => {
-                    let (formula, static_result) =
-                        &self.parsed_formulas[sheet as usize][i as usize];
+                    let formula = &self.parsed_formulas[sheet as usize][i as usize];
                     let cell_ref = CellReferenceRC {
                         sheet: self.workbook.worksheets[sheet as usize].get_name(),
                         row: target_row,
@@ -1569,8 +1203,7 @@ impl Model {
                         .get(sheet as usize)
                         .ok_or("missing sheet")?
                         .get(formula_index as usize)
-                        .ok_or("missing formula")?
-                        .0;
+                        .ok_or("missing formula")?;
                     let cell_ref = CellReferenceRC {
                         sheet: worksheet.get_name(),
                         row,
@@ -1804,25 +1437,6 @@ impl Model {
         column: i32,
         value: String,
     ) -> Result<(), String> {
-        // We need to check if the cell is part of a dynamic array
-        let cell = self
-            .workbook
-            .worksheet(sheet)?
-            .cell(row, column)
-            .cloned()
-            .unwrap_or_default();
-        // If the cell is a dynamic cell we need to delete all the cells in the range
-        if let Some((width, height)) = cell.get_dynamic_range() {
-            for r in row..row + height {
-                for c in column..column + width {
-                    // skip the "mother" cell
-                    if r == row && c == column {
-                        continue;
-                    }
-                    self.cell_clear_contents(sheet, r, c)?;
-                }
-            }
-        }
         // If value starts with "'" then we force the style to be quote_prefix
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
@@ -1848,9 +1462,8 @@ impl Model {
                     self.set_cell_with_formula(sheet, row, column, formula, new_style_index)?;
                 // Update the style if needed
                 let cell = CellReferenceIndex { sheet, row, column };
-                let (parsed_formula, static_result) =
-                    self.parsed_formulas[sheet as usize][formula_index as usize].clone();
-                if let Some(units) = self.compute_node_units(&parsed_formula, &cell) {
+                let parsed_formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
+                if let Some(units) = self.compute_node_units(parsed_formula, &cell) {
                     let new_style_index = self
                         .workbook
                         .styles
@@ -1858,14 +1471,6 @@ impl Model {
                     let style = self.workbook.styles.get_style(new_style_index)?;
                     self.set_cell_style(sheet, row, column, &style)?
                 }
-                match static_result {
-                    StaticResult::Scalar => {}
-                    StaticResult::Array(_, _)
-                    | StaticResult::Range(_, _)
-                    | StaticResult::Unknown => {
-                        self.workbook.spill_cells.push((sheet, row, column));
-                    }
-                }
             } else {
                 // The list of currencies is '$', '€' and the local currency
                 let mut currencies = vec!["$", "€"];
@@ -1939,7 +1544,6 @@ impl Model {
                 _ => parsed_formula = new_parsed_formula,
             }
         }
-        let static_result = run_static_analysis_on_node(&parsed_formula);
 
         let s = to_rc_format(&parsed_formula);
         let mut formula_index: i32 = -1;
@@ -1948,7 +1552,7 @@ impl Model {
         }
         if formula_index == -1 {
             shared_formulas.push(s);
-            self.parsed_formulas[sheet as usize].push((parsed_formula, static_result));
+            self.parsed_formulas[sheet as usize].push(parsed_formula);
             formula_index = (shared_formulas.len() as i32) - 1;
         }
         worksheet.set_cell_with_formula(row, column, formula_index, style)?;
@@ -2143,7 +1747,7 @@ impl Model {
         };
         match cell.get_formula() {
             Some(formula_index) => {
-                let formula = &self.parsed_formulas[sheet as usize][formula_index as usize].0;
+                let formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
                 let cell_ref = CellReferenceRC {
                     sheet: worksheet.get_name(),
                     row,
@@ -2179,34 +1783,9 @@ impl Model {
 
     /// Evaluates the model with a top-down recursive algorithm
     pub fn evaluate(&mut self) {
-        // We first evaluate all the cells that might spill to other cells
-        let mut spills_computed = false;
-        self.state = EvaluationState::EvaluatingSpills;
-        while !spills_computed {
-            spills_computed = true;
-            // clear all computation artifacts
-            self.cells.clear();
-            // Evaluate all the cells that might spill
-            let spill_cells = self.workbook.spill_cells.clone();
-            for (sheet, row, column) in spill_cells {
-                self.evaluate_cell(CellReferenceIndex { sheet, row, column });
-                if self.switch_cells.is_some() {
-                    spills_computed = false;
-                    break;
-                }
-            }
-            if let Some((index1, index2)) = self.switch_cells {
-                spills_computed = false;
-                // switch the cells indices in the spill_cells
-                let cell1 = self.workbook.spill_cells[index1 as usize];
-                let cell2 = self.workbook.spill_cells[index2 as usize];
-                self.workbook.spill_cells[index1 as usize] = cell2;
-                self.workbook.spill_cells[index2 as usize] = cell1;
-            }
-        }
-        self.state = EvaluationState::Evaluating;
+        // clear all computation artifacts
+        self.cells.clear();
 
-        // Now we compute all the rest
         let cells = self.get_all_cells();
 
         for cell in cells {
@@ -2216,7 +1795,6 @@ impl Model {
                 column: cell.column,
             });
         }
-        self.state = EvaluationState::Ready;
     }
 
     /// Removes the content of the cell but leaves the style.
@@ -2240,22 +1818,9 @@ impl Model {
     /// # }
     /// ```
     pub fn cell_clear_contents(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
-        // If it has a spill formula we need to delete the contents of all the spilled cells
-        let worksheet = self.workbook.worksheet_mut(sheet)?;
-        if let Some(cell) = worksheet.cell(row, column) {
-            if let Some((width, height)) = cell.get_dynamic_range() {
-                for r in row..row + height {
-                    for c in column..column + width {
-                        if row == r && column == c {
-                            // we skip the root cell
-                            continue;
-                        }
-                        worksheet.cell_clear_contents(r, c)?;
-                    }
-                }
-            }
-        }
-        worksheet.cell_clear_contents(row, column)?;
+        self.workbook
+            .worksheet_mut(sheet)?
+            .cell_clear_contents(row, column)?;
         Ok(())
     }
 
@@ -2280,18 +1845,6 @@ impl Model {
     /// # }
     pub fn cell_clear_all(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
         let worksheet = self.workbook.worksheet_mut(sheet)?;
-        // Delete the contents of spilled cells if any
-        if let Some(cell) = worksheet.cell(row, column) {
-            if let Some((width, height)) = cell.get_dynamic_range() {
-                for r in row..row + height {
-                    for c in column..column + width {
-                        if row == r && c == column {
-                            worksheet.cell_clear_contents(r, c)?;
-                        }
-                    }
-                }
-            }
-        }
 
         let sheet_data = &mut worksheet.sheet_data;
         if let Some(row_data) = sheet_data.get_mut(&row) {

base/src/new_empty.rs

@@ -8,7 +8,6 @@ use crate::{
     expressions::{
         lexer::LexerMode,
         parser::{
-            static_analysis::run_static_analysis_on_node,
             stringify::{rename_sheet_in_node, to_rc_format, to_string},
             Parser,
         },
@@ -16,7 +15,7 @@ use crate::{
     },
     language::get_language,
     locale::get_locale,
-    model::{get_milliseconds_since_epoch, EvaluationState, Model, ParsedDefinedName},
+    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
     types::{
         DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
         WorksheetView,
@@ -95,8 +94,7 @@ impl Model {
             let mut parse_formula = Vec::new();
             for formula in shared_formulas {
                 let t = self.parser.parse(formula, &cell_reference);
-                let static_result = run_static_analysis_on_node(&t);
-                parse_formula.push((t, static_result));
+                parse_formula.push(t);
             }
             self.parsed_formulas.push(parse_formula);
         }
@@ -407,7 +405,6 @@ impl Model {
             },
             tables: HashMap::new(),
             views,
-            spill_cells: Vec::new(),
         };
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
@@ -430,10 +427,6 @@ impl Model {
             language,
             tz,
             view_id: 0,
-            support_graph: HashMap::new(),
-            switch_cells: None,
-            stack: Vec::new(),
-            state: EvaluationState::Ready,
         };
         model.parse_formulas();
         Ok(model)

base/src/test/mod.rs

@@ -52,20 +52,15 @@ mod test_fn_offset;
 mod test_number_format;
 
 mod test_arrays;
-mod test_dynamic_arrays;
 mod test_escape_quotes;
 mod test_extend;
 mod test_fn_fv;
-mod test_fn_round;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_geomean;
 mod test_get_cell_content;
 mod test_implicit_intersection;
 mod test_issue_155;
-mod test_ln;
-mod test_log;
-mod test_log10;
 mod test_percentage;
 mod test_set_functions_error_handling;
 mod test_today;

base/src/test/test_actions.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -508,10 +508,6 @@ fn test_move_column_right() {
     assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
     assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
     assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G1"), "1");
-    assert_eq!(model._get_text("H1"), "3");
 }
 
 #[test]
@@ -536,249 +532,5 @@ fn tets_move_column_error() {
     assert!(result.is_ok());
 }
 
-#[test]
-fn test_move_row_down() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Formulas referencing rows 3 and 4
-    model._set("E3", "=G3");
-    model._set("E4", "=G4");
-    model._set("E5", "=SUM(G3:J3)");
-    model._set("E6", "=SUM(G3:G3)");
-    model._set("E7", "=SUM(G4:G4)");
-    model.evaluate();
-
-    // Move row 3 down by one position
-    let result = model.move_row_action(0, 3, 1);
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=G3");
-    assert_eq!(model._get_formula("E4"), "=G4");
-    assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
-    assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
-    assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G4"), "-2");
-    assert_eq!(model._get_text("G3"), "");
-}
-
-#[test]
-fn test_move_row_up() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Formulas referencing rows 4 and 5
-    model._set("E4", "=G4");
-    model._set("E5", "=G5");
-    model._set("E6", "=SUM(G4:J4)");
-    model._set("E7", "=SUM(G4:G4)");
-    model._set("E8", "=SUM(G5:G5)");
-    model.evaluate();
-
-    // Move row 5 up by one position
-    let result = model.move_row_action(0, 5, -1);
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E4"), "=G4");
-    assert_eq!(model._get_formula("E5"), "=G5");
-    assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
-    assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
-    assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G4"), "");
-    assert_eq!(model._get_text("G5"), "");
-}
-
-#[test]
-fn test_move_row_error() {
-    let mut model = new_empty_model();
-    model.evaluate();
-
-    let result = model.move_row_action(0, 7, -10);
-    assert!(result.is_err());
-
-    let result = model.move_row_action(0, -7, 20);
-    assert!(result.is_err());
-
-    let result = model.move_row_action(0, LAST_ROW, 1);
-    assert!(result.is_err());
-
-    let result = model.move_row_action(0, LAST_ROW + 1, -10);
-    assert!(result.is_err());
-
-    // This works
-    let result = model.move_row_action(0, LAST_ROW, -1);
-    assert!(result.is_ok());
-}
-
-#[test]
-fn test_move_row_down_absolute_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Absolute references
-    model._set("E3", "=$G$3");
-    model._set("E4", "=$G$4");
-    model._set("E5", "=SUM($G$3:$J$3)");
-    model._set("E6", "=SUM($G$3:$G$3)");
-    model._set("E7", "=SUM($G$4:$G$4)");
-    model.evaluate();
-
-    assert!(model.move_row_action(0, 3, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$G$3");
-    assert_eq!(model._get_formula("E4"), "=$G$4");
-    assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
-    assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
-}
-
-#[test]
-fn test_move_column_right_absolute_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Absolute references
-    model._set("E3", "=$G$3");
-    model._set("E4", "=$H$3");
-    model._set("E5", "=SUM($G$3:$J$7)");
-    model._set("E6", "=SUM($G$3:$G$7)");
-    model._set("E7", "=SUM($H$3:$H$7)");
-    model.evaluate();
-
-    assert!(model.move_column_action(0, 7, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$H$3");
-    assert_eq!(model._get_formula("E4"), "=$G$3");
-    assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
-    assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
-}
-
-#[test]
-fn test_move_row_down_mixed_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    model._set("E3", "=$G3"); // absolute col, relative row
-    model._set("E4", "=$G4");
-    model._set("E5", "=SUM($G3:$J3)");
-    model._set("E6", "=SUM($G3:$G3)");
-    model._set("E7", "=SUM($G4:$G4)");
-    model._set("F3", "=H$3"); // relative col, absolute row
-    model._set("F4", "=G$3");
-    model.evaluate();
-
-    assert!(model.move_row_action(0, 3, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$G3");
-    assert_eq!(model._get_formula("E4"), "=$G4");
-    assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
-    assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
-    assert_eq!(model._get_formula("F3"), "=G$4");
-    assert_eq!(model._get_formula("F4"), "=H$4");
-}
-
-#[test]
-fn test_move_column_right_mixed_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    model._set("E3", "=$G3");
-    model._set("E4", "=$H3");
-    model._set("E5", "=SUM($G3:$J7)");
-    model._set("E6", "=SUM($G3:$G7)");
-    model._set("E7", "=SUM($H3:$H7)");
-    model._set("F3", "=H$3");
-    model._set("F4", "=H$3");
-    model.evaluate();
-
-    assert!(model.move_column_action(0, 7, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$H3");
-    assert_eq!(model._get_formula("E4"), "=$G3");
-    assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
-    assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
-    assert_eq!(model._get_formula("F3"), "=G$3");
-    assert_eq!(model._get_formula("F4"), "=G$3");
-}
-
-#[test]
-fn test_move_row_height() {
-    let mut model = new_empty_model();
-    let sheet = 0;
-    let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
-    // Set a custom height for row 3
-    model
-        .workbook
-        .worksheet_mut(sheet)
-        .unwrap()
-        .set_row_height(3, custom_height)
-        .unwrap();
-
-    // Record the original height of row 4 (should be the default)
-    let original_row4_height = model.get_row_height(sheet, 4).unwrap();
-
-    // Move row 3 down by one position
-    assert!(model.move_row_action(sheet, 3, 1).is_ok());
-
-    // The custom height should now be on row 4
-    assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
-
-    // Row 3 should now have the previous height of row 4
-    assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
-}
-
-/// Moving a row down by two positions should shift formulas on intermediate
-/// rows by only one (the row that gets skipped), not by the full delta ‒ this
-/// guards against the regression fixed in the RowMove displacement logic.
-#[test]
-fn test_row_move_down_two_updates_intermediate_refs_by_one() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Set up formulas to verify intermediate rows shift by 1 (not full delta).
-    model._set("E3", "=G3"); // target row
-    model._set("E4", "=G4"); // intermediate row
-    model._set("E5", "=SUM(G3:J3)");
-    model.evaluate();
-
-    // Move row 3 down by two positions (row 3 -> row 5)
-    assert!(model.move_row_action(0, 3, 2).is_ok());
-    model.evaluate();
-
-    // Assert that references for the moved row and intermediate row are correct.
-    assert_eq!(model._get_formula("E3"), "=G3");
-    assert_eq!(model._get_formula("E5"), "=G5");
-    assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
-}
-
-/// Moving a column right by two positions should shift formulas on
-/// intermediate columns by only one, ensuring the ColumnMove displacement
-/// logic handles multi-position moves correctly.
-#[test]
-fn test_column_move_right_two_updates_intermediate_refs_by_one() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Set up formulas to verify intermediate columns shift by 1 (not full delta).
-    model._set("E3", "=$G3"); // target column
-    model._set("E4", "=$H3"); // intermediate column
-    model._set("E5", "=SUM($G3:$J7)");
-    model.evaluate();
-
-    // Move column G (7) right by two positions (G -> I)
-    assert!(model.move_column_action(0, 7, 2).is_ok());
-    model.evaluate();
-
-    // Assert that references for moved and intermediate columns are correct.
-    assert_eq!(model._get_formula("E3"), "=$I3");
-    assert_eq!(model._get_formula("E4"), "=$G3");
-    assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
-}
-
 // A  B  C  D  E  F  G   H  I  J   K   L   M   N   O   P   Q   R
 // 1  2  3  4  5  6  7   8  9  10  11  12  13  14  15  16  17  18

base/src/test/test_dynamic_arrays.rs

@@ -1,50 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn they_spill() {
-    let mut model = new_empty_model();
-    model._set("A1", "42");
-    model._set("A2", "5");
-    model._set("A3", "7");
-
-    model._set("B1", "=A1:A3");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"42");
-    assert_eq!(model._get_text("B2"), *"5");
-    assert_eq!(model._get_text("B3"), *"7");
-}
-
-#[test]
-fn spill_error() {
-    let mut model = new_empty_model();
-    model._set("A1", "42");
-    model._set("A2", "5");
-    model._set("A3", "7");
-
-    model._set("B1", "=A1:A3");
-    model._set("B2", "4");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"#SPILL!");
-    assert_eq!(model._get_text("B2"), *"4");
-    assert_eq!(model._get_text("B3"), *"");
-}
-
-#[test]
-fn second_evaluation() {
-    let mut model = new_empty_model();
-    model._set("C3", "={1,2,3}");
-    model.evaluate();
-
-    assert_eq!(model._get_text("D3"), "2");
-
-    model._set("D8", "23");
-    model.evaluate();
-
-    assert_eq!(model._get_text("D3"), "2");
-}

base/src/test/test_fn_or_xor.rs

@@ -91,12 +91,12 @@ fn fn_or_xor() {
         model._set("A10", &format!("={func}(X99:Z99"));
 
         // Reference to cell with reference to empty range
-        model._set("B11", "=@X99:Z99");
+        model._set("B11", "=X99:Z99");
         model._set("A11", &format!("={func}(B11)"));
 
         // Reference to cell with non-empty range
         model._set("X12", "1");
-        model._set("B12", "=@X12:Z12");
+        model._set("B12", "=X12:Z12");
         model._set("A12", &format!("={func}(B12)"));
 
         // Reference to text cell

base/src/test/test_fn_round.rs

@@ -1,15 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn fn_round_approximation() {
-    let mut model = new_empty_model();
-    model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
-    model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"0.0063");
-    assert_eq!(model._get_text("A2"), *"0.00625");
-}

base/src/test/test_implicit_intersection.rs

@@ -3,7 +3,7 @@
 use crate::test::util::new_empty_model;
 
 #[test]
-fn simple_column() {
+fn simple_colum() {
     let mut model = new_empty_model();
     // We populate cells A1 to A3
     model._set("A1", "1");
@@ -30,7 +30,7 @@ fn return_of_array_is_n_impl() {
 
     model.evaluate();
 
-    assert_eq!(model._get_text("C2"), "1".to_string());
+    assert_eq!(model._get_text("C2"), "#N/IMPL!".to_string());
     assert_eq!(model._get_text("D2"), "1.89188842".to_string());
 }
 

base/src/test/test_ln.rs

@@ -1,17 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LN(100)");
-    model._set("A2", "=LN()");
-    model._set("A3", "=LN(100, 10)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"4.605170186");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-}

base/src/test/test_log.rs

@@ -1,19 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG(100)");
-    model._set("A2", "=LOG()");
-    model._set("A3", "=LOG(10000, 10)");
-    model._set("A4", "=LOG(100, 10, 1)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"4");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-}

base/src/test/test_log10.rs

@@ -1,35 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG10(100)");
-    model._set("A2", "=LOG10()");
-    model._set("A3", "=LOG10(100, 10)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-}
-
-#[test]
-fn cell_and_function() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG10");
-
-    model.evaluate();
-
-    // This is the cell LOG10
-    assert_eq!(model._get_text("A1"), *"0");
-
-    model._set("LOG10", "1000");
-    model._set("A2", "=LOG10(LOG10)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"1000");
-    assert_eq!(model._get_text("A2"), *"3");
-}

base/src/test/user_model/mod.rs

@@ -1,21 +1,16 @@
 mod test_add_delete_sheets;
 mod test_autofill_columns;
 mod test_autofill_rows;
-mod test_batch_row_column_diff;
 mod test_border;
 mod test_clear_cells;
 mod test_column_style;
 mod test_defined_names;
-mod test_delete_evaluates;
 mod test_delete_row_column_formatting;
 mod test_diff_queue;
-mod test_dynamic_array;
 mod test_evaluation;
 mod test_general;
 mod test_grid_lines;
 mod test_keyboard_navigation;
-mod test_last_empty_cell;
-mod test_multi_row_column;
 mod test_on_area_selection;
 mod test_on_expand_selected_range;
 mod test_on_paste_styles;

base/src/test/user_model/test_batch_row_column_diff.rs

@@ -1,675 +0,0 @@
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::panic)]
-
-use bitcode::decode;
-
-use crate::{
-    constants::{LAST_COLUMN, LAST_ROW},
-    test::util::new_empty_model,
-    user_model::history::{Diff, QueueDiffs},
-    UserModel,
-};
-
-fn last_diff_list(model: &mut UserModel) -> Vec<Diff> {
-    let bytes = model.flush_send_queue();
-    let queue: Vec<QueueDiffs> = decode(&bytes).unwrap();
-    // Get the last operation's diff list
-    queue.last().unwrap().list.clone()
-}
-
-#[test]
-fn diff_invariant_insert_rows() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    assert!(model.insert_rows(0, 5, 3).is_ok());
-
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertRows {
-            sheet: 0,
-            row: 5,
-            count: 3
-        }
-    ));
-}
-
-#[test]
-fn diff_invariant_insert_columns() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    assert!(model.insert_columns(0, 2, 4).is_ok());
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertColumns {
-            sheet: 0,
-            column: 2,
-            count: 4
-        }
-    ));
-}
-
-#[test]
-fn undo_redo_after_batch_delete() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Place values that will shift.
-    model.set_user_input(0, 20, 1, "A").unwrap();
-    model.set_user_input(0, 1, 20, "B").unwrap();
-
-    // Fill some of the rows we are about to delete for testing
-    for r in 10..15 {
-        model.set_user_input(0, r, 1, "tmp").unwrap();
-    }
-
-    // Delete rows 10..14 and columns 5..8
-    assert!(model.delete_rows(0, 10, 5).is_ok());
-    assert!(model.delete_columns(0, 5, 4).is_ok());
-
-    // Verify shift
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
-
-    // Undo
-    model.undo().unwrap(); // columns
-    model.undo().unwrap(); // rows
-    assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "A");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 20).unwrap(), "B");
-
-    // Redo
-    model.redo().unwrap(); // rows
-    model.redo().unwrap(); // columns
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
-}
-
-#[test]
-fn diff_order_delete_rows() {
-    // Verifies that delete diffs are generated with all data preserved
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Populate rows to delete
-    for r in 5..10 {
-        model.set_user_input(0, r, 1, &r.to_string()).unwrap();
-    }
-
-    assert!(model.delete_rows(0, 5, 5).is_ok());
-
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-
-    // Should have one bulk diff with all the row data
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 5);
-            assert_eq!(*count, 5);
-            assert_eq!(old_data.len(), 5);
-            // Verify the data was collected for each row
-            for (i, row_data) in old_data.iter().enumerate() {
-                let _expected_value = (5 + i).to_string();
-                assert!(row_data.data.contains_key(&1));
-            }
-        }
-        _ => panic!("Unexpected diff variant"),
-    }
-}
-
-#[test]
-fn batch_operations_with_formulas() {
-    // Verifies formulas update correctly after batch ops
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    model.set_user_input(0, 1, 1, "10").unwrap();
-    model.set_user_input(0, 5, 1, "=A1*2").unwrap(); // Will become A3 after insert
-
-    assert!(model.insert_rows(0, 2, 2).is_ok());
-
-    // Formula should now reference A1 (unchanged) but be in row 7
-    assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "20");
-    assert_eq!(model.get_cell_content(0, 7, 1).unwrap(), "=A1*2");
-
-    // Undo and verify formula is back at original position
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "20");
-}
-
-#[test]
-fn edge_case_single_operation() {
-    // Single row/column operations should still work correctly
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    assert!(model.insert_rows(0, 1, 1).is_ok());
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-
-    assert!(model.insert_columns(0, 1, 1).is_ok());
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-}
-
-#[test]
-fn delete_empty_rows() {
-    // Delete multiple empty rows and verify behavior
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set data in rows 1 and 10, leaving rows 5-8 empty
-    model.set_user_input(0, 1, 1, "Before").unwrap();
-    model.set_user_input(0, 10, 1, "After").unwrap();
-
-    // Delete empty rows 5-8
-    assert!(model.delete_rows(0, 5, 4).is_ok());
-
-    // Verify shift
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
-
-    // Verify diffs now use bulk operation
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 5);
-            assert_eq!(*count, 4);
-            assert_eq!(old_data.len(), 4);
-            // All rows should be empty
-            for row_data in old_data {
-                assert!(row_data.data.is_empty());
-            }
-        }
-        _ => panic!("Unexpected diff variant"),
-    }
-
-    // Undo/redo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
-}
-
-#[test]
-fn delete_mixed_empty_and_filled_rows() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Alternating filled and empty rows
-    model.set_user_input(0, 5, 1, "Row5").unwrap();
-    model.set_user_input(0, 7, 1, "Row7").unwrap();
-    model.set_user_input(0, 9, 1, "Row9").unwrap();
-    model.set_user_input(0, 10, 1, "After").unwrap();
-
-    assert!(model.delete_rows(0, 5, 5).is_ok());
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "After");
-
-    // Verify mix of empty and filled row diffs
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 5);
-            assert_eq!(*count, 5);
-            assert_eq!(old_data.len(), 5);
-
-            // Count filled rows (should be 3: rows 5, 7, 9)
-            let filled_count = old_data
-                .iter()
-                .filter(|row_data| !row_data.data.is_empty())
-                .count();
-            assert_eq!(filled_count, 3);
-        }
-        _ => panic!("Unexpected diff variant"),
-    }
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
-    assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "Row7");
-    assert_eq!(model.get_formatted_cell_value(0, 9, 1).unwrap(), "Row9");
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
-}
-
-#[test]
-fn bulk_insert_rows_undo_redo() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up initial data
-    model.set_user_input(0, 1, 1, "A1").unwrap();
-    model.set_user_input(0, 2, 1, "A2").unwrap();
-    model.set_user_input(0, 5, 1, "A5").unwrap();
-
-    // Insert 3 rows at position 3
-    assert!(model.insert_rows(0, 3, 3).is_ok());
-
-    // Verify data has shifted
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 2, 1).unwrap(), "A2");
-    assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // A5 moved to A8
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertRows {
-            sheet: 0,
-            row: 3,
-            count: 3
-        }
-    ));
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "A5"); // Back to original position
-
-    // Redo
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // Shifted again
-}
-
-#[test]
-fn bulk_insert_columns_undo_redo() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up initial data
-    model.set_user_input(0, 1, 1, "A1").unwrap();
-    model.set_user_input(0, 1, 2, "B1").unwrap();
-    model.set_user_input(0, 1, 5, "E1").unwrap();
-
-    // Insert 3 columns at position 3
-    assert!(model.insert_columns(0, 3, 3).is_ok());
-
-    // Verify data has shifted
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "B1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // E1 moved to H1
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertColumns {
-            sheet: 0,
-            column: 3,
-            count: 3
-        }
-    ));
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1"); // Back to original position
-
-    // Redo
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // Shifted again
-}
-
-#[test]
-fn bulk_delete_rows_round_trip() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data with styles
-    model.set_user_input(0, 3, 1, "Row3").unwrap();
-    model.set_user_input(0, 4, 1, "Row4").unwrap();
-    model.set_user_input(0, 5, 1, "Row5").unwrap();
-    model.set_user_input(0, 6, 1, "Row6").unwrap();
-    model.set_user_input(0, 7, 1, "After").unwrap();
-
-    // Set some row heights to verify they're preserved
-    model.set_rows_height(0, 4, 4, 30.0).unwrap();
-    model.set_rows_height(0, 5, 5, 40.0).unwrap();
-
-    // Delete rows 3-6
-    assert!(model.delete_rows(0, 3, 4).is_ok());
-
-    // Verify deletion
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 3);
-            assert_eq!(*count, 4);
-            assert_eq!(old_data.len(), 4);
-            // Verify data was preserved
-            assert!(old_data[0].data.contains_key(&1)); // Row3
-            assert!(old_data[1].data.contains_key(&1)); // Row4
-            assert!(old_data[2].data.contains_key(&1)); // Row5
-            assert!(old_data[3].data.contains_key(&1)); // Row6
-        }
-        _ => panic!("Expected DeleteRows diff"),
-    }
-
-    // Undo - should restore all data and row heights
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
-    assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "After");
-    assert_eq!(model.get_row_height(0, 4).unwrap(), 30.0);
-    assert_eq!(model.get_row_height(0, 5).unwrap(), 40.0);
-
-    // Redo - should delete again
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
-
-    // Final undo to verify round-trip
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
-}
-
-#[test]
-fn bulk_delete_columns_round_trip() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data with styles
-    model.set_user_input(0, 1, 3, "C1").unwrap();
-    model.set_user_input(0, 1, 4, "D1").unwrap();
-    model.set_user_input(0, 1, 5, "E1").unwrap();
-    model.set_user_input(0, 1, 6, "F1").unwrap();
-    model.set_user_input(0, 1, 7, "After").unwrap();
-
-    // Set some column widths to verify they're preserved
-    model.set_columns_width(0, 4, 4, 100.0).unwrap();
-    model.set_columns_width(0, 5, 5, 120.0).unwrap();
-
-    // Delete columns 3-6
-    assert!(model.delete_columns(0, 3, 4).is_ok());
-
-    // Verify deletion
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteColumns {
-            sheet,
-            column,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*column, 3);
-            assert_eq!(*count, 4);
-            assert_eq!(old_data.len(), 4);
-            // Verify data was preserved
-            assert!(old_data[0].data.contains_key(&1)); // C1
-            assert!(old_data[1].data.contains_key(&1)); // D1
-            assert!(old_data[2].data.contains_key(&1)); // E1
-            assert!(old_data[3].data.contains_key(&1)); // F1
-        }
-        _ => panic!("Expected DeleteColumns diff"),
-    }
-
-    // Undo - should restore all data and column widths
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 7).unwrap(), "After");
-    assert_eq!(model.get_column_width(0, 4).unwrap(), 100.0);
-    assert_eq!(model.get_column_width(0, 5).unwrap(), 120.0);
-
-    // Redo - should delete again
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
-
-    // Final undo to verify round-trip
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
-}
-
-#[test]
-fn complex_bulk_operations_sequence() {
-    // Test a complex sequence of bulk operations
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Initial setup
-    model.set_user_input(0, 1, 1, "A1").unwrap();
-    model.set_user_input(0, 2, 2, "B2").unwrap();
-    model.set_user_input(0, 3, 3, "C3").unwrap();
-
-    // Operation 1: Insert 2 rows at position 2
-    model.insert_rows(0, 2, 2).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2"); // B2 moved down
-    assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3"); // C3 moved down
-
-    // Operation 2: Insert 2 columns at position 2
-    model.insert_columns(0, 2, 2).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2"); // B2 moved right
-    assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3"); // C3 moved right
-
-    // Operation 3: Delete the inserted rows
-    model.delete_rows(0, 2, 2).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
-
-    // Undo all operations
-    model.undo().unwrap(); // Undo delete rows
-    assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3");
-
-    model.undo().unwrap(); // Undo insert columns
-    assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3");
-
-    model.undo().unwrap(); // Undo insert rows
-    assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 3, 3).unwrap(), "C3");
-
-    // Redo all operations
-    model.redo().unwrap(); // Redo insert rows
-    model.redo().unwrap(); // Redo insert columns
-    model.redo().unwrap(); // Redo delete rows
-    assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
-}
-
-#[test]
-fn bulk_operations_with_formulas_update() {
-    // Test that formulas update correctly with bulk operations
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data and formulas
-    model.set_user_input(0, 1, 1, "10").unwrap();
-    model.set_user_input(0, 5, 1, "20").unwrap();
-    model.set_user_input(0, 10, 1, "=A1+A5").unwrap(); // Formula referencing A1 and A5
-
-    // Insert 3 rows at position 3
-    model.insert_rows(0, 3, 3).unwrap();
-
-    // Formula should update to reference the shifted cells
-    assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "30"); // Formula moved down
-    assert_eq!(model.get_cell_content(0, 13, 1).unwrap(), "=A1+A8"); // A5 became A8
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "30");
-    assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1+A5");
-
-    // Now test column insertion
-    model.set_user_input(0, 1, 5, "20").unwrap(); // Add value in E1
-    model.set_user_input(0, 1, 10, "=A1+E1").unwrap();
-    model.insert_columns(0, 3, 2).unwrap();
-
-    assert_eq!(model.get_formatted_cell_value(0, 1, 12).unwrap(), "30"); // Formula moved right
-    assert_eq!(model.get_cell_content(0, 1, 12).unwrap(), "=A1+G1"); // E1 became G1
-}
-
-#[test]
-fn bulk_delete_with_styles() {
-    // Test that cell and row/column styles are preserved
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data with various styles
-    for r in 5..10 {
-        model.set_user_input(0, r, 1, &format!("Row{r}")).unwrap();
-        model.set_rows_height(0, r, r, (r * 10) as f64).unwrap();
-    }
-
-    // Delete and verify style preservation
-    model.delete_rows(0, 5, 5).unwrap();
-
-    // Undo should restore all styles
-    model.undo().unwrap();
-    for r in 5..10 {
-        assert_eq!(
-            model.get_formatted_cell_value(0, r, 1).unwrap(),
-            format!("Row{r}")
-        );
-        assert_eq!(model.get_row_height(0, r).unwrap(), (r * 10) as f64);
-    }
-}
-
-#[test]
-fn bulk_operations_large_count() {
-    // Test operations with large counts
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Insert a large number of rows
-    model.set_user_input(0, 1, 1, "Before").unwrap();
-    model.set_user_input(0, 100, 1, "After").unwrap();
-
-    assert!(model.insert_rows(0, 50, 100).is_ok());
-
-    // Verify shift
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
-    assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After"); // Moved by 100
-
-    // Check diff
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertRows {
-            sheet: 0,
-            row: 50,
-            count: 100
-        }
-    ));
-
-    // Undo and redo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 100, 1).unwrap(), "After");
-
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After");
-}
-
-#[test]
-fn bulk_operations_error_cases() {
-    // Test error conditions
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Negative count should fail
-    assert!(model.insert_rows(0, 1, -5).is_err());
-    assert!(model.insert_columns(0, 1, -5).is_err());
-    assert!(model.delete_rows(0, 1, -5).is_err());
-    assert!(model.delete_columns(0, 1, -5).is_err());
-
-    // Zero count should fail
-    assert!(model.insert_rows(0, 1, 0).is_err());
-    assert!(model.insert_columns(0, 1, 0).is_err());
-    assert!(model.delete_rows(0, 1, 0).is_err());
-    assert!(model.delete_columns(0, 1, 0).is_err());
-
-    // Out of bounds operations should fail
-    assert!(model.delete_rows(0, LAST_ROW - 5, 10).is_err());
-    assert!(model.delete_columns(0, LAST_COLUMN - 5, 10).is_err());
-}
-
-#[test]
-fn bulk_diff_serialization() {
-    // Test that bulk diffs can be serialized/deserialized correctly
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Create some data
-    model.set_user_input(0, 1, 1, "Test").unwrap();
-    model.insert_rows(0, 2, 3).unwrap();
-
-    // Flush and get the serialized diffs
-    let bytes = model.flush_send_queue();
-
-    // Create a new model and apply the diffs
-    let base2 = new_empty_model();
-    let mut model2 = UserModel::from_model(base2);
-
-    assert!(model2.apply_external_diffs(&bytes).is_ok());
-
-    // Verify the state matches
-    assert_eq!(model2.get_formatted_cell_value(0, 1, 1).unwrap(), "Test");
-}
-
-#[test]
-fn boundary_validation() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Test deleting rows beyond valid range
-    assert!(model.delete_rows(0, LAST_ROW, 2).is_err());
-    assert!(model.delete_rows(0, LAST_ROW + 1, 1).is_err());
-
-    // Test deleting columns beyond valid range
-    assert!(model.delete_columns(0, LAST_COLUMN, 2).is_err());
-    assert!(model.delete_columns(0, LAST_COLUMN + 1, 1).is_err());
-
-    // Test valid boundary deletions (should work with our empty row fix)
-    assert!(model.delete_rows(0, LAST_ROW, 1).is_ok());
-    assert!(model.delete_columns(0, LAST_COLUMN, 1).is_ok());
-}

base/src/test/user_model/test_delete_evaluates.rs

@@ -1,47 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{expressions::types::Area, UserModel};
-
-#[test]
-fn clear_cell_contents_evaluates() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.set_user_input(0, 1, 1, "42").unwrap();
-    model.set_user_input(0, 1, 2, "=A1").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("42".to_string())
-    );
-    model
-        .range_clear_contents(&Area {
-            sheet: 0,
-            row: 1,
-            column: 1,
-            width: 1,
-            height: 1,
-        })
-        .unwrap();
-
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("0".to_string()));
-}
-
-#[test]
-fn clear_cell_all_evaluates() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.set_user_input(0, 1, 1, "42").unwrap();
-    model.set_user_input(0, 1, 2, "=A1").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("42".to_string())
-    );
-    model
-        .range_clear_all(&Area {
-            sheet: 0,
-            row: 1,
-            column: 1,
-            width: 1,
-            height: 1,
-        })
-        .unwrap();
-
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("0".to_string()));
-}

base/src/test/user_model/test_diff_queue.rs

@@ -65,8 +65,8 @@ fn queue_undo_redo_multiple() {
         model1.set_user_input(0, row, 17, "=ROW()").unwrap();
     }
 
-    model1.insert_rows(0, 3, 1).unwrap();
-    model1.insert_rows(0, 3, 1).unwrap();
+    model1.insert_row(0, 3).unwrap();
+    model1.insert_row(0, 3).unwrap();
 
     // undo al of them
     while model1.can_undo() {

base/src/test/user_model/test_dynamic_array.rs

@@ -1,130 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{expressions::types::Area, UserModel};
-
-// Tests basic behavour.
-#[test]
-fn basic() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    // We put a value by the dynamic array to check the border conditions
-    model.set_user_input(0, 2, 1, "22").unwrap();
-    model.set_user_input(0, 1, 1, "={34,35,3}").unwrap();
-
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 1),
-        Ok("34".to_string())
-    );
-}
-
-// Test that overwriting a dynamic array with a single value dissolves the array
-#[test]
-fn sett_user_input_mother() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.set_user_input(0, 1, 1, "={34,35,3}").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("35".to_string())
-    );
-    model.set_user_input(0, 1, 1, "123").unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("".to_string()));
-}
-
-#[test]
-fn set_user_input_sibling() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.set_user_input(0, 1, 1, "={43,55,34}").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("55".to_string())
-    );
-    // This does nothing
-    model.set_user_input(0, 1, 2, "123").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("55".to_string())
-    );
-}
-
-#[test]
-fn basic_undo_redo() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.set_user_input(0, 1, 1, "={34,35,3}").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("35".to_string())
-    );
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("".to_string()));
-    model.redo().unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("35".to_string())
-    );
-}
-
-#[test]
-fn mixed_spills() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    // D9 => ={1,2,3}
-    model.set_user_input(0, 9, 4, "={34,35,3}").unwrap();
-    // F6 => ={1;2;3;4}
-    model.set_user_input(0, 6, 6, "={1;2;3;4}").unwrap();
-
-    // F6 should be #SPILL!
-    assert_eq!(
-        model.get_formatted_cell_value(0, 6, 6),
-        Ok("#SPILL!".to_string())
-    );
-
-    // We delete D9
-    model
-        .range_clear_contents(&Area {
-            sheet: 0,
-            row: 9,
-            column: 4,
-            width: 1,
-            height: 1,
-        })
-        .unwrap();
-
-    // F6 should be 1
-    assert_eq!(model.get_formatted_cell_value(0, 6, 6), Ok("1".to_string()));
-
-    // Now we undo that
-    model.undo().unwrap();
-    // F6 should be #SPILL!
-    assert_eq!(
-        model.get_formatted_cell_value(0, 6, 6),
-        Ok("#SPILL!".to_string())
-    );
-}
-
-#[test]
-fn spill_order_d9_f6() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    // D9 => ={1,2,3}
-    model.set_user_input(0, 9, 4, "={34,35,3}").unwrap();
-    // F6 => ={1;2;3;4}
-    model.set_user_input(0, 6, 6, "={1;2;3;4}").unwrap();
-
-    // F6 should be #SPILL!
-    assert_eq!(
-        model.get_formatted_cell_value(0, 6, 6),
-        Ok("#SPILL!".to_string())
-    );
-}
-
-#[test]
-fn spill_order_f6_d9() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    // F6 => ={1;2;3;4}
-    model.set_user_input(0, 6, 6, "={1;2;3;4}").unwrap();
-    // D9 => ={1,2,3}
-    model.set_user_input(0, 9, 4, "={34,35,3}").unwrap();
-
-    // D9 should be #SPILL!
-    assert_eq!(
-        model.get_formatted_cell_value(0, 9, 4),
-        Ok("#SPILL!".to_string())
-    );
-}

base/src/test/user_model/test_general.rs

@@ -62,7 +62,7 @@ fn insert_remove_rows() {
     assert!(model.set_rows_height(0, 5, 5, 3.0 * height).is_ok());
 
     // remove the row
-    assert!(model.delete_rows(0, 5, 1).is_ok());
+    assert!(model.delete_row(0, 5).is_ok());
     // Row 5 has now the normal height
     assert_eq!(model.get_row_height(0, 5), Ok(height));
     // There is no value in A5
@@ -99,7 +99,7 @@ fn insert_remove_columns() {
     assert_eq!(model.get_column_width(0, 5).unwrap(), 3.0 * column_width);
 
     // remove the column
-    assert!(model.delete_columns(0, 5, 1).is_ok());
+    assert!(model.delete_column(0, 5).is_ok());
     // Column 5 has now the normal width
     assert_eq!(model.get_column_width(0, 5), Ok(column_width));
     // There is no value in E5

base/src/test/user_model/test_last_empty_cell.rs

@@ -1,55 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::constants::LAST_ROW;
-use crate::expressions::types::Area;
-use crate::test::util::new_empty_model;
-use crate::UserModel;
-
-#[test]
-fn basic_tests() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    // This is the first row, column 5
-    model.set_user_input(0, 3, 5, "todo").unwrap();
-
-    // Row 3 before column 5 should be empty
-    assert_eq!(
-        model
-            .get_last_non_empty_in_row_before_column(0, 3, 4)
-            .unwrap(),
-        None
-    );
-    // Row 3 before column 5 should be 5
-    assert_eq!(
-        model
-            .get_last_non_empty_in_row_before_column(0, 3, 7)
-            .unwrap(),
-        Some(5)
-    );
-}
-
-#[test]
-fn test_last_empty_cell() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // Column 7 has a style but it is empty
-    assert_eq!(
-        model
-            .get_last_non_empty_in_row_before_column(0, 3, 14)
-            .unwrap(),
-        None
-    );
-}

base/src/test/user_model/test_multi_row_column.rs

@@ -1,173 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{
-    constants::{LAST_COLUMN, LAST_ROW},
-    test::util::new_empty_model,
-    UserModel,
-};
-
-#[test]
-fn insert_multiple_rows_shifts_cells() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    // Place a value below the insertion point.
-    model.set_user_input(0, 10, 1, "42").unwrap();
-
-    // Insert 3 rows starting at row 5.
-    assert!(model.insert_rows(0, 5, 3).is_ok());
-
-    // The original value should have moved down by 3 rows.
-    assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
-
-    // Undo / redo cycle should restore the same behaviour.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "42");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
-}
-
-#[test]
-fn insert_rows_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.insert_rows(0, 1, -2),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-    assert_eq!(
-        model.insert_rows(0, 1, 0),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-
-    // Inserting too many rows so that the sheet would overflow.
-    let too_many = LAST_ROW; // This guarantees max_row + too_many > LAST_ROW.
-    assert_eq!(
-        model.insert_rows(0, 1, too_many),
-        Err(
-            "Cannot shift cells because that would delete cells at the end of a column".to_string()
-        )
-    );
-}
-
-#[test]
-fn insert_multiple_columns_shifts_cells() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    // Place a value to the right of the insertion point.
-    model.set_user_input(0, 1, 10, "99").unwrap();
-
-    // Insert 3 columns starting at column 5.
-    assert!(model.insert_columns(0, 5, 3).is_ok());
-
-    // The original value should have moved right by 3 columns.
-    assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
-
-    // Undo / redo cycle.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 10).unwrap(), "99");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
-}
-
-#[test]
-fn insert_columns_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.insert_columns(0, 1, -2),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-    assert_eq!(
-        model.insert_columns(0, 1, 0),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-
-    // Overflow to the right.
-    let too_many = LAST_COLUMN; // Ensures max_column + too_many > LAST_COLUMN
-    assert_eq!(
-        model.insert_columns(0, 1, too_many),
-        Err("Cannot shift cells because that would delete cells at the end of a row".to_string())
-    );
-}
-
-#[test]
-fn delete_multiple_rows_shifts_cells_upwards() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Populate rows 10..14 (to be deleted) so that the diff builder does not fail.
-    for r in 10..15 {
-        model.set_user_input(0, r, 1, "del").unwrap();
-    }
-    // Place a value below the deletion range.
-    model.set_user_input(0, 20, 1, "keep").unwrap();
-
-    // Delete 5 rows starting at row 10.
-    assert!(model.delete_rows(0, 10, 5).is_ok());
-
-    // The value originally at row 20 should now be at row 15.
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
-
-    // Undo / redo cycle.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "keep");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
-}
-
-#[test]
-fn delete_rows_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.delete_rows(0, 1, -3),
-        Err("Please use insert rows instead".to_string())
-    );
-    assert_eq!(
-        model.delete_rows(0, 1, 0),
-        Err("Please use insert rows instead".to_string())
-    );
-}
-
-#[test]
-fn delete_multiple_columns_shifts_cells_left() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Place a value to the right of the deletion range.
-    model.set_user_input(0, 1, 15, "88").unwrap();
-
-    // Delete 4 columns starting at column 5.
-    assert!(model.delete_columns(0, 5, 4).is_ok());
-
-    // The value originally at column 15 should now be at column 11.
-    assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
-
-    // Undo / redo cycle.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 15).unwrap(), "88");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
-}
-
-#[test]
-fn delete_columns_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.delete_columns(0, 1, -4),
-        Err("Please use insert columns instead".to_string())
-    );
-    assert_eq!(
-        model.delete_columns(0, 1, 0),
-        Err("Please use insert columns instead".to_string())
-    );
-}

base/src/test/user_model/test_paste_csv.rs

@@ -24,7 +24,6 @@ fn csv_paste() {
         model.get_formatted_cell_value(0, 7, 7),
         Ok("21".to_string())
     );
-    assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
 }
 
 #[test]
@@ -46,7 +45,6 @@ fn csv_paste_formula() {
         model.get_formatted_cell_value(0, 1, 1),
         Ok("2022".to_string())
     );
-    assert_eq!([1, 1, 1, 1], model.get_selected_view().range);
 }
 
 #[test]
@@ -71,7 +69,6 @@ fn tsv_crlf_paste() {
         model.get_formatted_cell_value(0, 7, 7),
         Ok("21".to_string())
     );
-    assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
 }
 
 #[test]
@@ -167,7 +164,7 @@ fn copy_paste_internal() {
     let copy = model.copy_to_clipboard().unwrap();
     assert_eq!(
         copy.csv,
-        "42\t127\n\"A season of faith\t \"\"perfection\"\"\""
+        "42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
     );
     assert_eq!(copy.range, (1, 1, 2, 2));
 

base/src/test/user_model/test_row_column.rs

@@ -14,7 +14,7 @@ fn simple_insert_row() {
     for row in 1..5 {
         assert!(model.set_user_input(sheet, row, column, "123").is_ok());
     }
-    assert!(model.insert_rows(sheet, 3, 1).is_ok());
+    assert!(model.insert_row(sheet, 3).is_ok());
     assert_eq!(
         model.get_formatted_cell_value(sheet, 3, column).unwrap(),
         ""
@@ -40,7 +40,7 @@ fn simple_insert_column() {
     for column in 1..5 {
         assert!(model.set_user_input(sheet, row, column, "123").is_ok());
     }
-    assert!(model.insert_columns(sheet, 3, 1).is_ok());
+    assert!(model.insert_column(sheet, 3).is_ok());
     assert_eq!(model.get_formatted_cell_value(sheet, row, 3).unwrap(), "");
 
     assert!(model.undo().is_ok());
@@ -62,7 +62,7 @@ fn simple_delete_column() {
         .set_columns_width(0, 5, 5, DEFAULT_COLUMN_WIDTH * 3.0)
         .unwrap();
 
-    model.delete_columns(0, 5, 1).unwrap();
+    model.delete_column(0, 5).unwrap();
 
     assert_eq!(model.get_formatted_cell_value(0, 2, 5), Ok("".to_string()));
     assert_eq!(model.get_column_width(0, 5), Ok(DEFAULT_COLUMN_WIDTH));
@@ -92,20 +92,20 @@ fn delete_column_errors() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
     assert_eq!(
-        model.delete_columns(1, 1, 1),
+        model.delete_column(1, 1),
         Err("Invalid sheet index".to_string())
     );
 
     assert_eq!(
-        model.delete_columns(0, 0, 1),
+        model.delete_column(0, 0),
         Err("Column number '0' is not valid.".to_string())
     );
     assert_eq!(
-        model.delete_columns(0, LAST_COLUMN + 1, 1),
-        Err(format!("Column number '{}' is not valid.", LAST_COLUMN + 1))
+        model.delete_column(0, LAST_COLUMN + 1),
+        Err("Column number '16385' is not valid.".to_string())
     );
 
-    assert_eq!(model.delete_columns(0, LAST_COLUMN, 1), Ok(()));
+    assert_eq!(model.delete_column(0, LAST_COLUMN), Ok(()));
 }
 
 #[test]
@@ -119,7 +119,7 @@ fn simple_delete_row() {
         .set_rows_height(0, 15, 15, DEFAULT_ROW_HEIGHT * 3.0)
         .unwrap();
 
-    model.delete_rows(0, 15, 1).unwrap();
+    model.delete_row(0, 15).unwrap();
 
     assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
     assert_eq!(model.get_row_height(0, 15), Ok(DEFAULT_ROW_HEIGHT));
@@ -150,7 +150,7 @@ fn simple_delete_row_no_style() {
     let mut model = UserModel::from_model(model);
     model.set_user_input(0, 15, 4, "3").unwrap();
     model.set_user_input(0, 15, 6, "=D15*2").unwrap();
-    model.delete_rows(0, 15, 1).unwrap();
+    model.delete_row(0, 15).unwrap();
 
     assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
 }
@@ -180,14 +180,14 @@ fn insert_row_evaluates() {
     model.set_user_input(0, 1, 1, "42").unwrap();
     model.set_user_input(0, 1, 2, "=A1*2").unwrap();
 
-    assert!(model.insert_rows(0, 1, 1).is_ok());
+    assert!(model.insert_row(0, 1).is_ok());
     assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
     model.undo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
     model.redo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
 
-    model.delete_rows(0, 1, 1).unwrap();
+    model.delete_row(0, 1).unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
     assert_eq!(model.get_cell_content(0, 1, 2).unwrap(), "=A1*2");
 }
@@ -199,7 +199,7 @@ fn insert_column_evaluates() {
     model.set_user_input(0, 1, 1, "42").unwrap();
     model.set_user_input(0, 10, 1, "=A1*2").unwrap();
 
-    assert!(model.insert_columns(0, 1, 1).is_ok());
+    assert!(model.insert_column(0, 1).is_ok());
     assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
 
     model.undo().unwrap();
@@ -207,7 +207,7 @@ fn insert_column_evaluates() {
     model.redo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
 
-    model.delete_columns(0, 1, 1).unwrap();
+    model.delete_column(0, 1).unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "84");
     assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1*2");
 }

base/src/test/user_model/test_view.rs

@@ -55,7 +55,7 @@ fn set_the_range_does_not_set_the_cell() {
     assert_eq!(
         model.set_selected_range(5, 4, 10, 6),
         Err(
-            "The selected cell is not in one of the corners. Row: '1' and row range '(5, 10)'"
+            "The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
                 .to_string()
         )
     );

base/src/types.rs

@@ -51,8 +51,6 @@ pub struct Workbook {
     pub metadata: Metadata,
     pub tables: HashMap<String, Table>,
     pub views: HashMap<u32, WorkbookView>,
-    /// The list of cells that spill in the order of evaluation
-    pub spill_cells: Vec<(u32, i32, i32)>,
 }
 
 /// A defined name. The `sheet_id` is the sheet index in case the name is local
@@ -161,17 +159,17 @@ pub enum CellType {
     CompoundData = 128,
 }
 
-/// Cell types
-/// s is always the style index of the cell
 #[derive(Encode, Decode, Debug, Clone, PartialEq)]
 pub enum Cell {
     EmptyCell {
         s: i32,
     },
+
     BooleanCell {
         v: bool,
         s: i32,
     },
+
     NumberCell {
         v: f64,
         s: i32,
@@ -183,7 +181,6 @@ pub enum Cell {
     },
     // Always a shared string
     SharedString {
-        // string index
         si: i32,
         s: i32,
     },
@@ -192,11 +189,13 @@ pub enum Cell {
         f: i32,
         s: i32,
     },
+
     CellFormulaBoolean {
         f: i32,
         v: bool,
         s: i32,
     },
+
     CellFormulaNumber {
         f: i32,
         v: f64,
@@ -208,9 +207,9 @@ pub enum Cell {
         v: String,
         s: i32,
     },
+
     CellFormulaError {
         f: i32,
-        // error index
         ei: Error,
         s: i32,
         // Origin: Sheet3!C4
@@ -218,81 +217,7 @@ pub enum Cell {
         // Error Message: "Not implemented function"
         m: String,
     },
-    // All Spill/dynamic cells have a boolean, a for array, if true it is an array formula
-    // Spill cells point to a mother cell (row, column)
-    SpillNumberCell {
-        v: f64,
-        s: i32,
-        // mother cell (row, column)
-        m: (i32, i32),
-    },
-    SpillBooleanCell {
-        v: bool,
-        s: i32,
-        // mother cell (row, column)
-        m: (i32, i32),
-    },
-    SpillErrorCell {
-        ei: Error,
-        s: i32,
-        // mother cell (row, column)
-        m: (i32, i32),
-    },
-    SpillStringCell {
-        v: String,
-        s: i32,
-        // mother cell (row, column)
-        m: (i32, i32),
-    },
-    // Dynamic cell formulas have a range (width, height)
-    DynamicCellFormula {
-        f: i32,
-        s: i32,
-        // range of the formula (width, height)
-        r: (i32, i32),
-        // true if the formula is a CSE formula
-        a: bool,
-    },
-    DynamicCellFormulaBoolean {
-        f: i32,
-        v: bool,
-        s: i32,
-        // range of the formula (width, height)
-        r: (i32, i32),
-        // true if the formula is a CSE formula
-        a: bool,
-    },
-    DynamicCellFormulaNumber {
-        f: i32,
-        v: f64,
-        s: i32,
-        // range of the formula (width, height)
-        r: (i32, i32),
-        // true if the formula is a CSE formula
-        a: bool,
-    },
-    DynamicCellFormulaString {
-        f: i32,
-        v: String,
-        s: i32,
-        // range of the formula (width, height)
-        r: (i32, i32),
-        // true if the formula is a CSE formula
-        a: bool,
-    },
-    DynamicCellFormulaError {
-        f: i32,
-        ei: Error,
-        s: i32,
-        // Cell origin of the error
-        o: String,
-        // Error message in text
-        m: String,
-        // range of the formula (width, height)
-        r: (i32, i32),
-        // true if the formula is a CSE formula
-        a: bool,
-    },
+    // TODO: Array formulas
 }
 
 impl Default for Cell {

base/src/user_model/common.rs

@@ -13,8 +13,8 @@ use crate::{
     },
     model::Model,
     types::{
-        Alignment, BorderItem, Cell, CellType, Col, HorizontalAlignment, SheetProperties,
-        SheetState, Style, VerticalAlignment,
+        Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, SheetState,
+        Style, VerticalAlignment,
     },
     utils::is_valid_hex_color,
 };
@@ -24,18 +24,6 @@ use crate::user_model::history::{
 };
 
 use super::border_utils::is_max_border;
-
-#[derive(Serialize, Deserialize)]
-pub enum CellArrayStructure {
-    // It s just a single cell
-    SingleCell,
-    // It is part o a dynamic array
-    // (mother_row, mother_column, width, height)
-    DynamicChild(i32, i32, i32, i32),
-    // Mother of a dynamic array (width, height)
-    DynamicMother(i32, i32),
-}
-
 /// Data for the clipboard
 pub type ClipboardData = HashMap<i32, HashMap<i32, ClipboardCell>>;
 
@@ -639,7 +627,6 @@ impl UserModel {
             }
         }
         self.push_diff_list(diff_list);
-        self.evaluate_if_not_paused();
         Ok(())
     }
 
@@ -669,16 +656,11 @@ impl UserModel {
             }
         }
         self.push_diff_list(diff_list);
-        self.evaluate_if_not_paused();
         Ok(())
     }
 
-    fn clear_column_formatting(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        diff_list: &mut Vec<Diff>,
-    ) -> Result<(), String> {
+    fn clear_column_formatting(&mut self, sheet: u32, column: i32) -> Result<(), String> {
+        let mut diff_list = Vec::new();
         let old_value = self.model.get_column_style(sheet, column)?;
         self.model.delete_column_style(sheet, column)?;
         diff_list.push(Diff::DeleteColumnStyle {
@@ -757,15 +739,12 @@ impl UserModel {
                 }
             }
         }
+        self.push_diff_list(diff_list);
         Ok(())
     }
 
-    fn clear_row_formatting(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        diff_list: &mut Vec<Diff>,
-    ) -> Result<(), String> {
+    fn clear_row_formatting(&mut self, sheet: u32, row: i32) -> Result<(), String> {
+        let mut diff_list = Vec::new();
         let old_value = self.model.get_row_style(sheet, row)?;
         self.model.delete_row_style(sheet, row)?;
         diff_list.push(Diff::DeleteRowStyle {
@@ -812,6 +791,8 @@ impl UserModel {
                 }
             }
         }
+        self.push_diff_list(diff_list);
+
         Ok(())
     }
 
@@ -822,21 +803,19 @@ impl UserModel {
     /// * [UserModel::range_clear_contents]
     pub fn range_clear_formatting(&mut self, range: &Area) -> Result<(), String> {
         let sheet = range.sheet;
-        let mut diff_list = Vec::new();
         if range.row == 1 && range.height == LAST_ROW {
             for column in range.column..range.column + range.width {
-                self.clear_column_formatting(sheet, column, &mut diff_list)?;
+                self.clear_column_formatting(sheet, column)?;
             }
-            self.push_diff_list(diff_list);
             return Ok(());
         }
         if range.column == 1 && range.width == LAST_COLUMN {
             for row in range.row..range.row + range.height {
-                self.clear_row_formatting(sheet, row, &mut diff_list)?;
+                self.clear_row_formatting(sheet, row)?;
             }
-            self.push_diff_list(diff_list);
             return Ok(());
         }
+        let mut diff_list = Vec::new();
         for row in range.row..range.row + range.height {
             for column in range.column..range.column + range.width {
                 if let Some(old_style) = self.model.get_cell_style_or_none(sheet, row, column)? {
@@ -872,184 +851,105 @@ impl UserModel {
         Ok(())
     }
 
-    /// Inserts `row_count` blank rows starting at `row` (both 0-based).
+    /// Inserts a row
     ///
-    /// Parameters
-    /// * `sheet` – worksheet index.
-    /// * `row` – first row to insert.
-    /// * `row_count` – number of rows (> 0).
-    ///
-    /// History: the method pushes `row_count` [`crate::user_model::history::Diff::InsertRow`]
-    /// items **all using the same `row` index**.  Replaying those diffs (undo / redo)
-    /// is therefore immune to the row-shifts that happen after each individual
-    /// insertion.
-    ///
-    /// See also [`Model::insert_rows`].
-    pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), String> {
-        self.model.insert_rows(sheet, row, row_count)?;
-
-        let diff_list = vec![Diff::InsertRows {
-            sheet,
-            row,
-            count: row_count,
-        }];
+    /// See also:
+    /// * [Model::insert_rows]
+    pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<(), String> {
+        let diff_list = vec![Diff::InsertRow { sheet, row }];
         self.push_diff_list(diff_list);
+        self.model.insert_rows(sheet, row, 1)?;
         self.evaluate_if_not_paused();
         Ok(())
     }
 
-    /// Inserts `column_count` blank columns starting at `column` (0-based).
+    /// Deletes a row
     ///
-    /// Parameters
-    /// * `sheet` – worksheet index.
-    /// * `column` – first column to insert.
-    /// * `column_count` – number of columns (> 0).
-    ///
-    /// History: pushes one [`crate::user_model::history::Diff::InsertColumn`]
-    /// per inserted column, all with the same `column` value, preventing index
-    /// drift when the diffs are reapplied.
-    ///
-    /// See also [`Model::insert_columns`].
-    pub fn insert_columns(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        column_count: i32,
-    ) -> Result<(), String> {
-        self.model.insert_columns(sheet, column, column_count)?;
-
-        let diff_list = vec![Diff::InsertColumns {
-            sheet,
-            column,
-            count: column_count,
-        }];
-        self.push_diff_list(diff_list);
-        self.evaluate_if_not_paused();
-        Ok(())
-    }
-
-    /// Deletes `row_count` rows starting at `row`.
-    ///
-    /// History: a [`crate::user_model::history::Diff::DeleteRow`] is created for
-    /// each row, ordered **bottom → top**.  Undo therefore recreates rows from
-    /// top → bottom and redo removes them bottom → top, avoiding index drift.
-    ///
-    /// See also [`Model::delete_rows`].
-    pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), String> {
+    /// See also:
+    /// * [Model::delete_rows]
+    pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<(), String> {
+        let mut row_data = None;
         let worksheet = self.model.workbook.worksheet(sheet)?;
-        let mut old_data = Vec::new();
-        // Collect data for all rows to be deleted
-        for r in row..row + row_count {
-            let mut row_data = None;
-            for rd in &worksheet.rows {
-                if rd.r == r {
-                    row_data = Some(rd.clone());
-                    break;
-                }
+        for rd in &worksheet.rows {
+            if rd.r == row {
+                row_data = Some(rd.clone());
+                break;
             }
-            let data = match worksheet.sheet_data.get(&r) {
-                Some(s) => s.clone(),
-                None => HashMap::new(),
-            };
-            old_data.push(RowData {
-                row: row_data,
-                data,
-            });
         }
-
-        self.model.delete_rows(sheet, row, row_count)?;
-
-        let diff_list = vec![Diff::DeleteRows {
+        let data = match worksheet.sheet_data.get(&row) {
+            Some(s) => s.clone(),
+            None => return Err(format!("Row number '{row}' is not valid.")),
+        };
+        let old_data = Box::new(RowData {
+            row: row_data,
+            data,
+        });
+        let diff_list = vec![Diff::DeleteRow {
             sheet,
             row,
-            count: row_count,
             old_data,
         }];
         self.push_diff_list(diff_list);
+        self.model.delete_rows(sheet, row, 1)?;
         self.evaluate_if_not_paused();
         Ok(())
     }
 
-    /// Deletes `column_count` columns starting at `column`.
+    /// Inserts a column
     ///
-    /// History: pushes one [`crate::user_model::history::Diff::DeleteColumn`]
-    /// per column, **right → left**, so replaying the list is always safe with
-    /// respect to index shifts.
+    /// See also:
+    /// * [Model::insert_columns]
+    pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<(), String> {
+        let diff_list = vec![Diff::InsertColumn { sheet, column }];
+        self.push_diff_list(diff_list);
+        self.model.insert_columns(sheet, column, 1)?;
+        self.evaluate_if_not_paused();
+        Ok(())
+    }
+
+    /// Deletes a column
     ///
-    /// See also [`Model::delete_columns`].
-    pub fn delete_columns(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        column_count: i32,
-    ) -> Result<(), String> {
+    /// See also:
+    /// * [Model::delete_columns]
+    pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<(), String> {
         let worksheet = self.model.workbook.worksheet(sheet)?;
-        let mut old_data = Vec::new();
-        // Collect data for all columns to be deleted
-        for c in column..column + column_count {
-            let mut column_data = None;
-            for col in &worksheet.cols {
-                if c >= col.min && c <= col.max {
-                    column_data = Some(Col {
-                        min: c,
-                        max: c,
-                        width: col.width,
-                        custom_width: col.custom_width,
-                        style: col.style,
-                    });
-                    break;
-                }
-            }
+        if !is_valid_column_number(column) {
+            return Err(format!("Column number '{column}' is not valid."));
+        }
 
-            let mut data = HashMap::new();
-            for (row_idx, row_data) in &worksheet.sheet_data {
-                if let Some(cell) = row_data.get(&c) {
-                    data.insert(*row_idx, cell.clone());
-                }
+        let mut column_data = None;
+        for col in &worksheet.cols {
+            let min = col.min;
+            let max = col.max;
+            if column >= min && column <= max {
+                column_data = Some(Col {
+                    min: column,
+                    max: column,
+                    width: col.width,
+                    custom_width: col.custom_width,
+                    style: col.style,
+                });
+                break;
             }
+        }
 
-            old_data.push(ColumnData {
+        let mut data = HashMap::new();
+        for (row, row_data) in &worksheet.sheet_data {
+            if let Some(cell) = row_data.get(&column) {
+                data.insert(*row, cell.clone());
+            }
+        }
+
+        let diff_list = vec![Diff::DeleteColumn {
+            sheet,
+            column,
+            old_data: Box::new(ColumnData {
                 column: column_data,
                 data,
-            });
-        }
-
-        self.model.delete_columns(sheet, column, column_count)?;
-
-        let diff_list = vec![Diff::DeleteColumns {
-            sheet,
-            column,
-            count: column_count,
-            old_data,
+            }),
         }];
         self.push_diff_list(diff_list);
-        self.evaluate_if_not_paused();
-        Ok(())
-    }
-
-    /// Moves a column horizontally and adjusts formulas
-    pub fn move_column_action(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        delta: i32,
-    ) -> Result<(), String> {
-        let diff_list = vec![Diff::MoveColumn {
-            sheet,
-            column,
-            delta,
-        }];
-        self.push_diff_list(diff_list);
-        self.model.move_column_action(sheet, column, delta)?;
-        self.evaluate_if_not_paused();
-        Ok(())
-    }
-
-    /// Moves a row vertically and adjusts formulas
-    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
-        let diff_list = vec![Diff::MoveRow { sheet, row, delta }];
-        self.push_diff_list(diff_list);
-        self.model.move_row_action(sheet, row, delta)?;
+        self.model.delete_columns(sheet, column, 1)?;
         self.evaluate_if_not_paused();
         Ok(())
     }
@@ -1695,125 +1595,6 @@ impl UserModel {
         Ok(self.model.workbook.worksheet(sheet)?.show_grid_lines)
     }
 
-    /// Returns the largest column in the row less than a column whose cell has a non empty value.
-    /// If there are none it returns `None`.
-    /// This is useful when rendering a part of a worksheet to know which cells spill over
-    pub fn get_last_non_empty_in_row_before_column(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<i32>, String> {
-        let worksheet = self.model.workbook.worksheet(sheet)?;
-        let data = worksheet.sheet_data.get(&row);
-        if let Some(row_data) = data {
-            let mut last_column = None;
-            let mut columns: Vec<i32> = row_data.keys().copied().collect();
-            columns.sort_unstable();
-            for col in columns {
-                if col < column {
-                    if let Some(cell) = worksheet.cell(row, col) {
-                        if matches!(cell, Cell::EmptyCell { .. }) {
-                            continue;
-                        }
-                    }
-                    last_column = Some(col);
-                }
-            }
-            Ok(last_column)
-        } else {
-            Ok(None)
-        }
-    }
-
-    /// Returns the smallest column in the row larger than "column" whose cell has a non empty value.
-    /// If there are none it returns `None`.
-    /// This is useful when rendering a part of a worksheet to know which cells spill over
-    pub fn get_first_non_empty_in_row_after_column(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<i32>, String> {
-        let worksheet = self.model.workbook.worksheet(sheet)?;
-        let data = worksheet.sheet_data.get(&row);
-        if let Some(row_data) = data {
-            let mut columns: Vec<i32> = row_data.keys().copied().collect();
-            // We sort the keys to ensure we are going from left to right
-            columns.sort_unstable();
-            for col in columns {
-                if col > column {
-                    if let Some(cell) = worksheet.cell(row, col) {
-                        if matches!(cell, Cell::EmptyCell { .. }) {
-                            continue;
-                        }
-                    }
-                    return Ok(Some(col));
-                }
-            }
-        }
-        Ok(None)
-    }
-
-    /// Returns the geometric structure of a cell
-    pub fn get_cell_array_structure(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<CellArrayStructure, String> {
-        let cell = self
-            .model
-            .workbook
-            .worksheet(sheet)?
-            .cell(row, column)
-            .cloned()
-            .unwrap_or_default();
-        match cell {
-            Cell::EmptyCell { .. }
-            | Cell::BooleanCell { .. }
-            | Cell::NumberCell { .. }
-            | Cell::ErrorCell { .. }
-            | Cell::SharedString { .. }
-            | Cell::CellFormula { .. }
-            | Cell::CellFormulaBoolean { .. }
-            | Cell::CellFormulaNumber { .. }
-            | Cell::CellFormulaString { .. }
-            | Cell::CellFormulaError { .. } => Ok(CellArrayStructure::SingleCell),
-            Cell::SpillNumberCell { m, .. }
-            | Cell::SpillBooleanCell { m, .. }
-            | Cell::SpillErrorCell { m, .. }
-            | Cell::SpillStringCell { m, .. } => {
-                let (m_row, m_column) = m;
-                let m_cell = self
-                    .model
-                    .workbook
-                    .worksheet(sheet)?
-                    .cell(m_row, m_column)
-                    .cloned()
-                    .unwrap_or_default();
-                let (width, height) = match m_cell {
-                    Cell::DynamicCellFormula { r, .. }
-                    | Cell::DynamicCellFormulaBoolean { r, .. }
-                    | Cell::DynamicCellFormulaNumber { r, .. }
-                    | Cell::DynamicCellFormulaString { r, .. }
-                    | Cell::DynamicCellFormulaError { r, .. } => (r.0, r.1),
-                    _ => return Err("Invalid structure".to_string()),
-                };
-                Ok(CellArrayStructure::DynamicChild(
-                    m_row, m_column, width, height,
-                ))
-            }
-            Cell::DynamicCellFormula { r, .. }
-            | Cell::DynamicCellFormulaBoolean { r, .. }
-            | Cell::DynamicCellFormulaNumber { r, .. }
-            | Cell::DynamicCellFormulaString { r, .. }
-            | Cell::DynamicCellFormulaError { r, .. } => {
-                Ok(CellArrayStructure::DynamicMother(r.0, r.1))
-            }
-        }
-    }
-
     /// Returns a copy of the selected area
     pub fn copy_to_clipboard(&self) -> Result<Clipboard, String> {
         let selected_area = self.get_selected_view();
@@ -1853,7 +1634,7 @@ impl UserModel {
         .map_err(|e| format!("Error converting from utf8: '{e}'"))?;
 
         Ok(Clipboard {
-            csv: csv.trim().to_string(),
+            csv,
             data,
             sheet,
             range: (row_start, column_start, row_end, column_end),
@@ -2021,7 +1802,7 @@ impl UserModel {
         }
         self.push_diff_list(diff_list);
         // select the pasted area
-        self.set_selected_range(area.row, area.column, row - 1, column - 1)?;
+        self.set_selected_range(area.row, area.column, row, column)?;
         self.evaluate_if_not_paused();
         Ok(())
     }
@@ -2116,24 +1897,6 @@ impl UserModel {
                     old_value,
                 } => {
                     needs_evaluation = true;
-                    let cell = self
-                        .model
-                        .workbook
-                        .worksheet(*sheet)?
-                        .cell(*row, *column)
-                        .cloned()
-                        .unwrap_or_default();
-                    if let Some((width, height)) = cell.get_dynamic_range() {
-                        for r in *row..*row + height {
-                            for c in *column..*column + width {
-                                // skip the "mother" cell
-                                if r == *row && c == *column {
-                                    continue;
-                                }
-                                self.model.cell_clear_contents(*sheet, r, c)?;
-                            }
-                        }
-                    }
                     match *old_value.clone() {
                         Some(value) => {
                             self.model
@@ -2204,56 +1967,45 @@ impl UserModel {
                         self.model.cell_clear_all(*sheet, *row, *column)?;
                     }
                 }
-                Diff::InsertRows { sheet, row, count } => {
-                    self.model.delete_rows(*sheet, *row, *count)?;
+                Diff::InsertRow { sheet, row } => {
+                    self.model.delete_rows(*sheet, *row, 1)?;
                     needs_evaluation = true;
                 }
-                Diff::DeleteRows {
+                Diff::DeleteRow {
                     sheet,
                     row,
-                    count: _,
                     old_data,
                 } => {
                     needs_evaluation = true;
-                    self.model
-                        .insert_rows(*sheet, *row, old_data.len() as i32)?;
+                    self.model.insert_rows(*sheet, *row, 1)?;
                     let worksheet = self.model.workbook.worksheet_mut(*sheet)?;
-                    for (i, row_data) in old_data.iter().enumerate() {
-                        let r = *row + i as i32;
-                        if let Some(row_style) = row_data.row.clone() {
-                            worksheet.rows.push(row_style);
-                        }
-                        worksheet.sheet_data.insert(r, row_data.data.clone());
+                    if let Some(row_data) = old_data.row.clone() {
+                        worksheet.rows.push(row_data);
                     }
+                    worksheet.sheet_data.insert(*row, old_data.data.clone());
                 }
-                Diff::InsertColumns {
-                    sheet,
-                    column,
-                    count,
-                } => {
-                    self.model.delete_columns(*sheet, *column, *count)?;
+                Diff::InsertColumn { sheet, column } => {
+                    self.model.delete_columns(*sheet, *column, 1)?;
                     needs_evaluation = true;
                 }
-                Diff::DeleteColumns {
+                Diff::DeleteColumn {
                     sheet,
                     column,
-                    count: _,
                     old_data,
                 } => {
                     needs_evaluation = true;
-                    self.model
-                        .insert_columns(*sheet, *column, old_data.len() as i32)?;
+                    // inserts an empty column
+                    self.model.insert_columns(*sheet, *column, 1)?;
+                    // puts all the data back
                     let worksheet = self.model.workbook.worksheet_mut(*sheet)?;
-                    for (i, col_data) in old_data.iter().enumerate() {
-                        let c = *column + i as i32;
-                        for (row, cell) in &col_data.data {
-                            worksheet.update_cell(*row, c, cell.clone())?;
-                        }
-                        if let Some(col) = &col_data.column {
-                            let width = col.width * constants::COLUMN_WIDTH_FACTOR;
-                            let style = col.style;
-                            worksheet.set_column_width_and_style(c, width, style)?;
-                        }
+                    for (row, cell) in &old_data.data {
+                        worksheet.update_cell(*row, *column, cell.clone())?;
+                    }
+                    // makes sure that the width and style is correct
+                    if let Some(col) = &old_data.column {
+                        let width = col.width * constants::COLUMN_WIDTH_FACTOR;
+                        let style = col.style;
+                        worksheet.set_column_width_and_style(*column, width, style)?;
                     }
                 }
                 Diff::SetFrozenRowsCount {
@@ -2411,21 +2163,6 @@ impl UserModel {
                         self.model.delete_row_style(*sheet, *row)?;
                     }
                 }
-                Diff::MoveColumn {
-                    sheet,
-                    column,
-                    delta,
-                } => {
-                    // For undo, we apply the opposite move
-                    self.model
-                        .move_column_action(*sheet, *column + *delta, -*delta)?;
-                    needs_evaluation = true;
-                }
-                Diff::MoveRow { sheet, row, delta } => {
-                    // For undo, we apply the opposite move
-                    self.model.move_row_action(*sheet, *row + *delta, -*delta)?;
-                    needs_evaluation = true;
-                }
             }
         }
         if needs_evaluation {
@@ -2494,34 +2231,28 @@ impl UserModel {
                 } => self
                     .model
                     .set_cell_style(*sheet, *row, *column, new_value)?,
-                Diff::InsertRows { sheet, row, count } => {
-                    self.model.insert_rows(*sheet, *row, *count)?;
+                Diff::InsertRow { sheet, row } => {
+                    self.model.insert_rows(*sheet, *row, 1)?;
                     needs_evaluation = true;
                 }
-                Diff::DeleteRows {
+                Diff::DeleteRow {
                     sheet,
                     row,
-                    count,
                     old_data: _,
                 } => {
-                    self.model.delete_rows(*sheet, *row, *count)?;
+                    self.model.delete_rows(*sheet, *row, 1)?;
                     needs_evaluation = true;
                 }
-                Diff::InsertColumns {
-                    sheet,
-                    column,
-                    count,
-                } => {
-                    self.model.insert_columns(*sheet, *column, *count)?;
+                Diff::InsertColumn { sheet, column } => {
                     needs_evaluation = true;
+                    self.model.insert_columns(*sheet, *column, 1)?;
                 }
-                Diff::DeleteColumns {
+                Diff::DeleteColumn {
                     sheet,
                     column,
-                    count,
                     old_data: _,
                 } => {
-                    self.model.delete_columns(*sheet, *column, *count)?;
+                    self.model.delete_columns(*sheet, *column, 1)?;
                     needs_evaluation = true;
                 }
                 Diff::SetFrozenRowsCount {
@@ -2633,18 +2364,6 @@ impl UserModel {
                 } => {
                     self.model.delete_row_style(*sheet, *row)?;
                 }
-                Diff::MoveColumn {
-                    sheet,
-                    column,
-                    delta,
-                } => {
-                    self.model.move_column_action(*sheet, *column, *delta)?;
-                    needs_evaluation = true;
-                }
-                Diff::MoveRow { sheet, row, delta } => {
-                    self.model.move_row_action(*sheet, *row, *delta)?;
-                    needs_evaluation = true;
-                }
             }
         }
 

base/src/user_model/history.rs

@@ -5,21 +5,18 @@ use bitcode::{Decode, Encode};
 use crate::types::{Cell, Col, Row, SheetState, Style, Worksheet};
 
 #[derive(Clone, Encode, Decode)]
-#[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct RowData {
     pub(crate) row: Option<Row>,
     pub(crate) data: HashMap<i32, Cell>,
 }
 
 #[derive(Clone, Encode, Decode)]
-#[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct ColumnData {
     pub(crate) column: Option<Col>,
     pub(crate) data: HashMap<i32, Cell>,
 }
 
 #[derive(Clone, Encode, Decode)]
-#[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) enum Diff {
     // Cell diffs
     SetCellValue {
@@ -90,27 +87,23 @@ pub(crate) enum Diff {
         row: i32,
         old_value: Box<Option<Style>>,
     },
-    InsertRows {
+    InsertRow {
         sheet: u32,
         row: i32,
-        count: i32,
     },
-    DeleteRows {
+    DeleteRow {
         sheet: u32,
         row: i32,
-        count: i32,
-        old_data: Vec<RowData>,
+        old_data: Box<RowData>,
     },
-    InsertColumns {
+    InsertColumn {
         sheet: u32,
         column: i32,
-        count: i32,
     },
-    DeleteColumns {
+    DeleteColumn {
         sheet: u32,
         column: i32,
-        count: i32,
-        old_data: Vec<ColumnData>,
+        old_data: Box<ColumnData>,
     },
     DeleteSheet {
         sheet: u32,
@@ -168,16 +161,6 @@ pub(crate) enum Diff {
         new_scope: Option<u32>,
         new_formula: String,
     },
-    MoveColumn {
-        sheet: u32,
-        column: i32,
-        delta: i32,
-    },
-    MoveRow {
-        sheet: u32,
-        row: i32,
-        delta: i32,
-    },
     // FIXME: we are missing SetViewDiffs
 }
 

base/src/user_model/mod.rs

@@ -3,7 +3,7 @@
 mod border;
 mod border_utils;
 mod common;
-pub(crate) mod history;
+mod history;
 mod ui;
 
 pub use common::UserModel;

base/src/user_model/ui.rs

@@ -2,11 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 
-use crate::{
-    constants::{LAST_COLUMN, LAST_ROW},
-    expressions::utils::{is_valid_column_number, is_valid_row},
-    worksheet::NavigationDirection,
-};
+use crate::expressions::utils::{is_valid_column_number, is_valid_row};
 
 use super::common::UserModel;
 
@@ -114,7 +110,7 @@ impl UserModel {
         Ok(())
     }
 
-    /// Sets the selected range. Note that the selected cell must be in the selected range.
+    /// Sets the selected range. Note that the selected cell must be in one of the corners.
     pub fn set_selected_range(
         &mut self,
         start_row: i32,
@@ -148,32 +144,16 @@ impl UserModel {
             if let Some(view) = worksheet.views.get_mut(&0) {
                 let selected_row = view.row;
                 let selected_column = view.column;
-                if start_row == 1 && end_row == LAST_ROW {
-                    // full row selected. The cell must be at the top or the bottom of the range
-                    if selected_column != start_column && selected_column != end_column {
-                        return Err(format!(
-                            "The selected cell is not the column edge. Column '{selected_column}' and column range '({start_column}, {end_column})'"
-                        ));
-                    }
-                } else if start_column == 1 && end_column == LAST_COLUMN {
-                    // full column selected. The cell must be at the left or the right of the range
-                    if selected_row != start_row && selected_row != end_row {
-                        return Err(format!(
-                            "The selected cell is not in the row edge. Row: '{selected_row}' and row range '({start_row}, {end_row})'"
-                        ));
-                    }
-                } else {
-                    // The selected cell must be on one of the corners of the selected range:
-                    if selected_row != start_row && selected_row != end_row {
-                        return Err(format!(
-                        "The selected cell is not in one of the corners. Row: '{selected_row}' and row range '({start_row}, {end_row})'"
+                // The selected cells must be on one of the corners of the selected range:
+                if selected_row != start_row && selected_row != end_row {
+                    return Err(format!(
+                        "The selected cells is not in one of the corners. Row: '{selected_row}' and row range '({start_row}, {end_row})'"
                     ));
-                    }
-                    if selected_column != start_column && selected_column != end_column {
-                        return Err(format!(
-                        "The selected cell is not in one of the corners. Column '{selected_column}' and column range '({start_column}, {end_column})'"
+                }
+                if selected_column != start_column && selected_column != end_column {
+                    return Err(format!(
+                        "The selected cells is not in one of the corners. Column '{selected_column}' and column range '({start_column}, {end_column})'"
                     ));
-                    }
                 }
                 view.range = [start_row, start_column, end_row, end_column];
             }
@@ -210,17 +190,6 @@ impl UserModel {
                 return Ok(());
             };
         let [row_start, column_start, row_end, column_end] = range;
-        if ["ArrowUp", "ArrowDown"].contains(&key) && row_start == 1 && row_end == LAST_ROW {
-            // full column selected, nothing to do
-            return Ok(());
-        }
-        if ["ArrowRight", "ArrowLeft"].contains(&key)
-            && column_start == 1
-            && column_end == LAST_COLUMN
-        {
-            // full row selected, nothing to do
-            return Ok(());
-        }
 
         match key {
             "ArrowRight" => {
@@ -503,7 +472,7 @@ impl UserModel {
         // if the row is not fully visible we 'scroll' down until it is
         let mut height = 0.0;
         let mut row = view.top_row;
-        while row <= new_row + 1 && row <= LAST_ROW {
+        while row <= new_row + 1 {
             height += self.model.get_row_height(sheet, row)?;
             row += 1;
         }
@@ -713,94 +682,4 @@ impl UserModel {
 
         Ok(())
     }
-
-    /// User navigates to the edge in the given direction
-    pub fn on_navigate_to_edge_in_direction(
-        &mut self,
-        direction: NavigationDirection,
-    ) -> Result<(), String> {
-        let (sheet, window_height, window_width) =
-            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
-                (view.sheet, view.window_height, view.window_width)
-            } else {
-                return Err("View not found".to_string());
-            };
-        let worksheet = match self.model.workbook.worksheet(sheet) {
-            Ok(s) => s,
-            Err(_) => return Err("Worksheet not found".to_string()),
-        };
-        let view = match worksheet.views.get(&self.model.view_id) {
-            Some(s) => s,
-            None => return Err("View not found".to_string()),
-        };
-        let row = view.row;
-        let column = view.column;
-        if !is_valid_row(row) || !is_valid_column_number(column) {
-            return Err("Invalid row or column".to_string());
-        }
-        let (new_row, new_column) =
-            worksheet.navigate_to_edge_in_direction(row, column, direction)?;
-        if !is_valid_row(new_row) || !is_valid_column_number(new_column) {
-            return Err("Invalid row or column after navigation".to_string());
-        }
-        if new_row == row && new_column == column {
-            return Ok(()); // No change in selection
-        }
-
-        let mut top_row = view.top_row;
-        let mut left_column = view.left_column;
-
-        match direction {
-            NavigationDirection::Left | NavigationDirection::Right => {
-                // If the new column is not fully visible we 'scroll' until it is
-                // We need to check two conditions:
-                // 1. new_column > view.left_column
-                // 2. right_column < new_column
-                if new_column < view.left_column {
-                    left_column = new_column;
-                } else {
-                    let mut c = new_column;
-                    let mut width = self.model.get_column_width(sheet, c)?;
-                    while c > 1 && width <= window_width as f64 {
-                        c -= 1;
-                        width += self.model.get_column_width(sheet, c)?;
-                    }
-                    if c > view.left_column {
-                        left_column = c;
-                    }
-                }
-            }
-            NavigationDirection::Up | NavigationDirection::Down => {
-                // If the new row is not fully visible we 'scroll' until it is
-                // We need to check two conditions:
-                // 1. new_row > view.top_row
-                // 2. bottom_row < new_row
-                if new_row < view.top_row {
-                    top_row = new_row;
-                } else {
-                    let mut r = new_row;
-                    let mut height = self.model.get_row_height(sheet, r)?;
-                    while r > 1 && height <= window_height as f64 {
-                        r -= 1;
-                        height += self.model.get_row_height(sheet, r)?;
-                    }
-                    if r > view.top_row {
-                        top_row = r;
-                    }
-                }
-            }
-        }
-
-        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
-            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
-                view.row = new_row;
-                view.column = new_column;
-                view.range = [new_row, new_column, new_row, new_column];
-
-                view.top_row = top_row;
-                view.left_column = left_column;
-            }
-        }
-        Ok(())
-    }
 }

bindings/nodejs/README.md

@@ -4,20 +4,15 @@
 Example usage:
 
 ```javascript
-import { Model } from '@ironcalc/nodejs';
+import { Model } from '@ironcalc/wasm';
  
 const model = new Model("Workbook1", "en", "UTC");
 
 model.setUserInput(0, 1, 1, "=1+1");
-
 const result1 = model.getFormattedCellValue(0, 1, 1);
-console.log('Cell value', result1); // "#ERROR"
 
-model.evaluate();
-
-const resultAfterEvaluate = model.getFormattedCellValue(0, 1, 1);
-console.log('Cell value', resultAfterEvaluate); // 2
+console.log('Cell value', result1);
 
 let result2 = model.getCellStyle(0, 1, 1);
 console.log('Cell style', result2);
-```
+```

bindings/nodejs/index.d.ts

@@ -59,10 +59,10 @@ export declare class UserModel {
   setSheetColor(sheet: number, color: string): void
   rangeClearAll(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
   rangeClearContents(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
-  insertRows(sheet: number, row: number, rowCount: number): void
-  insertColumns(sheet: number, column: number, columnCount: number): void
-  deleteRows(sheet: number, row: number, rowCount: number): void
-  deleteColumns(sheet: number, column: number, columnCount: number): void
+  insertRow(sheet: number, row: number): void
+  insertColumn(sheet: number, column: number): void
+  deleteRow(sheet: number, row: number): void
+  deleteColumn(sheet: number, column: number): void
   setRowHeight(sheet: number, row: number, height: number): void
   setColumnWidth(sheet: number, column: number, width: number): void
   getRowHeight(sheet: number, row: number): number

bindings/nodejs/src/model.rs

@@ -340,20 +340,4 @@ impl Model {
       .delete_defined_name(&name, scope)
       .map_err(|e| to_js_error(e.to_string()))
   }
-
-  #[napi(js_name = "moveColumn")]
-  pub fn move_column(&mut self, sheet: u32, column: i32, delta: i32) -> Result<()> {
-    self
-      .model
-      .move_column_action(sheet, column, delta)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "moveRow")]
-  pub fn move_row(&mut self, sheet: u32, row: i32, delta: i32) -> Result<()> {
-    self
-      .model
-      .move_row_action(sheet, row, delta)
-      .map_err(to_js_error)
-  }
 }

bindings/nodejs/src/user_model.rs

@@ -183,36 +183,24 @@ impl UserModel {
       .map_err(to_js_error)
   }
 
-  #[napi(js_name = "insertRows")]
-  pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<()> {
-    self
-      .model
-      .insert_rows(sheet, row, row_count)
-      .map_err(to_js_error)
+  #[napi(js_name = "insertRow")]
+  pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<()> {
+    self.model.insert_row(sheet, row).map_err(to_js_error)
   }
 
-  #[napi(js_name = "insertColumns")]
-  pub fn insert_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> Result<()> {
-    self
-      .model
-      .insert_columns(sheet, column, column_count)
-      .map_err(to_js_error)
+  #[napi(js_name = "insertColumn")]
+  pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<()> {
+    self.model.insert_column(sheet, column).map_err(to_js_error)
   }
 
-  #[napi(js_name = "deleteRows")]
-  pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<()> {
-    self
-      .model
-      .delete_rows(sheet, row, row_count)
-      .map_err(to_js_error)
+  #[napi(js_name = "deleteRow")]
+  pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<()> {
+    self.model.delete_row(sheet, row).map_err(to_js_error)
   }
 
-  #[napi(js_name = "deleteColumns")]
-  pub fn delete_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> Result<()> {
-    self
-      .model
-      .delete_columns(sheet, column, column_count)
-      .map_err(to_js_error)
+  #[napi(js_name = "deleteColumn")]
+  pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<()> {
+    self.model.delete_column(sheet, column).map_err(to_js_error)
   }
 
   #[napi(js_name = "setRowsHeight")]
@@ -663,20 +651,4 @@ impl UserModel {
       .delete_defined_name(&name, scope)
       .map_err(|e| to_js_error(e.to_string()))
   }
-
-  #[napi(js_name = "moveColumn")]
-  pub fn move_column(&mut self, sheet: u32, column: i32, delta: i32) -> Result<()> {
-    self
-      .model
-      .move_column_action(sheet, column, delta)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "moveRow")]
-  pub fn move_row(&mut self, sheet: u32, row: i32, delta: i32) -> Result<()> {
-    self
-      .model
-      .move_row_action(sheet, row, delta)
-      .map_err(to_js_error)
-  }
 }

bindings/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyroncalc"
-version = "0.5.7"
+version = "0.5.0"
 edition = "2021"
 
 
@@ -13,8 +13,7 @@ crate-type = ["cdylib"]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.5.0" }
-pyo3 = { version = "0.25", features = ["extension-module"] }
-bitcode = "0.6.3"
+pyo3 = { version = "0.23", features = ["extension-module"] }
 
 
 [features]

bindings/python/README.md

@@ -10,6 +10,9 @@ You can add cell values, retrieve them and most importantly you can evaluate spr
 pip install ironcalc
 ```
 
+
+
+
 ## Compile and test
 
 To compile this and test it:
@@ -25,18 +28,4 @@ examples $ python example.py
 
 From there if you use `python` you can `import ironcalc`. You can either create a new file, read it from a JSON string or import from Excel.
 
-Hopefully the API is straightforward.
-
-## Creating documentation
-
-We use sphinx
-
-```
-python -m venv venv
-source venv/bin/activate
-pip install maturin
-pip install sphinx
-maturin develop
-sphinx-build -M html docs html
-python -m http.server --directory html/html/
-```
+Hopefully the API is straightforward.

bindings/python/build_docs.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-python -m venv venv
-source venv/bin/activate
-pip install patchelf
-pip install maturin
-pip install sphinx
-maturin develop
-sphinx-build -M html docs html
-python -m http.server --directory html/html/

bindings/python/docs/api_reference.rst

@@ -1,6 +1,6 @@
 
-Raw API Reference
------------------
+API Reference
+-------------
 
 In general methods in IronCalc use a 0-index base for the the sheet index and 1-index base for the row and column indexes.
 
@@ -28,7 +28,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
 
 .. method:: get_cell_content(sheet: int, row: int, column: int) -> str
 
-      Returns the raw content of a cell. If the cell contains a formula,
+      Returns the raw content of a cell. If the cell contains a formula, 
       the returned string starts with ``"="``.
 
       :param sheet: The sheet index (0-based).
@@ -47,7 +47,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
 
 .. method:: get_formatted_cell_value(sheet: int, row: int, column: int) -> str
 
-      Returns the cell’s value as a formatted string, taking into
+      Returns the cell’s value as a formatted string, taking into 
       account any number/currency/date formatting.
 
       :param sheet: The sheet index (0-based).
@@ -167,7 +167,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
 
 .. method:: get_worksheets_properties() -> List[PySheetProperty]
 
-      Returns a list of :class:`PySheetProperty` describing each worksheet’s
+      Returns a list of :class:`PySheetProperty` describing each worksheet’s 
       name, visibility state, ID, and tab color.
 
       :rtype: list of PySheetProperty
@@ -204,7 +204,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
 
 .. method:: test_panic()
 
-      A test method that deliberately panics in Rust.
+      A test method that deliberately panics in Rust. 
       Used for testing panic handling at the method level.
 
       :raises WorkbookError: (wrapped Rust panic)

bindings/python/docs/index.rst

@@ -8,8 +8,7 @@ IronCalc
    installation
    usage_examples
    top_level_methods
-   raw_api_reference
-   user_api_reference
+   api_reference
    objects
 
 IronCalc is a spreadsheet engine that allows you to create, modify and save spreadsheets.

bindings/python/docs/top_level_methods.rst

@@ -1,13 +1,6 @@
 Top Level Methods
 -----------------
 
-This module provides a set of top-level methods for creating and loading IronCalc models.
-
 .. autofunction:: ironcalc.create
 .. autofunction:: ironcalc.load_from_xlsx
-.. autofunction:: ironcalc.load_from_icalc
-.. autofunction:: ironcalc.load_from_bytes
-.. autofunction:: ironcalc.create_user_model
-.. autofunction:: ironcalc.create_user_model_from_bytes
-.. autofunction:: ironcalc.create_user_model_from_xlsx
-.. autofunction:: ironcalc.create_user_model_from_icalc
+.. autofunction:: ironcalc.load_from_icalc

bindings/python/docs/user_api_reference.rst

@@ -1,41 +0,0 @@
-User API Reference
-------------------
-
-This is the "user api". Models here have history, they evaluate automatically with each change and have a "diff" history.
-
-
-.. method:: save_to_xlsx(file: str)
-
-    Saves the user model to file in the XLSX format.
-
-    ::param file: The file path to save the model to.
-
-.. method:: save_to_icalc(file: str)
-
-    Saves the user model to file in the internal binary ic format.
-
-    ::param file: The file path to save the model to.
-
-.. method:: apply_external_diffs(external_diffs: bytes)
-
-    Applies external diffs to the model. This is used to apply changes from other instances of the model.
-
-    ::param external_diffs: The external diffs to apply, as a byte array.
-
-.. method:: flush_send_queue() -> bytes
-
-    Flushes the send queue and returns the bytes to be sent to the client. This is used to send changes to the client.
-
-.. method:: set_user_input(sheet: int, row: int, column: int, value: str)
-
-    Sets an input in a cell, as would be done by a user typing into a spreadsheet cell.
-
-.. method:: get_formatted_cell_value(sheet: int, row: int, column: int) -> str
-
-    Returns the cell’s value as a formatted string, taking into account any number/currency/date formatting.
-
-.. method:: to_bytes() -> bytes
-
-    Returns the model as a byte array. This is useful for sending the model over a network or saving it to a file.
-
-

bindings/python/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ironcalc"
-version = "0.5.7"
+version = "0.5.0"
 description = "Create, edit and evaluate Excel spreadsheets"
 requires-python = ">=3.10"
 keywords = [

bindings/python/src/lib.rs

@@ -1,89 +1,19 @@
 use pyo3::exceptions::PyException;
 use pyo3::{create_exception, prelude::*, wrap_pyfunction};
 
-use types::{PyCellType, PySheetProperty, PyStyle};
-use xlsx::base::types::{Style, Workbook};
-use xlsx::base::{Model, UserModel};
+use types::{PySheetProperty, PyStyle};
+use xlsx::base::types::Style;
+use xlsx::base::Model;
 
 use xlsx::export::{save_to_icalc, save_to_xlsx};
 use xlsx::import;
 
 mod types;
 
+use crate::types::PyCellType;
+
 create_exception!(_ironcalc, WorkbookError, PyException);
 
-#[pyclass]
-pub struct PyUserModel {
-    /// The user model, which is a wrapper around the Model
-    pub model: UserModel,
-}
-
-#[pymethods]
-impl PyUserModel {
-    /// Saves the user model to an xlsx file
-    pub fn save_to_xlsx(&self, file: &str) -> PyResult<()> {
-        let model = self.model.get_model();
-        save_to_xlsx(model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
-    }
-
-    /// Saves the user model to file in the internal binary ic format
-    pub fn save_to_icalc(&self, file: &str) -> PyResult<()> {
-        let model = self.model.get_model();
-        save_to_icalc(model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
-    }
-
-    pub fn apply_external_diffs(&mut self, external_diffs: &[u8]) -> PyResult<()> {
-        self.model
-            .apply_external_diffs(external_diffs)
-            .map_err(|e| WorkbookError::new_err(e.to_string()))
-    }
-
-    pub fn flush_send_queue(&mut self) -> Vec<u8> {
-        self.model.flush_send_queue()
-    }
-
-    pub fn set_user_input(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-        value: &str,
-    ) -> PyResult<()> {
-        self.model
-            .set_user_input(sheet, row, column, value)
-            .map_err(|e| WorkbookError::new_err(e.to_string()))
-    }
-
-    pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
-        self.model
-            .get_formatted_cell_value(sheet, row, column)
-            .map_err(|e| WorkbookError::new_err(e.to_string()))
-    }
-
-    /// Gets the dimensions of a worksheet, returning the bounds of all non-empty cells.
-    /// Returns a tuple of (min_row, max_row, min_column, max_column).
-    /// For an empty sheet, returns (1, 1, 1, 1).
-    pub fn get_sheet_dimensions(&self, sheet: u32) -> PyResult<(i32, i32, i32, i32)> {
-        let model = self.model.get_model();
-        let worksheet = model
-            .workbook
-            .worksheet(sheet)
-            .map_err(|e| WorkbookError::new_err(e.to_string()))?;
-        let dimension = worksheet.dimension();
-        Ok((
-            dimension.min_row,
-            dimension.max_row,
-            dimension.min_column,
-            dimension.max_column,
-        ))
-    }
-
-    pub fn to_bytes(&self) -> PyResult<Vec<u8>> {
-        let bytes = self.model.to_bytes();
-        Ok(bytes)
-    }
-}
-
 /// This is a model implementing the 'raw' API
 #[pyclass]
 pub struct PyModel {
@@ -102,12 +32,6 @@ impl PyModel {
         save_to_icalc(&self.model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
     }
 
-    /// To bytes
-    pub fn to_bytes(&self) -> PyResult<Vec<u8>> {
-        let bytes = self.model.to_bytes();
-        Ok(bytes)
-    }
-
     /// Evaluates the workbook
     pub fn evaluate(&mut self) {
         self.model.evaluate()
@@ -301,24 +225,6 @@ impl PyModel {
             .map_err(|e| WorkbookError::new_err(e.to_string()))
     }
 
-    /// Gets the dimensions of a worksheet, returning the bounds of all non-empty cells.
-    /// Returns a tuple of (min_row, max_row, min_column, max_column).
-    /// For an empty sheet, returns (1, 1, 1, 1).
-    pub fn get_sheet_dimensions(&self, sheet: u32) -> PyResult<(i32, i32, i32, i32)> {
-        let worksheet = self
-            .model
-            .workbook
-            .worksheet(sheet)
-            .map_err(|e| WorkbookError::new_err(e.to_string()))?;
-        let dimension = worksheet.dimension();
-        Ok((
-            dimension.min_row,
-            dimension.max_row,
-            dimension.min_column,
-            dimension.max_column,
-        ))
-    }
-
     #[allow(clippy::panic)]
     pub fn test_panic(&self) -> PyResult<()> {
         panic!("This function panics for testing panic handling");
@@ -343,19 +249,7 @@ pub fn load_from_icalc(file_name: &str) -> PyResult<PyModel> {
     Ok(PyModel { model })
 }
 
-/// Loads a model from bytes
-/// This function expects the bytes to be in the internal binary ic format
-/// which is the same format used by the `save_to_icalc` function.
-#[pyfunction]
-pub fn load_from_bytes(bytes: &[u8]) -> PyResult<PyModel> {
-    let workbook: Workbook =
-        bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    let model =
-        Model::from_workbook(workbook).map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    Ok(PyModel { model })
-}
-
-/// Creates an empty model in the raw API
+/// Creates an empty model
 #[pyfunction]
 pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
     let model =
@@ -363,49 +257,6 @@ pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
     Ok(PyModel { model })
 }
 
-/// Creates a model with the user model API
-#[pyfunction]
-pub fn create_user_model(name: &str, locale: &str, tz: &str) -> PyResult<PyUserModel> {
-    let model = UserModel::new_empty(name, locale, tz)
-        .map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    Ok(PyUserModel { model })
-}
-
-/// Creates a user model from an Excel file
-#[pyfunction]
-pub fn create_user_model_from_xlsx(
-    file_path: &str,
-    locale: &str,
-    tz: &str,
-) -> PyResult<PyUserModel> {
-    let model = import::load_from_xlsx(file_path, locale, tz)
-        .map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    let model = UserModel::from_model(model);
-    Ok(PyUserModel { model })
-}
-
-/// Creates a user model from an icalc file
-#[pyfunction]
-pub fn create_user_model_from_icalc(file_name: &str) -> PyResult<PyUserModel> {
-    let model =
-        import::load_from_icalc(file_name).map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    let model = UserModel::from_model(model);
-    Ok(PyUserModel { model })
-}
-
-/// Creates a user model from bytes
-/// This function expects the bytes to be in the internal binary ic format
-/// which is the same format used by the `save_to_icalc` function.
-#[pyfunction]
-pub fn create_user_model_from_bytes(bytes: &[u8]) -> PyResult<PyUserModel> {
-    let workbook: Workbook =
-        bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    let model =
-        Model::from_workbook(workbook).map_err(|e| WorkbookError::new_err(e.to_string()))?;
-    let user_model = UserModel::from_model(model);
-    Ok(PyUserModel { model: user_model })
-}
-
 #[pyfunction]
 #[allow(clippy::panic)]
 pub fn test_panic() {
@@ -421,14 +272,7 @@ fn ironcalc(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(create, m)?)?;
     m.add_function(wrap_pyfunction!(load_from_xlsx, m)?)?;
     m.add_function(wrap_pyfunction!(load_from_icalc, m)?)?;
-    m.add_function(wrap_pyfunction!(load_from_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(test_panic, m)?)?;
 
-    // User model functions
-    m.add_function(wrap_pyfunction!(create_user_model, m)?)?;
-    m.add_function(wrap_pyfunction!(create_user_model_from_bytes, m)?)?;
-    m.add_function(wrap_pyfunction!(create_user_model_from_xlsx, m)?)?;
-    m.add_function(wrap_pyfunction!(create_user_model_from_icalc, m)?)?;
-
     Ok(())
 }

bindings/python/tests/test_create.py

@@ -6,52 +6,3 @@ def test_simple():
     model.evaluate()
 
     assert model.get_formatted_cell_value(0, 1, 1) == "3"
-
-    bytes = model.to_bytes()
-
-    model2 = ic.load_from_bytes(bytes)
-    assert model2.get_formatted_cell_value(0, 1, 1) == "3"
-
-
-def test_simple_user():
-    model = ic.create_user_model("model", "en", "UTC")
-    model.set_user_input(0, 1, 1, "=1+2")
-    model.set_user_input(0, 1, 2, "=A1+3")
-
-    assert model.get_formatted_cell_value(0, 1, 1) == "3"
-    assert model.get_formatted_cell_value(0, 1, 2) == "6"
-
-    diffs = model.flush_send_queue()
-
-    model2 = ic.create_user_model("model", "en", "UTC")
-    model2.apply_external_diffs(diffs)
-    assert model2.get_formatted_cell_value(0, 1, 1) == "3"
-    assert model2.get_formatted_cell_value(0, 1, 2) == "6"
-
-
-def test_sheet_dimensions():
-    # Test with empty sheet
-    model = ic.create("model", "en", "UTC")
-    min_row, max_row, min_col, max_col = model.get_sheet_dimensions(0)
-    assert (min_row, max_row, min_col, max_col) == (1, 1, 1, 1)
-    
-    # Add some cells
-    model.set_user_input(0, 3, 5, "Hello")
-    model.set_user_input(0, 10, 8, "World")
-    model.evaluate()
-    
-    # Check dimensions - should span from (3,5) to (10,8)
-    min_row, max_row, min_col, max_col = model.get_sheet_dimensions(0)
-    assert (min_row, max_row, min_col, max_col) == (3, 10, 5, 8)
-
-
-def test_sheet_dimensions_user_model():
-    # Test with user model API as well
-    model = ic.create_user_model("model", "en", "UTC")
-    
-    # Add a single cell
-    model.set_user_input(0, 2, 3, "Test")
-    
-    # Check dimensions
-    min_row, max_row, min_col, max_col = model.get_sheet_dimensions(0)
-    assert (min_row, max_row, min_col, max_col) == (2, 2, 3, 3)

bindings/wasm/src/lib.rs

@@ -7,7 +7,6 @@ use wasm_bindgen::{
 use ironcalc_base::{
     expressions::{lexer::util::get_tokens as tokenizer, types::Area, utils::number_to_column},
     types::{CellType, Style},
-    worksheet::NavigationDirection,
     BorderArea, ClipboardData, UserModel as BaseModel,
 };
 
@@ -196,61 +195,24 @@ impl Model {
             .map_err(to_js_error)
     }
 
-    #[wasm_bindgen(js_name = "insertRows")]
-    pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), JsError> {
-        self.model
-            .insert_rows(sheet, row, row_count)
-            .map_err(to_js_error)
+    #[wasm_bindgen(js_name = "insertRow")]
+    pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<(), JsError> {
+        self.model.insert_row(sheet, row).map_err(to_js_error)
     }
 
-    #[wasm_bindgen(js_name = "insertColumns")]
-    pub fn insert_columns(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        column_count: i32,
-    ) -> Result<(), JsError> {
-        self.model
-            .insert_columns(sheet, column, column_count)
-            .map_err(to_js_error)
+    #[wasm_bindgen(js_name = "insertColumn")]
+    pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<(), JsError> {
+        self.model.insert_column(sheet, column).map_err(to_js_error)
     }
 
-    #[wasm_bindgen(js_name = "deleteRows")]
-    pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), JsError> {
-        self.model
-            .delete_rows(sheet, row, row_count)
-            .map_err(to_js_error)
+    #[wasm_bindgen(js_name = "deleteRow")]
+    pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<(), JsError> {
+        self.model.delete_row(sheet, row).map_err(to_js_error)
     }
 
-    #[wasm_bindgen(js_name = "deleteColumns")]
-    pub fn delete_columns(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        column_count: i32,
-    ) -> Result<(), JsError> {
-        self.model
-            .delete_columns(sheet, column, column_count)
-            .map_err(to_js_error)
-    }
-
-    #[wasm_bindgen(js_name = "moveColumn")]
-    pub fn move_column_action(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        delta: i32,
-    ) -> Result<(), JsError> {
-        self.model
-            .move_column_action(sheet, column, delta)
-            .map_err(to_js_error)
-    }
-
-    #[wasm_bindgen(js_name = "moveRow")]
-    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), JsError> {
-        self.model
-            .move_row_action(sheet, row, delta)
-            .map_err(to_js_error)
+    #[wasm_bindgen(js_name = "deleteColumn")]
+    pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<(), JsError> {
+        self.model.delete_column(sheet, column).map_err(to_js_error)
     }
 
     #[wasm_bindgen(js_name = "setRowsHeight")]
@@ -568,20 +530,6 @@ impl Model {
         self.model.on_page_up().map_err(to_js_error)
     }
 
-    #[wasm_bindgen(js_name = "onNavigateToEdgeInDirection")]
-    pub fn on_navigate_to_edge_in_direction(&mut self, direction: &str) -> Result<(), JsError> {
-        let direction = match direction {
-            "ArrowLeft" => NavigationDirection::Left,
-            "ArrowRight" => NavigationDirection::Right,
-            "ArrowUp" => NavigationDirection::Up,
-            "ArrowDown" => NavigationDirection::Down,
-            _ => return Err(JsError::new(&format!("Invalid direction: {direction}"))),
-        };
-        self.model
-            .on_navigate_to_edge_in_direction(direction)
-            .map_err(to_js_error)
-    }
-
     #[wasm_bindgen(js_name = "setWindowWidth")]
     pub fn set_window_width(&mut self, window_width: f64) {
         self.model.set_window_width(window_width);
@@ -742,45 +690,4 @@ impl Model {
             .delete_defined_name(name, scope)
             .map_err(|e| to_js_error(e.to_string()))
     }
-
-    #[wasm_bindgen(js_name = "getLastNonEmptyInRowBeforeColumn")]
-    pub fn get_last_non_empty_in_row_before_column(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<i32>, JsError> {
-        self.model
-            .get_last_non_empty_in_row_before_column(sheet, row, column)
-            .map_err(to_js_error)
-    }
-
-    #[wasm_bindgen(js_name = "getFirstNonEmptyInRowAfterColumn")]
-    pub fn get_first_non_empty_in_row_after_column(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<i32>, JsError> {
-        self.model
-            .get_first_non_empty_in_row_after_column(sheet, row, column)
-            .map_err(to_js_error)
-    }
-
-    #[wasm_bindgen(
-        js_name = "getCellArrayStructure",
-        unchecked_return_type = "CellArrayStructure"
-    )]
-    pub fn get_cell_array_structure(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<JsValue, JsError> {
-        let cell_structure = self
-            .model
-            .get_cell_array_structure(sheet, row, column)
-            .map_err(|e| to_js_error(e.to_string()))?;
-        serde_wasm_bindgen::to_value(&cell_structure).map_err(JsError::from)
-    }
 }

bindings/wasm/tests/test.mjs

@@ -130,82 +130,5 @@ test("autofill", () => {
     assert.strictEqual(result, "23");
 });
 
-test('insertRows shifts cells', () => {
-    const model = new Model('Workbook1', 'en', 'UTC');
-    model.setUserInput(0, 1, 1, '42');
-    model.insertRows(0, 1, 1);
 
-    assert.strictEqual(model.getCellContent(0, 1, 1), '');
-    assert.strictEqual(model.getCellContent(0, 2, 1), '42');
-});
 
-test('insertColumns shifts cells', () => {
-    const model = new Model('Workbook1', 'en', 'UTC');
-    model.setUserInput(0, 1, 1, 'A');
-    model.setUserInput(0, 1, 2, 'B');
-
-    model.insertColumns(0, 2, 1);
-
-    assert.strictEqual(model.getCellContent(0, 1, 2), '');
-    assert.strictEqual(model.getCellContent(0, 1, 3), 'B');
-});
-
-test('deleteRows removes cells', () => {
-    const model = new Model('Workbook1', 'en', 'UTC');
-    model.setUserInput(0, 1, 1, '1');
-    model.setUserInput(0, 2, 1, '2');
-
-    model.deleteRows(0, 1, 1);
-
-    assert.strictEqual(model.getCellContent(0, 1, 1), '2');
-    assert.strictEqual(model.getCellContent(0, 2, 1), '');
-});
-
-test('deleteColumns removes cells', () => {
-    const model = new Model('Workbook1', 'en', 'UTC');
-    model.setUserInput(0, 1, 1, 'A');
-    model.setUserInput(0, 1, 2, 'B');
-
-    model.deleteColumns(0, 1, 1);
-
-    assert.strictEqual(model.getCellContent(0, 1, 1), 'B');
-    assert.strictEqual(model.getCellContent(0, 1, 2), '');
-});
-
-test("move row", () => {
-    const model = new Model('Workbook1', 'en', 'UTC');
-    model.setUserInput(0, 3, 5, "=G3");
-    model.setUserInput(0, 4, 5, "=G4");
-    model.setUserInput(0, 5, 5, "=SUM(G3:J3)");
-    model.setUserInput(0, 6, 5, "=SUM(G3:G3)");
-    model.setUserInput(0, 7, 5, "=SUM(G4:G4)");
-    model.evaluate();
-
-    model.moveRow(0, 3, 1);
-    model.evaluate();
-
-    assert.strictEqual(model.getCellContent(0, 3, 5), "=G3");
-    assert.strictEqual(model.getCellContent(0, 4, 5), "=G4");
-    assert.strictEqual(model.getCellContent(0, 5, 5), "=SUM(G4:J4)");
-    assert.strictEqual(model.getCellContent(0, 6, 5), "=SUM(G4:G4)");
-    assert.strictEqual(model.getCellContent(0, 7, 5), "=SUM(G3:G3)");
-});
-
-test("move column", () => {
-    const model = new Model('Workbook1', 'en', 'UTC');
-    model.setUserInput(0, 3, 5, "=G3");
-    model.setUserInput(0, 4, 5, "=H3");
-    model.setUserInput(0, 5, 5, "=SUM(G3:J7)");
-    model.setUserInput(0, 6, 5, "=SUM(G3:G7)");
-    model.setUserInput(0, 7, 5, "=SUM(H3:H7)");
-    model.evaluate();
-
-    model.moveColumn(0, 7, 1);
-    model.evaluate();
-
-    assert.strictEqual(model.getCellContent(0, 3, 5), "=H3");
-    assert.strictEqual(model.getCellContent(0, 4, 5), "=G3");
-    assert.strictEqual(model.getCellContent(0, 5, 5), "=SUM(H3:J7)");
-    assert.strictEqual(model.getCellContent(0, 6, 5), "=SUM(H3:H7)");
-    assert.strictEqual(model.getCellContent(0, 7, 5), "=SUM(G3:G7)");
-});

bindings/wasm/types.ts

@@ -109,11 +109,6 @@ export interface MarkedToken {
   end: number;
 }
 
-export type CellArrayStructure =
-  | "SingleCell"
-  | { DynamicChild: [number, number, number, number] }
-  | { DynamicMother: [number, number] };
-
 export interface WorksheetProperties {
   name: string;
   color: string;
@@ -221,7 +216,7 @@ export interface SelectedView {
 // };
 
 // type ClipboardData = Record<string, Record <string, ClipboardCell>>;
-type ClipboardData = Map<number, Map<number, ClipboardCell>>;
+type ClipboardData = Map<number, Map <number, ClipboardCell>>;
 
 export interface ClipboardCell {
   text: string;
@@ -238,4 +233,4 @@ export interface DefinedName {
   name: string;
   scope?: number;
   formula: string;
-}
+}

docs/package.json

@@ -6,7 +6,7 @@
   },
   "devDependencies": {
     "markdown-it-mathjax3": "^4.3.2",
-    "vitepress": "^v2.0.0-alpha.8",
-    "vue": "^3.5.17"
+    "vitepress": "^1.5.0",
+    "vue": "^3.5.12"
   }
 }

docs/src/features/keyboard-shortcuts.md

@@ -6,57 +6,23 @@ lang: en-US
 
 # Keyboard Shortcuts
 
-From within your keyboard you can navigate and interact with the spreadsheet.
+From within your keyboard you can navigate and interact with the spreadsheet. This is a fairly interesting feature for power users.
 
-## Navigation Shortcuts
+## Common Actions
 
-| Action                  | Linux/Windows     | Mac            |
-| ----------------------- | ----------------- | -------------- |
-| Move one cell           | Arrow Keys        | Arrow Keys     |
-| Move down (Excel-style) | Enter             | Enter          |
-| Move right              | Tab               | Tab            |
-| Move left               | Shift + Tab       | Shift + Tab    |
-| Jump to first column    | Home              | Fn + ←         |
-| Jump to last column     | End               | Fn + →         |
-| Scroll one screen down  | PageDown          | Fn + ↓         |
-| Scroll one screen up    | PageUp            | Fn + ↑         |
-| Jump to cell edge       | Ctrl + Arrow Keys | ⌘ + Arrow Keys |
-| Jump to start of sheet  | Ctrl + Home       | ⌘ + Fn + ←     |
-| Jump to end of sheet    | Ctrl + End        | ⌘ + Fn + →     |
+| Action | Windows  | Mac   |
+| ------ | -------- | ----- |
+| Copy   | ctrl + c | ⌘ + c |
+| Paste  | ctrl + v | ⌘ + v |
+| Cut    | ctrl + x | ⌘ + x |
+| Undo   | ctrl + z | ⌘ + z |
+| Redo   | ctrl + y | ⌘ + y |
 
-## Selection & Editing
+## Navigation
 
-| Action               | Linux/Windows      | Mac                |
-| -------------------- | ------------------ | ------------------ |
-| Expand selection     | Shift + Arrow Keys | Shift + Arrow Keys |
-| Start editing a cell | F2                 | F2                 |
-| Edit directly        | Any key            | Any key            |
-
-## Text Styling
-
-| Action    | Linux/Windows  | Mac   |
-| --------- | -------------- | ----- |
-| Bold      | Ctrl + B       | ⌘ + B |
-| Italic    | Ctrl + I       | ⌘ + I |
-| Underline | Ctrl + U       | ⌘ + U |
-
-## Undo / Redo
-
-| Action | Linux/Windows                | Mac                    |
-| ------ | ---------------------------- | -----------------------|
-| Undo   | Ctrl + Z                     | ⌘ + Z                  |
-| Redo   | Ctrl + Y or Ctrl + Shift + Z | ⌘ + Shift + Z or ⌘ + Y |
-
-## Sheet Navigation
-
-| Action         | Linux/Windows    | Mac            |
-| -------------- | ---------------- | -------------- |
-| Next sheet     | Alt + Arrow Down | ⌥ + Arrow Down |
-| Previous sheet | Alt + Arrow Up   | ⌥ + Arrow Up   |
-
-## Miscellaneous
-
-| Action        | Linux/Windows/Mac    |
-| ------------- | -------------------- |
-| Cancel action | Escape               |
-| Delete cells  | Delete               |
+| <div style="width:200px">Action</div> | <div style="width:80px">Windows</div> | <div style="width:80px">Mac</div> |
+| ------------------------------------- | ------------------------------------- | --------------------------------- |
+| Move to beginning of row              | ???                                   | Fn + Left Arrow                   |
+| Move to end of row                    | ???                                   | Fn + Right Arrow                  |
+| Move to previous sheet                | Option + Arrow Up                     | Option + Arrow Up                 |
+| Move to next sheet                    | Option + Arrow Down                   | Option + Arrow Down               |

docs/src/features/value-types.md

@@ -66,8 +66,4 @@ Using IronCalc, a complex number is a string of the form "1+j3".
 
 "#N/A" => #N/A
 
-## Arrays
-
-## References
-
-A reference is a pointer to a single cell or a range of cells. The reference can either be entered manually, for example "A4", or as the result of a calculation, such as the OFFSET Function or the INDIRECT Function. A reference can also be built, for example with the Colon (\:) Operator. 
+## Arrays

docs/src/functions/lookup-and-reference.md

@@ -16,7 +16,7 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | CHOOSE       | <Badge type="tip" text="Available" />          | –             |
 | CHOOSECOLS   | <Badge type="info" text="Not implemented yet" /> | –             |
 | CHOOSEROWS   | <Badge type="info" text="Not implemented yet" /> | –             |
-| COLUMN       | <Badge type="tip" text="Available" />          | [COLUMN](lookup_and_reference/column)             |
+| COLUMN       | <Badge type="tip" text="Available" />          | –             |
 | COLUMNS      | <Badge type="tip" text="Available" />          | –             |
 | DROP         | <Badge type="info" text="Not implemented yet" /> | –             |
 | EXPAND       | <Badge type="info" text="Not implemented yet" /> | –             |

docs/src/functions/lookup_and_reference/column.md

@@ -4,28 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# COLUMN function
-## Overview
-The COLUMN Function in IronCalc is a lookup & reference formula that is used to query and return the column number of a referenced Column or Cell.
-## Usage
-### Syntax
-**COLUMN(<span title="Reference" style="color:#1E88E5">reference</span>) => <span title="Number" style="color:#1E88E5">column</span>**
-### Argument descriptions
-* *reference* ([cell](/features/value-types#references), [optional](/features/optional-arguments.md)). The number of the cell you wish to reference the column number of.
-### Additional guidance
-* When referencing a range of cells, only the column number of the left most cell will be returned.
-* You are also able to reference complete columns instead of individual cells.
-### Returned value
-COLUMN returns the [number](/features/value-types#numbers) of the specific cell or column which is being referenced.
-### Error conditions
-* IronCalc currently does not support the referencing of cells with names.
-## Details
-The COLUMN Function can only be used to display the correlating number of a single column within a Sheet. If you wish to show the number of columns used within a specific range, you can use the COLUMNS Function.
-## Examples
-### No Cell Reference
-When no cell reference is made, the formula uses **=COLUMN()**. This will then output the column number of the cell where the formula is placed.<br><br>For example, if the formula is placed in cell A1, then "1" will be displayed.
-### With Cell Reference
-When a cell reference is made, the formula uses **=COLUMN([Referenced Cell])**. This will then output the column number of the referenced cell, regardless of where the formula is placed in the sheet.<br><br>For example, if the cell B1 is the referenced cell, "2" will be the output of the formula no matter where it is placed in the sheet.<br><br>**Note:** references do not always have to be specific cells, you can also reference complete columns. For example, **=COLUMN(B:B)** would also result in an output of "2".
-### Range References
-The COLUMN function can also be used to reference a range of Cells or Columns. In this case only the most left-hand column will be the resulting output.<br><br>For example, **=COLUMN(A1:J1)** will result in the ouput of "1".
-## Links
+# COLUMN
+
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math-and-trigonometry.md

@@ -12,17 +12,17 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | Function        | Status                                         | Documentation |
 | --------------- | ---------------------------------------------- | ------------- |
 | ABS             | <Badge type="tip" text="Available" />          | –             |
-| ACOS            | <Badge type="tip" text="Available" />          | [ACOS](math_and_trigonometry/acos) |
-| ACOSH           | <Badge type="tip" text="Available" />          | [ACOSH](math_and_trigonometry/acosh) |
+| ACOS            | <Badge type="tip" text="Available" />          | –             |
+| ACOSH           | <Badge type="tip" text="Available" />          | –             |
 | ACOT            | <Badge type="info" text="Not implemented yet" /> | –             |
 | ACOTH           | <Badge type="info" text="Not implemented yet" /> | –             |
 | AGGREGATE       | <Badge type="info" text="Not implemented yet" /> | –             |
 | ARABIC          | <Badge type="info" text="Not implemented yet" /> | –             |
-| ASIN            | <Badge type="tip" text="Available" />          | [ASIN](math_and_trigonometry/asin) |
-| ASINH           | <Badge type="tip" text="Available" />          | [ASINH](math_and_trigonometry/asinh) |
-| ATAN            | <Badge type="tip" text="Available" />          | [ATAN](math_and_trigonometry/atan) |
-| ATAN2           | <Badge type="tip" text="Available" />          | [ATAN2](math_and_trigonometry/atan2) |
-| ATANH           | <Badge type="tip" text="Available" />          | [ATANH](math_and_trigonometry/atanh) |
+| ASIN            | <Badge type="tip" text="Available" />          | –             |
+| ASINH           | <Badge type="tip" text="Available" />          | –             |
+| ATAN            | <Badge type="tip" text="Available" />          | –             |
+| ATAN2           | <Badge type="tip" text="Available" />          | –             |
+| ATANH           | <Badge type="tip" text="Available" />          | –             |
 | BASE            | <Badge type="info" text="Not implemented yet" /> | –             |
 | CEILING         | <Badge type="info" text="Not implemented yet" /> | –             |
 | CEILING.MATH    | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -30,7 +30,7 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | COMBIN          | <Badge type="info" text="Not implemented yet" /> | –             |
 | COMBINA         | <Badge type="info" text="Not implemented yet" /> | –             |
 | COS             | <Badge type="tip" text="Available" />          | [COS](math_and_trigonometry/cos) |
-| COSH            | <Badge type="tip" text="Available" />          | [COSH](math_and_trigonometry/cosh) |
+| COSH            | <Badge type="tip" text="Available" />          | –             |
 | COT             | <Badge type="info" text="Not implemented yet" /> | –             |
 | COTH            | <Badge type="info" text="Not implemented yet" /> | –             |
 | CSC             | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -49,9 +49,9 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | ISO.CEILING     | <Badge type="info" text="Not implemented yet" /> | –             |
 | LCM             | <Badge type="info" text="Not implemented yet" /> | –             |
 | LET             | <Badge type="info" text="Not implemented yet" /> | –             |
-| LN              | <Badge type="info" text="Available" />           | –             |
-| LOG             | <Badge type="info" text="Available" />           | –             |
-| LOG10           | <Badge type="info" text="Available" />           | –             |
+| LN              | <Badge type="info" text="Not implemented yet" /> | –             |
+| LOG             | <Badge type="info" text="Not implemented yet" /> | –             |
+| LOG10           | <Badge type="info" text="Not implemented yet" /> | –             |
 | MDETERM         | <Badge type="info" text="Not implemented yet" /> | –             |
 | MINVERSE        | <Badge type="info" text="Not implemented yet" /> | –             |
 | MMULT           | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -78,18 +78,18 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | SEQUENCE        | <Badge type="info" text="Not implemented yet" /> | –             |
 | SIGN            | <Badge type="info" text="Not implemented yet" /> | –             |
 | SIN             | <Badge type="tip" text="Available" />          | [SIN](math_and_trigonometry/sin) |
-| SINH            | <Badge type="tip" text="Available" />          | [SINH](math_and_trigonometry/sinh) |
+| SINH            | <Badge type="tip" text="Available" />          | –             |
 | SQRT            | <Badge type="tip" text="Available" />          | –             |
-| SQRTPI          | <Badge type="info" text="Available" />         | –             |
+| SQRTPI          | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUBTOTAL        | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUM             | <Badge type="tip" text="Available" />          | –             |
 | SUMIF           | <Badge type="tip" text="Available" />          | –             |
-| SUMIFS          | <Badge type="info" text="Available" />         | –             |
+| SUMIFS          | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMPRODUCT      | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMSQ           | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMX2MY2        | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMX2PY2        | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMXMY2         | <Badge type="info" text="Not implemented yet" /> | –             |
 | TAN             | <Badge type="tip" text="Available" />          | [TAN](math_and_trigonometry/tan) |
-| TANH            | <Badge type="tip" text="Available" />          | [TANH](math_and_trigonometry/tanh) |
+| TANH            | <Badge type="tip" text="Available" />          | –             |
 | TRUNC           | <Badge type="info" text="Not implemented yet" /> | –             |

docs/src/functions/math_and_trigonometry/acos.md

@@ -4,35 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# ACOS function
-## Overview
-ACOS is a function of the Math and Trigonometry category that calculates the inverse cosine (arccosine) of a number in the range [-1 to 1], returning an angle in the range [0 to $\pi$], expressed in radians.
-## Usage
-### Syntax
-**ACOS(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">acos</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The number whose arccosine is to be calculated, in the range [-1 to 1]. 
-### Additional guidance
-None.
-### Returned value
-ACOS returns a number in radians in the range [0 to $\pi$] that is the angle whose cosine is the specified number.
-### Error conditions
-* In common with many other IronCalc functions, ACOS propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then ACOS returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ACOS returns the [`#VALUE!`](/features/error-types.md#value) error.
-* If the value of the *number* argument lies outside the range [-1 to 1], then ACOS returns the [`#NUM!`](/features/error-types.md#num) error.
-* For some argument values, ACOS may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ACOS function utilizes the *acos()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the output of the ACOS function for angles $x$ in the range -1 to +1.
-<center><img src="/functions/images/arccosine-curve.png" width="350" alt="Graph showing acos(x) for x between -1 and +1."></center>
+# ACOS
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=acos).
-
-## Links
-* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
-* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
-* Visit Microsoft Excel's [ACOS function](https://support.microsoft.com/en-us/office/acos-function-cb73173f-d089-4582-afa1-76e5524b5d5b) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093461) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ACOS) provide versions of the ACOS function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/acosh.md

@@ -3,40 +3,9 @@ layout: doc
 outline: deep
 lang: en-US
 ---
-# ACOSH function
-## Overview
-ACOSH is a function of the Math and Trigonometry category that calculates the inverse hyperbolic cosine (hyperbolic arccosine) of a number, returning a non-negative value in the range [0, +∞).
-## Usage
-### Syntax
-**ACOSH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">acosh</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The value whose hyperbolic arccosine is to be calculated. The value must be greater than or equal to 1.
 
-### Additional guidance
-The hyperbolic arccosine function is defined as:
+# ACOSH
 
-$$
-\operatorname{acosh}(x) = \ln(x + \sqrt{x^2 - 1})
-$$
-
-### Returned value
-ACOSH returns a [number](/features/value-types#numbers) in the range [0, +∞) that is the hyperbolic arccosine of the specified value, expressed in radians.
-### Error conditions
-* In common with many other IronCalc functions, ACOSH propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then ACOSH returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ACOSH returns the [`#VALUE!`](/features/error-types.md#value) error.
-* If the value of the *number* argument is less than 1, then ACOSH returns the [`#NUM!`](/features/error-types.md#num) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ACOSH function utilizes the *acosh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the output of the ACOSH function for values $x \geq 1$ in the range [0, +∞).
-<center><img src="/functions/images/hyperbolicarccosine-curve.png" width="350" alt="Graph showing acosh(x) for x ≥ 1."></center>
-
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=acosh).
-
-## Links
-* For more information about inverse hyperbolic functions, visit Wikipedia's [Inverse hyperbolic functions](https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions) page.
-* See also IronCalc's [COSH](/functions/math_and_trigonometry/cosh), [ASINH](/functions/math_and_trigonometry/asinh) and [ATANH](/functions/math_and_trigonometry/atanh) functions.
-* Visit Microsoft Excel's [ACOSH function](https://support.microsoft.com/en-us/office/acosh-function-e3992cc1-103f-4e72-9f04-624b9ef5ebfe) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093391) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ACOSH) provide versions of the ACOSH function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/asin.md

@@ -4,37 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# ASIN function
+# ASIN
 
-## Overview
-ASIN is a function of the Math and Trigonometry category that calculates the inverse sine (arcsine) of a number in the range [-1 to +1], returning an angle in the range [-$\pi$/2 to +$\pi$/2], expressed in radians.
-## Usage
-### Syntax
-**ASIN(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">asin</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The number whose arcsine is to be calculated, in the range [-1 to +1]. 
-
-### Additional guidance
-None.
-### Returned value
-ASIN returns a number in radians in the range [-$\pi$/2 to +$\pi$/2] that is the angle whose sine is the specified number.
-### Error conditions
-* In common with many other IronCalc functions, ASIN propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then ASIN returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ASIN returns the [`#VALUE!`](/features/error-types.md#value) error.
-* If the value of the *number* argument lies outside the range [-1 to +1], then ASIN returns the [`#NUM!`](/features/error-types.md#num) error.
-* For some argument values, ASIN may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ASIN function utilizes the *asin()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the output of the ASIN function for angles $x$ in the range -1 to +1 radians.
-<center><img src="/functions/images/arcsine-curve.png" width="350" alt="Graph showing sin(x) for x between -2π and +2π."></center>
-
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=asin).
-
-## Links
-* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
-* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
-* Visit Microsoft Excel's [ASIN function](https://support.microsoft.com/en-us/office/asin-function-81fb95e5-6d6f-48c4-bc45-58f955c6d347) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093464) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ASIN) provide versions of the ASIN function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/asinh.md

@@ -4,36 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# ASINH function
-## Overview
-ASINH is a function of the Math and Trigonometry category that calculates the inverse hyperbolic sine (hyperbolic arcsine) of a number, returning the hyperbolic angle expressed in radians.
-## Usage
-### Syntax
-**ASINH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">asinh</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The value whose inverse hyperbolic sine is to be calculated. 
-### Additional guidance
-The hyperbolic arcsine function is defined as:
-$$
-\operatorname{asinh}(x) = \ln\!\left(x + \sqrt{x^2 + 1}\,\right)
-$$
-### Returned value
-ASINH returns a real [number](/features/value-types#numbers) in the range (-∞, +∞) that is the hyperbolic arcsine of the specified value, expressed in radians.
-### Error conditions
-* In common with many other IronCalc functions, ASINH propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then ASINH returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ASINH returns the [`#VALUE!`](/features/error-types.md#value) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ASINH function utilizes the *asinh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the output of the ASINH function.
-<center><img src="/functions/images/hyperbolicarcsine-curve.png" width="350" alt="Graph showing asinh(x)."></center>
+# ASINH
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=asinh).
-
-## Links
-* For more information about inverse hyperbolic functions, visit Wikipedia's [Inverse hyperbolic functions](https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions) page.
-* See also IronCalc's [SINH](/functions/math_and_trigonometry/sinh), [ACOSH](/functions/math_and_trigonometry/acosh) and [ATANH](/functions/math_and_trigonometry/atanh) functions.
-* Visit Microsoft Excel's [ASINH function](https://support.microsoft.com/de-de/office/asinh-function-62b4f5b6-d9cc-4c17-9d04-aa5371806c74) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093393) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ASINH) provide versions of the ASINH function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/atan.md

@@ -4,34 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# ATAN function
-## Overview
-ATAN is a function of the Math and Trigonometry category that calculates the inverse tangent (arctangent) of a number, returning an angle in the range [-$\pi$/2 to +$\pi$/2], expressed in radians.
-## Usage
-### Syntax
-**ATAN (<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">atan</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The number whose arctangent is to be calculated, in the range [-$\infty$, +$\infty$]. 
-### Additional guidance
-None.
-### Returned value
-ATAN returns a number in radians in the range [-$\pi$/2 to +$\pi$/2] that is the angle whose tangent is the specified number.
-### Error conditions
-* In common with many other IronCalc functions, ATAN propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then ATAN returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ATAN returns the [`#VALUE!`](/features/error-types.md#value) error.
-* For some argument values, ATAN may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ATAN function utilizes the *atan()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the output of the ATAN function for angles $x$ in the range [-$\infty$, +$\infty$].
-<center><img src="/functions/images/arctangent-curve.png" width="350" alt="Graph showing atan(x) for x between [-$\infty$, +$\infty$]."></center>
+# ATAN
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=atan).
-
-## Links
-* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
-* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
-* Visit Microsoft Excel's [ATAN function](https://support.microsoft.com/en-us/office/atan-function-50746fa8-630a-406b-81d0-4a2aed395543) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093395) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ATAN) provide versions of the ATAN function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/atan2.md

@@ -4,34 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# ATAN2 function
-## Overview
-ATAN2 is a function of the Math and Trigonometry category that calculates the inverse tangent (arctangent) for the specified *x* and *y* coordinates. The arctangent returns the angle defined by the x-axis and a line defined by the origin and a point with coordinates (x,y). The returned angle is expressed in radians, in the range (-$\pi$, +$\pi$].
-## Usage
-### Syntax
-**ATAN2(<span title="Number" style="color:#1E88E5">x,y</span>) => <span title="Number" style="color:#1E88E5">atan2</span>**
-### Argument descriptions
-* *x* ([number](/features/value-types#numbers), required). Value of the x coordinate.
-* *y* ([number](/features/value-types#numbers), required). Value of the y coordinate.
-### Additional guidance
-If the returned value is positive, it represents a counterclockwise angle from the x-axis, while a negative value represents a clockwise angle.  
-ATAN2(x,y) is equivalent to ATAN(y/x), with the difference that the x argument in ATAN2 can be 0.
-### Returned value
-ATAN2 returns a number in radians in the range (-$\pi$, +$\pi$] that is the inverse tangent for the specified x and y coordinates.
-### Error conditions
-* In common with many other IronCalc functions, ATAN2 propagates errors that are found in its argument.
-* If no argument, or arguments other than 2, are supplied, then ATAN2 returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of either the *x* or *y* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ATAN2 returns the [`#VALUE!`](/features/error-types.md#value) error.
-* If both *x* and *y* are equal to 0, ATAN2 returns a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ATAN2 function utilizes the *atan2()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=atan2).
-
-## Links
-* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
-* See also IronCalc's [ATAN](/functions/math_and_trigonometry/atan), [TAN](/functions/math_and_trigonometry/tan) and [ASIN](/functions/math_and_trigonometry/asin) functions.
-* Visit Microsoft Excel's [ATAN2 function](https://support.microsoft.com/en-us/office/atan2-function-51123ced-348c-416a-b2e2-833f7868569f) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093468) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ATAN2) provide versions of the ATAN2 function.
+# ATAN2
 
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/atanh.md

@@ -4,37 +4,8 @@ outline: deep
 lang: en-US
 ---
 
-# ATANH function
-## Overview
-ATANH is a function of the Math and Trigonometry category that calculates the inverse hyperbolic tangent (hyperbolic arctangent) of a number in the range (-1, +1), returning the hyperbolic angle expressed in radians.
-## Usage
-### Syntax
-**ATANH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">atanh</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The value whose inverse hyperbolic tangent is to be calculated, in the range (-1,+1).
-### Additional guidance
-The hyperbolic arctangent function is defined as:
-$$
-\operatorname{atanh}(x) = \tfrac{1}{2}\,\ln\!\left(\dfrac{1+x}{1-x}\right),\quad |x| < 1
-$$
-### Returned value
-ATANH returns a real [number](/features/value-types#numbers) in the range (-∞, +∞) that is the hyperbolic arctangent of the specified value, expressed in radians.
-### Error conditions
-* In common with many other IronCalc functions, ATANH propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then ATANH returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ATANH returns the [`#VALUE!`](/features/error-types.md#value) error.
-* If the value of the *number* argument lies outside the domain (-1, +1), then ATANH returns the [`#NUM!`](/features/error-types.md#num) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The ATANH function utilizes the *atanh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the output of the ATANH function.
-<center><img src="/functions/images/hyperbolicarctangent-curve.png" width="350" alt="Graph showing atanh(x)."></center>
+# ATANH
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=atanh).
-
-## Links
-* For more information about inverse hyperbolic functions, visit Wikipedia's [Inverse hyperbolic functions](https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions) page.
-* See also IronCalc's [ASINH](/functions/math_and_trigonometry/asinh), [ACOSH](/functions/math_and_trigonometry/acosh) and [TANH](/functions/math_and_trigonometry/tanh) functions.
-* Visit Microsoft Excel's [ATANH function](https://support.microsoft.com/de-de/office/atanh-function-453534d1-76a5-4f17-8c04-c3f2feee0dd5) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093397) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ATANH) provide versions of the ATANH function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/cosh.md

@@ -3,37 +3,9 @@ layout: doc
 outline: deep
 lang: en-US
 ---
-# COSH function
-## Overview
-COSH is a function of the Math and Trigonometry category that calculates the hyperbolic cosine of a number.
-## Usage
-### Syntax
-**COSH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">cosh</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The hyperbolic angle whose hyperbolic cosine is to be calculated, expressed in radians.
-### Additional guidance
-The formula for the hyperbolic cosine is:
-$$
-\text{cosh(x)} = \dfrac{e^x+e^{-x}}{2}
-$$
-### Returned value
-COSH returns a real [number](/features/value-types#numbers) that is the hyperbolic cosine of the specified hyperbolic angle.
-### Error conditions
-* In common with many other IronCalc functions, COSH propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then COSH returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then COSH returns the [`#VALUE!`](/features/error-types.md#value) error.
-* For some argument values, COSH may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The COSH function utilizes the *cosh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the COSH function.
-<center><img src="/functions/images/hyperboliccosine-curve.png" width="350" alt="Graph showing cosh(x)."></center>
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=cosh).
+# COSH
 
-## Links
-* For more information about hyperbolic functions, visit Wikipedia's [Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions) page.
-* See also IronCalc's [SINH](/functions/math_and_trigonometry/sinh), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
-* Visit Microsoft Excel's [COSH function](https://support.microsoft.com/en-us/office/cosh-function-e460d426-c471-43e8-9540-a57ff3b70555) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093477) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/COSH) provide versions of the COSH function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/ln.md

@@ -7,5 +7,6 @@ lang: en-US
 # LN
 
 ::: warning
-🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/math_and_trigonometry/log.md

@@ -7,5 +7,6 @@ lang: en-US
 # LOG
 
 ::: warning
-🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/math_and_trigonometry/log10.md

@@ -7,5 +7,6 @@ lang: en-US
 # LOG10
 
 ::: warning
-🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/math_and_trigonometry/sinh.md

@@ -3,37 +3,9 @@ layout: doc
 outline: deep
 lang: en-US
 ---
-# SINH function
-## Overview
-SINH is a function of the Math and Trigonometry category that calculates the hyperbolic sine of a number.
-## Usage
-### Syntax
-**SINH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">sinh</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The hyperbolic angle whose hyperbolic sine is to be calculated, expressed in radians.
-### Additional guidance
-The formula for the hyperbolic sine is:
-$$
-\text{sinh(x)} = \dfrac{e^x-e^{-x}}{2}
-$$
-### Returned value
-SINH returns a real [number](/features/value-types#numbers) that is the hyperbolic sine of the specified hyperbolic angle.
-### Error conditions
-* In common with many other IronCalc functions, SINH propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then SINH returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then SINH returns the [`#VALUE!`](/features/error-types.md#value) error.
-* For some argument values, SINH may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The SINH function utilizes the *sinh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the SINH function.
-<center><img src="/functions/images/hyperbolicsine-curve.png" width="350" alt="Graph showing sinh(x)."></center>
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=sinh).
+# SINH
 
-## Links
-* For more information about hyperbolic functions, visit Wikipedia's [Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions) page.
-* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
-* Visit Microsoft Excel's [SINH function](https://support.microsoft.com/en-us/office/sinh-function-4958f7e2-0d2b-4846-8ef5-8475f3aea5fb) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093517) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/SINH) provide versions of the SINH function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

docs/src/functions/math_and_trigonometry/tan.md

@@ -33,7 +33,7 @@ TAN returns a unitless [number](/features/value-types#numbers) that is the trigo
 * The figure below illustrates the output of the TAN function for angles $x$ in the range -2$π$ to +2$π$.
 <center><img src="/functions/images/tangent-curve.png" width="350" alt="Graph showing tan(x) for x between -2π and +2π."></center>
 
-* Theoretically, $\text{tan}(x)$ is undefined for any critical $x$ that satisfies $x = \frac{\pi}{2} + k\pi$ (where $k$ is any integer). However, an exact representation of the mathematical constant $\pi$ requires infinite precision, which cannot be achieved with the floating-point representation available. Hence, TAN will return very large or very small values close to critical $x$ values.
+* Theoretically, $\text{tan}(x)$ is undefined for any critical $x$ that satisfies $x = \frac{\pi}{2} + k\pi$ (where $k$ is any integer). However, an exact representation of the mathmatical constant $\pi$ requires infinite precision, which cannot be achieved with the floating-point representation available. Hence, TAN will return very large or very small values close to critical $x$ values.
 ## Examples
 [See some examples in IronCalc](https://app.ironcalc.com/?example=tan).
 

docs/src/functions/math_and_trigonometry/tanh.md

@@ -3,37 +3,9 @@ layout: doc
 outline: deep
 lang: en-US
 ---
-# TANH function
-## Overview
-TANH is a function of the Math and Trigonometry category that calculates the hyperbolic tangent of a number.
-## Usage
-### Syntax
-**TANH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">tanh</span>**
-### Argument descriptions
-* *number* ([number](/features/value-types#numbers), required). The hyperbolic angle whose hyperbolic tangent is to be calculated, expressed in radians.
-### Additional guidance
-The formula for the hyperbolic tangent is:
-$$
-\text{tanh(x)} = \dfrac{sinh(x)}{cosh(x)} = \dfrac{e^x-e^{-x}}{e^x+e^{-x}}
-$$
-### Returned value
-TANH returns a real [number](/features/value-types#numbers) in the range (-1,+1) that is the hyperbolic tangent of the specified hyperbolic angle.
-### Error conditions
-* In common with many other IronCalc functions, TANH propagates errors that are found in its argument.
-* If no argument, or more than one argument, is supplied, then TANH returns the [`#ERROR!`](/features/error-types.md#error) error.
-* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then TANH returns the [`#VALUE!`](/features/error-types.md#value) error.
-* For some argument values, TANH may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
-<!--@include: ../markdown-snippets/error-type-details.txt-->
-## Details
-* The TANH function utilizes the *tanh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
-* The figure below illustrates the TANH function.
-<center><img src="/functions/images/hyperbolictangent-curve.png" width="350" alt="Graph showing tanh(x)."></center>
 
-## Examples
-[See some examples in IronCalc](https://app.ironcalc.com/?example=tanh).
+# TANH
 
-## Links
-* For more information about hyperbolic functions, visit Wikipedia's [Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions) page.
-* See also IronCalc's [SINH](/functions/math_and_trigonometry/sinh), [COSH](/functions/math_and_trigonometry/cosh) and [TAN](/functions/math_and_trigonometry/tan) functions.
-* Visit Microsoft Excel's [TANH function](https://support.microsoft.com/en-us/office/tanh-function-017222f0-a0c3-4f69-9787-b3202295dc6c) page.
-* Both [Google Sheets](https://support.google.com/docs/answer/3093755) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/TANH) provide versions of the TANH function.
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::

webapp/IronCalc/src/components/Editor/Editor.tsx

@@ -249,9 +249,6 @@ const Editor = (options: EditorOptions) => {
           }
         }}
         onPaste={(event) => event.stopPropagation()}
-        onCopy={(event) => event.stopPropagation()}
-        onDoubleClick={(event) => event.stopPropagation()}
-        onCut={(event) => event.stopPropagation()}
       />
     </div>
   );

webapp/IronCalc/src/components/FormulaBar/FormulaBar.tsx

@@ -13,7 +13,6 @@ import type { WorkbookState } from "../workbookState";
 type FormulaBarProps = {
   cellAddress: string;
   formulaValue: string;
-  isPartOfArray: boolean;
   model: Model;
   workbookState: WorkbookState;
   onChange: () => void;
@@ -24,7 +23,6 @@ function FormulaBar(properties: FormulaBarProps) {
   const {
     cellAddress,
     formulaValue,
-    isPartOfArray,
     model,
     onChange,
     onTextUpdated,
@@ -64,9 +62,6 @@ function FormulaBar(properties: FormulaBarProps) {
             event.stopPropagation();
             event.preventDefault();
           }}
-          sx={{
-            color: isPartOfArray ? "grey" : "black",
-          }}
         >
           <Editor
             originalText={formulaValue}

webapp/IronCalc/src/components/Toolbar/Toolbar.tsx

@@ -14,8 +14,6 @@ import {
   ArrowUpToLine,
   Bold,
   ChevronDown,
-  DecimalsArrowLeft,
-  DecimalsArrowRight,
   Euro,
   Grid2X2,
   Grid2x2Check,
@@ -38,7 +36,11 @@ import {
 } from "lucide-react";
 import { useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { ArrowMiddleFromLine } from "../../icons";
+import {
+  ArrowMiddleFromLine,
+  DecimalPlacesDecreaseIcon,
+  DecimalPlacesIncreaseIcon,
+} from "../../icons";
 import { theme } from "../../theme";
 import BorderPicker from "../BorderPicker/BorderPicker";
 import ColorPicker from "../ColorPicker/ColorPicker";
@@ -166,7 +168,7 @@ function Toolbar(properties: ToolbarProperties) {
         disabled={!canEdit}
         title={t("toolbar.decimal_places_decrease")}
       >
-        <DecimalsArrowLeft />
+        <DecimalPlacesDecreaseIcon />
       </StyledButton>
       <StyledButton
         type="button"
@@ -179,7 +181,7 @@ function Toolbar(properties: ToolbarProperties) {
         disabled={!canEdit}
         title={t("toolbar.decimal_places_increase")}
       >
-        <DecimalsArrowRight />
+        <DecimalPlacesIncreaseIcon />
       </StyledButton>
       <FormatMenu
         numFmt={properties.numFmt}
@@ -274,10 +276,10 @@ function Toolbar(properties: ToolbarProperties) {
         disabled={!canEdit}
         title={t("toolbar.font_color")}
         ref={fontColorButton}
+        $underlinedColor={properties.fontColor}
         onClick={() => setFontColorPickerOpen(true)}
       >
         <Type />
-        <ColorLine color={properties.fontColor} />
       </StyledButton>
       <StyledButton
         type="button"
@@ -285,10 +287,10 @@ function Toolbar(properties: ToolbarProperties) {
         disabled={!canEdit}
         title={t("toolbar.fill_color")}
         ref={fillColorButton}
+        $underlinedColor={properties.fillColor}
         onClick={() => setFillColorPickerOpen(true)}
       >
         <PaintBucket />
-        <ColorLine color={properties.fillColor} />
       </StyledButton>
       <StyledButton
         type="button"
@@ -446,7 +448,7 @@ function Toolbar(properties: ToolbarProperties) {
       />
       <ColorPicker
         color={properties.fillColor}
-        defaultColor=""
+        defaultColor="#FFFFFF"
         title={t("color_picker.default")}
         onChange={(color): void => {
           if (color !== null) {
@@ -499,64 +501,58 @@ const ToolbarContainer = styled("div")`
   scrollbar-width: none;
 `;
 
-type TypeButtonProperties = { $pressed: boolean };
-export const StyledButton = styled("button", {
-  shouldForwardProp: (prop) => prop !== "$pressed",
-})<TypeButtonProperties>(({ disabled, $pressed }) => {
-  const result = {
-    width: "24px",
-    minWidth: "24px",
-    height: "24px",
-    display: "inline-flex",
-    alignItems: "center",
-    justifyContent: "center",
-    fontSize: "12px",
-    border: `0px solid ${theme.palette.common.white}`,
-    borderRadius: "4px",
-    transition: "all 0.2s",
-    outline: `1px solid ${theme.palette.common.white}`,
-    cursor: "pointer",
-    backgroundColor: "white",
-    padding: "0px",
-    position: "relative" as const,
-    svg: {
-      width: "16px",
-      height: "16px",
-    },
-  };
-  if (disabled) {
+type TypeButtonProperties = { $pressed: boolean; $underlinedColor?: string };
+export const StyledButton = styled("button")<TypeButtonProperties>(
+  ({ disabled, $pressed, $underlinedColor }) => {
+    const result = {
+      width: "24px",
+      minWidth: "24px",
+      height: "24px",
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      fontSize: "12px",
+      border: `0px solid ${theme.palette.common.white}`,
+      borderRadius: "4px",
+      transition: "all 0.2s",
+      outline: `1px solid ${theme.palette.common.white}`,
+      cursor: "pointer",
+      backgroundColor: "white",
+      padding: "0px",
+      svg: {
+        width: "16px",
+        height: "16px",
+      },
+    };
+    if (disabled) {
+      return {
+        ...result,
+        color: theme.palette.grey["400"],
+        cursor: "default",
+      };
+    }
     return {
       ...result,
-      color: theme.palette.grey["400"],
-      cursor: "default",
+      borderTop: $underlinedColor
+        ? `3px solid ${theme.palette.common.white}`
+        : "none",
+      borderBottom: $underlinedColor ? `3px solid ${$underlinedColor}` : "none",
+      color: theme.palette.grey["900"],
+      backgroundColor: $pressed
+        ? theme.palette.grey["300"]
+        : theme.palette.common.white,
+      "&:hover": {
+        transition: "all 0.2s",
+        outline: `1px solid ${theme.palette.grey["200"]}`,
+        borderTopColor: theme.palette.common.white,
+      },
+      "&:active": {
+        backgroundColor: theme.palette.grey["300"],
+        outline: `1px solid ${theme.palette.grey["300"]}`,
+      },
     };
-  }
-  return {
-    ...result,
-    color: theme.palette.grey["900"],
-    backgroundColor: $pressed
-      ? theme.palette.grey["300"]
-      : theme.palette.common.white,
-    "&:hover": {
-      transition: "all 0.2s",
-      outline: `1px solid ${theme.palette.grey["200"]}`,
-    },
-    "&:active": {
-      backgroundColor: theme.palette.grey["300"],
-      outline: `1px solid ${theme.palette.grey["300"]}`,
-    },
-  };
-});
-
-const ColorLine = styled("div")<{ color: string }>(({ color }) => ({
-  height: "3px",
-  width: "16px",
-  position: "absolute",
-  bottom: "0px",
-  left: "50%",
-  transform: "translateX(-50%)",
-  backgroundColor: color,
-}));
+  },
+);
 
 const Divider = styled("div")({
   width: "0px",