adding merge cell logic processing

formatting commit

addressing testcase failures

adding one more scenario to case

adding one more scenario to case

Adding update and unmerge functions for merge cell handling

adding one more case to testcase

adding testcases to base code

adding testcase for import/export

adding documentation to some of the PUB function

fixing warnings and test warnings

adding merge cell part cell update restriction to public sytle set fns

addressing reviwers comment : Changed Mergedcell structure and its side effercts

reverting it back to non pub.

renaming update_merge_cells to just merge_cells in model

renaming *unmerge_merged_cell* to *unmerge_cells*

addressing other reviewer's comment + cosmetica naming adjustments

cosmetic changes

.github/workflows/publish-wiki.yml

@@ -1,18 +0,0 @@
-name: Publish wiki
-on:
-  push:
-    branches: [main]
-    paths:
-      - wiki/**
-      - .github/workflows/publish-wiki.yml
-concurrency:
-  group: publish-wiki
-  cancel-in-progress: true
-permissions:
-  contents: write
-jobs:
-  publish-wiki:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Andrew-Chen-Wang/github-wiki-action@v4

.github/workflows/test-coverage.yaml

@@ -1,6 +1,10 @@
 name: Coverage
 
-on: [pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 jobs:
   coverage:

CHANGELOG.md

@@ -0,0 +1,26 @@
+# CHANGELOG
+
+## Unreleased
+
+### Added
+
+- New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
+- New document server (Thanks Dani!)
+- New function FORMULATEXT
+
+### Fixed
+
+- Fixed several issues with pasting content
+- Fixed several issues with borders
+
+## [0.2.0] - 2024-11-06 (The HN release)
+
+### Added
+
+- Rust crate ironcalc_base
+- Rust crate ironcalc
+- Minimal Python bindings (only Linux)
+- JavaScript bindings
+- React WebApp
+
+[0.2.0]: https://github.com/IronCalc/ironcalc/releases/tag/v0.2.0

CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# Contributing to IronCalc
+
+Whether you are a seasoned developer or a rookie, welcome to IronCalc! 
+
+🎉 We appreciate your interest in contributing to our project.
+
+Before starting any work it is best if you get in touch to make sure your work is relevant.
+
+Please be patient, I am only one and this is a side project.
+
+---
+
+## 🛠 Changes to the main repo
+
+If are comfortable working with GitHub and Git, the following steps should be straightforward. For more general information visit [GitHub Docs](https://docs.github.com/en) and [Git Documentation](https://git-scm.com/doc). 
+
+1. **Fork the repository**
+   Start by forking the repository to your own GitHub account. You can do this by clicking the "Fork" button on the top right of the repository page.
+
+2. **Clone the original repository**
+   Clone the original repository to your local machine:
+   ```bash
+   git clone https://github.com/ironcalc/IronCalc.git
+   cd IronCalc
+   ```
+
+
+3. **Add your fork as a remote**
+    Add your forked repository as a remote named fork:
+
+    ```bash
+    git remote add fork https://github.com/<your-username>/IronCalc.git
+    ```
+4. **Create a new branch**
+    Always create a new branch for your changes to keep your work isolated:
+
+    ```bash
+    git checkout -b your-feature-name
+    ```
+5. **Make changes**
+    Implement your changes, improvements, or bug fixes. Make sure to follow any coding style or project-specific guidelines.
+
+6. **Commit your changes**
+    Write clear and concise commit messages:
+
+    ```bash
+    git add .
+    git commit -m "Brief description of your changes"
+    ```
+7. **Push to your fork**
+    Push your branch to your forked repository:
+    ```bash
+    git push fork your-feature-name
+    ````
+
+8. **Create a Pull Request (PR)**
+   Follow the steps on the terminal or go to the orig IronCalc repository, and click on "New Pull Request."
+   Ensure your PR has a clear title and description explaining the purpose of your changes.
+
+Always start from the main branch in a clean state. `git pull` will generally get the lastest changes form the original repo.
+
+You should make sure that your changes are properly tested.
+
+# 🤝 Community and Support
+
+Feel free to reach out if you have questions or need help. Via GitHub, email, our discord server or bluesky.
+
+* Open an issue to report a bug or discuss a feature before implementing it.
+* Engage with the community to share ideas or seek guidance.
+
+Note that not all contributors need to be coding. To contribute testing, bug reports, typos, ideas of all kinds, you can just send us an email.
+
+Thank you for your contributions! 💪 Together, we can make IronCalc even better.

Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "adler"
@@ -43,6 +43,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "autocfg"
 version = "1.2.0"
@@ -57,19 +63,22 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "bitcode"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48bc1c27654127a24c476d40198746860ef56475f41a601bfa5c4d0f832968f0"
+checksum = "ee1bce7608560cd4bf0296a4262d0dbf13e6bcec5ff2105724c8ab88cc7fc784"
 dependencies = [
+ "arrayvec",
  "bitcode_derive",
  "bytemuck",
+ "glam",
+ "serde",
 ]
 
 [[package]]
 name = "bitcode_derive"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2966755a19aad59ee2aae91e2d48842c667a99d818ec72168efdab07200701cc"
+checksum = "a539389a13af092cd345a2b47ae7dec12deb306d660b2223d25cd3419b253ebe"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -142,9 +151,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.37"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -156,9 +165,9 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb"
+checksum = "cd6dd8046d00723a59a2f8c5f295c515b9bb9a331ee4f8f3d4dd49e428acd3b6"
 dependencies = [
  "chrono",
  "chrono-tz-build",
@@ -167,12 +176,11 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz-build"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1"
+checksum = "e94fea34d77a245229e7746bd2beb786cd2a896f306ff491fb8cecb3074b10a7"
 dependencies = [
  "parse-zoneinfo",
- "phf",
  "phf_codegen",
 ]
 
@@ -242,6 +250,27 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -299,6 +328,12 @@ dependencies = [
  "wasi",
 ]
 
+[[package]]
+name = "glam"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677"
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -375,10 +410,12 @@ dependencies = [
  "bitcode",
  "chrono",
  "chrono-tz",
+ "csv",
  "js-sys",
  "once_cell",
  "rand",
  "regex",
+ "regex-lite",
  "ryu",
  "serde",
  "serde_json",
@@ -476,9 +513,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "parse-zoneinfo"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
 dependencies = [
  "regex",
 ]
@@ -712,6 +749,12 @@ dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.3"

Makefile

@@ -1,7 +1,7 @@
 .PHONY: lint
 lint:
 	cargo fmt -- --check
-	cargo clippy --all-targets --all-features
+	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
 	cd webapp && npm install && npm run check
 
 .PHONY: format
@@ -10,9 +10,6 @@ format:
 
 .PHONY: tests
 tests: lint
-	cargo test
-	./target/debug/documentation
-	cmp functions.md wiki/functions.md || exit 1
 	make remove-artifacts
 	# Regretabbly we need to build the wasm twice, once for the nodejs tests
 	# and a second one for the vitest.
@@ -25,7 +22,6 @@ remove-artifacts:
 	rm -f xlsx/hello-calc.xlsx
 	rm -f xlsx/hello-styles.xlsx
 	rm -f xlsx/widths-and-heights.xlsx
-	rm -f functions.md
 
 .PHONY: clean
 clean: remove-artifacts
@@ -43,11 +39,6 @@ coverage:
 	CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
 	grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
 
-.PHONY: update-docs
-update-docs:
-	cargo build
-	./target/debug/documentation -o wiki/functions.md
-
 .PHONY: docs
 docs:
 	cargo doc --no-deps

README.md

@@ -123,7 +123,7 @@ See https://github.com/ironcalc
 
 An early preview of the technology running entirely in your browser:
 
-https://playground.ironcalc.com
+https://app.ironcalc.com
 
 
 # Collaborators needed!. Call to action

base/Cargo.toml

@@ -14,10 +14,17 @@ readme = "README.md"
 serde = { version = "1.0", features = ["derive"] }
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.9"
+chrono-tz = "0.10"
-regex = "1.0"
+regex = { version = "1.0", optional = true}
+regex-lite = { version = "0.1.6", optional = true}
 once_cell = "1.16.0"
-bitcode = "0.6.0"
+bitcode = "0.6.3"
+csv = "1.3.0"
+
+[features]
+default = ["use_regex_full"]
+use_regex_full = ["regex"]
+use_regex_lite = ["regex-lite"]
 
 [dev-dependencies]
 serde_json = "1.0"

base/src/actions.rs

@@ -383,11 +383,11 @@ impl Model {
     ///    * All cell references to initial_column will go to target_column
     ///    * All cell references to columns in between (initial_column, target_column] will be displaced one to the left
     ///    * All other cell references are left unchanged
-    /// Ranges. This is the tricky bit:
+    ///      Ranges. This is the tricky bit:
     ///    * 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 does NOT move the data in the columns or move the colum styles
     pub fn move_column_action(
         &mut self,
         sheet: u32,

base/src/cell.rs

@@ -176,3 +176,18 @@ impl Cell {
         }
     }
 }
+
+// Implementing methods for MergedCells struct
+
+impl MergedCells {
+    pub fn is_cell_part_of_merged_cells(&self, row: i32, col: i32) -> bool {
+        // This is merge Mother cell so do not include this cell as part of Merged Cells
+        if row == self.0 && col == self.1 {
+            return false;
+        }
+
+        let result: bool = (row >= self.0 && row <= self.2) && (col >= self.1 && col <= self.3);
+
+        result
+    }
+}

base/src/constants.rs

@@ -2,8 +2,8 @@
 /// COLUMN_WIDTH and ROW_HEIGHT are pixel values
 /// A column width of Excel value `w` will result in `w * COLUMN_WIDTH_FACTOR` pixels
 /// Note that these constants are inlined
-pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
-pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.0;
+pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
 pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
 pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
 pub(crate) const DEFAULT_WINDOW_HEIGH: i64 = 600;

base/src/diffs.rs

@@ -26,6 +26,7 @@ pub struct SetCellValue {
 }
 
 impl Model {
+    #[allow(clippy::expect_used)]
     pub(crate) fn shift_cell_formula(
         &mut self,
         sheet: u32,
@@ -57,6 +58,7 @@ impl Model {
         }
     }
 
+    #[allow(clippy::expect_used)]
     pub fn forward_references(
         &mut self,
         source_area: &Area,

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

@@ -1,3 +1,5 @@
+#![allow(clippy::expect_used)]
+
 use crate::expressions::{
     lexer::util::get_tokens,
     token::{OpCompare, OpSum, TokenType},

base/src/expressions/lexer/util.rs

@@ -52,7 +52,9 @@ pub fn get_tokens(formula: &str) -> Vec<MarkedToken> {
     let mut lexer = Lexer::new(
         formula,
         LexerMode::A1,
+        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
+        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     let mut start = lexer.get_position();

base/src/expressions/parser/mod.rs

@@ -63,7 +63,9 @@ pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String>
     let mut lexer = lexer::Lexer::new(
         formula,
         lexer::LexerMode::A1,
+        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
+        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     if let TokenType::Range {
@@ -202,7 +204,9 @@ impl Parser {
         let lexer = lexer::Lexer::new(
             "",
             lexer::LexerMode::A1,
+            #[allow(clippy::expect_used)]
             get_locale("en").expect(""),
+            #[allow(clippy::expect_used)]
             get_language("en").expect(""),
         );
         Parser {
@@ -675,14 +679,23 @@ impl Parser {
                         }
                     };
                     // table-name => table
-                    let table = self.tables.get(&table_name).unwrap_or_else(|| {
+                    let table = match self.tables.get(&table_name) {
-                        panic!(
+                        Some(t) => t,
-                            "Table not found: '{table_name}' at '{}!{}{}'",
+                        None => {
-                            context.sheet,
+                            let message = format!(
-                            number_to_column(context.column).expect(""),
+                                "Table not found: '{table_name}' at '{}!{}{}'",
-                            context.row
+                                context.sheet,
-                        )
+                                number_to_column(context.column)
-                    });
+                                    .unwrap_or(format!("{}", context.column)),
+                                context.row
+                            );
+                            return Node::ParseErrorKind {
+                                formula: self.lexer.get_formula(),
+                                position: 0,
+                                message,
+                            };
+                        }
+                    };
                     let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
                         Some(i) => i,
                         None => {
@@ -701,6 +714,7 @@ impl Parser {
                     };
 
                     // context must be with tables.reference
+                    #[allow(clippy::expect_used)]
                     let (column_start, mut row_start, column_end, mut row_end) =
                         parse_range(&table.reference).expect("Failed parsing range");
 

base/src/expressions/parser/test.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::panic)]
+
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;

base/src/expressions/token.rs

@@ -79,7 +79,7 @@ impl fmt::Display for OpProduct {
 /// Note that "#ERROR!" and "#N/IMPL!" are not part of the xlsx standard
 ///  * "#ERROR!" means there was an error processing the formula (for instance "=A1+")
 ///  * "#N/IMPL!" means the formula or feature in Excel but has not been implemented in IronCalc
-/// Note that they are serialized/deserialized by index
+///    Note that they are serialized/deserialized by index
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Error {
     REF,

base/src/formatter/dates.rs

@@ -5,6 +5,7 @@ use chrono::NaiveDate;
 use crate::constants::EXCEL_DATE_BASE;
 
 pub fn from_excel_date(days: i64) -> NaiveDate {
+    #[allow(clippy::expect_used)]
     let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
     dt + Duration::days(days - 2)
 }

base/src/functions/engineering/transcendental/test_bessel.rs

@@ -12,7 +12,7 @@ const EPS_LOW: f64 = 1e-6;
 
 // Known values computed with Arb via Nemo.jl in Julia
 // You can also use Mathematica
-/// But please do not use Excel or any other software without arbitrary precision
+// But please do not use Excel or any other software without arbitrary precision
 
 fn numbers_are_close(a: f64, b: f64) -> bool {
     if a == b {

base/src/functions/financial.rs

@@ -194,16 +194,24 @@ fn compute_ppmt(
 // In these formulas the payment (pmt) is normally negative
 
 impl Model {
-    // FIXME: These three functions (get_array_of_numbers..) need to be refactored
+    fn get_array_of_numbers_generic(
-    // They are really similar expect for small issues
-    fn get_array_of_numbers(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
+        accept_number_node: bool,
+        handle_empty_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
+        handle_non_number_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
     ) -> Result<Vec<f64>, CalcResult> {
         let mut values = Vec::new();
         match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) => values.push(value),
+            CalcResult::Number(value) if accept_number_node => values.push(value),
+            CalcResult::Number(_) => {
+                return Err(CalcResult::new_error(
+                    Error::VALUE,
+                    *cell,
+                    "Expected range of numbers".to_string(),
+                ));
+            }
             CalcResult::Range { left, right } => {
                 if left.sheet != right.sheet {
                     return Err(CalcResult::new_error(
@@ -212,6 +220,7 @@ impl Model {
                         "Ranges are in different sheets".to_string(),
                     ));
                 }
+                let sheet = left.sheet;
                 let row1 = left.row;
                 let mut row2 = right.row;
                 let column1 = left.column;
@@ -219,32 +228,46 @@ impl Model {
                 if row1 == 1 && row2 == LAST_ROW {
                     row2 = self
                         .workbook
-                        .worksheet(left.sheet)
+                        .worksheet(sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{}'", sheet),
+                            )
+                        })?
                         .dimension()
                         .max_row;
                 }
                 if column1 == 1 && column2 == LAST_COLUMN {
                     column2 = self
                         .workbook
-                        .worksheet(left.sheet)
+                        .worksheet(sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{}'", sheet),
+                            )
+                        })?
                         .dimension()
                         .max_column;
                 }
-                for row in row1..row2 + 1 {
+                for row in row1..=row2 {
-                    for column in column1..(column2 + 1) {
+                    for column in column1..=column2 {
-                        match self.evaluate_cell(CellReferenceIndex {
+                        let cell_ref = CellReferenceIndex { sheet, row, column };
-                            sheet: left.sheet,
+                        match self.evaluate_cell(cell_ref) {
-                            row,
+                            CalcResult::Number(value) => values.push(value),
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
                             error @ CalcResult::Error { .. } => return Err(error),
+                            CalcResult::EmptyCell => {
+                                if let Some(value) = handle_empty_cell()? {
+                                    values.push(value);
+                                }
+                            }
                             _ => {
-                                // We ignore booleans and strings
+                                if let Some(value) = handle_non_number_cell()? {
+                                    values.push(value);
+                                }
                             }
                         }
                     }
@@ -252,88 +275,51 @@ impl Model {
             }
             error @ CalcResult::Error { .. } => return Err(error),
             _ => {
-                // We ignore booleans and strings
+                handle_non_number_cell()?;
             }
-        };
+        }
         Ok(values)
     }
 
+    fn get_array_of_numbers(
+        &mut self,
+        arg: &Node,
+        cell: &CellReferenceIndex,
+    ) -> Result<Vec<f64>, CalcResult> {
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            true,        // accept_number_node
+            || Ok(None), // Ignore empty cells
+            || Ok(None), // Ignore non-number cells
+        )
+    }
+
     fn get_array_of_numbers_xpnv(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
         error: Error,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
+        self.get_array_of_numbers_generic(
-        match self.evaluate_node_in_context(arg, *cell) {
+            arg,
-            CalcResult::Number(value) => values.push(value),
+            cell,
-            CalcResult::Range { left, right } => {
+            true, // accept_number_node
-                if left.sheet != right.sheet {
+            || {
-                    return Err(CalcResult::new_error(
+                Err(CalcResult::new_error(
-                        Error::VALUE,
+                    Error::NUM,
-                        *cell,
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let row1 = left.row;
-                let mut row2 = right.row;
-                let column1 = left.column;
-                let mut column2 = right.column;
-                if row1 == 1 && row2 == LAST_ROW {
-                    row2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_row;
-                }
-                if column1 == 1 && column2 == LAST_COLUMN {
-                    column2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_column;
-                }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => {
-                                return Err(CalcResult::new_error(
-                                    Error::NUM,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    error,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
-                    error,
                     *cell,
                     "Expected number".to_string(),
-                ));
+                ))
-            }
+            },
-        };
+            || {
-        Ok(values)
+                Err(CalcResult::new_error(
+                    error.clone(),
+                    *cell,
+                    "Expected number".to_string(),
+                ))
+            },
+        )
     }
 
     fn get_array_of_numbers_xirr(
@@ -341,69 +327,19 @@ impl Model {
         arg: &Node,
         cell: &CellReferenceIndex,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
+        self.get_array_of_numbers_generic(
-        match self.evaluate_node_in_context(arg, *cell) {
+            arg,
-            CalcResult::Range { left, right } => {
+            cell,
-                if left.sheet != right.sheet {
+            false,            // Do not accept a single number node
-                    return Err(CalcResult::new_error(
+            || Ok(Some(0.0)), // Treat empty cells as zero
-                        Error::VALUE,
+            || {
-                        *cell,
+                Err(CalcResult::new_error(
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let row1 = left.row;
-                let mut row2 = right.row;
-                let column1 = left.column;
-                let mut column2 = right.column;
-                if row1 == 1 && row2 == LAST_ROW {
-                    row2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_row;
-                }
-                if column1 == 1 && column2 == LAST_COLUMN {
-                    column2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_column;
-                }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => values.push(0.0),
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    Error::VALUE,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
                     Error::VALUE,
                     *cell,
                     "Expected number".to_string(),
-                ));
+                ))
-            }
+            },
-        };
+        )
-        Ok(values)
     }
 
     /// PMT(rate, nper, pv, [fv], [type])
@@ -862,20 +798,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -1393,21 +1337,21 @@ impl Model {
         CalcResult::Number(result)
     }
 
-    /// This next three functions deal with Treasure Bills or T-Bills for short
+    // This next three functions deal with Treasure Bills or T-Bills for short
-    /// They are zero-coupon that mature in one year or less.
+    // They are zero-coupon that mature in one year or less.
-    ///  Definitions:
+    //  Definitions:
-    ///    $r$ be the discount rate
+    //    $r$ be the discount rate
-    ///    $v$ the face value of the Bill
+    //    $v$ the face value of the Bill
-    ///    $p$ the price of the Bill
+    //    $p$ the price of the Bill
-    ///    $d_m$ is the number of days from the settlement to maturity
+    //    $d_m$ is the number of days from the settlement to maturity
-    /// Then:
+    // Then:
-    ///   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
+    //   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
-    /// If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
+    // If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
-    /// $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
+    // $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
-    /// If d_m>= 183 days things are a bit more complicated.
+    // If d_m>= 183 days things are a bit more complicated.
-    /// Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
+    // Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
-    /// $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
+    // $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
-    /// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
+    // Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
 
     // TBILLEQ(settlement, maturity, discount)
     pub(crate) fn fn_tbilleq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {

base/src/functions/lookup_and_reference.rs

@@ -838,4 +838,43 @@ impl Model {
         };
         CalcResult::Range { left, right }
     }
+
+    pub(crate) fn fn_formulatext(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        if let CalcResult::Range { left, right } = self.evaluate_node_with_reference(&args[0], cell)
+        {
+            if left.sheet != right.sheet {
+                return CalcResult::Error {
+                    error: Error::ERROR,
+                    origin: cell,
+                    message: "3D ranges not supported".to_string(),
+                };
+            }
+            if left.row != right.row || left.column != right.column {
+                // FIXME: Implicit intersection or dynamic arrays
+                return CalcResult::Error {
+                    error: Error::ERROR,
+                    origin: cell,
+                    message: "argument must be a reference to a single cell".to_string(),
+                };
+            }
+            if let Ok(Some(f)) = self.get_cell_formula(left.sheet, left.row, left.column) {
+                CalcResult::String(f)
+            } else {
+                CalcResult::Error {
+                    error: Error::NA,
+                    origin: cell,
+                    message: "Reference does not have a formula".to_string(),
+                }
+            }
+        } else {
+            CalcResult::Error {
+                error: Error::ERROR,
+                origin: cell,
+                message: "Argument must be a reference".to_string(),
+            }
+        }
+    }
 }

base/src/functions/mathematical.rs

@@ -128,20 +128,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -195,20 +203,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {

base/src/functions/mod.rs

@@ -75,6 +75,7 @@ pub enum Function {
 
     // Information
     ErrorType,
+    Formulatext,
     Isblank,
     Iserr,
     Iserror,
@@ -122,6 +123,7 @@ pub enum Function {
     Textbefore,
     Textjoin,
     Trim,
+    Unicode,
     Upper,
     Value,
     Valuetotext,
@@ -246,7 +248,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 192> {
+    pub fn into_iter() -> IntoIter<Function, 194> {
         [
             Function::And,
             Function::False,
@@ -316,6 +318,7 @@ impl Function {
             Function::Search,
             Function::Text,
             Function::Trim,
+            Function::Unicode,
             Function::Upper,
             Function::Isnumber,
             Function::Isnontext,
@@ -330,6 +333,7 @@ impl Function {
             Function::Isodd,
             Function::Iseven,
             Function::ErrorType,
+            Function::Formulatext,
             Function::Isformula,
             Function::Type,
             Function::Sheet,
@@ -460,6 +464,7 @@ impl Function {
             Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
             Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
             Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
+            Function::Unicode => "_xlfn.UNICODE".to_string(),
             Function::Rri => "_xlfn.RRI".to_string(),
             Function::Pduration => "_xlfn.PDURATION".to_string(),
             Function::Bitand => "_xlfn.BITAND".to_string(),
@@ -479,6 +484,7 @@ impl Function {
             Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
             Function::Isformula => "_xlfn.ISFORMULA".to_string(),
             Function::Sheet => "_xlfn.SHEET".to_string(),
+            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
             _ => self.to_string(),
         }
     }
@@ -567,6 +573,7 @@ impl Function {
             "SEARCH" => Some(Function::Search),
             "TEXT" => Some(Function::Text),
             "TRIM" => Some(Function::Trim),
+            "UNICODE" | "_XLFN.UNICODE" => Some(Function::Unicode),
             "UPPER" => Some(Function::Upper),
 
             "REPT" => Some(Function::Rept),
@@ -588,6 +595,7 @@ impl Function {
             "ISODD" => Some(Function::Isodd),
             "ISEVEN" => Some(Function::Iseven),
             "ERROR.TYPE" => Some(Function::ErrorType),
+            "FORMULATEXT" | "_XLFN.FORMULATEXT" => Some(Function::Formulatext),
             "ISFORMULA" | "_XLFN.ISFORMULA" => Some(Function::Isformula),
             "TYPE" => Some(Function::Type),
             "SHEET" | "_XLFN.SHEET" => Some(Function::Sheet),
@@ -779,6 +787,7 @@ impl fmt::Display for Function {
             Function::Search => write!(f, "SEARCH"),
             Function::Text => write!(f, "TEXT"),
             Function::Trim => write!(f, "TRIM"),
+            Function::Unicode => write!(f, "UNICODE"),
             Function::Upper => write!(f, "UPPER"),
             Function::Isnumber => write!(f, "ISNUMBER"),
             Function::Isnontext => write!(f, "ISNONTEXT"),
@@ -793,6 +802,7 @@ impl fmt::Display for Function {
             Function::Isodd => write!(f, "ISODD"),
             Function::Iseven => write!(f, "ISEVEN"),
             Function::ErrorType => write!(f, "ERROR.TYPE"),
+            Function::Formulatext => write!(f, "FORMULATEXT"),
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
@@ -1012,6 +1022,7 @@ impl Model {
             Function::Search => self.fn_search(args, cell),
             Function::Text => self.fn_text(args, cell),
             Function::Trim => self.fn_trim(args, cell),
+            Function::Unicode => self.fn_unicode(args, cell),
             Function::Upper => self.fn_upper(args, cell),
             // Information
             Function::Isnumber => self.fn_isnumber(args, cell),
@@ -1027,6 +1038,7 @@ impl Model {
             Function::Isodd => self.fn_isodd(args, cell),
             Function::Iseven => self.fn_iseven(args, cell),
             Function::ErrorType => self.fn_errortype(args, cell),
+            Function::Formulatext => self.fn_formulatext(args, cell),
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
@@ -1148,6 +1160,7 @@ impl Model {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::unwrap_used)]
     use std::{
         fs::File,
         io::{BufRead, BufReader},

base/src/functions/statistical.rs

@@ -381,11 +381,16 @@ impl Model {
         let right_row = first_range.right.row;
         let right_column = first_range.right.column;
 
-        let dimension = self
+        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
-            .workbook
+            Ok(s) => s.dimension(),
-            .worksheet(first_range.left.sheet)
+            Err(_) => {
-            .expect("Sheet expected during evaluation.")
+                return CalcResult::new_error(
-            .dimension();
+                    Error::ERROR,
+                    cell,
+                    format!("Invalid worksheet index: '{}'", first_range.left.sheet),
+                )
+            }
+        };
         let max_row = dimension.max_row;
         let max_column = dimension.max_column;
 
@@ -526,20 +531,28 @@ impl Model {
         let mut right_column = sum_range.right.column;
 
         if left_row == 1 && right_row == LAST_ROW {
-            right_row = self
+            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
-                .workbook
+                Ok(s) => s.dimension().max_row,
-                .worksheet(sum_range.left.sheet)
+                Err(_) => {
-                .expect("Sheet expected during evaluation.")
+                    return Err(CalcResult::new_error(
-                .dimension()
+                        Error::ERROR,
-                .max_row;
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
         if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = self
+            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
-                .workbook
+                Ok(s) => s.dimension().max_column,
-                .worksheet(sum_range.left.sheet)
+                Err(_) => {
-                .expect("Sheet expected during evaluation.")
+                    return Err(CalcResult::new_error(
-                .dimension()
+                        Error::ERROR,
-                .max_column;
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
 
         for row in left_row..right_row + 1 {

base/src/functions/subtotal.rs

@@ -53,8 +53,13 @@ impl Model {
         false
     }
 
-    fn cell_hidden_status(&self, sheet_index: u32, row: i32, column: i32) -> CellTableStatus {
+    fn cell_hidden_status(
-        let worksheet = self.workbook.worksheet(sheet_index).expect("");
+        &self,
+        sheet_index: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<CellTableStatus, String> {
+        let worksheet = self.workbook.worksheet(sheet_index)?;
         let mut hidden = false;
         for row_style in &worksheet.rows {
             if row_style.r == row {
@@ -63,13 +68,13 @@ impl Model {
             }
         }
         if !hidden {
-            return CellTableStatus::Normal;
+            return Ok(CellTableStatus::Normal);
         }
         // The row is hidden we need to know if the table has filters
         if self.get_table_for_cell(sheet_index, row, column) {
-            CellTableStatus::Filtered
+            Ok(CellTableStatus::Filtered)
         } else {
-            CellTableStatus::Hidden
+            Ok(CellTableStatus::Hidden)
         }
     }
 
@@ -143,7 +148,11 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                    .map_err(|message| {
+                                        CalcResult::new_error(Error::ERROR, cell, message)
+                                    })?;
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -380,7 +389,14 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = match self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                {
+                                    Ok(s) => s,
+                                    Err(message) => {
+                                        return CalcResult::new_error(Error::ERROR, cell, message);
+                                    }
+                                };
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -449,7 +465,14 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = match self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                {
+                                    Ok(s) => s,
+                                    Err(message) => {
+                                        return CalcResult::new_error(Error::ERROR, cell, message);
+                                    }
+                                };
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }

base/src/functions/text.rs

@@ -151,7 +151,7 @@ impl Model {
     ///  * If find_text does not appear in within_text, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is not greater than zero, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is greater than the length of within_text, FIND and FINDB return the #VALUE! error value.
-    /// NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
+    ///    NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
     pub(crate) fn fn_find(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -203,7 +203,7 @@ impl Model {
     /// Same API as FIND but:
     ///  * Allows wildcards
     ///  * It is case insensitive
-    /// SEARCH(find_text, within_text, [start_num])
+    ///    SEARCH(find_text, within_text, [start_num])
     pub(crate) fn fn_search(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -342,6 +342,53 @@ impl Model {
         CalcResult::new_args_number_error(cell)
     }
 
+    pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() == 1 {
+            let s = match self.evaluate_node_in_context(&args[0], cell) {
+                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::String(v) => v,
+                CalcResult::Boolean(b) => {
+                    if b {
+                        "TRUE".to_string()
+                    } else {
+                        "FALSE".to_string()
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::Range { .. } => {
+                    // Implicit Intersection not implemented
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Implicit Intersection not implemented".to_string(),
+                    };
+                }
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Empty cell".to_string(),
+                    }
+                }
+            };
+
+            match s.chars().next() {
+                Some(c) => {
+                    let unicode_number = c as u32;
+                    return CalcResult::Number(unicode_number as f64);
+                }
+                None => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Empty cell".to_string(),
+                    };
+                }
+            }
+        }
+        CalcResult::new_args_number_error(cell)
+    }
+
     pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
@@ -503,7 +550,7 @@ impl Model {
             }
             result.push(ch);
         }
-        return CalcResult::String(result.chars().rev().collect::<String>());
+        CalcResult::String(result.chars().rev().collect::<String>())
     }
 
     pub(crate) fn fn_mid(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -888,20 +935,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {

base/src/functions/util.rs

@@ -1,4 +1,5 @@
-use regex::{escape, Regex};
+#[cfg(feature = "use_regex_lite")]
+use regex_lite as regex;
 
 use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
 
@@ -25,9 +26,9 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
     }
 }
 
-/// In Excel there are two ways of comparing cell values.
+// In Excel there are two ways of comparing cell values.
-/// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
+// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
-/// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
+// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
 
 // ..., -2, -1, 0, 1, 2, ..., A-Z, FALSE, TRUE;
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
@@ -86,7 +87,7 @@ pub(crate) fn from_wildcard_to_regex(
     exact: bool,
 ) -> Result<regex::Regex, regex::Error> {
     // 1. Escape all
-    let reg = &escape(wildcard);
+    let reg = &regex::escape(wildcard);
 
     // 2. We convert the escaped '?' into '.' (matches a single character)
     let reg = &reg.replace("\\?", ".");
@@ -109,13 +110,13 @@ pub(crate) fn from_wildcard_to_regex(
 
     // And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?")
     if exact {
-        return Regex::new(&format!("^{}$", reg));
+        return regex::Regex::new(&format!("^{}$", reg));
     }
-    Regex::new(reg)
+    regex::Regex::new(reg)
 }
 
-/// NUMBERS ///
+// NUMBERS ///
-///*********///
+//*********///
 
 // It could be either the number or a string representation of the number
 // In the rest of the cases calc_result needs to be a number (cannot be the string "23", for instance)
