UPDATE: WIP

Since https://github.com/ironcalc/IronCalc/pull/27, using
`base::model::Model` complains about `model` being a private modulde,
and `base::Model` should be used instead.

.github/workflows/pypi.yml

@@ -117,7 +117,7 @@ jobs:
           MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
         with:
           command: upload
-          args: "--skip-existing **/*.whl"
+          args: "--skip-existing **/*.whl **/*.tar.gz"
           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"
+          args: "--skip-existing **/*.whl **/*.tar.gz"
           working-directory: bindings/python

Cargo.lock

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

README.md

@@ -84,7 +84,7 @@ And then use this code in `main.rs`:
 
 ```rust
 use ironcalc::{
-    base::{expressions::utils::number_to_column, model::Model},
+    base::{expressions::utils::number_to_column, Model},
     export::save_to_xlsx,
 };
 

base/Cargo.toml

@@ -17,7 +17,6 @@ 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

@@ -212,6 +212,12 @@ 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;
@@ -384,6 +390,13 @@ 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();
@@ -444,7 +457,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 does NOT move the data in the columns or move the colum styles
+    ///      NOTE: This moves the data and column styles along with the formulas
     pub fn move_column_action(
         &mut self,
         sheet: u32,
@@ -460,7 +473,70 @@ impl Model {
             return Err("Initial column out of boundaries".to_string());
         }
 
-        // TODO: Add the actual displacement of data and styles
+        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)?;
 
         // Update all formulas in the workbook
         self.displace_cells(
@@ -473,4 +549,88 @@ 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/expressions/lexer/mod.rs

@@ -314,6 +314,9 @@ 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,5 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
+use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;
 
@@ -685,3 +686,29 @@ 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: "sheet not found".to_string(),
+                            message: format!("sheet not found: {}", context.sheet),
                         };
                     }
                 };
@@ -850,7 +850,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: "sheet not found".to_string(),
+                            message: format!("sheet not found: {}", context.sheet),
                         };
                     }
                 };
@@ -878,7 +878,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: "sheet not found".to_string(),
+                            message: format!("table sheet not found: {}", table.sheet_name),
                         };
                     }
                 };

base/src/expressions/parser/static_analysis.rs

@@ -2,15 +2,19 @@ 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)]
-static RE: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"));
+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"))
+}
 
 fn is_range_reference(s: &str) -> bool {
-    RE.is_match(s)
+    get_re().is_match(s)
 }
 
 /*
@@ -605,6 +609,9 @@ 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],
@@ -816,6 +823,9 @@ 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::OpUnary;
+use crate::expressions::token::{OpSum, OpUnary};
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -28,6 +28,11 @@ pub enum DisplaceData {
         column: i32,
         delta: i32,
     },
+    RowMove {
+        sheet: u32,
+        row: i32,
+        delta: i32,
+    },
     ColumnMove {
         sheet: u32,
         column: i32,
@@ -159,6 +164,29 @@ 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,
@@ -167,14 +195,18 @@ pub(crate) fn stringify_reference(
                     if sheet_index == *sheet {
                         if column == *move_column {
                             column += *delta;
-                        } else if (*delta > 0
-                            && column > *move_column
-                            && column <= *move_column + *delta)
-                            || (*delta < 0
-                                && column < *move_column
-                                && column >= *move_column + *delta)
-                        {
-                            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;
+                            }
                         }
                     }
                 }
@@ -451,34 +483,32 @@ fn stringify(
             kind,
             stringify(right, context, displace_data, export_to_excel)
         ),
-        OpSumKind { kind, left, right } => format!(
-            "{}{}{}",
-            stringify(left, context, displace_data, export_to_excel),
-            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}")
+        }
         OpProductKind { kind, left, right } => {
             let x = match **left {
-                OpSumKind { .. } => format!(
-                    "({})",
-                    stringify(left, context, displace_data, export_to_excel)
-                ),
-                CompareKind { .. } => format!(
+                OpSumKind { .. } | CompareKind { .. } => format!(
                     "({})",
                     stringify(left, context, displace_data, export_to_excel)
                 ),
                 _ => stringify(left, context, displace_data, export_to_excel),
             };
             let y = match **right {
-                OpSumKind { .. } => format!(
-                    "({})",
-                    stringify(right, context, displace_data, export_to_excel)
-                ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    stringify(right, context, displace_data, export_to_excel)
-                ),
-                OpProductKind { .. } => format!(
+                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
                     "({})",
                     stringify(right, context, displace_data, export_to_excel)
                 ),
@@ -589,10 +619,43 @@ fn stringify(
         WrongVariableKind(name) => name.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
-                format!(
-                    "-{}",
-                    stringify(right, context, displace_data, export_to_excel)
-                )
+                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)
+                    )
+                }
             }
             OpUnary::Percentage => {
                 format!(

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

@@ -32,3 +32,39 @@ 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,4 +211,6 @@ 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 % 2 == 0 {
+        if args_count.is_multiple_of(2) {
             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 % 2 != 0 {
+        if !args_count.is_multiple_of(2) {
             // Missing value for last condition
             return CalcResult::new_args_number_error(cell);
         }

base/src/functions/mathematical.rs

@@ -2,6 +2,7 @@ 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,
@@ -311,7 +312,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
+            Ok(f) => to_precision(f, 15),
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -327,12 +328,13 @@ 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) => f,
+            Ok(f) => to_precision(f, 15),
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -352,12 +354,13 @@ 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) => f,
+            Ok(f) => to_precision(f, 15),
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -378,6 +381,16 @@ 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)));
@@ -431,6 +444,47 @@ 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,6 +54,9 @@ pub enum Function {
     Columns,
     Cos,
     Cosh,
+    Log,
+    Log10,
+    Ln,
     Max,
     Min,
     Pi,
@@ -250,7 +253,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 195> {
+    pub fn into_iter() -> IntoIter<Function, 198> {
         [
             Function::And,
             Function::False,
@@ -277,6 +280,9 @@ impl Function {
             Function::Atanh,
             Function::Abs,
             Function::Pi,
+            Function::Ln,
+            Function::Log,
+            Function::Log10,
             Function::Sqrt,
             Function::Sqrtpi,
             Function::Atan2,
@@ -534,6 +540,10 @@ 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),
@@ -734,6 +744,9 @@ 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"),
@@ -961,6 +974,9 @@ 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 % 2 == 1 {
+        if args_count < 2 || !args_count.is_multiple_of(2) {
             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 % 2 == 0 {
+        if args_count < 3 || args_count.is_multiple_of(2) {
             return Err(CalcResult::new_args_number_error(cell));
         }
         let arg_0 = self.evaluate_node_in_context(&args[0], cell);

base/src/language/mod.rs

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

base/src/locale/mod.rs

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

base/src/test/mod.rs

@@ -55,12 +55,16 @@ mod test_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};
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -508,6 +508,10 @@ 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]
@@ -532,5 +536,249 @@ 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_fn_round.rs

@@ -0,0 +1,15 @@
+#![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_ln.rs

@@ -0,0 +1,17 @@
+#![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

@@ -0,0 +1,19 @@
+#![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

@@ -0,0 +1,35 @@
+#![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,6 +1,7 @@
 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;
@@ -11,6 +12,8 @@ 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

@@ -0,0 +1,675 @@
+#![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_diff_queue.rs

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

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_row(0, 5).is_ok());
+    assert!(model.delete_rows(0, 5, 1).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_column(0, 5).is_ok());
+    assert!(model.delete_columns(0, 5, 1).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

@@ -0,0 +1,55 @@
+#![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

@@ -0,0 +1,173 @@
+#![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,6 +24,7 @@ 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]
@@ -45,6 +46,7 @@ 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]
@@ -69,6 +71,7 @@ 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]
@@ -164,7 +167,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\"\"\"\t\n"
+        "42\t127\n\"A season of faith\t \"\"perfection\"\"\""
     );
     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_row(sheet, 3).is_ok());
+    assert!(model.insert_rows(sheet, 3, 1).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_column(sheet, 3).is_ok());
+    assert!(model.insert_columns(sheet, 3, 1).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_column(0, 5).unwrap();
+    model.delete_columns(0, 5, 1).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_column(1, 1),
+        model.delete_columns(1, 1, 1),
         Err("Invalid sheet index".to_string())
     );
 
     assert_eq!(
-        model.delete_column(0, 0),
+        model.delete_columns(0, 0, 1),
         Err("Column number '0' is not valid.".to_string())
     );
     assert_eq!(
-        model.delete_column(0, LAST_COLUMN + 1),
-        Err("Column number '16385' is not valid.".to_string())
+        model.delete_columns(0, LAST_COLUMN + 1, 1),
+        Err(format!("Column number '{}' is not valid.", LAST_COLUMN + 1))
     );
 
-    assert_eq!(model.delete_column(0, LAST_COLUMN), Ok(()));
+    assert_eq!(model.delete_columns(0, LAST_COLUMN, 1), Ok(()));
 }
 
 #[test]
@@ -119,7 +119,7 @@ fn simple_delete_row() {
         .set_rows_height(0, 15, 15, DEFAULT_ROW_HEIGHT * 3.0)
         .unwrap();
 
-    model.delete_row(0, 15).unwrap();
+    model.delete_rows(0, 15, 1).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_row(0, 15).unwrap();
+    model.delete_rows(0, 15, 1).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_row(0, 1).is_ok());
+    assert!(model.insert_rows(0, 1, 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_row(0, 1).unwrap();
+    model.delete_rows(0, 1, 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_column(0, 1).is_ok());
+    assert!(model.insert_columns(0, 1, 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_column(0, 1).unwrap();
+    model.delete_columns(0, 1, 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 cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
+            "The selected cell is not in one of the corners. Row: '1' and row range '(5, 10)'"
                 .to_string()
         )
     );

base/src/user_model/common.rs

@@ -13,8 +13,8 @@ use crate::{
     },
     model::Model,
     types::{
-        Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, SheetState,
-        Style, VerticalAlignment,
+        Alignment, BorderItem, Cell, CellType, Col, HorizontalAlignment, SheetProperties,
+        SheetState, Style, VerticalAlignment,
     },
     utils::is_valid_hex_color,
 };
@@ -659,8 +659,12 @@ impl UserModel {
         Ok(())
     }
 
-    fn clear_column_formatting(&mut self, sheet: u32, column: i32) -> Result<(), String> {
-        let mut diff_list = Vec::new();
+    fn clear_column_formatting(
+        &mut self,
+        sheet: u32,
+        column: i32,
+        diff_list: &mut Vec<Diff>,
+    ) -> Result<(), String> {
         let old_value = self.model.get_column_style(sheet, column)?;
         self.model.delete_column_style(sheet, column)?;
         diff_list.push(Diff::DeleteColumnStyle {
@@ -739,12 +743,15 @@ impl UserModel {
                 }
             }
         }
-        self.push_diff_list(diff_list);
         Ok(())
     }
 
-    fn clear_row_formatting(&mut self, sheet: u32, row: i32) -> Result<(), String> {
-        let mut diff_list = Vec::new();
+    fn clear_row_formatting(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        diff_list: &mut Vec<Diff>,
+    ) -> Result<(), String> {
         let old_value = self.model.get_row_style(sheet, row)?;
         self.model.delete_row_style(sheet, row)?;
         diff_list.push(Diff::DeleteRowStyle {
@@ -791,8 +798,6 @@ impl UserModel {
                 }
             }
         }
-        self.push_diff_list(diff_list);
-
         Ok(())
     }
 
@@ -803,19 +808,21 @@ 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)?;
+                self.clear_column_formatting(sheet, column, &mut diff_list)?;
             }
+            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)?;
+                self.clear_row_formatting(sheet, row, &mut diff_list)?;
             }
+            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)? {
@@ -851,105 +858,184 @@ impl UserModel {
         Ok(())
     }
 
-    /// Inserts a row
+    /// Inserts `row_count` blank rows starting at `row` (both 0-based).
     ///
-    /// 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 }];
+    /// 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,
+        }];
         self.push_diff_list(diff_list);
-        self.model.insert_rows(sheet, row, 1)?;
         self.evaluate_if_not_paused();
         Ok(())
     }
 
-    /// Deletes a row
+    /// Inserts `column_count` blank columns starting at `column` (0-based).
     ///
-    /// See also:
-    /// * [Model::delete_rows]
-    pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<(), String> {
-        let mut row_data = None;
+    /// 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> {
         let worksheet = self.model.workbook.worksheet(sheet)?;
-        for rd in &worksheet.rows {
-            if rd.r == row {
-                row_data = Some(rd.clone());
-                break;
+        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;
+                }
             }
+            let data = match worksheet.sheet_data.get(&r) {
+                Some(s) => s.clone(),
+                None => HashMap::new(),
+            };
+            old_data.push(RowData {
+                row: row_data,
+                data,
+            });
         }
-        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 {
+
+        self.model.delete_rows(sheet, row, row_count)?;
+
+        let diff_list = vec![Diff::DeleteRows {
             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(())
     }
 
-    /// Inserts a column
+    /// Deletes `column_count` columns starting at `column`.
     ///
-    /// 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
+    /// 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::delete_columns]
-    pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<(), String> {
+    /// See also [`Model::delete_columns`].
+    pub fn delete_columns(
+        &mut self,
+        sheet: u32,
+        column: i32,
+        column_count: i32,
+    ) -> Result<(), String> {
         let worksheet = self.model.workbook.worksheet(sheet)?;
-        if !is_valid_column_number(column) {
-            return Err(format!("Column number '{column}' is not valid."));
-        }
-
-        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;
+        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;
+                }
             }
-        }
 
-        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 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 diff_list = vec![Diff::DeleteColumn {
-            sheet,
-            column,
-            old_data: Box::new(ColumnData {
+            old_data.push(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.model.delete_columns(sheet, column, 1)?;
+        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.evaluate_if_not_paused();
         Ok(())
     }
@@ -1595,6 +1681,66 @@ 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 a copy of the selected area
     pub fn copy_to_clipboard(&self) -> Result<Clipboard, String> {
         let selected_area = self.get_selected_view();
@@ -1634,7 +1780,7 @@ impl UserModel {
         .map_err(|e| format!("Error converting from utf8: '{e}'"))?;
 
         Ok(Clipboard {
-            csv,
+            csv: csv.trim().to_string(),
             data,
             sheet,
             range: (row_start, column_start, row_end, column_end),
@@ -1802,7 +1948,7 @@ impl UserModel {
         }
         self.push_diff_list(diff_list);
         // select the pasted area
-        self.set_selected_range(area.row, area.column, row, column)?;
+        self.set_selected_range(area.row, area.column, row - 1, column - 1)?;
         self.evaluate_if_not_paused();
         Ok(())
     }
@@ -1967,45 +2113,56 @@ impl UserModel {
                         self.model.cell_clear_all(*sheet, *row, *column)?;
                     }
                 }
-                Diff::InsertRow { sheet, row } => {
-                    self.model.delete_rows(*sheet, *row, 1)?;
+                Diff::InsertRows { sheet, row, count } => {
+                    self.model.delete_rows(*sheet, *row, *count)?;
                     needs_evaluation = true;
                 }
-                Diff::DeleteRow {
+                Diff::DeleteRows {
                     sheet,
                     row,
+                    count: _,
                     old_data,
                 } => {
                     needs_evaluation = true;
-                    self.model.insert_rows(*sheet, *row, 1)?;
+                    self.model
+                        .insert_rows(*sheet, *row, old_data.len() as i32)?;
                     let worksheet = self.model.workbook.worksheet_mut(*sheet)?;
-                    if let Some(row_data) = old_data.row.clone() {
-                        worksheet.rows.push(row_data);
+                    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());
                     }
-                    worksheet.sheet_data.insert(*row, old_data.data.clone());
                 }
-                Diff::InsertColumn { sheet, column } => {
-                    self.model.delete_columns(*sheet, *column, 1)?;
-                    needs_evaluation = true;
-                }
-                Diff::DeleteColumn {
+                Diff::InsertColumns {
                     sheet,
                     column,
+                    count,
+                } => {
+                    self.model.delete_columns(*sheet, *column, *count)?;
+                    needs_evaluation = true;
+                }
+                Diff::DeleteColumns {
+                    sheet,
+                    column,
+                    count: _,
                     old_data,
                 } => {
                     needs_evaluation = true;
-                    // inserts an empty column
-                    self.model.insert_columns(*sheet, *column, 1)?;
-                    // puts all the data back
+                    self.model
+                        .insert_columns(*sheet, *column, old_data.len() as i32)?;
                     let worksheet = self.model.workbook.worksheet_mut(*sheet)?;
-                    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)?;
+                    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)?;
+                        }
                     }
                 }
                 Diff::SetFrozenRowsCount {
@@ -2163,6 +2320,21 @@ 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 {
@@ -2231,28 +2403,34 @@ impl UserModel {
                 } => self
                     .model
                     .set_cell_style(*sheet, *row, *column, new_value)?,
-                Diff::InsertRow { sheet, row } => {
-                    self.model.insert_rows(*sheet, *row, 1)?;
+                Diff::InsertRows { sheet, row, count } => {
+                    self.model.insert_rows(*sheet, *row, *count)?;
                     needs_evaluation = true;
                 }
-                Diff::DeleteRow {
+                Diff::DeleteRows {
                     sheet,
                     row,
+                    count,
                     old_data: _,
                 } => {
-                    self.model.delete_rows(*sheet, *row, 1)?;
+                    self.model.delete_rows(*sheet, *row, *count)?;
                     needs_evaluation = true;
                 }
-                Diff::InsertColumn { sheet, column } => {
-                    needs_evaluation = true;
-                    self.model.insert_columns(*sheet, *column, 1)?;
-                }
-                Diff::DeleteColumn {
+                Diff::InsertColumns {
                     sheet,
                     column,
+                    count,
+                } => {
+                    self.model.insert_columns(*sheet, *column, *count)?;
+                    needs_evaluation = true;
+                }
+                Diff::DeleteColumns {
+                    sheet,
+                    column,
+                    count,
                     old_data: _,
                 } => {
-                    self.model.delete_columns(*sheet, *column, 1)?;
+                    self.model.delete_columns(*sheet, *column, *count)?;
                     needs_evaluation = true;
                 }
                 Diff::SetFrozenRowsCount {
@@ -2364,6 +2542,18 @@ 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

@@ -87,23 +87,27 @@ pub(crate) enum Diff {
         row: i32,
         old_value: Box<Option<Style>>,
     },
-    InsertRow {
+    InsertRows {
         sheet: u32,
         row: i32,
+        count: i32,
     },
-    DeleteRow {
+    DeleteRows {
         sheet: u32,
         row: i32,
-        old_data: Box<RowData>,
+        count: i32,
+        old_data: Vec<RowData>,
     },
-    InsertColumn {
+    InsertColumns {
         sheet: u32,
         column: i32,
+        count: i32,
     },
-    DeleteColumn {
+    DeleteColumns {
         sheet: u32,
         column: i32,
-        old_data: Box<ColumnData>,
+        count: i32,
+        old_data: Vec<ColumnData>,
     },
     DeleteSheet {
         sheet: u32,
@@ -161,6 +165,16 @@ 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;
-mod history;
+pub(crate) mod history;
 mod ui;
 
 pub use common::UserModel;

base/src/user_model/ui.rs

@@ -2,7 +2,11 @@
 
 use serde::{Deserialize, Serialize};
 
-use crate::expressions::utils::{is_valid_column_number, is_valid_row};
+use crate::{
+    constants::{LAST_COLUMN, LAST_ROW},
+    expressions::utils::{is_valid_column_number, is_valid_row},
+    worksheet::NavigationDirection,
+};
 
 use super::common::UserModel;
 
@@ -110,7 +114,7 @@ impl UserModel {
         Ok(())
     }
 
-    /// Sets the selected range. Note that the selected cell must be in one of the corners.
+    /// Sets the selected range. Note that the selected cell must be in the selected range.
     pub fn set_selected_range(
         &mut self,
         start_row: i32,
@@ -144,16 +148,32 @@ impl UserModel {
             if let Some(view) = worksheet.views.get_mut(&0) {
                 let selected_row = view.row;
                 let selected_column = view.column;
-                // 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 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})'"
                     ));
-                }
-                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})'"
+                    }
+                    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})'"
                     ));
+                    }
                 }
                 view.range = [start_row, start_column, end_row, end_column];
             }
@@ -190,6 +210,17 @@ 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" => {
@@ -472,7 +503,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 {
+        while row <= new_row + 1 && row <= LAST_ROW {
             height += self.model.get_row_height(sheet, row)?;
             row += 1;
         }
@@ -682,4 +713,94 @@ 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,15 +4,20 @@
 Example usage:
 
 ```javascript