@@ -180,8 +181,8 @@ fn result_is_not_equal_to_number(calc_result: &CalcResult, target: f64) -> bool
     }
 }
 
-/// BOOLEANS ///
+// BOOLEANS ///
-///**********///
+//**********///
 
 // Booleans have to be "exactly" equal
 fn result_is_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
@@ -198,12 +199,12 @@ fn result_is_not_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
     }
 }
 
-/// STRINGS ///
+// STRINGS ///
-///*********///
+//*********///
 
-/// Note that strings are case insensitive. `target` must always be lower case.
+// Note that strings are case insensitive. `target` must always be lower case.
 
-pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &Regex) -> bool {
+pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &regex::Regex) -> bool {
     match calc_result {
         CalcResult::String(s) => reg.is_match(&s.to_lowercase()),
         _ => false,
@@ -269,8 +270,8 @@ fn result_is_greater_or_equal_than_string(calc_result: &CalcResult, target: &str
     }
 }
 
-/// ERRORS ///
+// ERRORS ///
-///********///
+//********///
 
 fn result_is_equal_to_error(calc_result: &CalcResult, target: &str) -> bool {
     match calc_result {
@@ -286,8 +287,8 @@ fn result_is_not_equal_to_error(calc_result: &CalcResult, target: &str) -> bool
     }
 }
 
-/// EMPTY ///
+// EMPTY ///
-///*******///
+//*******///
 
 // Note that these two are not inverse of each other.
 // In particular, you can never match an empty cell.

base/src/functions/xlookup.rs

@@ -251,20 +251,28 @@ impl Model {
                         let column1 = left.column;
 
                         if row1 == 1 && row2 == LAST_ROW {
-                            row2 = self
+                            row2 = match self.workbook.worksheet(left.sheet) {
-                                .workbook
+                                Ok(s) => s.dimension().max_row,
-                                .worksheet(left.sheet)
+                                Err(_) => {
-                                .expect("Sheet expected during evaluation.")
+                                    return CalcResult::new_error(
-                                .dimension()
+                                        Error::ERROR,
-                                .max_row;
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         if column1 == 1 && column2 == LAST_COLUMN {
-                            column2 = self
+                            column2 = match self.workbook.worksheet(left.sheet) {
-                                .workbook
+                                Ok(s) => s.dimension().max_column,
-                                .worksheet(left.sheet)
+                                Err(_) => {
-                                .expect("Sheet expected during evaluation.")
+                                    return CalcResult::new_error(
-                                .dimension()
+                                        Error::ERROR,
-                                .max_column;
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         let left = CellReferenceIndex {
                             sheet: left.sheet,

base/src/language/mod.rs

@@ -31,6 +31,7 @@ pub struct Language {
     pub errors: Errors,
 }
 
+#[allow(clippy::expect_used)]
 static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
     bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
 });

base/src/lib.rs

@@ -58,4 +58,5 @@ pub mod mock_time;
 pub use model::get_milliseconds_since_epoch;
 pub use model::Model;
 pub use user_model::BorderArea;
+pub use user_model::ClipboardData;
 pub use user_model::UserModel;

base/src/locale/mod.rs

@@ -65,6 +65,7 @@ pub struct DecimalFormats {
     pub standard: String,
 }
 
+#[allow(clippy::expect_used)]
 static LOCALES: Lazy<HashMap<String, Locale>> =
     Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
 

base/src/model.rs

@@ -15,7 +15,7 @@ use crate::{
         },
         token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
         types::*,
-        utils::{self, is_valid_column_number, is_valid_row},
+        utils::{self, is_valid_column_number, is_valid_row, parse_reference_a1},
     },
     formatter::{
         format::{format_number, parse_formatted_number},
@@ -41,6 +41,7 @@ pub use crate::mock_time::get_milliseconds_since_epoch;
 /// * Or mocked for tests
 #[cfg(not(test))]
 #[cfg(not(target_arch = "wasm32"))]
+#[allow(clippy::expect_used)]
 pub fn get_milliseconds_since_epoch() -> i64 {
     use std::time::{SystemTime, UNIX_EPOCH};
     SystemTime::now()
@@ -90,11 +91,11 @@ pub(crate) enum ParsedDefinedName {
 /// * The Locale: a parsed version of the Workbook's locale
 /// * The Timezone: an object representing the Workbook's timezone
 /// * The language. Note that the timezone and the locale belong to the workbook while
-/// the language can be different for different users looking _at the same_ workbook.
+///   the language can be different for different users looking _at the same_ workbook.
 /// * Parsed Formulas: All the formulas in the workbook are parsed here (runtime only)
 /// * A list of cells with its status (evaluating, evaluated, not evaluated)
 /// * A dictionary with the shared strings and their indices.
-/// This is an optimization for large files (~1 million rows)
+///   This is an optimization for large files (~1 million rows)
 pub struct Model {
     /// A Rust internal representation of an Excel workbook
     pub workbook: Workbook,
@@ -529,6 +530,7 @@ impl Model {
         }
     }
 
+    #[allow(clippy::expect_used)]
     fn cell_reference_to_string(
         &self,
         cell_reference: &CellReferenceIndex,
@@ -544,6 +546,7 @@ impl Model {
     /// Sets `result` in the cell given by `sheet` sheet index, row and column
     /// Note that will panic if the cell does not exist
     /// It will do nothing if the cell does not have a formula
+    #[allow(clippy::expect_used)]
     fn set_cell_value(&mut self, cell_reference: CellReferenceIndex, result: &CalcResult) {
         let CellReferenceIndex { sheet, column, row } = cell_reference;
         let cell = &self.workbook.worksheets[sheet as usize].sheet_data[&row][&column];
@@ -744,6 +747,29 @@ impl Model {
         self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
     }
 
+    /// Returns 'true' if the cell belongs to any Merged cells
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ironcalc_base::Model;
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
+    /// model.merge_cells(0, "A1:D5");
+    /// assert_eq!(model.is_part_of_merged_cells(0, 1, 2)?, true);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn is_part_of_merged_cells(
+        &self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<bool, String> {
+        self.workbook
+            .worksheet(sheet)?
+            .is_part_of_merged_cells(row, column)
+    }
+
     pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
         let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
             .sheet_data
@@ -875,6 +901,7 @@ impl Model {
             .map_err(|_| format!("Invalid timezone: {}", workbook.settings.tz))?;
 
         // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("").clone();
         let mut shared_strings = HashMap::new();
         for (index, s) in workbook.shared_strings.iter().enumerate() {
@@ -1221,6 +1248,14 @@ impl Model {
         column: i32,
         value: &str,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index;
         if common::value_needs_quoting(value, &self.language) {
@@ -1271,6 +1306,15 @@ impl Model {
         column: i32,
         value: bool,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
+
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
             self.workbook
@@ -1313,6 +1357,14 @@ impl Model {
         column: i32,
         value: f64,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
             self.workbook
@@ -1358,6 +1410,12 @@ impl Model {
         column: i32,
         formula: String,
     ) -> Result<(), String> {
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         let mut style_index = self.get_cell_style_index(sheet, row, column)?;
         if self.workbook.styles.style_is_quote_prefix(style_index) {
             style_index = self
@@ -1410,6 +1468,14 @@ impl Model {
         column: i32,
         value: String,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         // If value starts with "'" then we force the style to be quote_prefix
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
@@ -1924,6 +1990,7 @@ impl Model {
     /// Sets the number of frozen rows to `frozen_rows` in the workbook.
     /// Fails if `frozen`_rows` is either too small (<0) or too large (>LAST_ROW)`
     pub fn set_frozen_rows(&mut self, sheet: u32, frozen_rows: i32) -> Result<(), String> {
+        // TODO: What is frozen rows and do we need to take of this if row we are frozing is part of merge cells ?
         if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
             if frozen_rows < 0 {
                 return Err("Frozen rows cannot be negative".to_string());
@@ -1941,6 +2008,7 @@ impl Model {
     /// Sets the number of frozen columns to `frozen_column` in the workbook.
     /// Fails if `frozen`_columns` is either too small (<0) or too large (>LAST_COLUMN)`
     pub fn set_frozen_columns(&mut self, sheet: u32, frozen_columns: i32) -> Result<(), String> {
+        // TODO: What is frozen columns and do we need to take of this if column we are frozing is part of merge cells ?
         if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
             if frozen_columns < 0 {
                 return Err("Frozen columns cannot be negative".to_string());
@@ -1982,10 +2050,169 @@ impl Model {
             .worksheet_mut(sheet)?
             .set_row_height(column, height)
     }
+
+    fn parse_merged_range(&mut self, range: &str) -> Result<(i32, i32, i32, i32), String> {
+        let parts: Vec<&str> = range.split(':').collect();
+        if parts.len() == 1 {
+            Err(format!("Invalid range: '{}'", range))
+        } else if parts.len() == 2 {
+            match (parse_reference_a1(parts[0]), parse_reference_a1(parts[1])) {
+                (Some(left), Some(right)) => {
+                    return Ok((left.row, left.column, right.row, right.column));
+                }
+                _ => return Err(format!("Invalid range: '{}'", range)),
+            }
+        } else {
+            return Err(format!("Invalid range: '{}'", range));
+        }
+    }
+
+    // Implementing public APIS related to Merge cells handling
+
+    /// Merges given selected cells
+    /// If no overlap, it will create that merged cells with left most top cell value representing the whole merged cells
+    /// If new merge cells creation overlaps with any of the existing merged cells, Overlapped merged cells gets unmerged
+    /// and new merge cells gets added
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ironcalc_base::Model;
+    /// # use ironcalc_base::cell::CellValue;
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
+    /// model.merge_cells(0, "D4:F6").unwrap();
+    /// model.merge_cells(0, "A1:B4").unwrap();
+    /// assert_eq!(model.workbook.worksheet(0).unwrap().merged_cells_list.len(), 2);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// See also:
+    /// * [Model::update_cell_with_formula()]
+    /// * [Model::update_cell_with_number()]
+    /// * [Model::update_cell_with_bool()]
+    /// * [Model::update_cell_with_text()]
+    pub fn merge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
+        match self.parse_merged_range(range_ref) {
+            Ok(parsed_merge_cell_range) => {
+                // ATTENTION 2: Below thing we can support here but keeping it simple
+                // Web or different client needs to keep this in mind
+                // User can give errored parse ranges like C3:A1
+                // Where col_start and row_start and is greated then col_end and row_end
+                // Return error in these scenario
+                if parsed_merge_cell_range.0 > parsed_merge_cell_range.2
+                    || parsed_merge_cell_range.1 > parsed_merge_cell_range.3
+                {
+                    return Err(
+                        "Invalid parse range. Merge Mother cell always be top left cell"
+                            .to_string(),
+                    );
+                }
+
+                let mut merged_cells_overlaped_list: Vec<bool> = Vec::new();
+                // checking whether our new range overlaps with any of the already existing merged cells
+                // if so, need to unmerge those and create this new one
+                {
+                    let worksheet = self.workbook.worksheet(sheet)?;
+                    let merged_cells = worksheet.get_merged_cells_list();
+
+                    for merge_node in merged_cells {
+                        // checking whether any overlapping exist with this merge cell
+                        if !(parsed_merge_cell_range.1 > merge_node.3
+                            || parsed_merge_cell_range.3 < merge_node.1
+                            || parsed_merge_cell_range.0 > merge_node.2
+                            || parsed_merge_cell_range.2 < merge_node.0)
+                        {
+                            // overlap has happened
+                            merged_cells_overlaped_list.push(true);
+                        } else {
+                            merged_cells_overlaped_list.push(false);
+                        }
+                    }
+                }
+
+                if !merged_cells_overlaped_list.is_empty() {
+                    // Lets take Mutable ref to Merge cell and deletes all those nodes which has overlapped
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
+                    let merged_cells_list_mut = worksheet.get_merged_cells_list_mut();
+                    let mut merged_cells_overlaped_list_iter = merged_cells_overlaped_list.iter();
+                    merged_cells_list_mut
+                        .retain(|_| !(*merged_cells_overlaped_list_iter.next().unwrap()))
+                }
+
+                // Now need to update (n*m - 1) cells with empty cell ( except the Mother cell )
+                for row_index in parsed_merge_cell_range.0..=parsed_merge_cell_range.2 {
+                    for col_index in parsed_merge_cell_range.1..=parsed_merge_cell_range.3 {
+                        // skip Mother cell
+                        if row_index == parsed_merge_cell_range.0
+                            && col_index == parsed_merge_cell_range.2
+                        {
+                            continue;
+                        }
+
+                        //update the node with empty cell
+                        {
+                            self.workbook.worksheet_mut(sheet)?.update_cell(
+                                row_index,
+                                col_index,
+                                Cell::EmptyCell { s: 0 },
+                            )?;
+                        }
+                    }
+                }
+
+                let new_merged_cells = MergedCells::new(parsed_merge_cell_range);
+                {
+                    self.workbook
+                        .worksheet_mut(sheet)?
+                        .merged_cells_list
+                        .push(new_merged_cells);
+                }
+            }
+            Err(err) => {
+                return Err(err);
+            }
+        }
+        Ok(())
+    }
+
+    /// Unmerges a given/selected merged cells
+    /// Once unmerged, only top most left corner value gets retained and all the others will have empty cell
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ironcalc_base::Model;
+    /// # use ironcalc_base::cell::CellValue;
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
+    /// model.merge_cells(0, "D4:F6");
+    /// model.unmerge_cells(0, "D4:F6");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn unmerge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
+        let worksheet = self.workbook.worksheet(sheet)?;
+        let merged_cells = worksheet.get_merged_cells_list();
+        for (index, merge_node) in merged_cells.iter().enumerate() {
+            let merge_block_range_ref = merge_node.get_merged_cells_str_ref()?;
+            // finding the merge cell node to be deleted
+            if merge_block_range_ref.as_str() == range_ref {
+                // Merge cell to be deleted is found
+                self.workbook
+                    .worksheet_mut(sheet)?
+                    .merged_cells_list
+                    .remove(index);
+                return Ok(());
+            }
+        }
+        Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::expect_used)]
     use super::CellReferenceIndex as CellReference;
     use crate::{test::util::new_empty_model, types::Cell};
 

base/src/new_empty.rs

@@ -57,7 +57,7 @@ impl Model {
             rows: vec![],
             comments: vec![],
             dimension: "A1".to_string(),
-            merge_cells: vec![],
+            merged_cells_list: vec![],
             name: name.to_string(),
             shared_formulas: vec![],
             sheet_data: Default::default(),
@@ -392,6 +392,7 @@ impl Model {
         let cells = HashMap::new();
 
         // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("").clone();
 
         let mut model = Model {

base/src/styles.rs

@@ -223,6 +223,14 @@ impl Model {
         column: i32,
         style: &Style,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         let style_index = self.workbook.styles.get_style_index_or_create(style);
         self.workbook
             .worksheet_mut(sheet)?
@@ -252,6 +260,14 @@ impl Model {
         column: i32,
         style_name: &str,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
         self.workbook
             .worksheet_mut(sheet)?

base/src/test/mod.rs

@@ -15,6 +15,7 @@ mod test_fn_concatenate;
 mod test_fn_count;
 mod test_fn_exact;
 mod test_fn_financial;
+mod test_fn_formulatext;
 mod test_fn_if;
 mod test_fn_maxifs;
 mod test_fn_minifs;
@@ -24,6 +25,7 @@ mod test_fn_sum;
 mod test_fn_sumifs;
 mod test_fn_textbefore;
 mod test_fn_textjoin;
+mod test_fn_unicode;
 mod test_forward_references;
 mod test_frozen_rows_columns;
 mod test_general;
@@ -51,6 +53,7 @@ mod test_extend;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_get_cell_content;
+mod test_model_merge_cell_fns;
 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::LAST_COLUMN;
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -87,7 +87,8 @@ fn test_insert_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -106,7 +107,8 @@ fn test_insert_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
 
     // Row 10 is now row 15
@@ -120,7 +122,8 @@ fn test_delete_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -139,7 +142,8 @@ fn test_delete_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
 
     // Row 10 is now row 5

base/src/test/test_error_propagation.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::panic)]
 
 use crate::test::util::new_empty_model;
 use crate::types::Cell;

base/src/test/test_fn_formulatext.rs

@@ -0,0 +1,47 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_cases() {}
+
+#[test]
+fn wrong_number_of_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT()");
+    model._set("A2", "=FORMULATEXT(\"B\",\"A\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}
+
+#[test]
+fn multi_sheet_ref() {
+    let mut model = new_empty_model();
+    model.new_sheet();
+    model._set("A1", "=FORMULATEXT(Sheet1!A1:Sheet2!A1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn implicit_intersection() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT(C1:C2)");
+    model._set("A2", "=FORMULATEXT(D1:E1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}
+
+#[test]
+fn non_reference() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT(42)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}

base/src/test/test_fn_unicode.rs

@@ -0,0 +1,63 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_cases() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE(\"1,00\")");
+    model._set("A2", "=UNICODE(\"1\")");
+    model._set("A3", "=UNICODE(1)");
+    model._set("A4", "=UNICODE(\"T\")");
+    model._set("A5", "=UNICODE(\"TRUE\")");
+    model._set("A6", "=UNICODE(TRUE)");
+    model._set("A7", "=UNICODE(FALSE)");
+    model._set("A8", "=UNICODE(\"の\")");
+    model._set("A9", "=UNICODE(\" \")");
+
+    model._set("A10", "=_xlfn.UNICODE(\"T\")");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"49");
+    assert_eq!(model._get_text("A2"), *"49");
+    assert_eq!(model._get_text("A3"), *"49");
+    assert_eq!(model._get_text("A4"), *"84");
+    assert_eq!(model._get_text("A5"), *"84");
+    assert_eq!(model._get_text("A6"), *"84");
+    assert_eq!(model._get_text("A7"), *"70");
+    assert_eq!(model._get_text("A8"), *"12398");
+    assert_eq!(model._get_text("A9"), *"32");
+    assert_eq!(model._get_text("A10"), *"84");
+}
+
+#[test]
+fn test_error_cases() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE(\"\")");
+    model._set("A2", "=UNICODE(#CALC!)");
+    model._set("A3", "=UNICODE(#NAME?)");
+    model._set("A4", "=UNICODE(#VALUE!)");
+    model._set("A5", "=UNICODE(#REF!)");
+    model._set("A6", "=UNICODE(#DIV/0!)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#VALUE!");
+    assert_eq!(model._get_text("A2"), *"#CALC!");
+    assert_eq!(model._get_text("A3"), *"#NAME?");
+    assert_eq!(model._get_text("A4"), *"#VALUE!");
+    assert_eq!(model._get_text("A5"), *"#REF!");
+    assert_eq!(model._get_text("A6"), *"#DIV/0!");
+}
+
+#[test]
+fn wrong_number_of_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE()");
+    model._set("A2", "=UNICODE(\"B\",\"A\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}

base/src/test/test_metadata.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::test::util::new_empty_model;
 
 #[test]

base/src/test/test_model_merge_cell_fns.rs

@@ -0,0 +1,155 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{test::util::new_empty_model, types::CellType};
+
+#[test]
+fn test_model_set_fns_related_to_merge_cells() {
+    let mut model = new_empty_model();
+
+    // creating a merge cell of D1:F2
+    model.merge_cells(0, "D1:F2").unwrap();
+
+    // Updating the mother cell of Merge cells and expecting the update to go through
+    model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
+    assert_eq!(model.get_cell_content(0, 1, 4).unwrap(), "Hello");
+    assert_eq!(model.get_cell_type(0, 1, 4).unwrap(), CellType::Text);
+
+    // Updating cell which is not in Merge cell block
+    assert_eq!(model.set_user_input(0, 1, 3, "Hello".to_string()), Ok(()));
+    assert_eq!(model.get_cell_content(0, 1, 3), Ok("Hello".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 3), Ok(CellType::Text));
+
+    // 1: testing with set_user_input()
+    assert_eq!(
+        model
+            .set_user_input(0, 1, 5, "Hello".to_string()),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 2: testing with update_cell_with_bool()
+    assert_eq!(
+        model
+            .update_cell_with_bool(0, 1, 5, true),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 3: testing with update_cell_with_formula()
+    assert_eq!(
+        model
+            .update_cell_with_formula(0, 1, 5, "=SUM(A1+A2)".to_string()),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 4: testing with update_cell_with_number()
+    assert_eq!(
+        model
+            .update_cell_with_number(0, 1, 5, 10.0),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 5: testing with update_cell_with_text()
+    assert_eq!(
+        model
+            .update_cell_with_text(0, 1, 5, "new text"),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+}
+
+#[test]
+fn test_model_merge_cells_crud_api() {
+    let mut model = new_empty_model();
+
+    // creating a merge cell of D4:F6
+    model.merge_cells(0, "D4:F6").unwrap();
+    model
+        .set_user_input(0, 4, 4, "Merge Block".to_string())
+        .unwrap();
+    // CRUD APIS testing on Merge Cells
+
+    // Case1: Creating a new merge cell without overlapping
+    // Newly created Merge block is left to D4:F6
+    assert_eq!(model.merge_cells(0, "A1:B4"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        2
+    );
+    model.set_user_input(0, 1, 1, "left".to_string()).unwrap();
+
+    // Newly created Merge block is right to D4:F6
+    assert_eq!(model.merge_cells(0, "G1:H7"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        3
+    );
+    model.set_user_input(0, 1, 7, "right".to_string()).unwrap();
+
+    // Newly created Merge block is above to D4:F6
+    assert_eq!(model.merge_cells(0, "C1:D3"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        4
+    );
+    model.set_user_input(0, 1, 3, "top".to_string()).unwrap();
+
+    // Newly created Merge block is down to D4:F6
+    assert_eq!(model.merge_cells(0, "D8:E9"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        5
+    );
+    model.set_user_input(0, 8, 4, "down".to_string()).unwrap();
+
+    // Case2: Creating a new merge cell with overlapping with other 3 merged cell
+    assert_eq!(model.merge_cells(0, "C1:G4"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        3
+    );
+    model
+        .set_user_input(0, 1, 3, "overlapped_new_merge_block".to_string())
+        .unwrap();
+
+    // Case3: Giving wrong parsing range
+    assert_eq!(
+        model.merge_cells(0, "C3:A1"),
+        Err("Invalid parse range. Merge Mother cell always be top left cell".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "CA:A1"),
+        Err("Invalid range: 'CA:A1'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C0:A1"),
+        Err("Invalid range: 'C0:A1'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C1:A0"),
+        Err("Invalid range: 'C1:A0'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C1"),
+        Err("Invalid range: 'C1'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C1:A1:B1"),
+        Err("Invalid range: 'C1:A1:B1'".to_string())
+    );
+
+    // Case3: Giving wrong merge_ref, which would resulting in error (Merge cell to be deleted is not found)
+    assert_eq!(
+        model.unmerge_cells(0, "C1:E1"),
+        Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
+    );
+
+    // Case4: unmerge scenario
+    assert_eq!(model.unmerge_cells(0, "C1:G4"), Ok(()));
+}

base/src/test/test_set_functions_error_handling.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::{expressions::token, test::util::new_empty_model, types::Cell};
 
 #[test]

base/src/test/test_styles.rs

@@ -62,3 +62,45 @@ fn test_create_named_style() {
     let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
 }
+
+#[test]
+fn test_model_style_set_fns_in_merge_cell_context() {
+    let mut model = new_empty_model();
+
+    // creating a merge cell of D1:F2
+    model.merge_cells(0, "D1:F2").unwrap();
+    model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
+
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
+    assert!(!style.font.b);
+    style.font.b = true;
+
+    // Updating the mother cell of Merge cells and expecting the update to go through
+    // This should make the text "Hello" in bold format
+    assert_eq!(model.set_cell_style(0, 1, 4, &style), Ok(()));
+
+    // 1: testing with set_cell_style()
+    let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
+    assert_eq!(
+        model
+            .set_cell_style(0, 1, 5, &style),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
+
+    // 2: testing with set_cell_style_by_name
+    let mut style = model.get_style_for_cell(0, 1, 4).unwrap();
+    style.font.b = true;
+    assert_eq!(
+        model.workbook.styles.create_named_style("bold", &style),
+        Ok(())
+    );
+
+    let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
+    assert_eq!(
+        model
+            .set_cell_style_by_name(0, 1, 5, "bold"),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
+}

base/src/test/test_worksheet.rs

@@ -283,3 +283,87 @@ fn test_worksheet_navigate_to_edge_in_direction() {
     assert_eq!(navigate(8, 3, NavigationDirection::Up), (6, 3));
     assert_eq!(navigate(9, 3, NavigationDirection::Up), (6, 3));
 }
+
+// Tests Merge cells related functions of worksheet
+
+#[test]
+fn test_merge_cell_fns_worksheet() {
+    let mut model = new_empty_model();
+
+    // Adding one Merge cell
+    model.merge_cells(0, "D1:E3").unwrap();
+
+    // Lets check whether D1 (Mother Merge cell) is part of Merge block or not
+    // It should not be considered as part of Merge cell
+    assert!(!model
+        .workbook
+        .worksheet(0)
+        .unwrap()
+        .is_part_of_merged_cells(1, 4)
+        .unwrap(),);
+
+    // Lets give cell which is actually part of Merge block and expect true from fn
+    assert!(model
+        .workbook
+        .worksheet(0)
+        .unwrap()
+        .is_part_of_merged_cells(2, 4)
+        .unwrap());
+
+    // Lets give cell which is not a part of Merge block and expect false from fn
+    assert!(!model
+        .workbook
+        .worksheet(0)
+        .unwrap()
+        .is_part_of_merged_cells(2, 6)
+        .unwrap());
+
+    // Lets give an Invalid row
+    assert_eq!(
+        model
+            .workbook
+            .worksheet(0)
+            .unwrap()
+            .is_part_of_merged_cells(0, 1),
+        Err("Incorrect row or column".to_string())
+    );
+
+    //Lets give Invalid column
+    assert_eq!(
+        model
+            .workbook
+            .worksheet(0)
+            .unwrap()
+            .is_part_of_merged_cells(1, 0),
+        Err("Incorrect row or column".to_string())
+    );
+
+    // Verifying get fns of worksheet
+    assert_eq!(
+        model
+            .workbook
+            .worksheet(0)
+            .unwrap()
+            .get_merged_cells_list()
+            .len(),
+        1
+    );
+    {
+        let merge_cell_vec = model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .get_merged_cells_list_mut();
+        merge_cell_vec.remove(0);
+
+        assert_eq!(
+            model
+                .workbook
+                .worksheet(0)
+                .unwrap()
+                .get_merged_cells_list()
+                .len(),
+            0
+        );
+    }
+}

base/src/test/user_model/mod.rs

@@ -11,6 +11,7 @@ mod test_keyboard_navigation;
 mod test_on_area_selection;
 mod test_on_expand_selected_range;
 mod test_on_paste_styles;
+mod test_paste_csv;
 mod test_rename_sheet;
 mod test_row_column;
 mod test_styles;
@@ -18,3 +19,4 @@ mod test_to_from_bytes;
 mod test_undo_redo;
 mod test_view;
 mod test_window_size;
+mod util;

base/src/test/user_model/test_add_delete_sheets.rs

@@ -5,13 +5,13 @@ use crate::{constants::DEFAULT_COLUMN_WIDTH, UserModel};
 #[test]
 fn add_undo_redo() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.set_user_input(1, 1, 1, "=1 + 1").unwrap();
     model.set_user_input(1, 1, 2, "=A1*3").unwrap();
     model
         .set_column_width(1, 5, 5.0 * DEFAULT_COLUMN_WIDTH)
         .unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.set_user_input(2, 1, 1, "=Sheet2!B1").unwrap();
 
     model.undo().unwrap();
@@ -59,7 +59,7 @@ fn set_sheet_color() {
 #[test]
 fn new_sheet_propagates() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
 
     let send_queue = model.flush_send_queue();
 
@@ -72,7 +72,7 @@ fn new_sheet_propagates() {
 #[test]
 fn delete_sheet_propagates() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.delete_sheet(0).unwrap();
 
     let send_queue = model.flush_send_queue();
@@ -87,10 +87,18 @@ fn delete_sheet_propagates() {
 fn delete_last_sheet() {
     // Deleting the last sheet, selects the previous
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.set_selected_sheet(2).unwrap();
     model.delete_sheet(2).unwrap();
 
     assert_eq!(model.get_selected_sheet(), 1);
 }
+
+#[test]
+fn new_sheet_selects_it() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+    model.new_sheet().unwrap();
+    assert_eq!(model.get_selected_sheet(), 1);
+}

base/src/test/user_model/test_border.rs

@@ -1,11 +1,111 @@
 #![allow(clippy::unwrap_used)]
 
 use crate::{
+    constants::{LAST_COLUMN, LAST_ROW},
     expressions::{types::Area, utils::number_to_column},
     types::{Border, BorderItem, BorderStyle},
     BorderArea, UserModel,
 };
 
+// checks there are no borders in the sheet
+#[track_caller]
+fn check_no_borders(model: &UserModel) {
+    let workbook = &model.model.workbook;
+    for ws in &workbook.worksheets {
+        for data_row in ws.sheet_data.values() {
+            for cell in data_row.values() {
+                let style_index = cell.get_style();
+                let style = workbook.styles.get_style(style_index).unwrap();
+                assert_eq!(
+                    style.border,
+                    Border {
+                        diagonal_up: false,
+                        diagonal_down: false,
+                        left: None,
+                        right: None,
+                        top: None,
+                        bottom: None,
+                        diagonal: None
+                    }
+                )
+            }
+        }
+    }
+}
+
+// checks that all the borders are consistent
+#[track_caller]
+fn check_borders(model: &UserModel) {
+    let workbook = &model.model.workbook;
+    for (sheet_index, ws) in workbook.worksheets.iter().enumerate() {
+        let sheet = sheet_index as u32;
+        for (&row, data_row) in &ws.sheet_data {
+            for (&column, cell) in data_row {
+                let style_index = cell.get_style();
+                let style = workbook.styles.get_style(style_index).unwrap();
+                // Top border:
+                if let Some(top_border) = style.border.top {
+                    if row > 1 {
+                        let top_cell_style = model.get_cell_style(sheet, row - 1, column).unwrap();
+                        assert_eq!(
+                            Some(top_border),
+                            top_cell_style.border.bottom,
+                            "(Top). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
+                        );
+                    }
+                }
+                // Border to the right
+                if let Some(right_border) = style.border.right {
+                    if column < LAST_COLUMN {
+                        let right_cell_style =
+                            model.get_cell_style(sheet, row, column + 1).unwrap();
+                        assert_eq!(
+                            Some(right_border),
+                            right_cell_style.border.left,
+                            "(Right). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
+                        );
+                    }
+                }
+                // Bottom border:
+                if let Some(bottom_border) = style.border.bottom {
+                    if row < LAST_ROW {
+                        let bottom_cell_style =
+                            model.get_cell_style(sheet, row + 1, column).unwrap();
+                        assert_eq!(
+                            Some(bottom_border),
+                            bottom_cell_style.border.top,
+                            "(Bottom). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
+                        );
+                    }
+                }
+                // Left Border
+                if let Some(left_border) = style.border.left {
+                    if column > 1 {
+                        let left_cell_style = model.get_cell_style(sheet, row, column - 1).unwrap();
+                        assert_eq!(
+                            Some(left_border),
+                            left_cell_style.border.right,
+                            "(Left). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[test]
 fn borders_all() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
@@ -51,6 +151,86 @@ fn borders_all() {
         }
     }
 
+    // let's check the borders around
+    {
+        let row = 4;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let row = 9;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: Some(border_item.clone()),
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    {
+        let column = 5;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: Some(border_item.clone()),
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let column = 9;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+
+    check_borders(&model);
+
     // Lets remove all of them:
     let border_area: BorderArea = serde_json::from_str(
         r##"{
@@ -63,8 +243,8 @@ fn borders_all() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
-    for row in 5..9 {
+    for row in 4..10 {
-        for column in 6..9 {
+        for column in 5..10 {
             let style = model.get_cell_style(0, row, column).unwrap();
             let expected_border = Border {
                 diagonal_up: false,
@@ -78,11 +258,14 @@ fn borders_all() {
             assert_eq!(style.border, expected_border);
         }
     }
+
+    check_borders(&model);
 }
 
 #[test]
 fn borders_inner() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    check_borders(&model);
     // We set an outer border in cells F5:H9
     let range = &Area {
         sheet: 0,
@@ -105,6 +288,7 @@ fn borders_inner() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
+    check_borders(&model);
     // The inner part all have borders
     for row in 6..8 {
         for column in 7..8 {
@@ -191,6 +375,7 @@ fn borders_outer() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
+    check_borders(&model);
     {
         // We check the border on F5
         let style = model.get_cell_style(0, 5, 6).unwrap();
@@ -229,6 +414,84 @@ fn borders_outer() {
         };
         assert_eq!(style.border, expected_border);
     }
+
+    // let's check the borders around
+    {
+        let row = 4;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let row = 9;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: Some(border_item.clone()),
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    {
+        let column = 5;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: Some(border_item.clone()),
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let column = 9;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
 }
 
 #[test]
@@ -256,7 +519,35 @@ fn borders_top() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
+    check_borders(&model);
     for row in 5..9 {
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let bottom = if row == 8 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: Some(border_item.clone()),
+                bottom,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+
+    // let's check the borders around
+    {
+        let row = 4;
         for column in 6..9 {
             let style = model.get_cell_style(0, row, column).unwrap();
             let border_item = BorderItem {
@@ -268,13 +559,59 @@ fn borders_top() {
                 diagonal_down: false,
                 left: None,
                 right: None,
-                top: Some(border_item.clone()),
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let row = 9;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
                 bottom: None,
                 diagonal: None,
             };
             assert_eq!(style.border, expected_border);
         }
     }
+    {
+        let column = 5;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let column = 9;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    assert!(model.undo().is_ok());
+    check_no_borders(&model);
 }
 
 #[test]
@@ -302,18 +639,29 @@ fn borders_right() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
+
     for row in 5..9 {
-        for column in 6..9 {
+        for column in 6..10 {
             let style = model.get_cell_style(0, row, column).unwrap();
             let border_item = BorderItem {
                 style: BorderStyle::Thin,
                 color: Some("#FF5566".to_string()),
             };
+            let left = if column == 6 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
+            let right = if column == 9 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
             let expected_border = Border {
                 diagonal_up: false,
                 diagonal_down: false,
-                left: None,
+                left,
-                right: Some(border_item.clone()),
+                right,
                 top: None,
                 bottom: None,
                 diagonal: None,
@@ -348,6 +696,7 @@ fn borders_bottom() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
+    check_borders(&model);
     for row in 5..9 {
         for column in 6..9 {
             let style = model.get_cell_style(0, row, column).unwrap();
@@ -355,12 +704,18 @@ fn borders_bottom() {
                 style: BorderStyle::Thin,
                 color: Some("#FF5566".to_string()),
             };
+            // The top will also have a value for all but the first one
+            let top = if row == 5 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
             let expected_border = Border {
                 diagonal_up: false,
                 diagonal_down: false,
                 left: None,
                 right: None,
-                top: None,
+                top,
                 bottom: Some(border_item.clone()),
                 diagonal: None,
             };
@@ -394,18 +749,29 @@ fn borders_left() {
     )
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
+
     for row in 5..9 {
-        for column in 6..9 {
+        for column in 5..9 {
             let style = model.get_cell_style(0, row, column).unwrap();
             let border_item = BorderItem {
                 style: BorderStyle::Thin,
                 color: Some("#FF5566".to_string()),
             };
+            let left = if column == 5 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
+            let right = if column == 8 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
             let expected_border = Border {
                 diagonal_up: false,
                 diagonal_down: false,
-                left: Some(border_item.clone()),
+                left,
-                right: None,
+                right,
                 top: None,
                 bottom: None,
                 diagonal: None,
@@ -414,3 +780,255 @@ fn borders_left() {
         }
     }
 }
+
+#[test]
+fn none_borders_get_neighbour() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 1,
+        height: 1,
+    };
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "All"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+
+    // Get adjacent cells
+    {
+        // F4
+        let style = model.get_cell_style(0, 4, 6).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: None,
+            right: None,
+            top: None,
+            bottom: Some(border_item),
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+    {
+        // G5
+        let style = model.get_cell_style(0, 5, 7).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: Some(border_item),
+            right: None,
+            top: None,
+            bottom: None,
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+    {
+        // F6
+        let style = model.get_cell_style(0, 6, 6).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: None,
+            right: None,
+            top: Some(border_item),
+            bottom: None,
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+    {
+        // E5
+        let style = model.get_cell_style(0, 5, 5).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: None,
+            right: Some(border_item),
+            top: None,
+            bottom: None,
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+}
+
+#[test]
+fn heavier_borders() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    model._set_cell_border("F5", "#F2F2F2");
+
+    // We set an outer border in F4:
+    model._set_cell_border("F4", "#000000");
+
+    // We check the border between F4 and F5
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#000000".to_string()),
+    };
+    assert_eq!(model._get_cell_border("F5").top, Some(border_item.clone()));
+
+    // But the border is actually NOT changed (because it is lighter)
+    let border_item2 = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#F2F2F2".to_string()),
+    };
+    assert_eq!(model._get_cell_actual_border("F5").top, Some(border_item2));
+
+    model._set_cell_border("F6", "#000000");
+}
+
+#[test]
+fn lighter_borders() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    model._set_cell_border("F5", "#000000");
+
+    // We set an outer border all around that is "lighter":
+    model._set_cell_border("F4", "#F2F2F2");
+    model._set_cell_border("G5", "#F2F2F2");
+    model._set_cell_border("F6", "#F2F2F2");
+    model._set_cell_border("E5", "#F2F2F2");
+
+    // We check the border around F5
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#F2F2F2".to_string()),
+    };
+    let border = model._get_cell_border("F5");
+    assert_eq!(border.top, Some(border_item.clone()));
+    assert_eq!(border.right, Some(border_item.clone()));
+    assert_eq!(border.bottom, Some(border_item.clone()));
+    assert_eq!(border.left, Some(border_item.clone()));
+
+    // The border is actually changed (because it is heavier)
+    let actual_border = model._get_cell_actual_border("F5");
+    assert_eq!(actual_border.top, Some(border_item.clone()));
+    assert_eq!(actual_border.right, Some(border_item.clone()));
+    assert_eq!(actual_border.bottom, Some(border_item.clone()));
+    assert_eq!(actual_border.left, Some(border_item));
+
+    model.undo().unwrap();
+    model.undo().unwrap();
+    model.undo().unwrap();
+    model.undo().unwrap();
+
+    // after undoing the border is what it was
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#000000".to_string()),
+    };
+    let border = model._get_cell_border("F5");
+    assert_eq!(border.top, Some(border_item.clone()));
+    assert_eq!(border.right, Some(border_item.clone()));
+    assert_eq!(border.bottom, Some(border_item.clone()));
+    assert_eq!(border.left, Some(border_item.clone()));
+}
+
+#[test]
+fn autofill() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    model._set_area_border("C4:F6", "#F4F4F4", "All");
+
+    // Set a border in D2
+    model._set_cell_border("D2", "#000000");
+    // now we extend to D8
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 2,
+                column: 4,
+                width: 1,
+                height: 1,
+            },
+            8,
+        )
+        .unwrap();
+    // auto filling does not change the borders
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#000000".to_string()),
+    };
+    let border = model._get_cell_border("D4");
+    assert_eq!(border.top, Some(border_item.clone()));
+    assert_eq!(border.right, Some(border_item.clone()));
+    assert_eq!(border.bottom, Some(border_item.clone()));
+    assert_eq!(border.left, Some(border_item.clone()));
+
+    // E5
+    let border_e5 = model._get_cell_border("E5");
+    assert_eq!(border_e5.left, Some(border_item.clone()));
+
+    // but it hasn't really changed
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#F4F4F4".to_string()),
+    };
+    let border_e5_actual = model._get_cell_actual_border("E5");
+    assert_eq!(border_e5_actual.left, Some(border_item.clone()));
+}
+
+#[test]
+fn border_top() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    model._set_area_border("C4:F6", "#000000", "All");
+
+    // We set all with a lighter color in the top
+    model._set_area_border("C4:F6", "#F2F2F2", "Top");
+
+    // C3 doesn't have a border in the bottom
+    assert_eq!(model._get_cell_actual_border("C3").bottom, None);
+
+    // But C4 was changed
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#F2F2F2".to_string()),
+    };
+    assert_eq!(
+        model._get_cell_actual_border("C4").bottom,
+        Some(border_item)
+    );
+
+    model.undo().unwrap();
+
+    // This tests that diff lists go in the right order
+    let border_item = BorderItem {
+        style: BorderStyle::Thin,
+        color: Some("#000000".to_string()),
+    };
+    assert_eq!(model._get_cell_actual_border("C4").top, Some(border_item));
+}

base/src/test/user_model/test_diff_queue.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::{
     constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT},
     test::util::new_empty_model,
@@ -138,7 +140,7 @@ fn queue_undo_redo_multiple() {
 #[test]
 fn new_sheet() {
     let mut model1 = UserModel::from_model(new_empty_model());
-    model1.new_sheet();
+    model1.new_sheet().unwrap();
     model1.set_user_input(0, 1, 1, "42").unwrap();
     model1.set_user_input(1, 1, 1, "=Sheet1!A1*2").unwrap();
 

base/src/test/user_model/test_general.rs

@@ -129,3 +129,12 @@ fn delete_remove_cell() {
     let (sheet, row, column) = (0, 1, 1);
     model.set_user_input(sheet, row, column, "100$").unwrap();
 }
+
+#[test]
+fn get_and_set_name() {
+    let mut model = UserModel::new_empty("MyWorkbook123", "en", "UTC").unwrap();
+    assert_eq!(model.get_name(), "MyWorkbook123");
+
+    model.set_name("Another name");
+    assert_eq!(model.get_name(), "Another name");
+}

base/src/test/user_model/test_grid_lines.rs

@@ -7,7 +7,7 @@ use crate::UserModel;
 fn basic_tests() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
-    model.new_sheet();
+    model.new_sheet().unwrap();
 
     // default sheet has show_grid_lines = true
     assert_eq!(model.get_show_grid_lines(0), Ok(true));

base/src/test/user_model/test_paste_csv.rs

@@ -0,0 +1,187 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, UserModel};
+
+#[test]
+fn csv_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 7, 7, "=SUM(B4:D7)").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
+
+    // paste some numbers in B4:C7
+    let csv = "1\t2\t3\n4\t5\t6";
+    let area = Area {
+        sheet: 0,
+        row: 4,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(4, 2).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 7),
+        Ok("21".to_string())
+    );
+}
+
+#[test]
+fn csv_paste_formula() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    let csv = "=YEAR(TODAY())";
+    let area = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(1, 1).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("2022".to_string())
+    );
+}
+
+#[test]
+fn tsv_crlf_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 7, 7, "=SUM(B4:D7)").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
+
+    // paste some numbers in B4:C7
+    let csv = "1\t2\t3\r\n4\t5\t6";
+    let area = Area {
+        sheet: 0,
+        row: 4,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(4, 2).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 7),
+        Ok("21".to_string())
+    );
+}
+
+#[test]
+fn cut_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1*3+1").unwrap();
+
+    // set A1 bold
+    let range = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.update_range_style(&range, "font.b", "true").unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
+        .unwrap();
+
+    // Select A1:B2 and copy
+    model.set_selected_range(1, 1, 2, 2).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4)
+    model
+        .paste_from_clipboard((1, 1, 2, 2), &copy.data, true)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+
+    // range A1:B2 must be empty
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 2), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 2, 1), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 2, 2), Ok("".to_string()));
+}
+
+#[test]
+fn copy_paste_internal() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1*3+1").unwrap();
+
+    // set A1 bold
+    let range = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.update_range_style(&range, "font.b", "true").unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
+        .unwrap();
+
+    // Select A1:B2 and copy
+    model.set_selected_range(1, 1, 2, 2).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+    assert_eq!(
+        copy.csv,
+        "42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
+    );
+    assert_eq!(copy.range, (1, 1, 2, 2));
+
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4)
+    model
+        .paste_from_clipboard((1, 1, 2, 2), &copy.data, false)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("".to_string()));
+    // cell D4 must not be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(!style_d4.font.b);
+
+    model.redo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+}

base/src/test/user_model/test_rename_sheet.rs

@@ -9,6 +9,13 @@ fn basic_rename() {
     assert_eq!(model.get_worksheets_properties()[0].name, "NewSheet");
 }
 
+#[test]
+fn rename_with_same_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.rename_sheet(0, "Sheet1").unwrap();
+    assert_eq!(model.get_worksheets_properties()[0].name, "Sheet1");
+}
+
 #[test]
 fn undo_redo() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();

base/src/test/user_model/test_row_column.rs

@@ -154,3 +154,21 @@ fn simple_delete_row_no_style() {
 
     assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
 }
+
+#[test]
+fn row_heigh_increases_automatically() {
+    let mut model = UserModel::new_empty("Workbook1", "en", "UTC").unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(DEFAULT_ROW_HEIGHT));
+
+    // Entering a single line does not change the height
+    model
+        .set_user_input(0, 1, 1, "My home in Canada had horses")
+        .unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(DEFAULT_ROW_HEIGHT));
+
+    // entering a two liner does:
+    model
+        .set_user_input(0, 1, 1, "My home in Canada had horses\nAnd monkeys!")
+        .unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(2.0 * DEFAULT_ROW_HEIGHT));
+}

base/src/test/user_model/test_styles.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     expressions::types::Area,
-    types::{Alignment, BorderItem, BorderStyle, HorizontalAlignment, VerticalAlignment},
+    types::{Alignment, HorizontalAlignment, VerticalAlignment},
     UserModel,
 };
 
@@ -145,6 +145,7 @@ fn basic_fill() {
     let style = model.get_cell_style(0, 1, 1).unwrap();
     assert_eq!(style.fill.bg_color, None);
     assert_eq!(style.fill.fg_color, None);
+    assert_eq!(&style.fill.pattern_type, "none");
 
     // bg_color
     model
@@ -156,6 +157,7 @@ fn basic_fill() {
     let style = model.get_cell_style(0, 1, 1).unwrap();
     assert_eq!(style.fill.bg_color, Some("#F2F2F2".to_owned()));
     assert_eq!(style.fill.fg_color, Some("#F3F4F5".to_owned()));
+    assert_eq!(&style.fill.pattern_type, "solid");
 
     let send_queue = model.flush_send_queue();
 
@@ -227,157 +229,6 @@ fn basic_format() {
     assert_eq!(style.num_fmt, "$#,##0.0000");
 }
 
-#[test]
-fn basic_borders() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    model
-        .update_range_style(&range, "border.left", "thin,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "thin,")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: None,
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.right", "dotted,#F1F1F2")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.right,
-        Some(BorderItem {
-            style: BorderStyle::Dotted,
-            color: Some("#F1F1F2".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.top", "double,#F1F1F3")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.top,
-        Some(BorderItem {
-            style: BorderStyle::Double,
-            color: Some("#F1F1F3".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.bottom", "medium,#F1F1F4")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.bottom,
-        Some(BorderItem {
-            style: BorderStyle::Medium,
-            color: Some("#F1F1F4".to_owned()),
-        })
-    );
-
-    while model.can_undo() {
-        model.undo().unwrap();
-    }
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(style.border.left, None);
-    assert_eq!(style.border.top, None);
-    assert_eq!(style.border.right, None);
-    assert_eq!(style.border.bottom, None);
-
-    while model.can_redo() {
-        model.redo().unwrap();
-    }
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: None,
-        })
-    );
-    assert_eq!(
-        style.border.right,
-        Some(BorderItem {
-            style: BorderStyle::Dotted,
-            color: Some("#F1F1F2".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.top,
-        Some(BorderItem {
-            style: BorderStyle::Double,
-            color: Some("#F1F1F3".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.bottom,
-        Some(BorderItem {
-            style: BorderStyle::Medium,
-            color: Some("#F1F1F4".to_owned()),
-        })
-    );
-
-    let send_queue = model.flush_send_queue();
-
-    let mut model2 = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model2.apply_external_diffs(&send_queue).unwrap();
-
-    let style = model2.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: None,
-        })
-    );
-    assert_eq!(
-        style.border.right,
-        Some(BorderItem {
-            style: BorderStyle::Dotted,
-            color: Some("#F1F1F2".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.top,
-        Some(BorderItem {
-            style: BorderStyle::Double,
-            color: Some("#F1F1F3".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.bottom,
-        Some(BorderItem {
-            style: BorderStyle::Medium,
-            color: Some("#F1F1F4".to_owned()),
-        })
-    );
-}
-
 #[test]
 fn basic_alignment() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
@@ -565,142 +416,6 @@ fn basic_wrap_text() {
     );
 }
 
-#[test]
-fn more_basic_borders() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    model
-        .update_range_style(&range, "border.left", "thick,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thick,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "slantDashDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::SlantDashDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "mediumDashDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "mediumDashDotDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashDotDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "mediumDashed,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashed,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-}
-
-#[test]
-fn border_errors() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    assert_eq!(
-        model.update_range_style(&range, "border.lef", "thick,#F1F1F1"),
-        Err("Invalid style path: 'border.lef'.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", "thic,#F1F1F1"),
-        Err("Invalid border style: 'thic'.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", "thick,#F1F1F"),
-        Err("Invalid color: '#F1F1F'.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", " "),
-        Err("Invalid border value: ' '.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", "thick,#F1F1F1,thin"),
-        Err("Invalid border value: 'thick,#F1F1F1,thin'.".to_string())
-    );
-}
-
-#[test]
-fn empty_removes_border() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-    model
-        .update_range_style(&range, "border.left", "mediumDashDotDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashDotDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model.update_range_style(&range, "border.left", "").unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(style.border.left, None);
-}
-
 #[test]
 fn false_removes_value() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();

base/src/test/user_model/test_view.rs

@@ -65,13 +65,13 @@ fn set_the_range_does_not_set_the_cell() {
 fn add_new_sheet_and_back() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
-    model.new_sheet();
+    model.new_sheet().unwrap();
-    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_sheet(), 1);
     model.set_selected_cell(5, 4).unwrap();
-    model.set_selected_sheet(1).unwrap();
-    assert_eq!(model.get_selected_cell(), (1, 1, 1));
     model.set_selected_sheet(0).unwrap();
-    assert_eq!(model.get_selected_cell(), (0, 5, 4));
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    model.set_selected_sheet(1).unwrap();
+    assert_eq!(model.get_selected_cell(), (1, 5, 4));
 }
 
 #[test]

base/src/test/user_model/util.rs

@@ -0,0 +1,75 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, types::Border, BorderArea, UserModel};
+
+impl UserModel {
+    pub fn _set_cell_border(&mut self, cell: &str, color: &str) {
+        let cell_reference = self.model._parse_reference(cell);
+        let column = cell_reference.column;
+        let row = cell_reference.row;
+        let border_area: BorderArea = serde_json::from_str(&format!(
+            r##"{{
+                "item": {{
+                    "style": "thin",
+                    "color": "{}"
+                }},
+                "type": "All"
+            }}"##,
+            color
+        ))
+        .unwrap();
+        let range = &Area {
+            sheet: 0,
+            row,
+            column,
+            width: 1,
+            height: 1,
+        };
+        self.set_area_with_border(range, &border_area).unwrap();
+    }
+
+    pub fn _set_area_border(&mut self, range: &str, color: &str, kind: &str) {
+        let s: Vec<&str> = range.split(':').collect();
+        let left = self.model._parse_reference(s[0]);
+        let right = self.model._parse_reference(s[1]);
+        let column = left.column;
+        let row = left.row;
+        let width = right.column - column + 1;
+        let height = right.row - row + 1;
+        let border_area: BorderArea = serde_json::from_str(&format!(
+            r##"{{
+                "item": {{
+                    "style": "thin",
+                    "color": "{}"
+                }},
+                "type": "{}"
+            }}"##,
+            color, kind
+        ))
+        .unwrap();
+        let range = &Area {
+            sheet: 0,
+            row,
+            column,
+            width,
+            height,
+        };
+        self.set_area_with_border(range, &border_area).unwrap();
+    }
+
+    pub fn _get_cell_border(&self, cell: &str) -> Border {
+        let cell_reference = self.model._parse_reference(cell);
+        let column = cell_reference.column;
+        let row = cell_reference.row;
+        let style = self.get_cell_style(0, row, column).unwrap();
+        style.border
+    }
+
+    pub fn _get_cell_actual_border(&self, cell: &str) -> Border {
+        let cell_reference = self.model._parse_reference(cell);
+        let column = cell_reference.column;
+        let row = cell_reference.row;
+        let style = self.model.get_style_for_cell(0, row, column).unwrap();
+        style.border
+    }
+}

base/src/test/util.rs

@@ -9,7 +9,7 @@ pub fn new_empty_model() -> Model {
 }
 
 impl Model {
-    fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
+    pub fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
         if cell.contains('!') {
             self.parse_reference(cell).unwrap()
         } else {

base/src/types.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt::Display};
 
 use crate::expressions::token::Error;
+use crate::expressions::utils::number_to_column;
 
 fn default_as_false() -> bool {
     false
@@ -110,7 +111,7 @@ pub struct Worksheet {
     pub sheet_id: u32,
     pub state: SheetState,
     pub color: Option<String>,
-    pub merge_cells: Vec<String>,
+    pub merged_cells_list: Vec<MergedCells>,
     pub comments: Vec<Comment>,
     pub frozen_rows: i32,
     pub frozen_columns: i32,
@@ -351,6 +352,43 @@ pub enum FontScheme {
     None,
 }
 
+// MergedCells type
+// There will be one MergedCells struct maintained for every Merged cells that we load
+// merge_cell_range : Its tuple having [row_start, column_start, row_end, column_end]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+pub struct MergedCells(pub i32, pub i32, pub i32, pub i32);
+
+// implementing accessor function
+impl MergedCells {
+    // Method which returns range_ref from the tuple
+    // ex : (3,1,4,2) is interpreted as A3:B4
+    pub fn get_merged_cells_str_ref(&self) -> Result<String, String> {
+        let start_column = number_to_column(self.1).ok_or(format!(
+            "Error while converting column start {} number to column string ref",
+            self.1
+        ))?;
+        let end_column = number_to_column(self.3).ok_or(format!(
+            "Error while converting column end {} number to column string ref",
+            self.3
+        ))?;
+        return Ok(start_column
+            + &self.0.to_string()
+            + &":".to_string()
+            + &end_column
+            + &self.2.to_string());
+    }
+
+    // Only Public function where Merge cell can be created
+    pub fn new(merge_cell_parsed_range: (i32, i32, i32, i32)) -> Self {
+        Self(
+            merge_cell_parsed_range.0,
+            merge_cell_parsed_range.1,
+            merge_cell_parsed_range.2,
+            merge_cell_parsed_range.3,
+        )
+    }
+}
+
 impl Display for FontScheme {
     fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
@@ -578,7 +616,7 @@ impl Default for CellStyles {
     }
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, PartialOrd, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum BorderStyle {
     Thin,

base/src/units.rs

@@ -7,17 +7,20 @@ use crate::{
 
 pub enum Units {
     Number {
+        #[allow(dead_code)]
         group_separator: bool,
         precision: i32,
         num_fmt: String,
     },
     Currency {
+        #[allow(dead_code)]
         group_separator: bool,
         precision: i32,
         num_fmt: String,
         currency: String,
     },
     Percentage {
+        #[allow(dead_code)]
         group_separator: bool,
         precision: i32,
         num_fmt: String,

base/src/user_model/border_utils.rs

@@ -0,0 +1,137 @@
+use crate::types::BorderItem;
+
+fn parse_color(s: &str) -> Option<(u8, u8, u8)> {
+    let s = s.trim_start_matches('#');
+    match s.len() {
+        6 => {
+            let r = u8::from_str_radix(&s[0..2], 16).ok()?;
+            let g = u8::from_str_radix(&s[2..4], 16).ok()?;
+            let b = u8::from_str_radix(&s[4..6], 16).ok()?;
+            Some((r, g, b))
+        }
+        3 => {
+            let r = u8::from_str_radix(&s[0..1], 16).ok()?;
+            let g = u8::from_str_radix(&s[1..2], 16).ok()?;
+            let b = u8::from_str_radix(&s[2..3], 16).ok()?;
+            // Expand single hex digits to full bytes
+            Some((r * 17, g * 17, b * 17))
+        }
+        _ => None,
+    }
+}
+
+fn compute_luminance(r: u8, g: u8, b: u8) -> f64 {
+    // Normalize RGB values to [0, 1]
+    let r = r as f64 / 255.0;
+    let g = g as f64 / 255.0;
+    let b = b as f64 / 255.0;
+    // Calculate luminance using the Rec. 601 formula
+    0.299 * r + 0.587 * g + 0.114 * b
+}
+
+fn is_max_color(a: &str, b: &str) -> bool {
+    let (ar, ag, ab) = match parse_color(a) {
+        Some(rgb) => rgb,
+        None => return false, // Invalid color format for 'a'
+    };
+
+    let (br, bg, bb) = match parse_color(b) {
+        Some(rgb) => rgb,
+        None => return false, // Invalid color format for 'b'
+    };
+
+    let luminance_a = compute_luminance(ar, ag, ab);
+    let luminance_b = compute_luminance(br, bg, bb);
+
+    // 'b' is heavier if its luminance is less than 'a's luminance
+    luminance_b < luminance_a
+}
+
+/// Is border b "heavier" than a?
+pub(crate) fn is_max_border(a: Option<&BorderItem>, b: Option<&BorderItem>) -> bool {
+    match (a, b) {
+        (_, None) => false,
+        (None, Some(_)) => true,
+        (Some(item_a), Some(item_b)) => {
+            if item_a.style < item_b.style {
+                return true;
+            } else if item_a.style > item_b.style {
+                return false;
+            }
+            match (&item_a.color, &item_b.color) {
+                (_, None) => false,
+                (None, Some(_)) => true,
+                (Some(color_a), Some(color_b)) => is_max_color(color_a, color_b),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::BorderStyle;
+
+    #[test]
+    fn compare_borders() {
+        let b = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FFF".to_string()),
+        };
+        // Some border *always* beats no border
+        assert!(is_max_border(None, Some(&b)));
+
+        // No border is beaten by some border
+        assert!(!is_max_border(Some(&b), None));
+    }
+
+    #[test]
+    fn basic_colors() {
+        // Black vs White
+        assert!(is_max_color("#FFFFFF", "#000000"));
+        assert!(!is_max_color("#000000", "#FFFFFF"));
+
+        // Red vs Dark Red
+        assert!(is_max_color("#FF0000", "#800000"));
+        assert!(!is_max_color("#800000", "#FF0000"));
+
+        // Green vs Dark Green
+        assert!(is_max_color("#00FF00", "#008000"));
+        assert!(!is_max_color("#008000", "#00FF00"));
+
+        // Blue vs Dark Blue
+        assert!(is_max_color("#0000FF", "#000080"));
+        assert!(!is_max_color("#000080", "#0000FF"));
+    }
+
+    #[test]
+    fn same_color() {
+        // Comparing the same color should return false
+        assert!(!is_max_color("#123456", "#123456"));
+    }
+
+    #[test]
+    fn edge_cases() {
+        // Colors with minimal luminance difference
+        assert!(!is_max_color("#000000", "#010101"));
+        assert!(!is_max_color("#FEFEFE", "#FFFFFF"));
+        assert!(!is_max_color("#7F7F7F", "#808080"));
+    }
+
+    #[test]
+    fn luminance_ordering() {
+        // Colors with known luminance differences
+        assert!(is_max_color("#CCCCCC", "#333333")); // Light gray vs Day
+        assert!(is_max_color("#FFFF00", "#808000")); // Yellow ve
+        assert!(is_max_color("#FF00FF", "#800080")); // Magenta vle
+    }
+
+    #[test]
+    fn borderline_cases() {
+        // Testing colors with equal luminance
+        assert!(!is_max_color("#777777", "#777777"));
+
+        // Testing black against near-black
+        assert!(!is_max_color("#000000", "#010000"));
+    }
+}

base/src/user_model/common.rs

@@ -1,19 +1,20 @@
 #![deny(missing_docs)]
 
-use std::{collections::HashMap, fmt::Debug};
+use std::{collections::HashMap, fmt::Debug, io::Cursor};
 
+use csv::{ReaderBuilder, WriterBuilder};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    constants,
+    constants::{self, DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW},
     expressions::{
-        types::Area,
+        types::{Area, CellReferenceIndex},
         utils::{is_valid_column_number, is_valid_row},
     },
     model::Model,
     types::{
-        Alignment, BorderItem, BorderStyle, CellType, Col, HorizontalAlignment, SheetProperties,
+        Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, Style,
-        Style, VerticalAlignment,
+        VerticalAlignment,
     },
     utils::is_valid_hex_color,
 };
@@ -22,7 +23,26 @@ use crate::user_model::history::{
     ColumnData, Diff, DiffList, DiffType, History, QueueDiffs, RowData,
 };
 
+use super::border_utils::is_max_border;
+/// Data for the clipboard
+pub type ClipboardData = HashMap<i32, HashMap<i32, ClipboardCell>>;
+
+pub type ClipboardTuple = (i32, i32, i32, i32);
+
 #[derive(Serialize, Deserialize)]
+pub struct ClipboardCell {
+    text: String,
+    style: Style,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Clipboard {
+    pub(crate) csv: String,
+    pub(crate) data: ClipboardData,
+    pub(crate) range: (i32, i32, i32, i32),
+}
+
+#[derive(Serialize, Deserialize, PartialEq)]
 pub enum BorderType {
     All,
     Inner,
@@ -61,37 +81,6 @@ fn color(value: &str) -> Result<Option<String>, String> {
     Ok(Some(value.to_owned()))
 }
 
-fn border(value: &str) -> Result<Option<BorderItem>, String> {
-    if value.is_empty() {
-        return Ok(None);
-    }
-    let parts = value.split(',');
-    let values = parts.collect::<Vec<&str>>();
-    match values[..] {
-        [border_style, color_str] => {
-            let style = match border_style {
-                "thin" => BorderStyle::Thin,
-                "medium" => BorderStyle::Medium,
-                "thick" => BorderStyle::Thick,
-                "double" => BorderStyle::Double,
-                "dotted" => BorderStyle::Dotted,
-                "slantDashDot" => BorderStyle::SlantDashDot,
-                "mediumDashed" => BorderStyle::MediumDashed,
-                "mediumDashDotDot" => BorderStyle::MediumDashDotDot,
-                "mediumDashDot" => BorderStyle::MediumDashDot,
-                _ => {
-                    return Err(format!("Invalid border style: '{border_style}'."));
-                }
-            };
-            Ok(Some(BorderItem {
-                style,
-                color: color(color_str)?,
-            }))
-        }
-        _ => Err(format!("Invalid border value: '{value}'.")),
-    }
-}
-
 fn horizontal(value: &str) -> Result<HorizontalAlignment, String> {
     match value {
         "center" => Ok(HorizontalAlignment::Center),
@@ -345,13 +334,27 @@ impl UserModel {
 
         self.evaluate_if_not_paused();
 
-        let diff_list = vec![Diff::SetCellValue {
+        let mut diff_list = vec![Diff::SetCellValue {
             sheet,
             row,
             column,
             new_value: value.to_string(),
             old_value: Box::new(old_value),
         }];
+
+        let line_count = value.split("\n").count();
+        let row_height = self.model.get_row_height(sheet, row)?;
+        let cell_height = (line_count as f64) * DEFAULT_ROW_HEIGHT;
+        if cell_height > row_height {
+            diff_list.push(Diff::SetRowHeight {
+                sheet,
+                row,
+                new_value: cell_height,
+                old_value: row_height,
+            });
+            self.model.set_row_height(sheet, row, cell_height)?;
+        }
+
         self.push_diff_list(diff_list);
         Ok(())
     }
@@ -391,9 +394,11 @@ impl UserModel {
     ///
     /// See also:
     /// * [Model::new_sheet]
-    pub fn new_sheet(&mut self) {
+    pub fn new_sheet(&mut self) -> Result<(), String> {
         let (name, index) = self.model.new_sheet();
+        self.set_selected_sheet(index)?;
         self.push_diff_list(vec![Diff::NewSheet { index, name }]);
+        Ok(())
     }
 
     /// Deletes sheet by index
@@ -422,6 +427,9 @@ impl UserModel {
     /// * [Model::rename_sheet_by_index]
     pub fn rename_sheet(&mut self, sheet: u32, new_name: &str) -> Result<(), String> {
         let old_value = self.model.workbook.worksheet(sheet)?.name.clone();
+        if old_value == new_name {
+            return Ok(());
+        }
         self.model.rename_sheet_by_index(sheet, new_name)?;
         self.push_diff_list(vec![Diff::RenameSheet {
             index: sheet,
@@ -533,7 +541,10 @@ impl UserModel {
                 break;
             }
         }
-        let data = worksheet.sheet_data.get(&row).unwrap().clone();
+        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,
@@ -752,13 +763,14 @@ impl UserModel {
         Ok(())
     }
 
-    /// Sets the border
+    /// Sets the border in an area of cells.
+    /// When setting the border we need to check if the adjacent cells have a "heavier" border
+    /// If that is the case we need to change it
     pub fn set_area_with_border(
         &mut self,
         range: &Area,
         border_area: &BorderArea,
     ) -> Result<(), String> {
-        // FIXME: We need to set the border also in neighbouring cells.
         let sheet = range.sheet;
         let mut diff_list = Vec::new();
         let last_row = range.row + range.height - 1;
@@ -766,85 +778,312 @@ impl UserModel {
         for row in range.row..=last_row {
             for column in range.column..=last_column {
                 let old_value = self.model.get_style_for_cell(sheet, row, column)?;
-                let mut style = old_value.clone();
+                let mut new_value = old_value.clone();
-
-                // First remove all existing borders
-                style.border.top = None;
-                style.border.right = None;
-                style.border.bottom = None;
-                style.border.left = None;
 
                 match border_area.r#type {
                     BorderType::All => {
-                        style.border.top = Some(border_area.item.clone());
+                        new_value.border.top = Some(border_area.item.clone());
-                        style.border.right = Some(border_area.item.clone());
+                        new_value.border.right = Some(border_area.item.clone());
-                        style.border.bottom = Some(border_area.item.clone());
+                        new_value.border.bottom = Some(border_area.item.clone());
-                        style.border.left = Some(border_area.item.clone());
+                        new_value.border.left = Some(border_area.item.clone());
                     }
                     BorderType::Inner => {
                         if row != range.row {
-                            style.border.top = Some(border_area.item.clone());
+                            new_value.border.top = Some(border_area.item.clone());
                         }
                         if row != last_row {
-                            style.border.bottom = Some(border_area.item.clone());
+                            new_value.border.bottom = Some(border_area.item.clone());
                         }
                         if column != range.column {
-                            style.border.left = Some(border_area.item.clone());
+                            new_value.border.left = Some(border_area.item.clone());
                         }
                         if column != last_column {
-                            style.border.right = Some(border_area.item.clone());
+                            new_value.border.right = Some(border_area.item.clone());
                         }
                     }
                     BorderType::Outer => {
                         if row == range.row {
-                            style.border.top = Some(border_area.item.clone());
+                            new_value.border.top = Some(border_area.item.clone());
                         }
                         if row == last_row {
-                            style.border.bottom = Some(border_area.item.clone());
+                            new_value.border.bottom = Some(border_area.item.clone());
                         }
                         if column == range.column {
-                            style.border.left = Some(border_area.item.clone());
+                            new_value.border.left = Some(border_area.item.clone());
                         }
                         if column == last_column {
-                            style.border.right = Some(border_area.item.clone());
+                            new_value.border.right = Some(border_area.item.clone());
+                        }
+                    }
+                    BorderType::Top => {
+                        new_value.border.top = Some(border_area.item.clone());
+                        // Check if the cell above has a "heavier" bottom border
+                        if row > 1 {
+                            let old_value_cell_above =
+                                self.model.get_style_for_cell(sheet, row - 1, column)?;
+                            if is_max_border(
+                                Some(&border_area.item),
+                                old_value_cell_above.border.bottom.as_ref(),
+                            ) {
+                                let mut new_value_cell_above = old_value_cell_above.clone();
+                                if border_area.r#type == BorderType::None {
+                                    new_value_cell_above.border.bottom = None;
+                                } else {
+                                    new_value_cell_above.border.bottom =
+                                        Some(border_area.item.clone());
+                                }
+                                self.model.set_cell_style(
+                                    sheet,
+                                    row - 1,
+                                    column,
+                                    &new_value_cell_above,
+                                )?;
+                                diff_list.push(Diff::SetCellStyle {
+                                    sheet,
+                                    row: row - 1,
+                                    column,
+                                    old_value: Box::new(old_value_cell_above),
+                                    new_value: Box::new(new_value_cell_above),
+                                });
+                            }
+                        }
+                    }
+                    BorderType::Right => {
+                        new_value.border.right = Some(border_area.item.clone());
+                        // Check if the cell to the right has a "heavier" left border
+                        if column < LAST_COLUMN {
+                            let old_value_cell_right =
+                                self.model.get_style_for_cell(sheet, row, column + 1)?;
+                            if is_max_border(
+                                Some(&border_area.item),
+                                old_value_cell_right.border.left.as_ref(),
+                            ) {
+                                let mut new_value_cell_right = old_value_cell_right.clone();
+                                if border_area.r#type == BorderType::None {
+                                    new_value_cell_right.border.left = None;
+                                } else {
+                                    new_value_cell_right.border.left =
+                                        Some(border_area.item.clone());
+                                }
+                                self.model.set_cell_style(
+                                    sheet,
+                                    row,
+                                    column + 1,
+                                    &new_value_cell_right,
+                                )?;
+                                diff_list.push(Diff::SetCellStyle {
+                                    sheet,
+                                    row,
+                                    column: column + 1,
+                                    old_value: Box::new(old_value_cell_right),
+                                    new_value: Box::new(new_value_cell_right),
+                                });
+                            }
+                        }
+                    }
+                    BorderType::Bottom => {
+                        new_value.border.bottom = Some(border_area.item.clone());
+                        // Check if the cell bellow has a "heavier" top border
+                        if row < LAST_ROW {
+                            let old_value_cell_below =
+                                self.model.get_style_for_cell(sheet, row + 1, column)?;
+                            if is_max_border(
+                                Some(&border_area.item),
+                                old_value_cell_below.border.top.as_ref(),
+                            ) {
+                                let mut new_value_cell_below = old_value_cell_below.clone();
+                                if border_area.r#type == BorderType::None {
+                                    new_value_cell_below.border.top = None;
+                                } else {
+                                    new_value_cell_below.border.top =
+                                        Some(border_area.item.clone());
+                                }
+                                self.model.set_cell_style(
+                                    sheet,
+                                    row + 1,
+                                    column,
+                                    &new_value_cell_below,
+                                )?;
+                                diff_list.push(Diff::SetCellStyle {
+                                    sheet,
+                                    row: row + 1,
+                                    column,
+                                    old_value: Box::new(old_value_cell_below),
+                                    new_value: Box::new(new_value_cell_below),
+                                });
+                            }
+                        }
+                    }
+                    BorderType::Left => {
+                        new_value.border.left = Some(border_area.item.clone());
+                        // Check if the cell to the left has a "heavier" right border
+                        if column > 1 {
+                            let old_value_cell_left =
+                                self.model.get_style_for_cell(sheet, row, column - 1)?;
+                            if is_max_border(
+                                Some(&border_area.item),
+                                old_value_cell_left.border.right.as_ref(),
+                            ) {
+                                let mut new_value_cell_left = old_value_cell_left.clone();
+                                if border_area.r#type == BorderType::None {
+                                    new_value_cell_left.border.right = None;
+                                } else {
+                                    new_value_cell_left.border.right =
+                                        Some(border_area.item.clone());
+                                }
+                                self.model.set_cell_style(
+                                    sheet,
+                                    row,
+                                    column - 1,
+                                    &new_value_cell_left,
+                                )?;
+                                diff_list.push(Diff::SetCellStyle {
+                                    sheet,
+                                    row,
+                                    column: column - 1,
+                                    old_value: Box::new(old_value_cell_left),
+                                    new_value: Box::new(new_value_cell_left),
+                                });
+                            }
                         }
                     }
-                    BorderType::Top => style.border.top = Some(border_area.item.clone()),
-                    BorderType::Right => style.border.right = Some(border_area.item.clone()),
-                    BorderType::Bottom => style.border.bottom = Some(border_area.item.clone()),
-                    BorderType::Left => style.border.left = Some(border_area.item.clone()),
                     BorderType::CenterH => {
                         if row != range.row {
-                            style.border.top = Some(border_area.item.clone());
+                            new_value.border.top = Some(border_area.item.clone());
                         }
                         if row != last_row {
-                            style.border.bottom = Some(border_area.item.clone());
+                            new_value.border.bottom = Some(border_area.item.clone());
                         }
                     }
                     BorderType::CenterV => {
                         if column != range.column {
-                            style.border.left = Some(border_area.item.clone());
+                            new_value.border.left = Some(border_area.item.clone());
                         }
                         if column != last_column {
-                            style.border.right = Some(border_area.item.clone());
+                            new_value.border.right = Some(border_area.item.clone());
                         }
                     }
                     BorderType::None => {
-                        // noop, we already removed all the borders
+                        new_value.border.top = None;
+                        new_value.border.right = None;
+                        new_value.border.bottom = None;
+                        new_value.border.left = None;
                     }
                 }
 
-                self.model.set_cell_style(sheet, row, column, &style)?;
+                self.model.set_cell_style(sheet, row, column, &new_value)?;
                 diff_list.push(Diff::SetCellStyle {
                     sheet,
                     row,
                     column,
                     old_value: Box::new(old_value),
-                    new_value: Box::new(style),
+                    new_value: Box::new(new_value),
                 });
             }
         }
 
+        // bottom of the cells above the first
+        if range.row > 1
+            && [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
+        {
+            let row = range.row - 1;
+            for column in range.column..=last_column {
+                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
+                if is_max_border(Some(&border_area.item), old_value.border.bottom.as_ref()) {
+                    let mut style = old_value.clone();
+                    if border_area.r#type == BorderType::None {
+                        style.border.bottom = None;
+                    } else {
+                        style.border.bottom = Some(border_area.item.clone());
+                    }
+                    self.model.set_cell_style(sheet, row, column, &style)?;
+                    diff_list.push(Diff::SetCellStyle {
+                        sheet,
+                        row,
+                        column,
+                        old_value: Box::new(old_value),
+                        new_value: Box::new(style),
+                    });
+                }
+            }
+        }
+        // Cells to the right
+        if last_column < LAST_COLUMN
+            && [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
+        {
+            let column = last_column + 1;
+            for row in range.row..=last_row {
+                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
+                // If the border in the adjacent cell is "heavier" we change it
+                if is_max_border(Some(&border_area.item), old_value.border.left.as_ref()) {
+                    let mut style = old_value.clone();
+                    if border_area.r#type == BorderType::None {
+                        style.border.left = None;
+                    } else {
+                        style.border.left = Some(border_area.item.clone());
+                    }
+                    self.model.set_cell_style(sheet, row, column, &style)?;
+                    diff_list.push(Diff::SetCellStyle {
+                        sheet,
+                        row,
+                        column,
+                        old_value: Box::new(old_value),
+                        new_value: Box::new(style),
+                    });
+                }
+            }
+        }
+        // Cells bellow
+        if last_row < LAST_ROW
+            && [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
+        {
+            let row = last_row + 1;
+            for column in range.column..=last_column {
+                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
+                if is_max_border(Some(&border_area.item), old_value.border.top.as_ref()) {
+                    let mut style = old_value.clone();
+                    if border_area.r#type == BorderType::None {
+                        style.border.top = None;
+                    } else {
+                        style.border.top = Some(border_area.item.clone());
+                    }
+                    self.model.set_cell_style(sheet, row, column, &style)?;
+                    diff_list.push(Diff::SetCellStyle {
+                        sheet,
+                        row,
+                        column,
+                        old_value: Box::new(old_value),
+                        new_value: Box::new(style),
+                    });
+                }
+            }
+        }
+        // Cells to the left
+        if range.column > 1
+            && [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
+        {
+            let column = range.column - 1;
+            for row in range.row..=last_row {
+                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
+                if is_max_border(Some(&border_area.item), old_value.border.right.as_ref()) {
+                    let mut style = old_value.clone();
+                    if border_area.r#type == BorderType::None {
+                        style.border.right = None;
+                    } else {
+                        style.border.right = Some(border_area.item.clone());
+                    }
+                    self.model.set_cell_style(sheet, row, column, &style)?;
+                    diff_list.push(Diff::SetCellStyle {
+                        sheet,
+                        row,
+                        column,
+                        old_value: Box::new(old_value),
+                        new_value: Box::new(style),
+                    });
+                }
+            }
+        }
+
         self.push_diff_list(diff_list);
         Ok(())
     }
@@ -882,25 +1121,15 @@ impl UserModel {
                     }
                     "fill.bg_color" => {
                         style.fill.bg_color = color(value)?;
+                        style.fill.pattern_type = "solid".to_string();
                     }
                     "fill.fg_color" => {
                         style.fill.fg_color = color(value)?;
+                        style.fill.pattern_type = "solid".to_string();
                     }
                     "num_fmt" => {
                         value.clone_into(&mut style.num_fmt);
                     }
-                    "border.left" => {
-                        style.border.left = border(value)?;
-                    }
-                    "border.right" => {
-                        style.border.right = border(value)?;
-                    }
-                    "border.top" => {
-                        style.border.top = border(value)?;
-                    }
-                    "border.bottom" => {
-                        style.border.bottom = border(value)?;
-                    }
                     "alignment" => {
                         if !value.is_empty() {
                             return Err(format!("Alignment must be empty, but found: '{value}'."));
@@ -957,11 +1186,69 @@ impl UserModel {
 
     /// Returns the style for a cell
     ///
+    /// Cells share a border, so the left border of B1 is the right border of A1
+    /// In the object structure the borders of the cells might be difference,
+    /// We always pick the "heaviest" border.
+    ///
     /// See also:
     /// * [Model::get_style_for_cell]
-    #[inline]
+    pub fn get_cell_style(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
-    pub fn get_cell_style(&mut self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
+        let mut style = self.model.get_style_for_cell(sheet, row, column)?;
-        self.model.get_style_for_cell(sheet, row, column)
+
+        // We need to check if the adjacent cells have a "heavier" border
+        let border_top = if row > 1 {
+            self.model
+                .get_style_for_cell(sheet, row - 1, column)?
+                .border
+                .bottom
+        } else {
+            None
+        };
+
+        let border_right = if column < LAST_COLUMN {
+            self.model
+                .get_style_for_cell(sheet, row, column + 1)?
+                .border
+                .left
+        } else {
+            None
+        };
+
+        let border_bottom = if row < LAST_ROW {
+            self.model
+                .get_style_for_cell(sheet, row + 1, column)?
+                .border
+                .top
+        } else {
+            None
+        };
+
+        let border_left = if column > 1 {
+            self.model
+                .get_style_for_cell(sheet, row, column - 1)?
+                .border
+                .right
+        } else {
+            None
+        };
+
+        if is_max_border(style.border.top.as_ref(), border_top.as_ref()) {
+            style.border.top = border_top;
+        }
+
+        if is_max_border(style.border.right.as_ref(), border_right.as_ref()) {
+            style.border.right = border_right;
+        }
+
+        if is_max_border(style.border.bottom.as_ref(), border_bottom.as_ref()) {
+            style.border.bottom = border_bottom;
+        }
+
+        if is_max_border(style.border.left.as_ref(), border_left.as_ref()) {
+            style.border.left = border_left;
+        }
+
+        Ok(style)
     }
 
     /// Fills the cells from `source_area` until `to_row`.
@@ -1070,27 +1357,27 @@ impl UserModel {
     pub fn auto_fill_columns(&mut self, source_area: &Area, to_column: i32) -> Result<(), String> {
         let mut diff_list = Vec::new();
         let sheet = source_area.sheet;
-        let row1 = source_area.row;
+        let first_row = source_area.row;
-        let column1 = source_area.column;
+        let first_column = source_area.column;
-        let width1 = source_area.width;
+        let last_column = first_column + source_area.width - 1;
-        let height1 = source_area.height;
+        let last_row = first_row + source_area.height - 1;
 
         // Check first all parameters are valid
         if self.model.workbook.worksheet(sheet).is_err() {
             return Err(format!("Invalid worksheet index: '{sheet}'"));
         }
 
-        if !is_valid_column_number(column1) {
+        if !is_valid_column_number(first_column) {
-            return Err(format!("Invalid column: '{column1}'"));
+            return Err(format!("Invalid column: '{first_column}'"));
         }
-        if !is_valid_row(row1) {
+        if !is_valid_row(first_row) {
-            return Err(format!("Invalid row: '{row1}'"));
+            return Err(format!("Invalid row: '{first_row}'"));
         }
-        if !is_valid_column_number(column1 + width1 - 1) {
+        if !is_valid_column_number(last_column) {
-            return Err(format!("Invalid column: '{}'", column1 + width1 - 1));
+            return Err(format!("Invalid column: '{}'", last_column));
         }
-        if !is_valid_row(row1 + height1 - 1) {
+        if !is_valid_row(last_row) {
-            return Err(format!("Invalid row: '{}'", row1 + height1 - 1));
+            return Err(format!("Invalid row: '{}'", last_row));
         }
 
         if !is_valid_row(to_column) {
@@ -1103,21 +1390,21 @@ impl UserModel {
         // this is the range of columns we are going to fill
         let column_range: Vec<i32>;
 
-        if to_column >= column1 + width1 {
+        if to_column > last_column {
             // we go right, we start from `1 + width` to `to_column`,
-            anchor_column = column1;
+            anchor_column = first_column;
             sign = 1;
-            column_range = (column1 + width1..to_column + 1).collect();
+            column_range = (last_column + 1..to_column + 1).collect();
-        } else if to_column < column1 {
+        } else if to_column < first_column {
             // we go left, starting from `column1 - `` all the way to `to_column`
-            anchor_column = column1 + width1 - 1;
+            anchor_column = last_column;
             sign = -1;
-            column_range = (to_column..column1).rev().collect();
+            column_range = (to_column..first_column).rev().collect();
         } else {
             return Err("Invalid parameters for autofill".to_string());
         }
 
-        for row in row1..row1 + height1 {
+        for row in first_row..=last_row {
             let mut index = 0;
             for column_ref in &column_range {
                 let column = *column_ref;
@@ -1138,8 +1425,9 @@ impl UserModel {
                 self.model
                     .set_user_input(sheet, row, column, target_value.to_string())?;
 
-                // Compute the new style and set it
                 let new_style = self.model.get_style_for_cell(sheet, row, source_column)?;
+                // Compute the new style and set it
+
                 self.model.set_cell_style(sheet, row, column, &new_style)?;
 
                 // Add the diffs
@@ -1150,6 +1438,7 @@ impl UserModel {
                     old_value: Box::new(old_style),
                     new_value: Box::new(new_style),
                 });
+
                 diff_list.push(Diff::SetCellValue {
                     sheet,
                     row,
@@ -1158,7 +1447,7 @@ impl UserModel {
                     old_value: Box::new(old_value),
                 });
 
-                index = (index + sign) % width1;
+                index = (index + sign) % source_area.width;
             }
         }
         self.push_diff_list(diff_list);
@@ -1193,6 +1482,213 @@ impl UserModel {
         Ok(self.model.workbook.worksheet(sheet)?.show_grid_lines)
     }
 
+    /// Returns a copy of the selected area
+    pub fn copy_to_clipboard(&self) -> Result<Clipboard, String> {
+        let selected_area = self.get_selected_view();
+        let sheet = selected_area.sheet;
+        let mut wtr = WriterBuilder::new().delimiter(b'\t').from_writer(vec![]);
+
+        let mut data = HashMap::new();
+        let [row_start, column_start, row_end, column_end] = selected_area.range;
+        for row in row_start..=row_end {
+            let mut data_row = HashMap::new();
+            let mut text_row = Vec::new();
+            for column in column_start..=column_end {
+                let text = self.get_formatted_cell_value(sheet, row, column)?;
+                let content = self.get_cell_content(sheet, row, column)?;
+                let style = self.model.get_style_for_cell(sheet, row, column)?;
+                data_row.insert(
+                    column,
+                    ClipboardCell {
+                        text: content,
+                        style,
+                    },
+                );
+                text_row.push(text);
+            }
+            wtr.write_record(text_row)
+                .map_err(|e| format!("Error while processing csv: {}", e))?;
+            data.insert(row, data_row);
+        }
+
+        let csv = String::from_utf8(
+            wtr.into_inner()
+                .map_err(|e| format!("Processing error: '{}'", e))?,
+        )
+        .map_err(|e| format!("Error converting from utf8: '{}'", e))?;
+
+        Ok(Clipboard {
+            csv,
+            data,
+            range: (row_start, column_start, row_end, column_end),
+        })
+    }
+
+    /// Paste text that we copied
+    pub fn paste_from_clipboard(
+        &mut self,
+        source_range: ClipboardTuple,
+        clipboard: &ClipboardData,
+        is_cut: bool,
+    ) -> Result<(), String> {
+        let mut diff_list = Vec::new();
+        let view = self.get_selected_view();
+        let (source_first_row, source_first_column, source_last_row, source_last_column) =
+            source_range;
+        let sheet = view.sheet;
+        let [selected_row, selected_column, _, _] = view.range;
+        let mut max_row = selected_row;
+        let mut max_column = selected_column;
+        let area = &Area {
+            sheet,
+            row: source_first_row,
+            column: source_first_column,
+            width: source_last_column - source_first_column + 1,
+            height: source_last_row - source_first_row + 1,
+        };
+        for (source_row, data_row) in clipboard {
+            let delta_row = source_row - source_first_row;
+            let target_row = selected_row + delta_row;
+            max_row = max_row.max(target_row);
+            for (source_column, value) in data_row {
+                let delta_column = source_column - source_first_column;
+                let target_column = selected_column + delta_column;
+                max_column = max_column.max(target_column);
+
+                // We are copying the value in
+                // (source_row, source_column) to (target_row , target_column)
+                // References in formulas are displaced
+
+                // remain in the copied area
+                let source = &CellReferenceIndex {
+                    sheet,
+                    column: *source_column,
+                    row: *source_row,
+                };
+                let target = &CellReferenceIndex {
+                    sheet,
+                    column: target_column,
+                    row: target_row,
+                };
+                let new_value = if is_cut {
+                    self.model
+                        .move_cell_value_to_area(&value.text, source, target, area)?
+                } else {
+                    self.model
+                        .extend_copied_value(&value.text, source, target)?
+                };
+
+                let old_value = self
+                    .model
+                    .workbook
+                    .worksheet(sheet)?
+                    .cell(target_row, target_column)
+                    .cloned();
+
+                let old_style = self
+                    .model
+                    .get_style_for_cell(sheet, target_row, target_column)?;
+
+                self.model
+                    .set_user_input(sheet, target_row, target_column, new_value.clone())?;
+                self.model
+                    .set_cell_style(sheet, target_row, target_column, &value.style)?;
+
+                diff_list.push(Diff::SetCellValue {
+                    sheet,
+                    row: target_row,
+                    column: target_column,
+                    new_value,
+                    old_value: Box::new(old_value),
+                });
+
+                diff_list.push(Diff::SetCellStyle {
+                    sheet,
+                    row: target_row,
+                    column: target_column,
+                    old_value: Box::new(old_style),
+                    new_value: Box::new(value.style.clone()),
+                });
+            }
+        }
+        if is_cut {
+            for row in source_first_row..=source_last_row {
+                for column in source_first_column..=source_last_column {
+                    let old_value = self
+                        .model
+                        .workbook
+                        .worksheet(sheet)?
+                        .cell(row, column)
+                        .cloned();
+
+                    diff_list.push(Diff::CellClearContents {
+                        sheet,
+                        row,
+                        column,
+                        old_value: Box::new(old_value),
+                    });
+                    self.model.cell_clear_contents(sheet, row, column)?;
+                }
+            }
+        }
+        self.push_diff_list(diff_list);
+        // select the pasted area
+        self.set_selected_range(selected_row, selected_column, max_row, max_column)?;
+        self.evaluate_if_not_paused();
+        Ok(())
+    }
+
+    /// Paste a csv-string into the model
+    pub fn paste_csv_string(&mut self, area: &Area, csv: &str) -> Result<(), String> {
+        let mut diff_list = Vec::new();
+        let sheet = area.sheet;
+        let mut row = area.row;
+        let mut column = area.column;
+        let mut csv_reader = Cursor::new(csv);
+        csv_reader.set_position(0);
+        let mut reader = ReaderBuilder::new()
+            .delimiter(b'\t')
+            .has_headers(false)
+            .from_reader(csv_reader);
+        for record in reader.records() {
+            match record {
+                Ok(r) => {
+                    column = area.column;
+                    for value in &r {
+                        let old_value = self
+                            .model
+                            .workbook
+                            .worksheet(sheet)?
+                            .cell(row, column)
+                            .cloned();
+                        // let old_style = self.model.get_style_for_cell(sheet, row, column)?;
+                        self.model
+                            .set_user_input(sheet, row, column, value.to_string())?;
+
+                        diff_list.push(Diff::SetCellValue {
+                            sheet,
+                            row,
+                            column,
+                            new_value: value.to_string(),
+                            old_value: Box::new(old_value),
+                        });
+                        column += 1;
+                    }
+                }
+                Err(_) => {
+                    // skip
+                    continue;
+                }
+            };
+            row += 1;
+        }
+        self.push_diff_list(diff_list);
+        // select the pasted area
+        self.set_selected_range(area.row, area.column, row, column)?;
+        self.evaluate_if_not_paused();
+        Ok(())
+    }
+
     // **** Private methods ****** //
 
     fn push_diff_list(&mut self, diff_list: DiffList) {
@@ -1211,7 +1707,7 @@ impl UserModel {
 
     fn apply_undo_diff_list(&mut self, diff_list: &DiffList) -> Result<(), String> {
         let mut needs_evaluation = false;
-        for diff in diff_list {
+        for diff in diff_list.iter().rev() {
             match diff {
                 Diff::SetCellValue {
                     sheet,

base/src/user_model/mod.rs

@@ -1,5 +1,6 @@
 #![deny(missing_docs)]
 
+mod border_utils;
 mod common;
 mod history;
 mod ui;
@@ -10,3 +11,4 @@ pub use common::UserModel;
 pub use ui::SelectedView;
 
 pub use common::BorderArea;
+pub use common::ClipboardData;

base/src/utils.rs

@@ -34,6 +34,7 @@ impl ParsedReference {
         locale: &Locale,
         get_sheet_index_by_name: F,
     ) -> Result<ParsedReference, String> {
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("");
         let mut lexer = Lexer::new(reference, LexerMode::A1, locale, language);
 
@@ -151,6 +152,8 @@ pub(crate) fn is_valid_hex_color(color: &str) -> bool {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::expect_used)]
+
     use super::*;
     use crate::language::get_language;
     use crate::locale::{get_locale, Locale};

base/src/worksheet.rs

@@ -254,6 +254,7 @@ impl Worksheet {
     /// Changes the height of a row.
     ///   * If the row does not a have a style we add it.
     ///   * If it has we modify the height and make sure it is applied.
+    ///
     /// Fails if column index is outside allowed range.
     pub fn set_row_height(&mut self, row: i32, height: f64) -> Result<(), String> {
         if !is_valid_row(row) {
@@ -282,6 +283,7 @@ impl Worksheet {
     /// Changes the width of a column.
     ///   * If the column does not a have a width we simply add it
     ///   * If it has, it might be part of a range and we ned to split the range.
+    ///
     /// Fails if column index is outside allowed range.
     pub fn set_column_width(&mut self, column: i32, width: f64) -> Result<(), String> {
         self.set_column_width_and_style(column, width, None)
@@ -522,6 +524,23 @@ impl Worksheet {
         Ok(is_empty)
     }
 
+    /// Returns true if cell part of Merged Cells.
+    /// First cell of Merged cells block is not considered as part of Merged cells
+    /// Ex : if Merged cells were A1-C3, A1 is not considered as part of Merged cells block
+    pub fn is_part_of_merged_cells(&self, row: i32, column: i32) -> Result<bool, String> {
+        if !is_valid_column_number(column) || !is_valid_row(row) {
+            return Err("Incorrect row or column".to_string());
+        }
+
+        // traverse through Vector of Merged Cells and return (linear search)
+        for merged_cells in &self.merged_cells_list {
+            if merged_cells.is_cell_part_of_merged_cells(row, column) {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
     /// It provides convenient method for user navigation in the spreadsheet by jumping to edges.
     /// Spreadsheet engines usually allow this method of navigation by using CTRL+arrows.
     /// Behaviour summary:
@@ -575,6 +594,16 @@ impl Worksheet {
             }
         }
     }
+
+    /// Returns mutable reference to Vector of Merged cells list
+    pub fn get_merged_cells_list_mut(&mut self) -> &mut Vec<MergedCells> {
+        &mut self.merged_cells_list
+    }
+
+    /// Returns reference to Vector of Merged cells list
+    pub fn get_merged_cells_list(&self) -> &Vec<MergedCells> {
+        &self.merged_cells_list
+    }
 }
 
 struct WalkFoundCells {

bindings/python/Cargo.toml

@@ -19,6 +19,3 @@ pyo3 = { version = "0.22.3", features = ["extension-module"] }
 [features]
 extension-module = ["pyo3/extension-module"]
 default = ["extension-module"]
-
-[tool.maturin]
-features = ["pyo3/extension-module"]

bindings/python/run_examples.sh

@@ -9,6 +9,14 @@ if [ ! -d "$EXAMPLES_DIR" ]; then
   exit 1
 fi
 
+python -m venv venv
+source venv/bin/activate
+# not sure why this is needed
+pip install patchelf
+pip install maturin
+pip install pytest
+maturin develop
+
 # Iterate over all Python files in the examples directory
 for file in "$EXAMPLES_DIR"/*.py; do
   # Check if there are any Python files

bindings/python/src/lib.rs

@@ -208,12 +208,13 @@ impl PyModel {
             .map_err(|e| WorkbookError::new_err(e.to_string()))
     }
 
+    #[allow(clippy::panic)]
     pub fn test_panic(&self) -> PyResult<()> {
         panic!("This function panics for testing panic handling");
     }
 }
 
-/// Create methods
+// Create methods
 
 /// Loads a function from an xlsx file
 #[pyfunction]
@@ -240,6 +241,7 @@ pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
 }
 
 #[pyfunction]
+#[allow(clippy::panic)]
 pub fn test_panic() {
     panic!("This function panics for testing panic handling");
 }

bindings/wasm/Cargo.toml

@@ -14,7 +14,7 @@ crate-type = ["cdylib"]
 # Uses `../ironcalc/base` when used locally, and uses
 # the inicated version from crates.io when published.
 # https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#multiple-locations
-ironcalc_base = { path = "../../base", version = "0.2" }
+ironcalc_base = { path = "../../base", version = "0.2", features = ["use_regex_lite"] }
 serde = { version = "1.0", features = ["derive"] }
 wasm-bindgen = "0.2.92"
 serde-wasm-bindgen = "0.4"

bindings/wasm/fix_types.py

@@ -137,6 +137,54 @@ set_area_border_types = r"""
   setAreaWithBorder(area: Area, border_area: BorderArea): void;
 """
 
+paste_csv_string = r"""
+/**
+* @param {any} area
+* @param {string} csv
+*/
+  pasteCsvText(area: any, csv: string): void;
+"""
+
+paste_csv_string_types = r"""
+/**
+* @param {Area} area
+* @param {string} csv
+*/
+  pasteCsvText(area: Area, csv: string): void;
+"""
+
+clipboard = r"""
+/**
+* @returns {any}
+*/
+  copyToClipboard(): any;
+"""
+
+clipboard_types = r"""
+/**
+* @returns {Clipboard}
+*/
+  copyToClipboard(): Clipboard;
+"""
+
+paste_from_clipboard = r"""
+/**
+* @param {any} source_range
+* @param {any} clipboard
+* @param {boolean} is_cut
+*/
+  pasteFromClipboard(source_range: any, clipboard: any, is_cut: boolean): void;
+"""
+
+paste_from_clipboard_types = r"""
+/**
+* @param {[number, number, number, number]} source_range
+* @param {ClipboardData} clipboard
+* @param {boolean} is_cut
+*/
+  pasteFromClipboard(source_range: [number, number, number, number], clipboard: ClipboardData, is_cut: boolean): void;
+"""
+
 def fix_types(text):
     text = text.replace(get_tokens_str, get_tokens_str_types)
     text = text.replace(update_style_str, update_style_str_types)
@@ -147,6 +195,9 @@ def fix_types(text):
     text = text.replace(autofill_columns, autofill_columns_types)
     text = text.replace(set_cell_style, set_cell_style_types)
     text = text.replace(set_area_border, set_area_border_types)
+    text = text.replace(paste_csv_string, paste_csv_string_types)
+    text = text.replace(clipboard, clipboard_types)
+    text = text.replace(paste_from_clipboard, paste_from_clipboard_types)
     with open("types.ts") as f:
         types_str = f.read()
         header_types = "{}\n\n{}".format(header, types_str)

bindings/wasm/src/lib.rs

@@ -6,7 +6,7 @@ use wasm_bindgen::{
 use ironcalc_base::{
     expressions::{lexer::util::get_tokens as tokenizer, types::Area, utils::number_to_column},
     types::{CellType, Style},
-    BorderArea, UserModel as BaseModel,
+    BorderArea, ClipboardData, UserModel as BaseModel,
 };
 
 fn to_js_error(error: String) -> JsError {
@@ -97,8 +97,8 @@ impl Model {
     }
 
     #[wasm_bindgen(js_name = "newSheet")]
-    pub fn new_sheet(&mut self) {
+    pub fn new_sheet(&mut self) -> Result<(), JsError> {
-        self.model.new_sheet()
+        self.model.new_sheet().map_err(to_js_error)
     }
 
     #[wasm_bindgen(js_name = "deleteSheet")]
@@ -274,15 +274,18 @@ impl Model {
         row: i32,
         column: i32,
     ) -> Result<JsValue, JsError> {
-        self.model
+        let style = self
+            .model
             .get_cell_style(sheet, row, column)
-            .map_err(to_js_error)
+            .map_err(to_js_error)?;
-            .map(|x| serde_wasm_bindgen::to_value(&x).unwrap())
+
+        serde_wasm_bindgen::to_value(&style).map_err(|e| to_js_error(e.to_string()))
     }
 
     #[wasm_bindgen(js_name = "onPasteStyles")]
     pub fn on_paste_styles(&mut self, styles: JsValue) -> Result<(), JsError> {
-        let styles: &Vec<Vec<Style>> = &serde_wasm_bindgen::from_value(styles).unwrap();
+        let styles: &Vec<Vec<Style>> =
+            &serde_wasm_bindgen::from_value(styles).map_err(|e| to_js_error(e.to_string()))?;
         self.model.on_paste_styles(styles).map_err(to_js_error)
     }
 
@@ -304,7 +307,10 @@ impl Model {
         )
     }
 
+    // I don't _think_ serializing to JsValue can't fail
+    // FIXME: Remove this clippy directive
     #[wasm_bindgen(js_name = "getWorksheetsProperties")]
+    #[allow(clippy::unwrap_used)]
     pub fn get_worksheets_properties(&self) -> JsValue {
         serde_wasm_bindgen::to_value(&self.model.get_worksheets_properties()).unwrap()
     }
@@ -320,7 +326,10 @@ impl Model {
         vec![sheet as i32, row, column]
     }
 
+    // I don't _think_ serializing to JsValue can't fail
+    // FIXME: Remove this clippy directive
     #[wasm_bindgen(js_name = "getSelectedView")]
+    #[allow(clippy::unwrap_used)]
     pub fn get_selected_view(&self) -> JsValue {
         serde_wasm_bindgen::to_value(&self.model.get_selected_view()).unwrap()
     }
@@ -497,4 +506,39 @@ impl Model {
     pub fn set_name(&mut self, name: &str) {
         self.model.set_name(name);
     }
+
+    #[wasm_bindgen(js_name = "copyToClipboard")]
+    pub fn copy_to_clipboard(&self) -> Result<JsValue, JsError> {
+        let data = self
+            .model
+            .copy_to_clipboard()
+            .map_err(|e| to_js_error(e.to_string()))?;
+
+        serde_wasm_bindgen::to_value(&data).map_err(|e| to_js_error(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "pasteFromClipboard")]
+    pub fn paste_from_clipboard(
+        &mut self,
+        source_range: JsValue,
+        clipboard: JsValue,
+        is_cut: bool,
+    ) -> Result<(), JsError> {
+        let source_range: (i32, i32, i32, i32) =
+            serde_wasm_bindgen::from_value(source_range).map_err(|e| to_js_error(e.to_string()))?;
+        let clipboard: ClipboardData =
+            serde_wasm_bindgen::from_value(clipboard).map_err(|e| to_js_error(e.to_string()))?;
+        self.model
+            .paste_from_clipboard(source_range, &clipboard, is_cut)
+            .map_err(|e| to_js_error(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "pasteCsvText")]
+    pub fn paste_csv_string(&mut self, area: JsValue, csv: &str) -> Result<(), JsError> {
+        let range: Area =
+            serde_wasm_bindgen::from_value(area).map_err(|e| to_js_error(e.to_string()))?;
+        self.model
+            .paste_csv_string(&range, csv)
+            .map_err(|e| to_js_error(e.to_string()))
+    }
 }

bindings/wasm/tests/test.mjs

@@ -2,8 +2,10 @@ import test from 'node:test';
 import assert from 'node:assert'
 import { Model } from "../pkg/wasm.js";
 
+const DEFAULT_ROW_HEIGHT = 28;
+
 test('Frozen rows and columns', () => {
-    let model = new Model('en', 'UTC');
+    let model = new Model('Workbook1', 'en', 'UTC');
     assert.strictEqual(model.getFrozenRowsCount(0), 0);
     assert.strictEqual(model.getFrozenColumnsCount(0), 0);
 
@@ -15,14 +17,14 @@ test('Frozen rows and columns', () => {
 });
 
 test('Row height', () => {
-    let model = new Model('en', 'UTC');
+    let model = new Model('Workbook1', 'en', 'UTC');
-    assert.strictEqual(model.getRowHeight(0, 3), 21);
+    assert.strictEqual(model.getRowHeight(0, 3), DEFAULT_ROW_HEIGHT);
 
     model.setRowHeight(0, 3, 32);
     assert.strictEqual(model.getRowHeight(0, 3), 32);
 
     model.undo();
-    assert.strictEqual(model.getRowHeight(0, 3), 21);
+    assert.strictEqual(model.getRowHeight(0, 3), DEFAULT_ROW_HEIGHT);
 
     model.redo();
     assert.strictEqual(model.getRowHeight(0, 3), 32);
@@ -32,7 +34,7 @@ test('Row height', () => {
 });
 
 test('Evaluates correctly', (t) => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     model.setUserInput(0, 1, 1, "23");
     model.setUserInput(0, 1, 2, "=A1*3+1");
 
@@ -41,7 +43,7 @@ test('Evaluates correctly', (t) => {
 });
 
 test('Styles work', () => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     let style = model.getCellStyle(0, 1, 1);
     assert.deepEqual(style, {
         num_fmt: 'general',
@@ -74,7 +76,7 @@ test('Styles work', () => {
 });
 
 test("Add sheets", (t) => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     model.newSheet();
     model.renameSheet(1, "NewName");
     let props = model.getWorksheetsProperties();
@@ -92,7 +94,7 @@ test("Add sheets", (t) => {
 });
 
 test("invalid sheet index throws an exception", () => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     assert.throws(() => {
         model.setRowHeight(1, 1, 100);
     }, {
@@ -102,7 +104,7 @@ test("invalid sheet index throws an exception", () => {
 });
 
 test("invalid column throws an exception", () => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     assert.throws(() => {
         model.setRowHeight(0, -1, 100);
     }, {
@@ -112,7 +114,7 @@ test("invalid column throws an exception", () => {
 });
 
 test("floating column numbers get truncated", () => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     model.setRowHeight(0.8, 5.2, 100.5);
 
     assert.strictEqual(model.getRowHeight(0.11, 5.99), 100.5);
@@ -120,7 +122,7 @@ test("floating column numbers get truncated", () => {
 });
 
 test("autofill", () => {
-    const model = new Model('en', 'UTC');
+    const model = new Model('Workbook1', 'en', 'UTC');
     model.setUserInput(0, 1, 1, "23");
     model.autoFillRows({sheet: 0, row: 1, column: 1, width: 1, height: 1}, 2);
 

bindings/wasm/types.ts

@@ -143,10 +143,12 @@ export enum BorderStyle {
   Thin = "thin",
   Medium = "medium",
   Thick = "thick",
-  Dashed = "dashed",
-  Dotted = "dotted",
   Double = "double",
-  None = "none",
+  Dotted = "dotted",
+  SlantDashDot = "slantdashdot",
+  MediumDashed = "mediumdashed",
+  MediumDashDotDot = "mediumdashdotdot",
+  MediumDashDot = "mediumdashdot",
 }
 
 interface BorderItem {
@@ -205,3 +207,23 @@ export interface SelectedView {
   top_row: number;
   left_column: number;
 }
+
+// type ClipboardData = {
+//   [row: number]: {
+//       [column: number]: ClipboardCell;
+//   };
+// };
+
+// type ClipboardData = Record<string, Record <string, ClipboardCell>>;
+type ClipboardData = Map<number, Map <number, ClipboardCell>>;
+
+export interface ClipboardCell {
+  text: string;
+  style: CellStyle;
+}
+
+export interface Clipboard {
+  csv: string;
+  data: ClipboardData;
+  range: [number, number, number, number];
+}

docs/.gitignore

@@ -0,0 +1,3 @@
+src/.vitepress/cache/*
+src/.vitepress/dist/*
+node_modules/*

docs/README.md

@@ -0,0 +1,40 @@
+# IronCalc Docs
+
+This repository contains IronCalc's end-user documentation. Here, you can explore supported features, functions, and more.
+
+## Prerequisites
+
+To manage the documentation, we use [VitePress](https://vitepress.dev/guide/what-is-vitepress), a Static Site Generator (SSG).
+
+First, ensure you have [nodejs](https://nodejs.org/) installed in your system.
+
+## Installation
+
+Start installing the required dependencies by changing directory to the _docs_ folder of the IronCalc repository and running the following command in your terminal:
+
+```bash
+npm install
+```
+
+## Running the Project
+
+Start a development instance of the documentation server with:
+
+```bash
+npm run dev
+```
+
+After running the command, you can view the documentation in your browser at http://localhost:5173 if the port is available.
+Making changes to the Markdown will automatically reload your browser.
+
+
+## Build the Project
+
+To deploy the project:
+
+```bash
+npm run build
+```
+
+The project will be build in `src/.vitepress/dist`
+

docs/package.json

@@ -0,0 +1,12 @@
+{
+  "scripts": {
+    "dev": "vitepress dev src",
+    "build": "vitepress build src",
+    "preview": "vitepress preview src"
+  },
+  "devDependencies": {
+    "markdown-it-mathjax3": "^4.3.2",
+    "vitepress": "^1.5.0",
+    "vue": "^3.5.12"
+  }
+}

docs/src/.vitepress/theme/index.ts

@@ -0,0 +1,18 @@
+// https://vitepress.dev/guide/custom-theme
+import { h } from "vue";
+import type { Theme } from "vitepress";
+import DefaultTheme from "vitepress/theme";
+import "./style.css";
+import "./vars.css";
+
+export default {
+  extends: DefaultTheme,
+  Layout: () => {
+    return h(DefaultTheme.Layout, null, {
+      // https://vitepress.dev/guide/extending-default-theme#layout-slots
+    });
+  },
+  enhanceApp({ app, router, siteData }) {
+    // ...
+  },
+} satisfies Theme;

docs/src/.vitepress/theme/style.css

@@ -0,0 +1,209 @@
+/**
+ * Customize default theme styling by overriding CSS variables:
+ * https://github.com/vuejs/vitepress/blob/main/src/client/theme-default/styles/vars.css
+ */
+
+/**
+ * Colors
+ *
+ * Each colors have exact same color scale system with 3 levels of solid
+ * colors with different brightness, and 1 soft color.
+ *
+ * - `XXX-1`: The most solid color used mainly for colored text. It must
+ *   satisfy the contrast ratio against when used on top of `XXX-soft`.
+ *
+ * - `XXX-2`: The color used mainly for hover state of the button.
+ *
+ * - `XXX-3`: The color for solid background, such as bg color of the button.
+ *   It must satisfy the contrast ratio with pure white (#ffffff) text on
+ *   top of it.
+ *
+ * - `XXX-soft`: The color used for subtle background such as custom container
+ *   or badges. It must satisfy the contrast ratio when putting `XXX-1` colors
+ *   on top of it.
+ *
+ *   The soft color must be semi transparent alpha channel. This is crucial
+ *   because it allows adding multiple "soft" colors on top of each other
+ *   to create a accent, such as when having inline code block inside
+ *   custom containers.
+ *
+ * - `default`: The color used purely for subtle indication without any
+ *   special meanings attached to it such as bg color for menu hover state.
+ *
+ * - `brand`: Used for primary brand colors, such as link text, button with
+ *   brand theme, etc.
+ *
+ * - `tip`: Used to indicate useful information. The default theme uses the
+ *   brand color for this by default.
+ *
+ * - `warning`: Used to indicate warning to the users. Used in custom
+ *   container, badges, etc.
+ *
+ * - `danger`: Used to show error, or dangerous message to the users. Used
+ *   in custom container, badges, etc.
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-default-1: #9e9e9e;
+  --vp-c-default-2: red;
+  --vp-c-default-3: yellow;
+  --vp-c-default-soft: var(--vp-c-gray-soft);
+
+  --vp-c-brand-1: #f2994a;
+  --vp-c-brand-2: #efaa6d;
+  --vp-c-brand-3: #d68742;
+  --vp-c-brand-soft: var(--vp-c-indigo-soft);
+
+  --vp-c-tip-1: var(--vp-c-brand-1);
+  --vp-c-tip-2: var(--vp-c-brand-2);
+  --vp-c-tip-3: var(--vp-c-brand-3);
+  --vp-c-tip-soft: var(--vp-c-brand-soft);
+
+  --vp-c-warning-1: var(--vp-c-yellow-1);
+  --vp-c-warning-2: var(--vp-c-yellow-2);
+  --vp-c-warning-3: var(--vp-c-yellow-3);
+  --vp-c-warning-soft: var(--vp-c-yellow-soft);
+
+  --vp-c-danger-1: var(--vp-c-red-1);
+  --vp-c-danger-2: var(--vp-c-red-2);
+  --vp-c-danger-3: var(--vp-c-red-3);
+  --vp-c-danger-soft: var(--vp-c-red-soft);
+}
+
+/**
+ * Component: Button
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-button-brand-border: transparent;
+  --vp-button-brand-text: var(--vp-c-white);
+  --vp-button-brand-bg: var(--vp-c-brand-3);
+  --vp-button-brand-hover-border: transparent;
+  --vp-button-brand-hover-text: var(--vp-c-white);
+  --vp-button-brand-hover-bg: var(--vp-c-brand-2);
+  --vp-button-brand-active-border: transparent;
+  --vp-button-brand-active-text: var(--vp-c-white);
+  --vp-button-brand-active-bg: var(--vp-c-brand-1);
+}
+
+/**
+ * Component: Home
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-home-hero-name-color: transparent;
+  --vp-home-hero-name-background: -webkit-linear-gradient(
+    120deg,
+    #bd34fe 30%,
+    #41d1ff
+  );
+
+  --vp-home-hero-image-background-image: linear-gradient(
+    -45deg,
+    #bd34fe 50%,
+    #47caff 50%
+  );
+  --vp-home-hero-image-filter: blur(44px);
+}
+
+@media (min-width: 640px) {
+  :root {
+    --vp-home-hero-image-filter: blur(56px);
+  }
+}
+
+@media (min-width: 960px) {
+  :root {
+    --vp-home-hero-image-filter: blur(68px);
+  }
+}
+
+/**
+ * Component: Custom Block
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-custom-block-tip-border: transparent;
+  --vp-custom-block-tip-text: var(--vp-c-text-1);
+  --vp-custom-block-tip-bg: var(--vp-c-brand-soft);
+  --vp-custom-block-tip-code-bg: var(--vp-c-brand-soft);
+}
+
+/**
+ * Component: Algolia
+ * -------------------------------------------------------------------------- */
+
+.DocSearch {
+  --docsearch-primary-color: var(--vp-c-brand-1) !important;
+}
+
+/* IronCalc Docs custom css */
+
+.content p {
+  font-size: 14px;
+}
+
+.VPSidebar {
+  border-right: 1px solid var(--vp-c-divider);
+  padding-bottom: 32px !important;
+}
+
+/* .curtain {
+  background-color: white !important;
+} */
+
+.edit-info {
+  border-top: 1px solid var(--vp-c-divider);
+  padding-top: 14px;
+}
+
+li::marker {
+  color: var(--vp-c-brand-1);
+}
+
+.DocSearch-Button-Placeholder {
+  min-width: 200px;
+  text-align: left;
+}
+
+.vp-doc h2 {
+  margin: 36px 0 16px;
+  padding-top: 36px;
+}
+
+.vp-doc h2 .header-anchor {
+  top: 36px;
+}
+
+.VPSwitch {
+  background-color: var(--vp-c-bg-alt) !important;
+}
+
+.VPDocFooter {
+  margin-top: 36px !important;
+}
+
+table {
+  width: 100%;
+}
+
+.VPSidebarItem.level-0 {
+  padding-bottom: 10px !important;
+}
+
+.VPBadge.info {
+  background-color: var(--vp-c-gray-3);
+}
+
+.custom-block {
+  padding: 8px 16px;
+}
+
+.vp-doc ul,
+.vp-doc ol {
+  font-size: 14px;
+}
+
+.vp-doc h2 > .VPBadge {
+  vertical-align: middle;
+}

docs/src/.vitepress/theme/vars.css

@@ -0,0 +1,598 @@
+/**
+ * Colors: Solid
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-white: #ffffff;
+  --vp-c-black: #000000;
+
+  --vp-c-neutral: var(--vp-c-black);
+  --vp-c-neutral-inverse: var(--vp-c-white);
+}
+
+.dark {
+  --vp-c-neutral: var(--vp-c-white);
+  --vp-c-neutral-inverse: var(--vp-c-black);
+}
+
+/**
+ * Colors: Palette
+ *
+ * The primitive colors used for accent colors. These colors are referenced
+ * by functional colors such as "Text", "Background", or "Brand".
+ *
+ * Each colors have exact same color scale system with 3 levels of solid
+ * colors with different brightness, and 1 soft color.
+ *
+ * - `XXX-1`: The most solid color used mainly for colored text. It must
+ *   satisfy the contrast ratio against when used on top of `XXX-soft`.
+ *
+ * - `XXX-2`: The color used mainly for hover state of the button.
+ *
+ * - `XXX-3`: The color for solid background, such as bg color of the button.
+ *    It must satisfy the contrast ratio with pure white (#ffffff) text on
+ *    top of it.
+ *
+ * - `XXX-soft`: The color used for subtle background such as custom container
+ *    or badges. It must satisfy the contrast ratio when putting `XXX-1` colors
+ *    on top of it.
+ *
+ *    The soft color must be semi transparent alpha channel. This is crucial
+ *    because it allows adding multiple "soft" colors on top of each other
+ *    to create a accent, such as when having inline code block inside
+ *    custom containers.
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-gray-1: #dddde3;
+  --vp-c-gray-2: #e4e4e9;
+  --vp-c-gray-3: #ebebef;
+  --vp-c-gray-soft: rgba(242, 150, 170, 0.14);
+
+  --vp-c-indigo-1: #f2994a;
+  --vp-c-indigo-2: #efaa6d;
+  --vp-c-indigo-3: #d68742;
+  --vp-c-indigo-soft: rgba(242, 153, 74, 0.14);
+
+  --vp-c-purple-1: #6f42c1;
+  --vp-c-purple-2: #7e4cc9;
+  --vp-c-purple-3: #8e5cd9;
+  --vp-c-purple-soft: rgba(159, 122, 234, 0.14);
+
+  --vp-c-green-1: #18794e;
+  --vp-c-green-2: #299764;
+  --vp-c-green-3: #30a46c;
+  --vp-c-green-soft: rgba(16, 185, 129, 0.14);
+
+  --vp-c-yellow-1: #915930;
+  --vp-c-yellow-2: #946300;
+  --vp-c-yellow-3: #9f6a00;
+  --vp-c-yellow-soft: rgba(234, 179, 8, 0.14);
+
+  --vp-c-red-1: #b8272c;
+  --vp-c-red-2: #d5393e;
+  --vp-c-red-3: #e0575b;
+  --vp-c-red-soft: rgba(244, 63, 94, 0.14);
+
+  --vp-c-sponsor: #db2777;
+
+  /* ironcalc colors */
+
+  --primary-main: #f2994a;
+  --primary-light: #efaa6d;
+  --primary-dark: #d68742;
+  --primary-contrastText: #ffffff;
+
+  --secondary-main: #2f80ed;
+  --secondary-light: #4e92ec;
+  --secondary-dark: #2b6ec8;
+  --secondary-contrastText: #ffffff;
+
+  --info-main: #9e9e9e;
+  --info-light: #e0e0e0;
+  --info-dark: #757575;
+  --info-contrastText: #ffffff;
+
+  --grey-50: #f2f2f2;
+  --grey-100: #f5f5f5;
+  --grey-200: #eeeeee;
+  --grey-300: #e0e0e0;
+  --grey-400: #bdbdbd;
+  --grey-500: #9e9e9e;
+  --grey-600: #757575;
+  --grey-700: #616161;
+  --grey-800: #424242;
+  --grey-900: #333333;
+
+  --dark: #272525;
+  --background-color: #fcfcfc;
+}
+
+.dark {
+  --vp-c-gray-1: #515c67;
+  --vp-c-gray-2: #414853;
+  --vp-c-gray-3: #32363f;
+  --vp-c-gray-soft: rgba(101, 117, 133, 0.16);
+
+  --vp-c-indigo-1: #f2994a;
+  --vp-c-indigo-2: #efaa6d;
+  --vp-c-indigo-3: #d68742;
+  --vp-c-indigo-soft: rgba(242, 153, 74, 0.14);
+
+  --vp-c-purple-1: #c8abfa;
+  --vp-c-purple-2: #a879e6;
+  --vp-c-purple-3: #8e5cd9;
+  --vp-c-purple-soft: rgba(159, 122, 234, 0.16);
+
+  --vp-c-green-1: #3dd68c;
+  --vp-c-green-2: #30a46c;
+  --vp-c-green-3: #298459;
+  --vp-c-green-soft: rgba(16, 185, 129, 0.16);
+
+  --vp-c-yellow-1: #f9b44e;
+  --vp-c-yellow-2: #da8b17;
+  --vp-c-yellow-3: #a46a0a;
+  --vp-c-yellow-soft: rgba(234, 179, 8, 0.16);
+
+  --vp-c-red-1: #f66f81;
+  --vp-c-red-2: #f14158;
+  --vp-c-red-3: #b62a3c;
+  --vp-c-red-soft: rgba(244, 63, 94, 0.16);
+}
+
+/**
+ * Colors: Background
+ *
+ * - `bg`: The bg color used for main screen.
+ *
+ * - `bg-alt`: The alternative bg color used in places such as "sidebar",
+ *   or "code block".
+ *
+ * - `bg-elv`: The elevated bg color. This is used at parts where it "floats",
+ *   such as "dialog".
+ *
+ * - `bg-soft`: The bg color to slightly distinguish some components from
+ *   the page. Used for things like "carbon ads" or "table".
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-bg: #ffffff;
+  --vp-c-bg-alt: #f6f6f7;
+  --vp-c-bg-elv: #ffffff;
+  --vp-c-bg-soft: #f6f6f7;
+}
+
+.dark {
+  --vp-c-bg: #1b1b1f;
+  --vp-c-bg-alt: #161618;
+  --vp-c-bg-elv: #202127;
+  --vp-c-bg-soft: #202127;
+}
+
+/**
+ * Colors: Borders
+ *
+ * - `divider`: This is used for separators. This is used to divide sections
+ *   within the same components, such as having separator on "h2" heading.
+ *
+ * - `border`: This is designed for borders on interactive components.
+ *   For example this should be used for a button outline.
+ *
+ * - `gutter`: This is used to divide components in the page. For example
+ *   the header and the lest of the page.
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-border: #c2c2c4;
+  --vp-c-divider: #e2e2e3;
+  --vp-c-gutter: #e2e2e3;
+}
+
+.dark {
+  --vp-c-border: #3c3f44;
+  --vp-c-divider: #2e2e32;
+  --vp-c-gutter: #000000;
+}
+
+/**
+ * Colors: Text
+ *
+ * - `text-1`: Used for primary text.
+ *
+ * - `text-2`: Used for muted texts, such as "inactive menu" or "info texts".
+ *
+ * - `text-3`: Used for subtle texts, such as "placeholders" or "caret icon".
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-text-1: rgba(60, 60, 67);
+  --vp-c-text-2: rgba(60, 60, 67, 0.78);
+  --vp-c-text-3: rgba(60, 60, 67, 0.56);
+}
+
+.dark {
+  --vp-c-text-1: rgba(255, 255, 245, 0.86);
+  --vp-c-text-2: rgba(235, 235, 245, 0.6);
+  --vp-c-text-3: rgba(235, 235, 245, 0.38);
+}
+
+/**
+ * Colors: Function
+ *
+ * - `default`: The color used purely for subtle indication without any
+ *   special meanings attached to it such as bg color for menu hover state.
+ *
+ * - `brand`: Used for primary brand colors, such as link text, button with
+ *   brand theme, etc.
+ *
+ * - `tip`: Used to indicate useful information. The default theme uses the
+ *   brand color for this by default.
+ *
+ * - `warning`: Used to indicate warning to the users. Used in custom
+ *   container, badges, etc.
+ *
+ * - `danger`: Used to show error, or dangerous message to the users. Used
+ *   in custom container, badges, etc.
+ *
+ * To understand the scaling system, refer to "Colors: Palette" section.
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-c-default-1: var(--vp-c-gray-1);
+  --vp-c-default-2: var(--vp-c-gray-2);
+  --vp-c-default-3: var(--vp-c-gray-3);
+  --vp-c-default-soft: var(--vp-c-gray-soft);
+
+  --vp-c-brand-1: var(--vp-c-indigo-1);
+  --vp-c-brand-2: var(--vp-c-indigo-2);
+  --vp-c-brand-3: var(--vp-c-indigo-3);
+  --vp-c-brand-soft: var(--vp-c-indigo-soft);
+
+  /* DEPRECATED: Use `--vp-c-brand-1` instead. */
+  --vp-c-brand: var(--vp-c-brand-1);
+
+  --vp-c-tip-1: var(--vp-c-brand-1);
+  --vp-c-tip-2: var(--vp-c-brand-2);
+  --vp-c-tip-3: var(--vp-c-brand-3);
+  --vp-c-tip-soft: var(--vp-c-brand-soft);
+
+  --vp-c-note-1: var(--vp-c-brand-1);
+  --vp-c-note-2: var(--vp-c-brand-2);
+  --vp-c-note-3: var(--vp-c-brand-3);
+  --vp-c-note-soft: var(--vp-c-brand-soft);
+
+  --vp-c-success-1: var(--vp-c-green-1);
+  --vp-c-success-2: var(--vp-c-green-2);
+  --vp-c-success-3: var(--vp-c-green-3);
+  --vp-c-success-soft: var(--vp-c-green-soft);
+
+  --vp-c-important-1: var(--vp-c-purple-1);
+  --vp-c-important-2: var(--vp-c-purple-2);
+  --vp-c-important-3: var(--vp-c-purple-3);
+  --vp-c-important-soft: var(--vp-c-purple-soft);
+
+  --vp-c-warning-1: var(--vp-c-yellow-1);
+  --vp-c-warning-2: var(--vp-c-yellow-2);
+  --vp-c-warning-3: var(--vp-c-yellow-3);
+  --vp-c-warning-soft: var(--vp-c-yellow-soft);
+
+  --vp-c-danger-1: var(--vp-c-red-1);
+  --vp-c-danger-2: var(--vp-c-red-2);
+  --vp-c-danger-3: var(--vp-c-red-3);
+  --vp-c-danger-soft: var(--vp-c-red-soft);
+
+  --vp-c-caution-1: var(--vp-c-red-1);
+  --vp-c-caution-2: var(--vp-c-red-2);
+  --vp-c-caution-3: var(--vp-c-red-3);
+  --vp-c-caution-soft: var(--vp-c-red-soft);
+}
+
+/**
+ * Typography
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-font-family-base: "Inter", ui-sans-serif, system-ui, sans-serif,
+    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  --vp-font-family-mono: ui-monospace, "Menlo", "Monaco", "Consolas",
+    "Liberation Mono", "Courier New", monospace;
+  font-optical-sizing: auto;
+}
+
+:root:where(:lang(zh)) {
+  --vp-font-family-base: "Punctuation SC", "Inter", ui-sans-serif, system-ui,
+    sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol",
+    "Noto Color Emoji";
+}
+
+/**
+ * Shadows
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-shadow-1: 0 1px 2px rgba(0, 0, 0, 0.04), 0 1px 2px rgba(0, 0, 0, 0.06);
+  --vp-shadow-2: 0 3px 12px rgba(0, 0, 0, 0.07), 0 1px 4px rgba(0, 0, 0, 0.07);
+  --vp-shadow-3: 0 12px 32px rgba(0, 0, 0, 0.1), 0 2px 6px rgba(0, 0, 0, 0.08);
+  --vp-shadow-4: 0 14px 44px rgba(0, 0, 0, 0.12), 0 3px 9px rgba(0, 0, 0, 0.12);
+  --vp-shadow-5: 0 18px 56px rgba(0, 0, 0, 0.16), 0 4px 12px rgba(0, 0, 0, 0.16);
+}
+
+/**
+ * Z-indexes
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-z-index-footer: 10;
+  --vp-z-index-local-nav: 20;
+  --vp-z-index-nav: 30;
+  --vp-z-index-layout-top: 40;
+  --vp-z-index-backdrop: 50;
+  --vp-z-index-sidebar: 60;
+}
+
+@media (min-width: 960px) {
+  :root {
+    --vp-z-index-sidebar: 25;
+  }
+}
+
+/**
+ * Layouts
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-layout-max-width: 1440px;
+}
+
+/**
+ * Component: Header Anchor
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-header-anchor-symbol: "#";
+}
+
+/**
+ * Component: Code
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-code-line-height: 1.7;
+  --vp-code-font-size: 0.875em;
+  --vp-code-color: var(--vp-c-brand-1);
+  --vp-code-link-color: var(--vp-c-brand-1);
+  --vp-code-link-hover-color: var(--vp-c-brand-2);
+  --vp-code-bg: var(--vp-c-gray-3);
+
+  --vp-code-block-color: var(--vp-c-text-2);
+  --vp-code-block-bg: var(--vp-c-bg-alt);
+  --vp-code-block-divider-color: var(--vp-c-gutter);
+
+  --vp-code-lang-color: var(--vp-c-text-3);
+
+  --vp-code-line-highlight-color: var(--vp-c-default-soft);
+  --vp-code-line-number-color: var(--vp-c-text-3);
+
+  --vp-code-line-diff-add-color: var(--vp-c-success-soft);
+  --vp-code-line-diff-add-symbol-color: var(--vp-c-success-1);
+
+  --vp-code-line-diff-remove-color: var(--vp-c-danger-soft);
+  --vp-code-line-diff-remove-symbol-color: var(--vp-c-danger-1);
+
+  --vp-code-line-warning-color: var(--vp-c-warning-soft);
+  --vp-code-line-error-color: var(--vp-c-danger-soft);
+
+  --vp-code-copy-code-border-color: var(--vp-c-divider);
+  --vp-code-copy-code-bg: var(--vp-c-bg-soft);
+  --vp-code-copy-code-hover-border-color: var(--vp-c-divider);
+  --vp-code-copy-code-hover-bg: var(--vp-c-bg);
+  --vp-code-copy-code-active-text: var(--vp-c-text-2);
+  --vp-code-copy-copied-text-content: "Copied";
+
+  --vp-code-tab-divider: var(--vp-code-block-divider-color);
+  --vp-code-tab-text-color: var(--vp-c-text-2);
+  --vp-code-tab-bg: var(--vp-code-block-bg);
+  --vp-code-tab-hover-text-color: var(--vp-c-text-1);
+  --vp-code-tab-active-text-color: var(--vp-c-text-1);
+  --vp-code-tab-active-bar-color: var(--vp-c-brand-1);
+}
+
+/**
+ * Component: Button
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-button-brand-border: transparent;
+  --vp-button-brand-text: var(--vp-c-white);
+  --vp-button-brand-bg: var(--vp-c-brand-3);
+  --vp-button-brand-hover-border: transparent;
+  --vp-button-brand-hover-text: var(--vp-c-white);
+  --vp-button-brand-hover-bg: var(--vp-c-brand-2);
+  --vp-button-brand-active-border: transparent;
+  --vp-button-brand-active-text: var(--vp-c-white);
+  --vp-button-brand-active-bg: var(--vp-c-brand-1);
+
+  --vp-button-alt-border: transparent;
+  --vp-button-alt-text: var(--vp-c-text-1);
+  --vp-button-alt-bg: var(--vp-c-default-3);
+  --vp-button-alt-hover-border: transparent;
+  --vp-button-alt-hover-text: var(--vp-c-text-1);
+  --vp-button-alt-hover-bg: var(--vp-c-default-2);
+  --vp-button-alt-active-border: transparent;
+  --vp-button-alt-active-text: var(--vp-c-text-1);
+  --vp-button-alt-active-bg: var(--vp-c-default-1);
+
+  --vp-button-sponsor-border: var(--vp-c-text-2);
+  --vp-button-sponsor-text: var(--vp-c-text-2);
+  --vp-button-sponsor-bg: transparent;
+  --vp-button-sponsor-hover-border: var(--vp-c-sponsor);
+  --vp-button-sponsor-hover-text: var(--vp-c-sponsor);
+  --vp-button-sponsor-hover-bg: transparent;
+  --vp-button-sponsor-active-border: var(--vp-c-sponsor);
+  --vp-button-sponsor-active-text: var(--vp-c-sponsor);
+  --vp-button-sponsor-active-bg: transparent;
+}
+
+/**
+ * Component: Custom Block
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-custom-block-font-size: 14px;
+  --vp-custom-block-code-font-size: 13px;
+
+  --vp-custom-block-info-border: transparent;
+  --vp-custom-block-info-text: var(--vp-c-text-1);
+  --vp-custom-block-info-bg: var(--vp-c-gray-3);
+  --vp-custom-block-info-code-bg: var(--vp-c-default-soft);
+
+  --vp-custom-block-note-border: transparent;
+  --vp-custom-block-note-text: var(--vp-c-text-1);
+  --vp-custom-block-note-bg: var(--vp-c-default-soft);
+  --vp-custom-block-note-code-bg: var(--vp-c-default-soft);
+
+  --vp-custom-block-tip-border: transparent;
+  --vp-custom-block-tip-text: var(--vp-c-text-1);
+  --vp-custom-block-tip-bg: var(--vp-c-tip-soft);
+  --vp-custom-block-tip-code-bg: var(--vp-c-tip-soft);
+
+  --vp-custom-block-important-border: transparent;
+  --vp-custom-block-important-text: var(--vp-c-text-1);
+  --vp-custom-block-important-bg: var(--vp-c-important-soft);
+  --vp-custom-block-important-code-bg: var(--vp-c-important-soft);
+
+  --vp-custom-block-warning-border: transparent;
+  --vp-custom-block-warning-text: var(--vp-c-text-1);
+  --vp-custom-block-warning-bg: var(--vp-c-warning-soft);
+  --vp-custom-block-warning-code-bg: var(--vp-c-warning-soft);
+
+  --vp-custom-block-danger-border: transparent;
+  --vp-custom-block-danger-text: var(--vp-c-text-1);
+  --vp-custom-block-danger-bg: var(--vp-c-danger-soft);
+  --vp-custom-block-danger-code-bg: var(--vp-c-danger-soft);
+
+  --vp-custom-block-caution-border: transparent;
+  --vp-custom-block-caution-text: var(--vp-c-text-1);
+  --vp-custom-block-caution-bg: var(--vp-c-caution-soft);
+  --vp-custom-block-caution-code-bg: var(--vp-c-caution-soft);
+
+  --vp-custom-block-details-border: var(--vp-custom-block-info-border);
+  --vp-custom-block-details-text: var(--vp-custom-block-info-text);
+  --vp-custom-block-details-bg: var(--vp-custom-block-info-bg);
+  --vp-custom-block-details-code-bg: var(--vp-custom-block-info-code-bg);
+}
+
+/**
+ * Component: Input
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-input-border-color: var(--vp-c-border);
+  --vp-input-bg-color: var(--vp-c-bg-alt);
+
+  --vp-input-switch-bg-color: var(--vp-c-default-soft);
+}
+
+/**
+ * Component: Nav
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-nav-height: 64px;
+  --vp-nav-bg-color: var(--vp-c-bg);
+  --vp-nav-screen-bg-color: var(--vp-c-bg);
+  --vp-nav-logo-height: 24px;
+}
+
+.hide-nav {
+  --vp-nav-height: 0px;
+}
+
+.hide-nav .VPSidebar {
+  --vp-nav-height: 22px;
+}
+
+/**
+ * Component: Local Nav
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-local-nav-bg-color: var(--vp-c-bg);
+}
+
+/**
+ * Component: Sidebar
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-sidebar-width: 272px;
+  --vp-sidebar-bg-color: var(--vp-c-bg-alt);
+}
+
+/**
+ * Colors Backdrop
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-backdrop-bg-color: rgba(0, 0, 0, 0.6);
+}
+
+/**
+ * Component: Home
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-home-hero-name-color: var(--vp-c-brand-1);
+  --vp-home-hero-name-background: transparent;
+
+  --vp-home-hero-image-background-image: none;
+  --vp-home-hero-image-filter: none;
+}
+
+/**
+ * Component: Badge
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-badge-info-border: transparent;
+  --vp-badge-info-text: var(--vp-c-text-2);
+  --vp-badge-info-bg: var(--vp-c-default-soft);
+
+  --vp-badge-tip-border: transparent;
+  --vp-badge-tip-text: var(--vp-c-tip-1);
+  --vp-badge-tip-bg: var(--vp-c-tip-soft);
+
+  --vp-badge-warning-border: transparent;
+  --vp-badge-warning-text: var(--vp-c-warning-1);
+  --vp-badge-warning-bg: var(--vp-c-warning-soft);
+
+  --vp-badge-danger-border: transparent;
+  --vp-badge-danger-text: var(--vp-c-danger-1);
+  --vp-badge-danger-bg: var(--vp-c-danger-soft);
+}
+
+/**
+ * Component: Carbon Ads
+ * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-carbon-ads-text-color: var(--vp-c-text-1);
+  --vp-carbon-ads-poweredby-color: var(--vp-c-text-2);
+  --vp-carbon-ads-bg-color: var(--vp-c-bg-soft);
+  --vp-carbon-ads-hover-text-color: var(--vp-c-brand-1);
+  --vp-carbon-ads-hover-poweredby-color: var(--vp-c-text-1);
+}
+
+/**
+  * Component: Local Search
+  * -------------------------------------------------------------------------- */
+
+:root {
+  --vp-local-search-bg: var(--vp-c-bg);
+  --vp-local-search-result-bg: var(--vp-c-bg);
+  --vp-local-search-result-border: var(--vp-c-divider);
+  --vp-local-search-result-selected-bg: var(--vp-c-bg);
+  --vp-local-search-result-selected-border: var(--vp-c-brand-1);
+  --vp-local-search-highlight-bg: var(--vp-c-brand-1);
+  --vp-local-search-highlight-text: var(--vp-c-neutral-inverse);
+}

docs/src/contributing/how-to-contribute.md

@@ -0,0 +1,9 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# How to Contribute
+
+If you want to give us a hand, take a look at our [GitHub repository](https://github.com/ironcalc/IronCalc?tab=readme-ov-file#collaborators-needed-call-to-action), join our [Discord Channel](https://discord.gg/sjaefMWE) or send us an email to [hello@ironcalc.com](mailto:hello@ironcalc.com).

docs/src/desktop/about.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# The desktop application
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/issues/57)
+:::

docs/src/features/error-types.md

@@ -0,0 +1,79 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Error Types
+
+::: warning
+**Note:** This page is in construction 🚧
+:::
+
+When working with formulas, you may encounter these common errors:
+
+---
+
+### **`#ERROR!`**
+
+**Cause:** General formula issue, like syntax errors or invalid references.  
+**Fix:** Check the formula for mistakes or invalid cell references.
+
+---
+
+### **`#VALUE!`**
+
+**Cause:** Mismatched data types (e.g., text used where numbers are expected).  
+**Fix:** Ensure input types are correct; convert text to numbers if needed.
+
+---
+
+### **`#DIV/0!`**
+
+**Cause:** Division by zero or an empty cell.  
+**Fix:** Ensure the denominator isn’t zero or blank. Use `IF` to handle such cases:
+
+```
+=IF(B1=0, "N/A", A1/B1)
+```
+
+### **`#NAME?`**
+
+**Cause:** Unrecognized text in the formula (e.g., misspelled function names or undefined named ranges).  
+**Fix:** Correct spelling or define the missing name.
+
+### **`#REF!`**
+
+**Cause:** Invalid cell reference, often from deleting cells used in a formula.  
+**Fix:** Update the formula with correct references.
+
+### **`#NUM!`**
+
+**Cause:** Invalid numeric operation (e.g., calculating a square root of a negative number).  
+**Fix:** Adjust the formula to ensure valid numeric operations.
+
+### **`#N/A`**
+
+**Cause:** A value is not available, often in lookup functions like VLOOKUP.  
+**Fix:** Ensure the lookup value exists or use IFNA() to handle missing values:
+
+```
+=IFNA(VLOOKUP(A1, B1:C10, 2, FALSE), "Not Found")
+```
+
+### **`#NULL!`**
+
+**Cause:** Incorrect range operator in a formula (e.g., missing a colon between cell references).  
+**Fix:** Use correct range operators (e.g., A1:A10).
+
+
+### **`#CIRC!`**
+
+**Cause:** Circular reference.  
+**Fix:** Remove the circular reference.
+
+
+### **`#####`**
+
+**Cause:** The column isn’t wide enough to display the value.  
+**Fix:** Resize the column width to fit the content.

docs/src/features/formatting-values.md

@@ -0,0 +1,42 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Formatting Values
+
+You can format numbers in **scientific notation**, as **currencies**, **percentages**, or **dates**.
+
+## How to Format Values
+
+To change the format of the values:
+
+- Click on the **€** or **%** buttons in the toolbox for quick access.
+- Alternatively, click on the **123 dropdown** to select one of the predefined formats:
+  - Number
+  - Percentage
+  - Euro (€)
+  - Dollar ($)
+  - British Pound (£)
+  - Short Date
+  - Long Date
+
+You can also **create a custom format** directly from the dropdown.
+
+## Creating Custom Formats
+
+To create a custom format, you need to use a specific formatting string. Here's an example:
+
+- **`"$"#,##0.00`**
+  - **`$`**: Displays the dollar symbol. You can replace this with another currency symbol like **€** or **£**.
+  - **`#,##0`**: Formats numbers with a thousands separator (`,`).
+  - **`.00`**: Ensures two decimal places are always displayed.
+
+### Common Custom Format Examples
+
+- **`"€"#,##0.00`**: Formats numbers as Euros with two decimal places.
+- **`0.00%`**: Formats numbers as percentages with two decimal places.
+- **`yyyy-mm-dd`**: Displays dates in the year-month-day format.
+
+For more advanced options, refer to standard number formatting guides.

docs/src/features/keyboard-shortcuts.md

@@ -0,0 +1,28 @@
+---
+layout: doc
+outline: deep
+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.
+
+## Common Actions
+
+| Action | Windows  | Mac   |
+| ------ | -------- | ----- |
+| Copy   | ctrl + c | ⌘ + c |
+| Paste  | ctrl + v | ⌘ + v |
+| Cut    | ctrl + x | ⌘ + x |
+| Undo   | ctrl + z | ⌘ + z |
+| Redo   | ctrl + y | ⌘ + y |
+
+## Navigation
+
+| <div style="width:200px">Action</div> | <div style="width:80px">Windows</div> | <div style="width:80px">Mac</div> |
+| ------------------------------------- | ------------------------------------- | --------------------------------- |
+| Move to beginning of row              | ???                                   | Fn + Left Arrow                   |
+| Move to end of row                    | ???                                   | Fn + Right Arrow                  |
+| Move to previous sheet                | Option + Arrow Up                     | Option + Arrow Up                 |
+| Move to next sheet                    | Option + Arrow Down                   | Option + Arrow Down               |

docs/src/features/unsupported-features.md

@@ -0,0 +1,29 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Important Unsupported Features
+
+Although IronCalc is ready for use, it’s important to understand its current limitations. Below, we list the most significant missing features of a modern spreadsheet engine. If you can live without these features for now, IronCalc might be the product you’re looking for.
+
+## **Arrays and Array Formulas** <Badge type="info" text="Planned" />
+
+IronCalc currently does not implement arrays or array formulas. These are planned and are coming very soon, as they are the highest priority on the engine side.
+
+## **Name Manager** <Badge type="info" text="Planned" />
+
+While IronCalc supports importing and exporting defined names, it does not yet allow you to create, delete, or update them in the UI. This feature is expected to be implemented shortly.
+
+## **Only English Supported**
+
+The MVP version of IronCalc supports only the English language. However, version 1.0 will include support for three languages: **English**, **German**, and **Spanish**.
+
+## **No Autocomplete**
+
+Spreadsheet users are accustomed to autocompleting sequences (e.g., filling in `4, 5, 6` after `1, 2, 3`). This feature is not yet available in IronCalc but is on the roadmap for future updates.
+
+## **Charts** <Badge type="info" text="Not Planned for v1" />
+
+Although charts are an essential feature for any serious spreadsheet program, they are not planned for version 1.0. Adding chart support will become a high priority after the release of version 1.0.

docs/src/features/using-styles.md

@@ -0,0 +1,28 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Using Styles
+
+In IronCalc you can aldo customize the appearance of your data with a variety of style options:
+
+- **Background Colors**: Apply colors to cell backgrounds.
+- **Text Colors**: Change the color of the text within cells.
+- **Borders**: Add or modify borders around cells, including **border color** and **line thickness** (thin, medium or thick).
+- **Font Styles**: Use **bold**, _italics_, _underlined_, or **strikethrough** text for emphasis.
+- **Alignment**: Align text both **horizontally** and **vertically**, with options to **align middle** for both axes for perfect centering.
+
+You can also **show or hide grid lines** for a cleaner layout.
+
+## Adjusting Row and Column Dimensions
+
+You can also customize the layout by modifying:
+
+- **Row Heights**: Adjust the height of rows to fit your content.
+- **Column Widths**: Resize columns for optimal visibility of data.
+
+## Copying and Pasting Styles
+
+Styles can be easily **copied and pasted** from one cell or cell range to another. Simply copy the cell with the desired style and paste it into another cell or range to apply the same formatting.

docs/src/functions/cube.md

@@ -0,0 +1,19 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Cube functions
+
+At the moment IronCalc does not support any function in this section. All are planned.
+You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/58).
+
+| Function           | Status                                         | Documentation |
+| ------------------ | ---------------------------------------------- | ------------- |
+| CUBEKPIMEMBER      | <Badge type="info" text="Not implemented yet" /> | –             |
+| CUBEMEMBERPROPERTY | <Badge type="info" text="Not implemented yet" /> | –             |
+| CUBERANKEDMEMBER   | <Badge type="info" text="Not implemented yet" /> | –             |
+| CUBESET            | <Badge type="info" text="Not implemented yet" /> | –             |
+| CUBESETCOUNT       | <Badge type="info" text="Not implemented yet" /> | –             |
+| CUBEVALUE          | <Badge type="info" text="Not implemented yet" /> | –             |

docs/src/functions/cube/cubekpimember.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBEKPIMEMBER
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/cube/cubemember.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBEMEMBER
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/cube/cubememberproperty.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBEMEMBERPROPERTY
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/cube/cuberankedmember.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBERANKEDMEMBER
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/cube/cubeset.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBESET
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/cube/cubesetcount.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBESETCOUNT
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/cube/cubevalue.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# CUBEVALUE
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/database.md

@@ -0,0 +1,25 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Database functions
+
+At the moment IronCalc does not support any function in this section. All are planned.  
+You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/47).
+
+| Function | Status                                         | Documentation |
+| -------- | ---------------------------------------------- | ------------- |
+| DAVERAGE | <Badge type="info" text="Not implemented yet" /> | –             |
+| DCOUNT   | <Badge type="info" text="Not implemented yet" /> | –             |
+| DCOUNTA  | <Badge type="info" text="Not implemented yet" /> | –             |
+| DGET     | <Badge type="info" text="Not implemented yet" /> | –             |
+| DMAX     | <Badge type="info" text="Not implemented yet" /> | –             |
+| DMIN     | <Badge type="info" text="Not implemented yet" /> | –             |
+| DPRODUCT | <Badge type="info" text="Not implemented yet" /> | –             |
+| DSTDEV   | <Badge type="info" text="Not implemented yet" /> | –             |
+| DSTDEVP  | <Badge type="info" text="Not implemented yet" /> | –             |
+| DSUM     | <Badge type="info" text="Not implemented yet" /> | –             |
+| DVAR     | <Badge type="info" text="Not implemented yet" /> | –             |
+| DVARP    | <Badge type="info" text="Not implemented yet" /> | –             |

docs/src/functions/database/daverage.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# DAVERAGE
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/database/dcount.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# DCOUNT
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::

docs/src/functions/database/dcounta.md

@@ -0,0 +1,12 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# DCOUNTA
+
+::: warning
+🚧 This function is not yet available in IronCalc.
+[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+:::