-import { Model } from '@ironcalc/wasm';
+import { Model } from '@ironcalc/nodejs';
  
 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);
+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
 
 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
-  insertRow(sheet: number, row: number): void
-  insertColumn(sheet: number, column: number): void
-  deleteRow(sheet: number, row: number): void
-  deleteColumn(sheet: number, column: 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
   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,4 +340,20 @@ 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,24 +183,36 @@ impl UserModel {
       .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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "setRowsHeight")]
@@ -651,4 +663,20 @@ 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.0"
+version = "0.5.7"
 edition = "2021"
 
 
@@ -13,7 +13,8 @@ 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.23", features = ["extension-module"] }
+pyo3 = { version = "0.25", features = ["extension-module"] }
+bitcode = "0.6.3"
 
 
 [features]

bindings/python/README.md

@@ -10,9 +10,6 @@ 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:
@@ -28,4 +25,18 @@ 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.
+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/
+```

bindings/python/build_docs.sh

@@ -0,0 +1,9 @@
+#!/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/index.rst

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

bindings/python/docs/raw_api_reference.rst

@@ -1,6 +1,6 @@
 
-API Reference
--------------
+Raw 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/top_level_methods.rst

@@ -1,6 +1,13 @@
 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_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

bindings/python/docs/user_api_reference.rst

@@ -0,0 +1,41 @@
+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.0"
+version = "0.5.7"
 description = "Create, edit and evaluate Excel spreadsheets"
 requires-python = ">=3.10"
 keywords = [

bindings/python/src/lib.rs

@@ -1,19 +1,89 @@
 use pyo3::exceptions::PyException;
 use pyo3::{create_exception, prelude::*, wrap_pyfunction};
 
-use types::{PySheetProperty, PyStyle};
-use xlsx::base::types::Style;
-use xlsx::base::Model;
+use types::{PyCellType, PySheetProperty, PyStyle};
+use xlsx::base::types::{Style, Workbook};
+use xlsx::base::{Model, UserModel};
 
 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 {
@@ -32,6 +102,12 @@ 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()
@@ -225,6 +301,24 @@ 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");
@@ -249,7 +343,19 @@ pub fn load_from_icalc(file_name: &str) -> PyResult<PyModel> {
     Ok(PyModel { model })
 }
 
-/// Creates an empty 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
 #[pyfunction]
 pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
     let model =
@@ -257,6 +363,49 @@ 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() {
@@ -272,7 +421,14 @@ 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,3 +6,52 @@ 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,6 +7,7 @@ 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,
 };
 
@@ -195,24 +196,61 @@ impl Model {
             .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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "setRowsHeight")]
@@ -530,6 +568,20 @@ 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);
@@ -690,4 +742,28 @@ 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)
+    }
 }

bindings/wasm/tests/test.mjs

@@ -130,5 +130,82 @@ 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)");
+});

docs/package.json

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

docs/src/features/keyboard-shortcuts.md

@@ -6,23 +6,57 @@ lang: en-US
 
 # Keyboard Shortcuts
 
-From within your keyboard you can navigate and interact with the spreadsheet. This is a fairly interesting feature for power users.
+From within your keyboard you can navigate and interact with the spreadsheet.
 
-## Common Actions
+## Navigation Shortcuts
 
-| Action | Windows  | Mac   |
-| ------ | -------- | ----- |
-| Copy   | ctrl + c | ⌘ + c |
-| Paste  | ctrl + v | ⌘ + v |
-| Cut    | ctrl + x | ⌘ + x |
-| Undo   | ctrl + z | ⌘ + z |
-| Redo   | ctrl + y | ⌘ + y |
+| 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 + →     |
 
-## Navigation
+## Selection & Editing
 
-| <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               |
+| 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               |

docs/src/features/value-types.md

@@ -66,4 +66,8 @@ Using IronCalc, a complex number is a string of the form "1+j3".
 
 "#N/A" => #N/A
 
-## Arrays
+## 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. 

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       | <Badge type="tip" text="Available" />          | [COLUMN](lookup_and_reference/column)             |
 | 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,8 +4,28 @@ outline: deep
 lang: en-US
 ---
 
-# 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).
-:::
+# 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

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" />          | –             |
-| ACOSH           | <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) |
 | 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" />          | –             |
-| ASINH           | <Badge type="tip" text="Available" />          | –             |
-| ATAN            | <Badge type="tip" text="Available" />          | –             |
-| ATAN2           | <Badge type="tip" text="Available" />          | –             |
-| ATANH           | <Badge type="tip" text="Available" />          | –             |
+| 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) |
 | 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            | <Badge type="tip" text="Available" />          | [COSH](math_and_trigonometry/cosh) |
 | 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="Not implemented yet" /> | –             |
-| LOG             | <Badge type="info" text="Not implemented yet" /> | –             |
-| LOG10           | <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" />           | –             |
 | 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            | <Badge type="tip" text="Available" />          | [SINH](math_and_trigonometry/sinh) |
 | SQRT            | <Badge type="tip" text="Available" />          | –             |
-| SQRTPI          | <Badge type="info" text="Not implemented yet" /> | –             |
+| SQRTPI          | <Badge type="info" text="Available" />         | –             |
 | 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="Not implemented yet" /> | –             |
+| SUMIFS          | <Badge type="info" text="Available" />         | –             |
 | 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            | <Badge type="tip" text="Available" />          | [TANH](math_and_trigonometry/tanh) |
 | TRUNC           | <Badge type="info" text="Not implemented yet" /> | –             |

docs/src/functions/math_and_trigonometry/acos.md

@@ -4,8 +4,35 @@ outline: deep
 lang: en-US
 ---
 
-# ACOS
+# 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>
 
-::: 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).
-:::
+## 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.

docs/src/functions/math_and_trigonometry/acosh.md

@@ -3,9 +3,40 @@ 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.
 
-# ACOSH
+### Additional guidance
+The hyperbolic arccosine function is defined as:
 
-::: 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).
-:::
+$$
+\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.

docs/src/functions/math_and_trigonometry/asin.md

@@ -4,8 +4,37 @@ outline: deep
 lang: en-US
 ---
 
-# ASIN
+# 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).
-:::
+## 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.

docs/src/functions/math_and_trigonometry/asinh.md

@@ -4,8 +4,36 @@ outline: deep
 lang: en-US
 ---
 
-# ASINH
+# 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>
 
-::: 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).
-:::
+## 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.

docs/src/functions/math_and_trigonometry/atan.md

@@ -4,8 +4,34 @@ outline: deep
 lang: en-US
 ---
 
-# ATAN
+# 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>
 
-::: 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).
-:::
+## 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.

docs/src/functions/math_and_trigonometry/atan2.md

@@ -4,8 +4,34 @@ outline: deep
 lang: en-US
 ---
 
-# ATAN2
+# 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.
 
-::: 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,8 +4,37 @@ outline: deep
 lang: en-US
 ---
 
-# ATANH
+# 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>
 
-::: 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).
-:::
+## 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.

docs/src/functions/math_and_trigonometry/cosh.md

@@ -3,9 +3,37 @@ 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>
 
-# COSH
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=cosh).
 
-::: 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).
-:::
+## 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.

docs/src/functions/math_and_trigonometry/ln.md

@@ -7,6 +7,5 @@ lang: en-US
 # LN
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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/log.md

@@ -7,6 +7,5 @@ lang: en-US
 # LOG
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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/log10.md

@@ -7,6 +7,5 @@ lang: en-US
 # LOG10
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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/sinh.md

@@ -3,9 +3,37 @@ 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>
 
-# SINH
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=sinh).
 
-::: 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).
-:::
+## 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.

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 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.
+* 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.
 ## Examples
 [See some examples in IronCalc](https://app.ironcalc.com/?example=tan).
 

docs/src/functions/math_and_trigonometry/tanh.md

@@ -3,9 +3,37 @@ 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>
 
-# TANH
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=tanh).
 
-::: 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).
-:::
+## 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.

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

@@ -249,6 +249,9 @@ 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

@@ -99,10 +99,9 @@ const FormulaSymbolButton = styled(StyledButton)`
 
 const Divider = styled("div")`
   background-color: ${theme.palette.grey["300"]};
-  width: 1px;
-  height: 20px;
-  margin-left: 16px;
-  margin-right: 16px;
+  min-width: 1px;
+  height: 16px;
+  margin: 0px 16px;
 `;
 
 const FormulaContainer = styled("div")`

webapp/IronCalc/src/components/Workbook/Workbook.tsx

@@ -13,6 +13,7 @@ import Worksheet from "../Worksheet/Worksheet";
 import {
   COLUMN_WIDTH_SCALE,
   LAST_COLUMN,
+  LAST_ROW,
   ROW_HEIGH_SCALE,
 } from "../WorksheetCanvas/constants";
 import type WorksheetCanvas from "../WorksheetCanvas/worksheetCanvas";
@@ -21,6 +22,7 @@ import {
   CLIPBOARD_ID_SESSION_STORAGE_KEY,
   getNewClipboardId,
 } from "../clipboard";
+import { TOOLBAR_HEIGHT } from "../constants";
 import {
   type NavigationKey,
   getCellAddress,
@@ -40,6 +42,8 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
   // This is needed because `model` or `workbookState` can change without React being aware of it
   const setRedrawId = useState(0)[1];
 
+  const [isDrawerOpen, setDrawerOpen] = useState(false);
+
   const worksheets = model.getWorksheetsProperties();
   const info = worksheets.map(
     ({ name, color, sheet_id, state }: WorksheetProperties) => {
@@ -249,8 +253,8 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
       onToggleUnderline(!value);
     },
     onNavigationToEdge: (direction: NavigationKey): void => {
-      console.log(direction);
-      throw new Error("Function not implemented.");
+      model.onNavigateToEdgeInDirection(direction);
+      setRedrawId((id) => id + 1);
     },
     onPageDown: (): void => {
       model.onPageDown();
@@ -318,6 +322,16 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
       workbookState.clearCutRange();
       setRedrawId((id) => id + 1);
     },
+    onSelectColumn: (): void => {
+      const { column } = model.getSelectedView();
+      model.setSelectedRange(1, column, LAST_ROW, column);
+      setRedrawId((id) => id + 1);
+    },
+    onSelectRow: (): void => {
+      const { row } = model.getSelectedView();
+      model.setSelectedRange(row, 1, row, LAST_COLUMN);
+      setRedrawId((id) => id + 1);
+    },
     root: rootRef,
   });
 
@@ -473,7 +487,7 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
           sheet,
           clipboardId,
         });
-        event.clipboardData.setData("text/plain", data.csv);
+        event.clipboardData.setData("text/plain", data.csv.trim());
         event.clipboardData.setData("application/json", clipboardJsonStr);
         event.preventDefault();
         event.stopPropagation();
@@ -681,77 +695,119 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
           worksheets,
           definedNameList: model.getDefinedNameList(),
         }}
-      />
-      <FormulaBar
-        cellAddress={cellAddress()}
-        formulaValue={formulaValue()}
-        onChange={() => {
-          setRedrawId((id) => id + 1);
-          focusWorkbook();
+        openDrawer={() => {
+          setDrawerOpen(true);
         }}
-        onTextUpdated={() => {
-          setRedrawId((id) => id + 1);
-        }}
-        model={model}
-        workbookState={workbookState}
-      />
-      <Worksheet
-        model={model}
-        workbookState={workbookState}
-        refresh={(): void => {
-          setRedrawId((id) => id + 1);
-        }}
-        ref={worksheetRef}
       />
+      <WorksheetAreaLeft $drawerWidth={isDrawerOpen ? DRAWER_WIDTH : 0}>
+        <FormulaBar
+          cellAddress={cellAddress()}
+          formulaValue={formulaValue()}
+          onChange={() => {
+            setRedrawId((id) => id + 1);
+            focusWorkbook();
+          }}
+          onTextUpdated={() => {
+            setRedrawId((id) => id + 1);
+          }}
+          model={model}
+          workbookState={workbookState}
+        />
+        <Worksheet
+          model={model}
+          workbookState={workbookState}
+          refresh={(): void => {
+            setRedrawId((id) => id + 1);
+          }}
+          ref={worksheetRef}
+        />
 
-      <SheetTabBar
-        sheets={info}
-        selectedIndex={model.getSelectedSheet()}
-        workbookState={workbookState}
-        onSheetSelected={(sheet: number): void => {
-          if (info[sheet].state !== "visible") {
-            model.unhideSheet(sheet);
-          }
-          model.setSelectedSheet(sheet);
-          setRedrawId((value) => value + 1);
-        }}
-        onAddBlankSheet={(): void => {
-          model.newSheet();
-          setRedrawId((value) => value + 1);
-        }}
-        onSheetColorChanged={(hex: string): void => {
-          try {
-            model.setSheetColor(model.getSelectedSheet(), hex);
+        <SheetTabBar
+          sheets={info}
+          selectedIndex={model.getSelectedSheet()}
+          workbookState={workbookState}
+          onSheetSelected={(sheet: number): void => {
+            if (info[sheet].state !== "visible") {
+              model.unhideSheet(sheet);
+            }
+            model.setSelectedSheet(sheet);
             setRedrawId((value) => value + 1);
-          } catch (e) {
-            // TODO: Show a proper modal dialog
-            alert(`${e}`);
-          }
-        }}
-        onSheetRenamed={(name: string): void => {
-          try {
-            model.renameSheet(model.getSelectedSheet(), name);
+          }}
+          onAddBlankSheet={(): void => {
+            model.newSheet();
             setRedrawId((value) => value + 1);
-          } catch (e) {
-            // TODO: Show a proper modal dialog
-            alert(`${e}`);
-          }
-        }}
-        onSheetDeleted={(): void => {
-          const selectedSheet = model.getSelectedSheet();
-          model.deleteSheet(selectedSheet);
-          setRedrawId((value) => value + 1);
-        }}
-        onHideSheet={(): void => {
-          const selectedSheet = model.getSelectedSheet();
-          model.hideSheet(selectedSheet);
-          setRedrawId((value) => value + 1);
-        }}
-      />
+          }}
+          onSheetColorChanged={(hex: string): void => {
+            try {
+              model.setSheetColor(model.getSelectedSheet(), hex);
+              setRedrawId((value) => value + 1);
+            } catch (e) {
+              // TODO: Show a proper modal dialog
+              alert(`${e}`);
+            }
+          }}
+          onSheetRenamed={(name: string): void => {
+            try {
+              model.renameSheet(model.getSelectedSheet(), name);
+              setRedrawId((value) => value + 1);
+            } catch (e) {
+              // TODO: Show a proper modal dialog
+              alert(`${e}`);
+            }
+          }}
+          onSheetDeleted={(): void => {
+            const selectedSheet = model.getSelectedSheet();
+            model.deleteSheet(selectedSheet);
+            setRedrawId((value) => value + 1);
+          }}
+          onHideSheet={(): void => {
+            const selectedSheet = model.getSelectedSheet();
+            model.hideSheet(selectedSheet);
+            setRedrawId((value) => value + 1);
+          }}
+        />
+      </WorksheetAreaLeft>
+      <WorksheetAreaRight $drawerWidth={isDrawerOpen ? DRAWER_WIDTH : 0}>
+        <span
+          onClick={() => setDrawerOpen(false)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter" || e.key === " ") {
+              setDrawerOpen(false);
+            }
+          }}
+          aria-label="Close drawer"
+        >
+          x
+        </span>
+      </WorksheetAreaRight>
     </Container>
   );
 };
 
+const DRAWER_WIDTH = 300;
+
+type WorksheetAreaLeftProps = { $drawerWidth: number };
+const WorksheetAreaLeft = styled("div")<WorksheetAreaLeftProps>(
+  ({ $drawerWidth }) => ({
+    position: "absolute",
+    top: `${TOOLBAR_HEIGHT + 1}px`,
+    width: `calc(100% - ${$drawerWidth}px)`,
+    height: `calc(100% - ${TOOLBAR_HEIGHT + 1}px)`,
+  }),
+);
+
+const WorksheetAreaRight = styled("div")<WorksheetAreaLeftProps>(
+  ({ $drawerWidth }) => ({
+    position: "absolute",
+    overflow: "hidden",
+    backgroundColor: "red",
+    right: 0,
+    top: `${TOOLBAR_HEIGHT + 1}px`,
+    bottom: 0,
+    width: `${$drawerWidth}px`,
+  }),
+);
+
 const Container = styled("div")`
   display: flex;
   flex-direction: column;

webapp/IronCalc/src/components/Workbook/useKeyboardNavigation.ts

@@ -32,6 +32,8 @@ interface Options {
   onNextSheet: () => void;
   onPreviousSheet: () => void;
   onEscape: () => void;
+  onSelectColumn: () => void;
+  onSelectRow: () => void;
   root: RefObject<HTMLDivElement | null>;
 }
 
@@ -51,6 +53,16 @@ interface Options {
 // * Ctrl+u/i/b: style
 // * Ctrl+z/y: undo/redo
 // * F2: start editing
+// * Ctrl+Space: select column
+// * Shift+Space: select row
+//
+// # Not implemented yet:
+// * Ctrl+a: select all (continuous area around the selection, if it exists,
+//   otherwise select whole sheet)
+// * Ctrl+Shift+Arrows: select to edge
+// * Ctrl+Shift+Home/End: select to end
+// * Ctrl+Shift++: (after selecting) insert row/column (also Alt+I, R or C)
+// * Ctrl+-: (after selecting) delete row/column
 
 // References:
 // In Google Sheets: Ctrl+/ shows the list of keyboard shortcuts
@@ -63,6 +75,7 @@ const useKeyboardNavigation = (
   const onKeyDown = useCallback(
     (event: KeyboardEvent) => {
       const { key } = event;
+      const lowerKey = key.toLowerCase();
       const { root } = options;
       // Silence the linter
       if (!root.current) {
@@ -71,41 +84,40 @@ const useKeyboardNavigation = (
       if (event.target !== root.current) {
         return;
       }
-      if (event.metaKey || event.ctrlKey) {
-        switch (key) {
+      const isCtrl = event.metaKey || event.ctrlKey;
+      const isShift = event.shiftKey;
+      const isAlt = event.altKey;
+      if (isCtrl && !isShift && !isAlt) {
+        // Ctrl+...
+        switch (lowerKey) {
           case "z": {
             options.onUndo();
             event.stopPropagation();
             event.preventDefault();
-
             break;
           }
           case "y": {
             options.onRedo();
             event.stopPropagation();
             event.preventDefault();
-
             break;
           }
           case "b": {
             options.onBold();
             event.stopPropagation();
             event.preventDefault();
-
             break;
           }
           case "i": {
             options.onItalic();
             event.stopPropagation();
             event.preventDefault();
-
             break;
           }
           case "u": {
             options.onUnderline();
             event.stopPropagation();
             event.preventDefault();
-
             break;
           }
           case "a": {
@@ -115,18 +127,60 @@ const useKeyboardNavigation = (
             event.preventDefault();
             break;
           }
+          case " ": {
+            options.onSelectColumn();
+            event.stopPropagation();
+            event.preventDefault();
+            break;
+          }
           // No default
         }
         if (isNavigationKey(key)) {
           // Ctrl+Arrows, Ctrl+Home/End
           options.onNavigationToEdge(key);
-          // navigate_to_edge_in_direction
           event.stopPropagation();
           event.preventDefault();
         }
         return;
       }
-      if (event.altKey) {
+      if (isCtrl && isShift && !isAlt) {
+        // Ctrl+Shift+...
+        switch (lowerKey) {
+          case "z": {
+            options.onRedo();
+            event.stopPropagation();
+            event.preventDefault();
+            break;
+          }
+        }
+        return;
+      }
+      if (isShift && !isAlt && !isCtrl) {
+        // Shift+...
+        switch (key) {
+          case " ": {
+            options.onSelectRow();
+            event.stopPropagation();
+            event.preventDefault();
+            break;
+          }
+          case "ArrowRight":
+          case "ArrowLeft":
+          case "ArrowUp":
+          case "ArrowDown": {
+            options.onExpandAreaSelectedKeyboard(key);
+            break;
+          }
+          case "Tab": {
+            options.onArrowLeft();
+            event.stopPropagation();
+            event.preventDefault();
+            break;
+          }
+        }
+      }
+      if (isAlt && !isCtrl && !isShift) {
+        // Alt+...
         switch (key) {
           case "ArrowDown": {
             // select next sheet
@@ -143,13 +197,13 @@ const useKeyboardNavigation = (
             break;
           }
         }
-      }
-      if (key === "F2") {
-        options.onCellEditStart();
-        event.stopPropagation();
-        event.preventDefault();
         return;
       }
+      if (isCtrl || isAlt) {
+        // Other combinations with Ctrl or Alt are not handled
+        return;
+      }
+
       if (isEditingKey(key) || key === "Backspace") {
         const initText = key === "Backspace" ? "" : key;
         options.onEditKeyPressStart(initText);
@@ -157,68 +211,54 @@ const useKeyboardNavigation = (
         event.preventDefault();
         return;
       }
-      // Worksheet Navigation
-      if (event.shiftKey) {
-        if (
-          key === "ArrowRight" ||
-          key === "ArrowLeft" ||
-          key === "ArrowUp" ||
-          key === "ArrowDown"
-        ) {
-          options.onExpandAreaSelectedKeyboard(key);
-        } else if (key === "Tab") {
-          options.onArrowLeft();
-          event.stopPropagation();
-          event.preventDefault();
-        }
+      if (isShift) {
+        // Other combinations with Shift are not handled
         return;
       }
+      if (key === "F2") {
+        options.onCellEditStart();
+        event.stopPropagation();
+        event.preventDefault();
+        return;
+      }
+      // Worksheet Navigation
       switch (key) {
         case "ArrowRight":
         case "Tab": {
           options.onArrowRight();
-
           break;
         }
         case "ArrowLeft": {
           options.onArrowLeft();
-
           break;
         }
         case "ArrowDown":
         case "Enter": {
           options.onArrowDown();
-
           break;
         }
         case "ArrowUp": {
           options.onArrowUp();
-
           break;
         }
         case "End": {
           options.onKeyEnd();
-
           break;
         }
         case "Home": {
           options.onKeyHome();
-
           break;
         }
         case "Delete": {
           options.onCellsDeleted();
-
           break;
         }
         case "PageDown": {
           options.onPageDown();
-
           break;
         }
         case "PageUp": {
           options.onPageUp();
-
           break;
         }
         case "Escape": {

webapp/IronCalc/src/components/Worksheet/CellContextMenu.tsx

@@ -1,5 +1,7 @@
 import { Menu, MenuItem, styled } from "@mui/material";
 import {
+  ArrowLeftRight,
+  ArrowUpDown,
   BetweenHorizontalStart,
   BetweenVerticalStart,
   ChevronRight,
@@ -26,6 +28,10 @@ interface CellContextMenuProps {
   onUnfreezeRows: () => void;
   onDeleteRow: () => void;
   onDeleteColumn: () => void;
+  onMoveColumnLeft: () => void;
+  onMoveColumnRight: () => void;
+  onMoveRowUp: () => void;
+  onMoveRowDown: () => void;
   row: number;
   column: string;
 }
@@ -46,6 +52,10 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
     onUnfreezeRows,
     onDeleteRow,
     onDeleteColumn,
+    onMoveColumnLeft,
+    onMoveColumnRight,
+    onMoveRowUp,
+    onMoveRowDown,
     row,
     column,
   } = properties;
@@ -58,6 +68,12 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
   const [insertColumnMenuOpen, setInsertColumnMenuOpen] = useState(false);
   const insertColumnRef = useRef(null);
 
+  const [moveRowMenuOpen, setMoveRowMenuOpen] = useState(false);
+  const moveRowRef = useRef(null);
+
+  const [moveColumnMenuOpen, setMoveColumnMenuOpen] = useState(false);
+  const moveColumnRef = useRef(null);
+
   return (
     <>
       <StyledMenu
@@ -90,6 +106,23 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
           <ChevronRightStyled />
         </StyledMenuItem>
         <MenuDivider />
+        <StyledMenuItem
+          ref={moveRowRef}
+          onClick={() => setMoveRowMenuOpen(true)}
+        >
+          <ArrowUpDownStyled />
+          <ItemNameStyled>{t("cell_context.move_row")}</ItemNameStyled>
+          <ChevronRightStyled />
+        </StyledMenuItem>
+        <StyledMenuItem
+          ref={moveColumnRef}
+          onClick={() => setMoveColumnMenuOpen(true)}
+        >
+          <ArrowLeftRightStyled />
+          <ItemNameStyled>{t("cell_context.move_column")}</ItemNameStyled>
+          <ChevronRightStyled />
+        </StyledMenuItem>
+        <MenuDivider />
         <StyledMenuItem ref={freezeRef} onClick={() => setFreezeMenuOpen(true)}>
           <StyledSnowflake />
           <ItemNameStyled>{t("cell_context.freeze")}</ItemNameStyled>
@@ -165,6 +198,58 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
           </ItemNameStyled>
         </StyledMenuItem>
       </StyledMenu>
+      <StyledMenu
+        open={moveRowMenuOpen}
+        onClose={() => setMoveRowMenuOpen(false)}
+        anchorEl={moveRowRef.current}
+        anchorOrigin={{
+          vertical: "top",
+          horizontal: "right",
+        }}
+      >
+        <StyledMenuItem
+          onClick={() => {
+            onMoveRowUp();
+            setMoveRowMenuOpen(false);
+          }}
+        >
+          <ItemNameStyled>{t("cell_context.move_row_up")}</ItemNameStyled>
+        </StyledMenuItem>
+        <StyledMenuItem
+          onClick={() => {
+            onMoveRowDown();
+            setMoveRowMenuOpen(false);
+          }}
+        >
+          <ItemNameStyled>{t("cell_context.move_row_down")}</ItemNameStyled>
+        </StyledMenuItem>
+      </StyledMenu>
+      <StyledMenu
+        open={moveColumnMenuOpen}
+        onClose={() => setMoveColumnMenuOpen(false)}
+        anchorEl={moveColumnRef.current}
+        anchorOrigin={{
+          vertical: "top",
+          horizontal: "right",
+        }}
+      >
+        <StyledMenuItem
+          onClick={() => {
+            onMoveColumnLeft();
+            setMoveColumnMenuOpen(false);
+          }}
+        >
+          <ItemNameStyled>{t("cell_context.move_column_left")}</ItemNameStyled>
+        </StyledMenuItem>
+        <StyledMenuItem
+          onClick={() => {
+            onMoveColumnRight();
+            setMoveColumnMenuOpen(false);
+          }}
+        >
+          <ItemNameStyled>{t("cell_context.move_column_right")}</ItemNameStyled>
+        </StyledMenuItem>
+      </StyledMenu>
       <StyledMenu
         open={freezeMenuOpen}
         onClose={() => setFreezeMenuOpen(false)}
@@ -230,6 +315,20 @@ const BetweenHorizontalStartStyled = styled(BetweenHorizontalStart)`
   padding-right: 10px;
 `;
 
+const ArrowLeftRightStyled = styled(ArrowLeftRight)`
+  width: 16px;
+  height: 16px;
+  color: ${theme.palette.grey[900]};
+  padding-right: 10px;
+`;
+
+const ArrowUpDownStyled = styled(ArrowUpDown)`
+  width: 16px;
+  height: 16px;
+  color: ${theme.palette.grey[900]};
+  padding-right: 10px;
+`;
+
 const StyledSnowflake = styled(Snowflake)`
   width: 16px;
   height: 16px;

webapp/IronCalc/src/components/Worksheet/Worksheet.tsx

@@ -18,11 +18,7 @@ import {
   outlineColor,
 } from "../WorksheetCanvas/constants";
 import WorksheetCanvas from "../WorksheetCanvas/worksheetCanvas";
-import {
-  FORMULA_BAR_HEIGHT,
-  NAVIGATION_HEIGHT,
-  TOOLBAR_HEIGHT,
-} from "../constants";
+import { FORMULA_BAR_HEIGHT, NAVIGATION_HEIGHT } from "../constants";
 import type { Cell } from "../types";
 import type { WorkbookState } from "../workbookState";
 import CellContextMenu from "./CellContextMenu";
@@ -340,22 +336,42 @@ const Worksheet = forwardRef(
           anchorEl={cellOutline.current}
           onInsertRowAbove={(): void => {
             const view = model.getSelectedView();
-            model.insertRow(view.sheet, view.row);
+            model.insertRows(view.sheet, view.row, 1);
             setContextMenuOpen(false);
           }}
           onInsertRowBelow={(): void => {
             const view = model.getSelectedView();
-            model.insertRow(view.sheet, view.row + 1);
+            model.insertRows(view.sheet, view.row + 1, 1);
             setContextMenuOpen(false);
           }}
           onInsertColumnLeft={(): void => {
             const view = model.getSelectedView();
-            model.insertColumn(view.sheet, view.column);
+            model.insertColumns(view.sheet, view.column, 1);
             setContextMenuOpen(false);
           }}
           onInsertColumnRight={(): void => {
             const view = model.getSelectedView();
-            model.insertColumn(view.sheet, view.column + 1);
+            model.insertColumns(view.sheet, view.column + 1, 1);
+            setContextMenuOpen(false);
+          }}
+          onMoveColumnLeft={(): void => {
+            const view = model.getSelectedView();
+            model.moveColumn(view.sheet, view.column, -1);
+            setContextMenuOpen(false);
+          }}
+          onMoveColumnRight={(): void => {
+            const view = model.getSelectedView();
+            model.moveColumn(view.sheet, view.column, 1);
+            setContextMenuOpen(false);
+          }}
+          onMoveRowUp={(): void => {
+            const view = model.getSelectedView();
+            model.moveRow(view.sheet, view.row, -1);
+            setContextMenuOpen(false);
+          }}
+          onMoveRowDown={(): void => {
+            const view = model.getSelectedView();
+            model.moveRow(view.sheet, view.row, 1);
             setContextMenuOpen(false);
           }}
           onFreezeColumns={(): void => {
@@ -380,12 +396,12 @@ const Worksheet = forwardRef(
           }}
           onDeleteRow={(): void => {
             const view = model.getSelectedView();
-            model.deleteRow(view.sheet, view.row);
+            model.deleteRows(view.sheet, view.row, 1);
             setContextMenuOpen(false);
           }}
           onDeleteColumn={(): void => {
             const view = model.getSelectedView();
-            model.deleteColumn(view.sheet, view.column);
+            model.deleteColumns(view.sheet, view.column, 1);
             setContextMenuOpen(false);
           }}
           row={model.getSelectedView().row}
@@ -439,7 +455,7 @@ const SheetContainer = styled("div")`
 const Wrapper = styled("div")({
   position: "absolute",
   overflow: "scroll",
-  top: TOOLBAR_HEIGHT + FORMULA_BAR_HEIGHT + 1,
+  top: FORMULA_BAR_HEIGHT + 1,
   left: 0,
   right: 0,
   bottom: NAVIGATION_HEIGHT + 1,

webapp/IronCalc/src/components/Worksheet/usePointer.ts

@@ -179,6 +179,7 @@ const usePointer = (options: PointerSettings): PointerEvents => {
       if (cell) {
         if (editingCell) {
           if (
+            model.getSelectedSheet() === editingCell.sheet &&
             cell.row === editingCell.row &&
             cell.column === editingCell.column
           ) {

webapp/IronCalc/src/components/WorksheetCanvas/constants.ts

@@ -19,3 +19,5 @@ export const LAST_ROW = 1_048_576;
 
 export const ROW_HEIGH_SCALE = 1;
 export const COLUMN_WIDTH_SCALE = 1;
+
+export const cellPadding = 4;

webapp/IronCalc/src/components/WorksheetCanvas/worksheetCanvas.ts

@@ -1,4 +1,4 @@
-import type { Model } from "@ironcalc/wasm";
+import type { CellStyle, Model } from "@ironcalc/wasm";
 import { columnNameFromNumber } from "@ironcalc/wasm";
 import { getColor } from "../Editor/util";
 import type { Cell } from "../types";
@@ -8,6 +8,7 @@ import {
   LAST_COLUMN,
   LAST_ROW,
   ROW_HEIGH_SCALE,
+  cellPadding,
   defaultTextColor,
   gridColor,
   gridSeparatorColor,
@@ -54,6 +55,20 @@ export const defaultCellFontFamily = fonts.regular;
 export const headerFontFamily = fonts.regular;
 export const frozenSeparatorWidth = 3;
 
+interface TextProperties {
+  row: number;
+  column: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  fontSize: number;
+  textColor: string;
+  font: string;
+  underlined: boolean;
+  strike: boolean;
+  lines: [string, number, number, number][];
+}
 export default class WorksheetCanvas {
   sheetWidth: number;
 
@@ -93,6 +108,9 @@ export default class WorksheetCanvas {
 
   refresh: () => void;
 
+  cells: TextProperties[];
+  spills: Map<string, number>;
+
   constructor(options: CanvasSettings) {
     this.model = options.model;
     this.sheetWidth = 0;
@@ -116,6 +134,10 @@ export default class WorksheetCanvas {
     this.onRowHeightChanges = options.onRowHeightChanges;
     this.resetHeaders();
     this.cellOutlineHandle = attachOutlineHandle(this);
+
+    // a cell marked as "spill" means its left border should be skipped
+    this.spills = new Map<string, number>();
+    this.cells = [];
   }
 
   setScrollPosition(scrollPosition: { left: number; top: number }): void {
@@ -318,7 +340,376 @@ export default class WorksheetCanvas {
     return left;
   }
 
-  private renderCell(
+  private getFontStyle(style: CellStyle): {
+    font: string;
+    color: string;
+    fontSize: number;
+  } {
+    const fontSize = style.font?.sz || 13;
+    let font = `${fontSize}px ${defaultCellFontFamily}`;
+    let color = defaultTextColor;
+
+    if (style.font) {
+      color = style.font.color;
+      font = style.font.b ? `bold ${font}` : `400 ${font}`;
+      if (style.font.i) {
+        font = `italic ${font}`;
+      }
+    }
+
+    return { font, color, fontSize };
+  }
+
+  private getAlignment(
+    style: CellStyle,
+    cellType: number,
+  ): { horizontal: string; vertical: string } {
+    let horizontal = style.alignment?.horizontal || "general";
+    const vertical = style.alignment?.vertical || "bottom";
+
+    if (horizontal === "general") {
+      if (cellType === 1) {
+        horizontal = "right";
+      } else if (cellType === 4) {
+        horizontal = "center";
+      } else {
+        horizontal = "left";
+      }
+    }
+
+    return { horizontal, vertical };
+  }
+
+  // Computes the text of cells that are off the screen. They are important because their text may spill into the viewport.
+  private computeCellTextLeftRight(
+    selectedSheet: number,
+    row: number,
+    rowHeight: number,
+    topLeftCell: Cell,
+    bottomRightCell: Cell,
+  ): void {
+    const frozenColumnsCount = this.model.getFrozenColumnsCount(selectedSheet);
+    // First compute the text to the left of the viewport
+    const columnToTheLeft = this.model.getLastNonEmptyInRowBeforeColumn(
+      selectedSheet,
+      row,
+      topLeftCell.column,
+    );
+    // If it is one of the frozen columns it is already computed
+    if (columnToTheLeft && columnToTheLeft > frozenColumnsCount) {
+      const columnWidth = this.getColumnWidth(selectedSheet, columnToTheLeft);
+      const [textX, textY] = this.getCoordinatesByCell(row, columnToTheLeft);
+      this.computeCellText(
+        row,
+        columnToTheLeft,
+        textX,
+        textY,
+        columnWidth,
+        rowHeight,
+      );
+    }
+    // Compute the text to the right of the viewport
+    const columnToTheRight = this.model.getFirstNonEmptyInRowAfterColumn(
+      selectedSheet,
+      row,
+      bottomRightCell.column,
+    );
+
+    if (columnToTheRight) {
+      const columnWidth = this.getColumnWidth(selectedSheet, columnToTheRight);
+      const [textX, textY] = this.getCoordinatesByCell(row, columnToTheRight);
+      this.computeCellText(
+        row,
+        columnToTheRight,
+        textX,
+        textY,
+        columnWidth,
+        rowHeight,
+      );
+    }
+  }
+
+  // Goes through all the visible cells and computes their text properties
+  private computeCellsText(): void {
+    const { topLeftCell, bottomRightCell } = this.getVisibleCells();
+    const selectedSheet = this.model.getSelectedSheet();
+
+    this.cells = [];
+
+    const frozenColumns = this.model.getFrozenColumnsCount(selectedSheet);
+    const frozenRows = this.model.getFrozenRowsCount(selectedSheet);
+
+    // Top-left-pane
+    let x = headerColumnWidth + 0.5;
+    let y = headerRowHeight + 0.5;
+    for (let row = 1; row <= frozenRows; row += 1) {
+      const rowHeight = this.getRowHeight(selectedSheet, row);
+      this.computeCellTextLeftRight(
+        selectedSheet,
+        row,
+        rowHeight,
+        topLeftCell,
+        bottomRightCell,
+      );
+
+      x = headerColumnWidth + 0.5;
+      for (let column = 1; column <= frozenColumns; column += 1) {
+        const columnWidth = this.getColumnWidth(selectedSheet, column);
+        this.computeCellText(row, column, x, y, columnWidth, rowHeight);
+
+        x += columnWidth;
+      }
+      y += rowHeight;
+    }
+    if (frozenRows === 0 && frozenColumns !== 0) {
+      x = headerColumnWidth + 0.5;
+      for (let column = 1; column <= frozenColumns; column += 1) {
+        x += this.getColumnWidth(selectedSheet, column);
+      }
+    }
+
+    // If there are frozen rows draw a separator
+    if (frozenRows) {
+      y += frozenSeparatorWidth;
+    }
+
+    // If there are frozen columns draw a separator
+    if (frozenColumns) {
+      x += frozenSeparatorWidth;
+    }
+
+    const frozenX = x;
+    const frozenY = y;
+    // Top-right pane
+    y = headerRowHeight + 0.5;
+    for (let row = 1; row <= frozenRows; row += 1) {
+      x = frozenX;
+      const rowHeight = this.getRowHeight(selectedSheet, row);
+      for (
+        let { column } = topLeftCell;
+        column <= bottomRightCell.column;
+        column += 1
+      ) {
+        const columnWidth = this.getColumnWidth(selectedSheet, column);
+        this.computeCellText(row, column, x, y, columnWidth, rowHeight);
+
+        x += columnWidth;
+      }
+      y += rowHeight;
+    }
+
+    // Bottom-left pane
+    y = frozenY;
+    for (let { row } = topLeftCell; row <= bottomRightCell.row; row += 1) {
+      x = headerColumnWidth;
+      const rowHeight = this.getRowHeight(selectedSheet, row);
+
+      this.computeCellTextLeftRight(
+        selectedSheet,
+        row,
+        rowHeight,
+        topLeftCell,
+        bottomRightCell,
+      );
+      for (let column = 1; column <= frozenColumns; column += 1) {
+        const columnWidth = this.getColumnWidth(selectedSheet, column);
+        this.computeCellText(row, column, x, y, columnWidth, rowHeight);
+
+        x += columnWidth;
+      }
+      y += rowHeight;
+    }
+
+    // Bottom-right pane
+    y = frozenY;
+    for (let { row } = topLeftCell; row <= bottomRightCell.row; row += 1) {
+      x = frozenX;
+      const rowHeight = this.getRowHeight(selectedSheet, row);
+
+      for (
+        let { column } = topLeftCell;
+        column <= bottomRightCell.column;
+        column += 1
+      ) {
+        const columnWidth = this.getColumnWidth(selectedSheet, column);
+        this.computeCellText(row, column, x, y, columnWidth, rowHeight);
+
+        x += columnWidth;
+      }
+      y += rowHeight;
+    }
+  }
+
+  // Compute the text properties for a cell
+  private computeCellText(
+    row: number,
+    column: number,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  ) {
+    const selectedSheet = this.model.getSelectedSheet();
+
+    const style = this.model.getCellStyle(selectedSheet, row, column);
+
+    const { font, color: textColor, fontSize } = this.getFontStyle(style);
+
+    // Number = 1,
+    // Text = 2,
+    // LogicalValue = 4,
+    // ErrorValue = 16,
+    // Array = 64,
+    // CompoundData = 128,
+    const cellType = this.model.getCellType(selectedSheet, row, column);
+    const { horizontal: horizontalAlign, vertical: verticalAlign } =
+      this.getAlignment(style, cellType);
+
+    const wrapText = style.alignment?.wrap_text || false;
+
+    const context = this.ctx;
+    context.font = font;
+    context.fillStyle = textColor;
+    const fullText = this.model.getFormattedCellValue(
+      selectedSheet,
+      row,
+      column,
+    );
+
+    // Is there any better to determine the line height?
+    const lineHeight = fontSize * 1.5;
+    const lines = computeWrappedLines(
+      fullText,
+      wrapText,
+      context,
+      width - cellPadding,
+    );
+    const lineCount = lines.length;
+    let maxWidth = 0;
+    let minX = x;
+    let maxX = x + width;
+    const textProperties = {
+      row,
+      column,
+      x: minX,
+      y,
+      width,
+      height,
+      fontSize,
+      textColor,
+      font,
+      underlined: style.font?.u || false,
+      strike: style.font?.strike || false,
+      lines: [] as [string, number, number, number][],
+    };
+
+    lines.forEach((text, line) => {
+      const textWidth = context.measureText(text).width;
+      let textX: number;
+      let textY: number;
+      // The idea is that in the present font-size and default row heigh,
+      // top/bottom and center horizontalAlign coincide
+      const verticalPadding = 4;
+      if (horizontalAlign === "right") {
+        textX = width - cellPadding + x - textWidth / 2;
+      } else if (horizontalAlign === "center") {
+        textX = x + width / 2;
+      } else {
+        // left aligned
+        textX = cellPadding + x + textWidth / 2;
+      }
+      if (verticalAlign === "bottom") {
+        textY =
+          y +
+          height -
+          fontSize / 2 -
+          verticalPadding +
+          (line - lineCount + 1) * lineHeight;
+      } else if (verticalAlign === "center") {
+        textY = y + height / 2 + (line + (1 - lineCount) / 2) * lineHeight;
+      } else {
+        // aligned top
+        textY = y + fontSize / 2 + verticalPadding + line * lineHeight;
+      }
+      textProperties.lines.push([text, textX, textY, textWidth]);
+      minX = Math.min(minX, textX - textWidth / 2);
+      maxX = Math.max(maxX, textX + textWidth / 2);
+      maxWidth = Math.max(maxWidth, textX + textWidth / 2 - x);
+    });
+    // we need to see if the text spills to the right of the cell
+    let leftColumnX = x;
+    let rightColumnX = x + width;
+    if (
+      maxX > rightColumnX &&
+      column < LAST_COLUMN &&
+      this.model.getFormattedCellValue(selectedSheet, row, column + 1) === ""
+    ) {
+      let spillColumn = column + 1;
+      // Keep expanding the spill to the right until:
+      // 1. There is a non-empty cell
+      // 2. Reaches the end of the row
+      // 3. There is the end of frozen columns
+      const frozenColumns = this.model.getFrozenColumnsCount(selectedSheet);
+      while (
+        rightColumnX < maxX &&
+        this.model.getFormattedCellValue(selectedSheet, row, spillColumn) ===
+          "" &&
+        spillColumn <= LAST_COLUMN &&
+        ((column < frozenColumns && spillColumn <= frozenColumns) ||
+          column > frozenColumns)
+      ) {
+        rightColumnX += this.model.getColumnWidth(selectedSheet, spillColumn);
+        // marks (row, spillColumn) as spilling so we don't draw a border to the left
+        this.spills.set(`${row}-${spillColumn}`, 1);
+        spillColumn += 1;
+      }
+    }
+    // Same thing in the other direction, to the left of the cell
+    const frozenColumnsCount = this.model.getFrozenColumnsCount(selectedSheet);
+    if (
+      minX < leftColumnX &&
+      column > 1 &&
+      this.model.getFormattedCellValue(selectedSheet, row, column - 1) === ""
+    ) {
+      let spillColumn = column - 1;
+      // Keep expanding the spill to the left until:
+      // 1. There is a non-empty cell
+      // 2. Reaches the beginning of the row
+      // 3. There is the end of frozen columns
+      while (
+        leftColumnX > minX &&
+        this.model.getFormattedCellValue(selectedSheet, row, spillColumn) ===
+          "" &&
+        spillColumn >= 1 &&
+        ((column <= frozenColumnsCount && spillColumn <= frozenColumnsCount) ||
+          column > frozenColumnsCount)
+      ) {
+        leftColumnX -= this.getColumnWidth(selectedSheet, spillColumn);
+        // This is tricky but correct. The reason is we only draw the left borders of the cells
+        // (because the left border of a cell MUST be the right border of the one to the left).
+        // So if we want to remove the right border of this cell we need to skip the left border of the next.
+        this.spills.set(`${row}-${spillColumn + 1}`, 1);
+        spillColumn -= 1;
+      }
+    }
+
+    if (frozenColumnsCount > 0) {
+      const frozenColumnsX =
+        this.getCoordinatesByCell(row, frozenColumnsCount)[0] +
+        this.getColumnWidth(selectedSheet, frozenColumnsCount);
+      if (column > frozenColumnsCount) {
+        leftColumnX = Math.max(leftColumnX, frozenColumnsX);
+      } else {
+        rightColumnX = Math.min(rightColumnX, frozenColumnsX);
+      }
+    }
+    textProperties.x = leftColumnX;
+    textProperties.width = rightColumnX - leftColumnX;
+    this.cells.push(textProperties);
+  }
+
+  /// Renders the cell style: colors, borders, etc. But not the text.
+  private renderCellStyle(
     row: number,
     column: number,
     x: number,
@@ -329,6 +720,7 @@ export default class WorksheetCanvas {
     const selectedSheet = this.model.getSelectedSheet();
     const style = this.model.getCellStyle(selectedSheet, row, column);
 
+    // first the background
     let backgroundColor = "#FFFFFF";
     if (style.fill.fg_color) {
       backgroundColor = style.fill.fg_color;
@@ -336,32 +728,9 @@ export default class WorksheetCanvas {
     const cellGridColor = this.model.getShowGridLines(selectedSheet)
       ? gridColor
       : backgroundColor;
-
-    const fontSize = style.font?.sz || 13;
-    let font = `${fontSize}px ${defaultCellFontFamily}`;
-    let textColor = defaultTextColor;
-    if (style.font) {
-      textColor = style.font.color;
-      font = style.font.b ? `bold ${font}` : `400 ${font}`;
-      if (style.font.i) {
-        font = `italic ${font}`;
-      }
-    }
-    let horizontalAlign = "general";
-    if (style.alignment?.horizontal) {
-      horizontalAlign = style.alignment.horizontal;
-    }
-    let verticalAlign = "bottom";
-    if (style.alignment?.vertical) {
-      verticalAlign = style.alignment.vertical;
-    }
-    const wrapText = style.alignment?.wrap_text || false;
-
     const context = this.ctx;
-    context.font = font;
     context.fillStyle = backgroundColor;
     context.fillRect(x, y, width, height);
-    context.fillStyle = textColor;
 
     // Let's do the border
     // Algorithm:
@@ -373,24 +742,13 @@ export default class WorksheetCanvas {
     // We only set the left and top borders (right and bottom are set later)
     const border = style.border;
 
-    let borderLeftColor = cellGridColor;
-    let borderLeftWidth = 1;
-    if (border.left) {
-      borderLeftColor = border.left.color;
-      switch (border.left.style) {
-        case "thin":
-          break;
-        case "medium":
-          borderLeftWidth = 2;
-          break;
-        case "thick":
-          borderLeftWidth = 3;
-      }
-    } else {
-      const leftStyle = this.model.getCellStyle(selectedSheet, row, column - 1);
-      if (leftStyle.border.right) {
-        borderLeftColor = leftStyle.border.right.color;
-        switch (leftStyle.border.right.style) {
+    // we skip don't draw a left border if it is marked as a "spill cell"
+    if (this.spills.get(`${row}-${column}`) !== 1) {
+      let borderLeftColor = cellGridColor;
+      let borderLeftWidth = 1;
+      if (border.left) {
+        borderLeftColor = border.left.color;
+        switch (border.left.style) {
           case "thin":
             break;
           case "medium":
@@ -399,18 +757,37 @@ export default class WorksheetCanvas {
           case "thick":
             borderLeftWidth = 3;
         }
-      } else if (style.fill.fg_color) {
-        borderLeftColor = style.fill.fg_color;
-      } else if (leftStyle.fill.fg_color) {
-        borderLeftColor = leftStyle.fill.fg_color;
+      } else {
+        const leftStyle = this.model.getCellStyle(
+          selectedSheet,
+          row,
+          column - 1,
+        );
+        if (leftStyle.border.right) {
+          borderLeftColor = leftStyle.border.right.color;
+          switch (leftStyle.border.right.style) {
+            case "thin":
+              break;
+            case "medium":
+              borderLeftWidth = 2;
+              break;
+            case "thick":
+              borderLeftWidth = 3;
+          }
+        } else if (style.fill.fg_color) {
+          borderLeftColor = style.fill.fg_color;
+        } else if (leftStyle.fill.fg_color) {
+          borderLeftColor = leftStyle.fill.fg_color;
+        }
       }
+
+      context.beginPath();
+      context.strokeStyle = borderLeftColor;
+      context.lineWidth = borderLeftWidth;
+      context.moveTo(x, y);
+      context.lineTo(x, y + height);
+      context.stroke();
     }
-    context.beginPath();
-    context.strokeStyle = borderLeftColor;
-    context.lineWidth = borderLeftWidth;
-    context.moveTo(x, y);
-    context.lineTo(x, y + height);
-    context.stroke();
 
     let borderTopColor = cellGridColor;
     let borderTopWidth = 1;
@@ -450,100 +827,56 @@ export default class WorksheetCanvas {
     context.moveTo(x, y);
     context.lineTo(x + width, y);
     context.stroke();
+  }
 
-    // Number = 1,
-    // Text = 2,
-    // LogicalValue = 4,
-    // ErrorValue = 16,
-    // Array = 64,
-    // CompoundData = 128,
-
-    const cellType = this.model.getCellType(selectedSheet, row, column);
-    const fullText = this.model.getFormattedCellValue(
-      selectedSheet,
-      row,
-      column,
-    );
-    const padding = 4;
-    if (horizontalAlign === "general") {
-      if (cellType === 1) {
-        horizontalAlign = "right";
-      } else if (cellType === 4) {
-        horizontalAlign = "center";
-      } else {
-        horizontalAlign = "left";
-      }
-    }
+  /// Renders the text in the cell.
+  private renderCellText(textProperties: TextProperties) {
+    const {
+      x,
+      y,
+      width,
+      height,
+      font,
+      underlined,
+      strike,
+      fontSize,
+      textColor,
+      lines,
+    } = textProperties;
+    const context = this.ctx;
 
+    context.font = font;
+    context.fillStyle = textColor;
     // Create a rectangular clipping region
     context.save();
     context.beginPath();
     context.rect(x, y, width, height);
     context.clip();
 
-    // Is there any better to determine the line height?
-    const lineHeight = fontSize * 1.5;
-    const lines = computeWrappedLines(
-      fullText,
-      wrapText,
-      context,
-      width - padding,
-    );
-    const lineCount = lines.length;
+    lines.forEach((line, _) => {
+      const [textContent, textX, textY, textWidth] = line;
+      context.fillText(textContent, textX, textY);
 
-    lines.forEach((text, line) => {
-      const textWidth = context.measureText(text).width;
-      let textX: number;
-      let textY: number;
-      // The idea is that in the present font-size and default row heigh,
-      // top/bottom and center horizontalAlign coincide
-      const verticalPadding = 4;
-      if (horizontalAlign === "right") {
-        textX = width - padding + x - textWidth / 2;
-      } else if (horizontalAlign === "center") {
-        textX = x + width / 2;
-      } else {
-        // left aligned
-        textX = padding + x + textWidth / 2;
+      if (underlined) {
+        // There are no text-decoration in canvas. You have to do the underline yourself.
+        const offset = Math.floor(fontSize / 2);
+        context.beginPath();
+        context.strokeStyle = textColor;
+        context.lineWidth = 1;
+        context.moveTo(textX - textWidth / 2, textY + offset);
+        context.lineTo(textX + textWidth / 2, textY + offset);
+        context.stroke();
       }
-      if (verticalAlign === "bottom") {
-        textY =
-          y +
-          height -
-          fontSize / 2 -
-          verticalPadding +
-          (line - lineCount + 1) * lineHeight;
-      } else if (verticalAlign === "center") {
-        textY = y + height / 2 + (line + (1 - lineCount) / 2) * lineHeight;
-      } else {
-        // aligned top
-        textY = y + fontSize / 2 + verticalPadding + line * lineHeight;
-      }
-      context.fillText(text, textX, textY);
-      if (style.font) {
-        if (style.font.u) {
-          // There are no text-decoration in canvas. You have to do the underline yourself.
-          const offset = Math.floor(fontSize / 2);
-          context.beginPath();
-          context.strokeStyle = textColor;
-          context.lineWidth = 1;
-          context.moveTo(textX - textWidth / 2, textY + offset);
-          context.lineTo(textX + textWidth / 2, textY + offset);
-          context.stroke();
-        }
-        if (style.font.strike) {
-          // There are no text-decoration in canvas. You have to do the strikethrough yourself.
-          context.beginPath();
-          context.strokeStyle = textColor;
-          context.lineWidth = 1;
-          context.moveTo(textX - textWidth / 2, textY);
-          context.lineTo(textX + textWidth / 2, textY);
-          context.stroke();
-        }
+      if (strike) {
+        // There are no text-decoration in canvas. You have to do the strikethrough yourself.
+        context.beginPath();
+        context.strokeStyle = textColor;
+        context.lineWidth = 1;
+        context.moveTo(textX - textWidth / 2, textY);
+        context.lineTo(textX + textWidth / 2, textY);
+        context.stroke();
       }
     });
-
-    // remove the clipping region
     context.restore();
   }
 
@@ -1412,6 +1745,7 @@ export default class WorksheetCanvas {
     this.removeHandles();
 
     const { topLeftCell, bottomRightCell } = this.getVisibleCells();
+    this.computeCellsText();
 
     const frozenColumns = this.model.getFrozenColumnsCount(selectedSheet);
     const frozenRows = this.model.getFrozenRowsCount(selectedSheet);
@@ -1424,7 +1758,7 @@ export default class WorksheetCanvas {
       x = headerColumnWidth + 0.5;
       for (let column = 1; column <= frozenColumns; column += 1) {
         const columnWidth = this.getColumnWidth(selectedSheet, column);
-        this.renderCell(row, column, x, y, columnWidth, rowHeight);
+        this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
         x += columnWidth;
       }
       y += rowHeight;
@@ -1474,7 +1808,7 @@ export default class WorksheetCanvas {
         column += 1
       ) {
         const columnWidth = this.getColumnWidth(selectedSheet, column);
-        this.renderCell(row, column, x, y, columnWidth, rowHeight);
+        this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
         x += columnWidth;
       }
       y += rowHeight;
@@ -1488,7 +1822,7 @@ export default class WorksheetCanvas {
 
       for (let column = 1; column <= frozenColumns; column += 1) {
         const columnWidth = this.getColumnWidth(selectedSheet, column);
-        this.renderCell(row, column, x, y, columnWidth, rowHeight);
+        this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
 
         x += columnWidth;
       }
@@ -1507,13 +1841,18 @@ export default class WorksheetCanvas {
         column += 1
       ) {
         const columnWidth = this.getColumnWidth(selectedSheet, column);
-        this.renderCell(row, column, x, y, columnWidth, rowHeight);
+        this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
 
         x += columnWidth;
       }
       y += rowHeight;
     }
 
+    // Render all cell texts
+    for (const cell of this.cells) {
+      this.renderCellText(cell);
+    }
+
     // Draw column headers
     this.renderColumnHeaders(
       frozenColumns,

webapp/IronCalc/src/components/constants.tsx

@@ -1,3 +1,3 @@
-export const TOOLBAR_HEIGHT = 48;
+export const TOOLBAR_HEIGHT = 40;
 export const FORMULA_BAR_HEIGHT = 40;
 export const NAVIGATION_HEIGHT = 40;

webapp/IronCalc/src/components/util.ts

@@ -3,6 +3,34 @@ import type { Area, Cell } from "./types";
 import { type SelectedView, columnNameFromNumber } from "@ironcalc/wasm";
 import { LAST_COLUMN, LAST_ROW } from "./WorksheetCanvas/constants";
 
+// FIXME: Use the `quoteName` function from the wasm module
+function nameNeedsQuoting(name: string): boolean {
+  // it contains any of these characters: ()'$,;-+{} or space
+  for (const char of name) {
+    if (" ()'$,;-+{}".includes(char)) {
+      return true;
+    }
+  }
+
+  // TODO:
+  // - cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
+  // - cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
+  // - integers
+
+  return false;
+}
+
+/**
+ * Quotes a string sheet name if it needs to
+ * NOTE: Invalid characters in a sheet name: \, /, *, [, ], :, ?
+ */
+export function quoteName(name: string): string {
+  if (nameNeedsQuoting(name)) {
+    return `'${name.replace(/'/g, "''")}'`;
+  }
+  return name;
+}
+
 /**
  *  Returns true if the keypress should start editing
  */
@@ -66,7 +94,8 @@ export function rangeToStr(
   referenceName: string,
 ): string {
   const { sheet, rowStart, rowEnd, columnStart, columnEnd } = range;
-  const sheetName = sheet === referenceSheet ? "" : `'${referenceName}'!`;
+  const sheetName =
+    sheet === referenceSheet ? "" : `${quoteName(referenceName)}!`;
   if (rowStart === rowEnd && columnStart === columnEnd) {
     return `${sheetName}${columnNameFromNumber(columnStart)}${rowStart}`;
   }
@@ -82,7 +111,7 @@ export function getFullRangeToString(
   worksheetNames: string[],
 ): string {
   const [rowStart, columnStart, rowEnd, columnEnd] = selectedView.range;
-  const sheetName = `${worksheetNames[selectedView.sheet]}`;
+  const sheetName = quoteName(worksheetNames[selectedView.sheet]);
 
   if (rowStart === rowEnd && columnStart === columnEnd) {
     return `${sheetName}!$${columnNameFromNumber(columnStart)}$${rowStart}`;

webapp/IronCalc/src/icons/decrease-decimal.svg

@@ -1,6 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M12.5 11.3333H5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M7 9.33333L5 11.3333L7 13.3333" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M7.66667 4.33333C7.66667 3.59695 7.06971 3 6.33333 3C5.59695 3 5 3.59695 5 4.33333V5.66667C5 6.40305 5.59695 7 6.33333 7C7.06971 7 7.66667 6.40305 7.66667 5.66667V4.33333Z" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M3 7H3.00667" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>

webapp/IronCalc/src/icons/increase-decimal.svg

@@ -1,7 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M12.5 11.3333H5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M10.5 9.33333L12.5 11.3333L10.5 13.3333" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M7.66667 4.33333C7.66667 3.59695 7.06971 3 6.33333 3C5.59695 3 5 3.59695 5 4.33333V5.66667C5 6.40305 5.59695 7 6.33333 7C7.06971 7 7.66667 6.40305 7.66667 5.66667V4.33333Z" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M12.3333 4.33333C12.3333 3.59695 11.7364 3 11 3C10.2636 3 9.66667 3.59695 9.66667 4.33333V5.66667C9.66667 6.40305 10.2636 7 11 7C11.7364 7 12.3333 6.40305 12.3333 5.66667V4.33333Z" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M3 7H3.00667" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>

webapp/IronCalc/src/icons/index.ts

@@ -1,6 +1,3 @@
-import DecimalPlacesDecreaseIcon from "./decrease-decimal.svg?react";
-import DecimalPlacesIncreaseIcon from "./increase-decimal.svg?react";
-
 import BorderBottomIcon from "./border-bottom.svg?react";
 import BorderCenterHIcon from "./border-center-h.svg?react";
 import BorderCenterVIcon from "./border-center-v.svg?react";
@@ -21,14 +18,13 @@ import InsertRowAboveIcon from "./insert-row-above.svg?react";
 import InsertRowBelow from "./insert-row-below.svg?react";
 
 import IronCalcIcon from "./ironcalc_icon.svg?react";
+import IronCalcIconWhite from "./ironcalc_icon_white.svg?react";
 import IronCalcLogo from "./orange+black.svg?react";
 
 import Fx from "./fx.svg?react";
 
 export {
   ArrowMiddleFromLine,
-  DecimalPlacesDecreaseIcon,
-  DecimalPlacesIncreaseIcon,
   BorderBottomIcon,
   BorderCenterHIcon,
   BorderCenterVIcon,
@@ -46,6 +42,7 @@ export {
   InsertRowAboveIcon,
   InsertRowBelow,
   IronCalcIcon,
+  IronCalcIconWhite,
   IronCalcLogo,
   Fx,
 };

webapp/IronCalc/src/icons/ironcalc_icon_white.svg

@@ -0,0 +1,7 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.8" d="M9.95898 8.08594C9.60893 8.35318 9.27389 8.64313 8.95898 8.95801C7.09126 10.8257 6.042 13.3586 6.04199 16H6.04102V7.91406C6.39142 7.64662 6.72781 7.35715 7.04297 7.04199C8.90157 5.18307 9.9492 2.6648 9.95898 0.0371094V8.08594Z" fill="white"/>
+<path opacity="0.8" d="M6.04102 7.91406C4.31493 9.23162 2.19571 9.95898 0 9.95898V6.04102C1.60208 6.04102 3.13861 5.40429 4.27148 4.27148C5.40436 3.13861 6.04101 1.60213 6.04102 0L6.04102 7.91406Z" fill="white"/>
+<path opacity="0.8" d="M9.95947 8.08594C11.6856 6.76838 13.8048 6.04102 16.0005 6.04102V9.95898C14.3984 9.95898 12.8619 10.5957 11.729 11.7285C10.5961 12.8614 9.95948 14.3979 9.95947 16L9.95947 8.08594Z" fill="white"/>
+<path d="M9.95898 0C9.95898 2.64126 8.90957 5.17429 7.04199 7.04199C6.727 7.35698 6.39119 7.64674 6.04102 7.91406L6.04102 0H9.95898Z" fill="white"/>
+<path d="M6.04102 16C6.04102 13.3587 7.09042 10.8257 8.95801 8.95801C9.273 8.64302 9.60881 8.35326 9.95898 8.08594V16H6.04102Z" fill="white"/>
+</svg>