WIP

refactored NameManager logic for new design
NamedRanges changes
2024-12-30 11:46:46 +01:00 · 2024-12-29 18:12:00 +01:00 · 2024-12-28 12:32:40 +01:00 · 2024-12-26 15:06:54 +01:00 · 2024-12-26 15:06:54 +01:00 · 2024-12-26 10:21:21 +01:00
650 changed files with 17943 additions and 2174 deletions
--- a/.github/workflows/publish-wiki.yml
+++ b/.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
--- a/.github/workflows/test-coverage.yaml
+++ b/.github/workflows/test-coverage.yaml
@@ -1,6 +1,7 @@
 name: Coverage

-on: [pull_request]
+on:
+  workflow_dispatch:

 jobs:
  coverage:
@@ -16,8 +17,9 @@ jobs:
      - name: Generate code coverage
        run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v5
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
          files: lcov.info
          fail_ci_if_error: true
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,18 @@
 # CHANGELOG

-## [Unreleased]
+## 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
+- Fixed bug where columns and rows could be resized to negative width and height, respectively

 ## [0.2.0] - 2024-11-06 (The HN release)

--- a/CONTRIBUTING.md
+++ b/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.
--- a/Cargo.lock
+++ b/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"
@@ -19,15 +19,6 @@ dependencies = [
 "cpufeatures",
 ]

-[[package]]
-name = "aho-corasick"
-version = "0.6.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -52,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"
@@ -66,31 +63,28 @@ 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",
 "syn",
 ]

-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -157,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",
@@ -171,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",
@@ -182,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",
 ]

@@ -278,19 +271,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "csv-sniffer"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b8e952164bb270a505d6cb6136624174c34cfb9abd16e0011f5e53058317f39"
-dependencies = [
- "bitflags",
- "csv",
- "csv-core",
- "memchr",
- "regex 0.2.11",
-]
-
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -348,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"
@@ -425,11 +411,11 @@ dependencies = [
 "chrono",
 "chrono-tz",
 "csv",
- "csv-sniffer",
 "js-sys",
 "once_cell",
 "rand",
- "regex 1.10.4",
+ "regex",
+ "regex-lite",
 "ryu",
 "serde",
 "serde_json",
@@ -468,12 +454,6 @@ dependencies = [
 "wasm-bindgen",
 ]

-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
 [[package]]
 name = "libc"
 version = "0.2.153"
@@ -533,11 +513,11 @@ 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 1.10.4",
+ "regex",
 ]

 [[package]]
@@ -746,29 +726,16 @@ dependencies = [
 "getrandom",
 ]

-[[package]]
-name = "regex"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9329abc99e39129fcceabd24cf5d85b4671ef7c29c50e972bc5afe32438ec384"
-dependencies = [
- "aho-corasick 0.6.10",
- "memchr",
- "regex-syntax 0.5.6",
- "thread_local",
- "utf8-ranges",
-]
-
 [[package]]
 name = "regex"
 version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
- "aho-corasick 1.1.3",
+ "aho-corasick",
 "memchr",
 "regex-automata",
- "regex-syntax 0.8.3",
+ "regex-syntax",
 ]

 [[package]]
@@ -777,19 +744,16 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
 dependencies = [
- "aho-corasick 1.1.3",
+ "aho-corasick",
 "memchr",
- "regex-syntax 0.8.3",
+ "regex-syntax",
 ]

 [[package]]
-name = "regex-syntax"
-version = "0.5.6"
+name = "regex-lite"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d707a4fa2637f2dca2ef9fd02225ec7661fe01a53623c1e6515b6916511f7a7"
-dependencies = [
- "ucd-util",
-]
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"

 [[package]]
 name = "regex-syntax"
@@ -928,15 +892,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "thread_local"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
-dependencies = [
- "lazy_static",
-]
-
 [[package]]
 name = "time"
 version = "0.3.34"
@@ -962,12 +917,6 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

-[[package]]
-name = "ucd-util"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abd2fc5d32b590614af8b0a20d837f32eca055edd0bbead59a9cfe80858be003"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
@@ -980,12 +929,6 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"

-[[package]]
-name = "utf8-ranges"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
-
 [[package]]
 name = "uuid"
 version = "1.8.0"
--- a/10
+++ b/10
@@ -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
@@ -11,8 +11,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 +23,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 +40,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
--- a/base/Cargo.toml
+++ b/base/Cargo.toml
@@ -14,12 +14,17 @@ readme = "README.md"
 serde = { version = "1.0", features = ["derive"] }
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.9"
-regex = "1.0"
+chrono-tz = "0.10"
+regex = { version = "1.0", optional = true}
+regex-lite = { version = "0.1.6", optional = true}
 once_cell = "1.16.0"
-bitcode = "0.6.0"
+bitcode = "0.6.3"
 csv = "1.3.0"
-csv-sniffer = "0.1"
+
+[features]
+default = ["use_regex_full"]
+use_regex_full = ["regex"]
+use_regex_lite = ["regex-lite"]

 [dev-dependencies]
 serde_json = "1.0"
--- a/base/src/actions.rs
+++ b/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,
--- a/base/src/calc_result.rs
+++ b/base/src/calc_result.rs
@@ -2,6 +2,7 @@ use std::cmp::Ordering;

 use crate::expressions::{token::Error, types::CellReferenceIndex};

+#[derive(Clone)]
 pub struct Range {
    pub left: CellReferenceIndex,
    pub right: CellReferenceIndex,
--- a/base/src/constants.rs
+++ b/base/src/constants.rs
@@ -6,7 +6,7 @@ pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.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;
+pub(crate) const DEFAULT_WINDOW_HEIGHT: i64 = 600;
 pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;

 pub(crate) const LAST_COLUMN: i32 = 16_384;
--- a/base/src/diffs.rs
+++ b/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,
--- a/base/src/expressions/lexer/test/test_util.rs
+++ b/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},
@@ -22,6 +24,25 @@ fn test_get_tokens() {
    assert_eq!(l.end, 10);
 }

+#[test]
+fn get_tokens_unicode() {
+    let formula = "'🇵🇭 Philippines'!A1";
+    let t = get_tokens(formula);
+    assert_eq!(t.len(), 1);
+
+    let expected = TokenType::Reference {
+        sheet: Some("🇵🇭 Philippines".to_string()),
+        row: 1,
+        column: 1,
+        absolute_column: false,
+        absolute_row: false,
+    };
+    let l = t.first().expect("expected token");
+    assert_eq!(l.token, expected);
+    assert_eq!(l.start, 0);
+    assert_eq!(l.end, 19);
+}
+
 #[test]
 fn test_simple_tokens() {
    assert_eq!(
--- a/base/src/expressions/lexer/util.rs
+++ b/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();
--- a/base/src/expressions/parser/mod.rs
+++ b/base/src/expressions/parser/mod.rs
@@ -49,21 +49,15 @@ pub mod stringify;
 pub mod walk;

 #[cfg(test)]
-mod test;
-
-#[cfg(test)]
-mod test_ranges;
-
-#[cfg(test)]
-mod test_move_formula;
-#[cfg(test)]
-mod test_tables;
+mod tests;

 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 {
@@ -170,7 +164,9 @@ pub enum Node {
        args: Vec<Node>,
    },
    ArrayKind(Vec<Node>),
-    VariableKind(String),
+    DefinedNameKind((String, Option<u32>)),
+    TableNameKind(String),
+    WrongVariableKind(String),
    CompareKind {
        kind: OpCompare,
        left: Box<Node>,
@@ -193,22 +189,35 @@ pub enum Node {
 pub struct Parser {
    lexer: lexer::Lexer,
    worksheets: Vec<String>,
-    context: Option<CellReferenceRC>,
+    defined_names: Vec<(String, Option<u32>)>,
+    context: CellReferenceRC,
    tables: HashMap<String, Table>,
 }

 impl Parser {
-    pub fn new(worksheets: Vec<String>, tables: HashMap<String, Table>) -> Parser {
+    pub fn new(
+        worksheets: Vec<String>,
+        defined_names: Vec<(String, Option<u32>)>,
+        tables: HashMap<String, Table>,
+    ) -> 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(""),
        );
+        let context = CellReferenceRC {
+            sheet: worksheets.first().map_or("", |v| v).to_string(),
+            column: 1,
+            row: 1,
+        };
        Parser {
            lexer,
            worksheets,
-            context: None,
+            defined_names,
+            context,
            tables,
        }
    }
@@ -216,13 +225,18 @@ impl Parser {
        self.lexer.set_lexer_mode(mode)
    }

-    pub fn set_worksheets(&mut self, worksheets: Vec<String>) {
+    pub fn set_worksheets_and_names(
+        &mut self,
+        worksheets: Vec<String>,
+        defined_names: Vec<(String, Option<u32>)>,
+    ) {
        self.worksheets = worksheets;
+        self.defined_names = defined_names;
    }

-    pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
+    pub fn parse(&mut self, formula: &str, context: &CellReferenceRC) -> Node {
        self.lexer.set_formula(formula);
-        self.context.clone_from(context);
+        self.context = context.clone();
        self.parse_expr()
    }

@@ -236,6 +250,24 @@ impl Parser {
        None
    }

+    // Returns:
+    //  * None: If there is no defined name by that name
+    //  * Some(Some(index)): If there is a defined name local to that sheet
+    //  * Some(None): If there is a global defined name
+    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<Option<u32>> {
+        for (df_name, df_scope) in &self.defined_names {
+            if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
+                return Some(*df_scope);
+            }
+        }
+        for (df_name, df_scope) in &self.defined_names {
+            if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
+                return Some(None);
+            }
+        }
+        None
+    }
+
    fn parse_expr(&mut self) -> Node {
        let mut t = self.parse_concat();
        if let Node::ParseErrorKind { .. } = t {
@@ -450,16 +482,7 @@ impl Parser {
                absolute_column,
                absolute_row,
            } => {
-                let context = match &self.context {
-                    Some(c) => c,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "Expected context for the reference".to_string(),
-                        }
-                    }
-                };
+                let context = &self.context;
                let sheet_index = match &sheet {
                    Some(name) => self.get_sheet_index_by_name(name),
                    None => self.get_sheet_index_by_name(&context.sheet),
@@ -494,16 +517,7 @@ impl Parser {
                }
            }
            TokenType::Range { sheet, left, right } => {
-                let context = match &self.context {
-                    Some(c) => c,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "Expected context for the reference".to_string(),
-                        }
-                    }
-                };
+                let context = &self.context;
                let sheet_index = match &sheet {
                    Some(name) => self.get_sheet_index_by_name(name),
                    None => self.get_sheet_index_by_name(&context.sheet),
@@ -518,20 +532,6 @@ impl Parser {
                let mut absolute_row1 = left.absolute_row;
                let mut absolute_row2 = right.absolute_row;

-                if self.lexer.is_a1_mode() {
-                    if !left.absolute_row {
-                        row1 -= context.row
-                    };
-                    if !left.absolute_column {
-                        column1 -= context.column
-                    };
-                    if !right.absolute_row {
-                        row2 -= context.row
-                    };
-                    if !right.absolute_column {
-                        column2 -= context.column
-                    };
-                }
                if row1 > row2 {
                    (row2, row1) = (row1, row2);
                    (absolute_row2, absolute_row1) = (absolute_row1, absolute_row2);
@@ -540,6 +540,22 @@ impl Parser {
                    (column2, column1) = (column1, column2);
                    (absolute_column2, absolute_column1) = (absolute_column1, absolute_column2);
                }
+
+                if self.lexer.is_a1_mode() {
+                    if !absolute_row1 {
+                        row1 -= context.row
+                    };
+                    if !absolute_column1 {
+                        column1 -= context.column
+                    };
+                    if !absolute_row2 {
+                        row2 -= context.row
+                    };
+                    if !absolute_column2 {
+                        column2 -= context.column
+                    };
+                }
+
                match sheet_index {
                    Some(index) => Node::RangeKind {
                        sheet_name: sheet,
@@ -587,11 +603,33 @@ impl Parser {
                            kind: function_kind,
                            args,
                        };
-                    } else {
-                        return Node::InvalidFunctionKind { name, args };
+                    }
+                    return Node::InvalidFunctionKind { name, args };
+                }
+                let context = &self.context;
+
+                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                    Some(i) => i,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: "sheet not found".to_string(),
+                        };
+                    }
+                };
+
+                // Could be a defined name or a table
+                if let Some(scope) = self.get_defined_name(&name, context_sheet_index) {
+                    return Node::DefinedNameKind((name, scope));
+                }
+                let name_lower = name.to_lowercase();
+                for table_name in self.tables.keys() {
+                    if table_name.to_lowercase() == name_lower {
+                        return Node::TableNameKind(name);
                    }
                }
-                Node::VariableKind(name)
+                Node::WrongVariableKind(name)
            }
            TokenType::Error(kind) => Node::ErrorKind(kind),
            TokenType::Illegal(error) => Node::ParseErrorKind {
@@ -663,177 +701,177 @@ impl Parser {
                // We will try to convert to a normal reference
                // table_name[column_name] => cell1:cell2
                // table_name[[#This Row], [column_name]:[column_name]] => cell1:cell2
-                if let Some(context) = &self.context {
-                    let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
-                        Some(i) => i,
-                        None => {
-                            return Node::ParseErrorKind {
-                                formula: self.lexer.get_formula(),
-                                position: 0,
-                                message: "sheet not found".to_string(),
-                            };
-                        }
-                    };
-                    // table-name => table
-                    let table = self.tables.get(&table_name).unwrap_or_else(|| {
-                        panic!(
+                let context = &self.context;
+                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                    Some(i) => i,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: "sheet not found".to_string(),
+                        };
+                    }
+                };
+                // table-name => table
+                let table = match self.tables.get(&table_name) {
+                    Some(t) => t,
+                    None => {
+                        let message = format!(
                            "Table not found: '{table_name}' at '{}!{}{}'",
                            context.sheet,
-                            number_to_column(context.column).expect(""),
+                            number_to_column(context.column)
+                                .unwrap_or(format!("{}", context.column)),
                            context.row
-                        )
-                    });
-                    let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
-                        Some(i) => i,
-                        None => {
-                            return Node::ParseErrorKind {
-                                formula: self.lexer.get_formula(),
-                                position: 0,
-                                message: "sheet not found".to_string(),
-                            };
-                        }
-                    };
+                        );
+                        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 => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: "sheet not found".to_string(),
+                        };
+                    }
+                };

-                    let sheet_name = if table_sheet_index == context_sheet_index {
-                        None
-                    } else {
-                        Some(table.sheet_name.clone())
-                    };
+                let sheet_name = if table_sheet_index == context_sheet_index {
+                    None
+                } else {
+                    Some(table.sheet_name.clone())
+                };

-                    // context must be with tables.reference
-                    let (column_start, mut row_start, column_end, mut row_end) =
-                        parse_range(&table.reference).expect("Failed parsing range");
+                // 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");

-                    let totals_row_count = table.totals_row_count as i32;
-                    let header_row_count = table.header_row_count as i32;
-                    row_end -= totals_row_count;
+                let totals_row_count = table.totals_row_count as i32;
+                let header_row_count = table.header_row_count as i32;
+                row_end -= totals_row_count;

-                    match specifier {
-                        Some(token::TableSpecifier::ThisRow) => {
-                            row_start = context.row;
-                            row_end = context.row;
-                        }
-                        Some(token::TableSpecifier::Totals) => {
-                            if totals_row_count != 0 {
-                                row_start = row_end + 1;
-                                row_end = row_start;
-                            } else {
-                                // Table1[#Totals] is #REF! if Table1 does not have totals
-                                return Node::ErrorKind(token::Error::REF);
-                            }
-                        }
-                        Some(token::TableSpecifier::Headers) => {
+                match specifier {
+                    Some(token::TableSpecifier::ThisRow) => {
+                        row_start = context.row;
+                        row_end = context.row;
+                    }
+                    Some(token::TableSpecifier::Totals) => {
+                        if totals_row_count != 0 {
+                            row_start = row_end + 1;
                            row_end = row_start;
-                        }
-                        Some(token::TableSpecifier::Data) => {
-                            row_start += header_row_count;
-                        }
-                        Some(token::TableSpecifier::All) => {
-                            if totals_row_count != 0 {
-                                row_end += 1;
-                            }
-                        }
-                        None => {
-                            // skip the headers
-                            row_start += header_row_count;
+                        } else {
+                            // Table1[#Totals] is #REF! if Table1 does not have totals
+                            return Node::ErrorKind(token::Error::REF);
                        }
                    }
-                    match table_reference {
-                        None => {
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: column_start,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: column_end,
-                            };
-                        }
-                        Some(TableReference::ColumnReference(s)) => {
-                            let column_index = match get_table_column_by_name(&s, table) {
-                                Some(s) => s + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {s} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-                            if row_start == row_end {
-                                return Node::ReferenceKind {
-                                    sheet_name,
-                                    sheet_index: table_sheet_index,
-                                    absolute_row: true,
-                                    absolute_column: true,
-                                    row: row_start,
-                                    column: column_index,
-                                };
-                            }
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: column_index,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: column_index,
-                            };
-                        }
-                        Some(TableReference::RangeReference((left, right))) => {
-                            let left_column_index = match get_table_column_by_name(&left, table) {
-                                Some(f) => f + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {left} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-
-                            let right_column_index = match get_table_column_by_name(&right, table) {
-                                Some(f) => f + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {right} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: left_column_index,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: right_column_index,
-                            };
+                    Some(token::TableSpecifier::Headers) => {
+                        row_end = row_start;
+                    }
+                    Some(token::TableSpecifier::Data) => {
+                        row_start += header_row_count;
+                    }
+                    Some(token::TableSpecifier::All) => {
+                        if totals_row_count != 0 {
+                            row_end += 1;
                        }
                    }
+                    None => {
+                        // skip the headers
+                        row_start += header_row_count;
+                    }
                }
-                Node::ParseErrorKind {
-                    formula: self.lexer.get_formula(),
-                    position: 0,
-                    message: "Structured references not supported in R1C1 mode".to_string(),
+                match table_reference {
+                    None => Node::RangeKind {
+                        sheet_name,
+                        sheet_index: table_sheet_index,
+                        absolute_row1: true,
+                        absolute_column1: true,
+                        row1: row_start,
+                        column1: column_start,
+                        absolute_row2: true,
+                        absolute_column2: true,
+                        row2: row_end,
+                        column2: column_end,
+                    },
+                    Some(TableReference::ColumnReference(s)) => {
+                        let column_index = match get_table_column_by_name(&s, table) {
+                            Some(s) => s + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!("Expecting column: {s} in table {table_name}"),
+                                };
+                            }
+                        };
+                        if row_start == row_end {
+                            return Node::ReferenceKind {
+                                sheet_name,
+                                sheet_index: table_sheet_index,
+                                absolute_row: true,
+                                absolute_column: true,
+                                row: row_start,
+                                column: column_index,
+                            };
+                        }
+                        Node::RangeKind {
+                            sheet_name,
+                            sheet_index: table_sheet_index,
+                            absolute_row1: true,
+                            absolute_column1: true,
+                            row1: row_start,
+                            column1: column_index,
+                            absolute_row2: true,
+                            absolute_column2: true,
+                            row2: row_end,
+                            column2: column_index,
+                        }
+                    }
+                    Some(TableReference::RangeReference((left, right))) => {
+                        let left_column_index = match get_table_column_by_name(&left, table) {
+                            Some(f) => f + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!(
+                                        "Expecting column: {left} in table {table_name}"
+                                    ),
+                                };
+                            }
+                        };
+
+                        let right_column_index = match get_table_column_by_name(&right, table) {
+                            Some(f) => f + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!(
+                                        "Expecting column: {right} in table {table_name}"
+                                    ),
+                                };
+                            }
+                        };
+                        Node::RangeKind {
+                            sheet_name,
+                            sheet_index: table_sheet_index,
+                            absolute_row1: true,
+                            absolute_column1: true,
+                            row1: row_start,
+                            column1: left_column_index,
+                            absolute_row2: true,
+                            absolute_column2: true,
+                            row2: row_end,
+                            column2: right_column_index,
+                        }
+                    }
                }
            }
        }
--- a/base/src/expressions/parser/move_formula.rs
+++ b/base/src/expressions/parser/move_formula.rs
@@ -375,7 +375,9 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
            }
            format!("{{{}}}", arguments)
        }
-        VariableKind(value) => value.to_string(),
+        DefinedNameKind((name, _)) => name.to_string(),
+        TableNameKind(name) => name.to_string(),
+        WrongVariableKind(name) => name.to_string(),
        CompareKind { kind, left, right } => format!(
            "{}{}{}",
            to_string_moved(left, move_context),
--- a/base/src/expressions/parser/stringify.rs
+++ b/base/src/expressions/parser/stringify.rs
@@ -456,11 +456,69 @@ fn stringify(
            };
            format!("{}{}{}", x, kind, y)
        }
-        OpPowerKind { left, right } => format!(
-            "{}^{}",
-            stringify(left, context, displace_data, use_original_name),
-            stringify(right, context, displace_data, use_original_name)
-        ),
+        OpPowerKind { left, right } => {
+            let x = match **left {
+                BooleanKind(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | DefinedNameKind(_)
+                | TableNameKind(_)
+                | WrongVariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(left, context, displace_data, use_original_name)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(left, context, displace_data, use_original_name)
+                ),
+            };
+            let y = match **right {
+                BooleanKind(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | DefinedNameKind(_)
+                | TableNameKind(_)
+                | WrongVariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(right, context, displace_data, use_original_name)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(right, context, displace_data, use_original_name)
+                ),
+            };
+            format!("{}^{}", x, y)
+        }
        InvalidFunctionKind { name, args } => {
            format_function(name, args, context, displace_data, use_original_name)
        }
@@ -489,7 +547,9 @@ fn stringify(
            }
            format!("{{{}}}", arguments)
        }
-        VariableKind(value) => value.to_string(),
+        TableNameKind(value) => value.to_string(),
+        DefinedNameKind((name, _)) => name.to_string(),
+        WrongVariableKind(name) => name.to_string(),
        UnaryKind { kind, right } => match kind {
            OpUnary::Minus => {
                format!(
@@ -606,7 +666,90 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
        Node::ErrorKind(_) => {}
        Node::ParseErrorKind { .. } => {}
        Node::ArrayKind(_) => {}
-        Node::VariableKind(_) => {}
+        Node::DefinedNameKind(_) => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
        Node::EmptyArgKind => {}
    }
 }
+
+pub(crate) fn rename_defined_name_in_node(
+    node: &mut Node,
+    name: &str,
+    scope: Option<u32>,
+    new_name: &str,
+) {
+    match node {
+        // Rename
+        Node::DefinedNameKind((n, s)) => {
+            if name.to_lowercase() == n.to_lowercase() && *s == scope {
+                *n = new_name.to_string();
+            }
+        }
+        // Go next level
+        Node::OpRangeKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpConcatenateKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpSumKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpProductKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpPowerKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::FunctionKind { kind: _, args } => {
+            for arg in args {
+                rename_defined_name_in_node(arg, name, scope, new_name);
+            }
+        }
+        Node::InvalidFunctionKind { name: _, args } => {
+            for arg in args {
+                rename_defined_name_in_node(arg, name, scope, new_name);
+            }
+        }
+        Node::CompareKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::UnaryKind { kind: _, right } => {
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+
+        // Do nothing
+        Node::BooleanKind(_) => {}
+        Node::NumberKind(_) => {}
+        Node::StringKind(_) => {}
+        Node::ErrorKind(_) => {}
+        Node::ParseErrorKind { .. } => {}
+        Node::ArrayKind(_) => {}
+        Node::EmptyArgKind => {}
+        Node::ReferenceKind { .. } => {}
+        Node::RangeKind { .. } => {}
+        Node::WrongReferenceKind { .. } => {}
+        Node::WrongRangeKind { .. } => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
+    }
+}
--- a/base/src/expressions/parser/tests/mod.rs
+++ b/base/src/expressions/parser/tests/mod.rs
@@ -0,0 +1,6 @@
+mod test_general;
+mod test_issue_155;
+mod test_move_formula;
+mod test_ranges;
+mod test_stringify;
+mod test_tables;
--- a/base/src/expressions/parser/tests/test_general.rs
+++ b/base/src/expressions/parser/tests/test_general.rs
@@ -1,17 +1,13 @@
+#![allow(clippy::panic)]
+
 use std::collections::HashMap;

 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::DisplaceData;
-
-use super::super::types::CellReferenceRC;
-use super::Parser;
-use super::{
-    super::parser::{
-        stringify::{to_rc_format, to_string},
-        Node,
-    },
-    stringify::to_string_displaced,
+use crate::expressions::parser::stringify::{
+    to_rc_format, to_string, to_string_displaced, DisplaceData,
 };
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;

 struct Formula<'a> {
    initial: &'a str,
@@ -21,7 +17,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_reference() {
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -29,14 +25,14 @@ fn test_parser_reference() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("A2", &Some(cell_reference));
+    let t = parser.parse("A2", &cell_reference);
    assert_eq!(to_rc_format(&t), "R[1]C[0]");
 }

 #[test]
 fn test_parser_absolute_column() {
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -44,14 +40,14 @@ fn test_parser_absolute_column() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("$A1", &Some(cell_reference));
+    let t = parser.parse("$A1", &cell_reference);
    assert_eq!(to_rc_format(&t), "R[0]C1");
 }

 #[test]
 fn test_parser_absolute_row_col() {
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -59,14 +55,14 @@ fn test_parser_absolute_row_col() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("$C$5", &Some(cell_reference));
+    let t = parser.parse("$C$5", &cell_reference);
    assert_eq!(to_rc_format(&t), "R5C3");
 }

 #[test]
 fn test_parser_absolute_row_col_1() {
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -74,14 +70,14 @@ fn test_parser_absolute_row_col_1() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("$A$1", &Some(cell_reference));
+    let t = parser.parse("$A$1", &cell_reference);
    assert_eq!(to_rc_format(&t), "R1C1");
 }

 #[test]
 fn test_parser_simple_formula() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -90,14 +86,14 @@ fn test_parser_simple_formula() {
        column: 1,
    };

-    let t = parser.parse("C3+Sheet2!D4", &Some(cell_reference));
+    let t = parser.parse("C3+Sheet2!D4", &cell_reference);
    assert_eq!(to_rc_format(&t), "R[2]C[2]+Sheet2!R[3]C[3]");
 }

 #[test]
 fn test_parser_boolean() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -106,14 +102,14 @@ fn test_parser_boolean() {
        column: 1,
    };

-    let t = parser.parse("true", &Some(cell_reference));
+    let t = parser.parse("true", &cell_reference);
    assert_eq!(to_rc_format(&t), "TRUE");
 }

 #[test]
 fn test_parser_bad_formula() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -121,7 +117,7 @@ fn test_parser_bad_formula() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("#Value", &Some(cell_reference));
+    let t = parser.parse("#Value", &cell_reference);
    match &t {
        Node::ParseErrorKind {
            formula,
@@ -142,7 +138,7 @@ fn test_parser_bad_formula() {
 #[test]
 fn test_parser_bad_formula_1() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -150,7 +146,7 @@ fn test_parser_bad_formula_1() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("<5", &Some(cell_reference));
+    let t = parser.parse("<5", &cell_reference);
    match &t {
        Node::ParseErrorKind {
            formula,
@@ -171,7 +167,7 @@ fn test_parser_bad_formula_1() {
 #[test]
 fn test_parser_bad_formula_2() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -179,7 +175,7 @@ fn test_parser_bad_formula_2() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("*5", &Some(cell_reference));
+    let t = parser.parse("*5", &cell_reference);
    match &t {
        Node::ParseErrorKind {
            formula,
@@ -200,7 +196,7 @@ fn test_parser_bad_formula_2() {
 #[test]
 fn test_parser_bad_formula_3() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -208,7 +204,7 @@ fn test_parser_bad_formula_3() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("SUM(#VALVE!)", &Some(cell_reference));
+    let t = parser.parse("SUM(#VALVE!)", &cell_reference);
    match &t {
        Node::ParseErrorKind {
            formula,
@@ -229,7 +225,7 @@ fn test_parser_bad_formula_3() {
 #[test]
 fn test_parser_formulas() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    let formulas = vec![
        Formula {
@@ -263,11 +259,11 @@ fn test_parser_formulas() {
    for formula in formulas {
        let t = parser.parse(
            formula.initial,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                sheet: "Sheet1".to_string(),
                row: 1,
                column: 1,
-            }),
+            },
        );
        assert_eq!(to_rc_format(&t), formula.expected);
        assert_eq!(to_string(&t, &cell_reference), formula.initial);
@@ -277,7 +273,7 @@ fn test_parser_formulas() {
 #[test]
 fn test_parser_r1c1_formulas() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
    parser.set_lexer_mode(LexerMode::R1C1);

    let formulas = vec![
@@ -328,11 +324,11 @@ fn test_parser_r1c1_formulas() {
    for formula in formulas {
        let t = parser.parse(
            formula.initial,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                sheet: "Sheet1".to_string(),
                row: 1,
                column: 1,
-            }),
+            },
        );
        assert_eq!(to_string(&t, &cell_reference), formula.expected);
        assert_eq!(to_rc_format(&t), formula.initial);
@@ -342,7 +338,7 @@ fn test_parser_r1c1_formulas() {
 #[test]
 fn test_parser_quotes() {
    let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -351,14 +347,14 @@ fn test_parser_quotes() {
        column: 1,
    };

-    let t = parser.parse("C3+'Second Sheet'!D4", &Some(cell_reference));
+    let t = parser.parse("C3+'Second Sheet'!D4", &cell_reference);
    assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second Sheet'!R[3]C[3]");
 }

 #[test]
 fn test_parser_escape_quotes() {
    let worksheets = vec!["Sheet1".to_string(), "Second '2' Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -367,14 +363,14 @@ fn test_parser_escape_quotes() {
        column: 1,
    };

-    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(cell_reference));
+    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &cell_reference);
    assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second ''2'' Sheet'!R[3]C[3]");
 }

 #[test]
 fn test_parser_parenthesis() {
    let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -383,14 +379,14 @@ fn test_parser_parenthesis() {
        column: 1,
    };

-    let t = parser.parse("(C3=\"Yes\")*5", &Some(cell_reference));
+    let t = parser.parse("(C3=\"Yes\")*5", &cell_reference);
    assert_eq!(to_rc_format(&t), "(R[2]C[2]=\"Yes\")*5");
 }

 #[test]
 fn test_parser_excel_xlfn() {
    let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -399,7 +395,7 @@ fn test_parser_excel_xlfn() {
        column: 1,
    };

-    let t = parser.parse("_xlfn.CONCAT(C3)", &Some(cell_reference));
+    let t = parser.parse("_xlfn.CONCAT(C3)", &cell_reference);
    assert_eq!(to_rc_format(&t), "CONCAT(R[2]C[2])");
 }

@@ -411,9 +407,9 @@ fn test_to_string_displaced() {
        column: 1,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
    let displace_data = DisplaceData::Column {
        sheet: 0,
        column: 1,
@@ -431,9 +427,9 @@ fn test_to_string_displaced_full_ranges() {
        column: 1,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

-    let node = parser.parse("SUM(3:3)", &Some(context.clone()));
+    let node = parser.parse("SUM(3:3)", context);
    let displace_data = DisplaceData::Column {
        sheet: 0,
        column: 1,
@@ -444,7 +440,7 @@ fn test_to_string_displaced_full_ranges() {
        "SUM(3:3)".to_string()
    );

-    let node = parser.parse("SUM(D:D)", &Some(context.clone()));
+    let node = parser.parse("SUM(D:D)", context);
    let displace_data = DisplaceData::Row {
        sheet: 0,
        row: 3,
@@ -464,9 +460,9 @@ fn test_to_string_displaced_too_low() {
        column: 1,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
    let displace_data = DisplaceData::Column {
        sheet: 0,
        column: 1,
@@ -484,9 +480,9 @@ fn test_to_string_displaced_too_high() {
        column: 1,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
    let displace_data = DisplaceData::Column {
        sheet: 0,
        column: 1,
--- a/base/src/expressions/parser/tests/test_issue_155.rs
+++ b/base/src/expressions/parser/tests/test_issue_155.rs
@@ -0,0 +1,69 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn issue_155_parser() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 2,
+        column: 2,
+    };
+    let t = parser.parse("A$1:A2", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "A$1:A2");
+}
+
+#[test]
+fn issue_155_parser_case_2() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    let t = parser.parse("C$1:D2", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "C$1:D2");
+}
+
+#[test]
+fn issue_155_parser_only_row() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("A$2:B1", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "A1:B$2");
+}
+
+#[test]
+fn issue_155_parser_only_column() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("D1:$A3", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
+}
--- a/base/src/expressions/parser/tests/test_move_formula.rs
+++ b/base/src/expressions/parser/tests/test_move_formula.rs
@@ -1,10 +1,8 @@
 use std::collections::HashMap;

 use crate::expressions::parser::move_formula::{move_formula, MoveContext};
-use crate::expressions::types::Area;
-
-use super::super::types::CellReferenceRC;
-use super::Parser;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::{Area, CellReferenceRC};

 #[test]
 fn test_move_formula() {
@@ -17,7 +15,7 @@ fn test_move_formula() {
        column,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Area is C2:F6
    let area = &Area {
@@ -29,7 +27,7 @@ fn test_move_formula() {
    };

    // formula AB31 will not change
-    let node = parser.parse("AB31", &Some(context.clone()));
+    let node = parser.parse("AB31", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -45,7 +43,7 @@ fn test_move_formula() {
    assert_eq!(t, "AB31");

    // formula $AB$31 will not change
-    let node = parser.parse("AB31", &Some(context.clone()));
+    let node = parser.parse("AB31", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -61,7 +59,7 @@ fn test_move_formula() {
    assert_eq!(t, "AB31");

    // but formula D5 will change to N15  (N = D + 10)
-    let node = parser.parse("D5", &Some(context.clone()));
+    let node = parser.parse("D5", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -77,7 +75,7 @@ fn test_move_formula() {
    assert_eq!(t, "N15");

    // Also formula $D$5 will change to N15  (N = D + 10)
-    let node = parser.parse("$D$5", &Some(context.clone()));
+    let node = parser.parse("$D$5", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -104,7 +102,7 @@ fn test_move_formula_context_offset() {
        column,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Area is C2:F6
    let area = &Area {
@@ -115,7 +113,7 @@ fn test_move_formula_context_offset() {
        height: 5,
    };

-    let node = parser.parse("-X9+C2%", &Some(context.clone()));
+    let node = parser.parse("-X9+C2%", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -142,7 +140,7 @@ fn test_move_formula_area_limits() {
        column,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Area is C2:F6
    let area = &Area {
@@ -154,7 +152,7 @@ fn test_move_formula_area_limits() {
    };

    // Outside of the area. Not moved
-    let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
+    let node = parser.parse("B2+B3+C1+G6+H5", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -170,7 +168,7 @@ fn test_move_formula_area_limits() {
    assert_eq!(t, "B2+B3+C1+G6+H5");

    // In the area. Moved
-    let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
+    let node = parser.parse("C2+F4+F5+F6", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -197,7 +195,7 @@ fn test_move_formula_ranges() {
        column,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    let area = &Area {
        sheet: 0,
@@ -207,7 +205,7 @@ fn test_move_formula_ranges() {
        height: 5,
    };
    // Ranges inside the area are fully displaced (absolute or not)
-    let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
+    let node = parser.parse("SUM(C2:F5)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -222,7 +220,7 @@ fn test_move_formula_ranges() {
    );
    assert_eq!(t, "SUM(M12:P15)");

-    let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
+    let node = parser.parse("SUM($C$2:$F$5)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -238,7 +236,7 @@ fn test_move_formula_ranges() {
    assert_eq!(t, "SUM($M$12:$P$15)");

    // Ranges completely outside of the area are not touched
-    let node = parser.parse("SUM(A1:B3)", &Some(context.clone()));
+    let node = parser.parse("SUM(A1:B3)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -253,7 +251,7 @@ fn test_move_formula_ranges() {
    );
    assert_eq!(t, "SUM(A1:B3)");

-    let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
+    let node = parser.parse("SUM($A$1:$B$3)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -269,7 +267,7 @@ fn test_move_formula_ranges() {
    assert_eq!(t, "SUM($A$1:$B$3)");

    // Ranges that overlap with the area are also NOT displaced
-    let node = parser.parse("SUM(A1:F5)", &Some(context.clone()));
+    let node = parser.parse("SUM(A1:F5)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -285,7 +283,7 @@ fn test_move_formula_ranges() {
    assert_eq!(t, "SUM(A1:F5)");

    // Ranges that contain the area are also NOT displaced
-    let node = parser.parse("SUM(A1:X50)", &Some(context.clone()));
+    let node = parser.parse("SUM(A1:X50)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -320,10 +318,10 @@ fn test_move_formula_wrong_reference() {
        height: 5,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Wrong formulas will NOT be displaced
-    let node = parser.parse("Sheet3!AB31", &Some(context.clone()));
+    let node = parser.parse("Sheet3!AB31", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -337,7 +335,7 @@ fn test_move_formula_wrong_reference() {
        },
    );
    assert_eq!(t, "Sheet3!AB31");
-    let node = parser.parse("Sheet3!$X$9", &Some(context.clone()));
+    let node = parser.parse("Sheet3!$X$9", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -352,7 +350,7 @@ fn test_move_formula_wrong_reference() {
    );
    assert_eq!(t, "Sheet3!$X$9");

-    let node = parser.parse("SUM(Sheet3!D2:D3)", &Some(context.clone()));
+    let node = parser.parse("SUM(Sheet3!D2:D3)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -379,7 +377,7 @@ fn test_move_formula_misc() {
        column,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Area is C2:F6
    let area = &Area {
@@ -389,7 +387,7 @@ fn test_move_formula_misc() {
        width: 4,
        height: 5,
    };
-    let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
+    let node = parser.parse("X9^C2-F4*H2", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -404,7 +402,7 @@ fn test_move_formula_misc() {
    );
    assert_eq!(t, "X9^M12-P14*H2");

-    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
+    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -419,7 +417,7 @@ fn test_move_formula_misc() {
    );
    assert_eq!(t, "P15*(-N15)*SUM(A1,X9,$N$15)");

-    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
+    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", context);
    let t = move_formula(
        &node,
        &MoveContext {
@@ -447,7 +445,7 @@ fn test_move_formula_another_sheet() {
    };
    // we add two sheets and we cut/paste from Sheet1 to Sheet2
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Area is C2:F6
    let area = &Area {
@@ -459,10 +457,7 @@ fn test_move_formula_another_sheet() {
    };

    // Formula AB31 and JJ3:JJ4 refers to original Sheet1!AB31 and Sheet1!JJ3:JJ4
-    let node = parser.parse(
-        "AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
-        &Some(context.clone()),
-    );
+    let node = parser.parse("AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)", context);
    let t = move_formula(
        &node,
        &MoveContext {
--- a/base/src/expressions/parser/tests/test_ranges.rs
+++ b/base/src/expressions/parser/tests/test_ranges.rs
@@ -2,9 +2,9 @@ use std::collections::HashMap;

 use crate::expressions::lexer::LexerMode;

-use super::super::parser::stringify::{to_rc_format, to_string};
-use super::super::types::CellReferenceRC;
-use super::Parser;
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;

 struct Formula<'a> {
    formula_a1: &'a str,
@@ -14,7 +14,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_formulas_with_full_ranges() {
    let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    let formulas = vec![
        Formula {
@@ -52,11 +52,11 @@ fn test_parser_formulas_with_full_ranges() {
    for formula in &formulas {
        let t = parser.parse(
            formula.formula_a1,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                sheet: "Sheet1".to_string(),
                row: 1,
                column: 1,
-            }),
+            },
        );
        assert_eq!(to_rc_format(&t), formula.formula_r1c1);
        assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
@@ -67,11 +67,11 @@ fn test_parser_formulas_with_full_ranges() {
    for formula in &formulas {
        let t = parser.parse(
            formula.formula_r1c1,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                sheet: "Sheet1".to_string(),
                row: 1,
                column: 1,
-            }),
+            },
        );
        assert_eq!(to_rc_format(&t), formula.formula_r1c1);
        assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
@@ -81,7 +81,7 @@ fn test_parser_formulas_with_full_ranges() {
 #[test]
 fn test_range_inverse_order() {
    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -93,7 +93,7 @@ fn test_range_inverse_order() {
    // D4:C2 => C2:D4
    let t = parser.parse(
        "SUM(D4:C2)*SUM(Sheet2!D4:C20)*SUM($C$20:D4)",
-        &Some(cell_reference.clone()),
+        &cell_reference,
    );
    assert_eq!(
        to_string(&t, &cell_reference),
--- a/base/src/expressions/parser/tests/test_stringify.rs
+++ b/base/src/expressions/parser/tests/test_stringify.rs
@@ -0,0 +1,34 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn exp_order() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("(1 + 2)^3  + 4", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
+
+    let t = parser.parse("(C5 + 3)^R4", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
+
+    let t = parser.parse("(C5 + 3)^(R4*6)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
+
+    let t = parser.parse("(C5)^(R4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "C5^R4");
+
+    let t = parser.parse("(5)^(4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "5^4");
+}
--- a/base/src/expressions/parser/tests/test_tables.rs
+++ b/base/src/expressions/parser/tests/test_tables.rs
@@ -6,8 +6,8 @@ use crate::expressions::parser::stringify::to_string;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};

-use super::super::types::CellReferenceRC;
-use super::Parser;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;

 fn create_test_table(
    table_name: &str,
@@ -63,7 +63,7 @@ fn simple_table() {
    let row_count = 3;
    let tables = create_test_table("tblIncome", &column_names, "A1", row_count);

-    let mut parser = Parser::new(worksheets, tables);
+    let mut parser = Parser::new(worksheets, vec![], tables);
    // Reference cell is 'Sheet One'!F2
    let cell_reference = CellReferenceRC {
        sheet: "Sheet One".to_string(),
@@ -72,7 +72,7 @@ fn simple_table() {
    };

    let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
    assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");

    // Cell A3
@@ -82,7 +82,7 @@ fn simple_table() {
        column: 1,
    };
    let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
    assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");

    // Cell A3 in 'Second Sheet'
@@ -92,7 +92,7 @@ fn simple_table() {
        column: 1,
    };
    let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
    assert_eq!(
        to_string(&t, &cell_reference),
        "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"
--- a/base/src/expressions/parser/walk.rs
+++ b/base/src/expressions/parser/walk.rs
@@ -263,7 +263,9 @@ pub(crate) fn forward_references(
        // TODO: Not implemented
        Node::ArrayKind(_) => {}
        // Do nothing. Note: we could do a blanket _ => {}
-        Node::VariableKind(_) => {}
+        Node::DefinedNameKind(_) => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
        Node::ErrorKind(_) => {}
        Node::ParseErrorKind { .. } => {}
        Node::EmptyArgKind => {}
--- a/base/src/expressions/token.rs
+++ b/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,
--- a/base/src/formatter/dates.rs
+++ b/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)
 }
--- a/base/src/formatter/format.rs
+++ b/base/src/formatter/format.rs
@@ -245,6 +245,9 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
        }
        ParsePart::Number(p) => {
            let mut text = "".to_string();
+            if let Some(c) = p.currency {
+                text = format!("{}", c);
+            }
            let tokens = &p.tokens;
            value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
            // p.precision is the number of significant digits _after_ the decimal point
--- a/base/src/formatter/lexer.rs
+++ b/base/src/formatter/lexer.rs
@@ -10,6 +10,7 @@ pub struct Lexer {
 pub enum Token {
    Color(i32),              // [Red] or [Color 23]
    Condition(Compare, f64), // [<=100] (Comparator, number)
+    Currency(char),          // [$€] ($ currency symbol)
    Literal(char), // €, $, (, ), /, :, +, -, ^, ', {, }, <, =, !, ~, > and space or scaped \X
    Spacer(char),  // *X
    Ghost(char),   // _X
@@ -274,6 +275,15 @@ impl Lexer {
                                self.set_error("Failed to parse condition");
                                Token::ILLEGAL
                            }
+                        } else if c == '$' {
+                            // currency
+                            self.read_next_char();
+                            if let Some(currency) = self.read_next_char() {
+                                self.read_next_char();
+                                return Token::Currency(currency);
+                            }
+                            self.set_error("Failed to parse currency");
+                            Token::ILLEGAL
                        } else {
                            // Color
                            if let Some(index) = self.consume_color() {
--- a/base/src/formatter/mod.rs
+++ b/base/src/formatter/mod.rs
@@ -74,6 +74,7 @@ mod test;
 //
 // * Color [Red] or [Color 23] or [Color23]
 // * Conditions [<100]
+// * Currency [$€]
 // * Space _X when X is any given char
 // * A spacer of chars: *X where X is repeated as much as possible
 // * Literals: $, (, ), :, +, - and space
--- a/base/src/formatter/parser.rs
+++ b/base/src/formatter/parser.rs
@@ -40,6 +40,7 @@ pub struct NumberPart {
    pub is_scientific: bool,
    pub scientific_minus: bool,
    pub exponent_digit_count: i32,
+    pub currency: Option<char>,
 }

 pub struct DatePart {
@@ -114,6 +115,7 @@ impl Parser {
        let mut exponent_digit_count = 0;
        let mut number = 'i';
        let mut index = 0;
+        let mut currency = None;

        while token != Token::EOF && token != Token::Separator {
            let next_token = self.lexer.next_token();
@@ -170,6 +172,9 @@ impl Parser {
                Token::Condition(cmp, value) => {
                    condition = Some((cmp, value));
                }
+                Token::Currency(c) => {
+                    currency = Some(c);
+                }
                Token::QuestionMark => {
                    tokens.push(TextToken::Digit(Digit {
                        kind: '?',
@@ -291,6 +296,7 @@ impl Parser {
                is_scientific,
                scientific_minus,
                exponent_digit_count,
+                currency,
            })
        }
    }
--- a/base/src/formatter/test/test_general.rs
+++ b/base/src/formatter/test/test_general.rs
@@ -76,6 +76,14 @@ fn test_color() {
    assert_eq!(format_number(3.1, "[blue]0.00", locale).color, Some(4));
 }

+#[test]
+fn dollar_euro() {
+    let locale = get_default_locale();
+    let format = "[$€]#,##0.00";
+    let t = format_number(3.1, format, locale);
+    assert_eq!(t.text, "€3.10");
+}
+
 #[test]
 fn test_parts() {
    let locale = get_default_locale();
--- a/base/src/functions/engineering/transcendental/test_bessel.rs
+++ b/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 {
--- a/base/src/functions/financial.rs
+++ b/base/src/functions/financial.rs
@@ -89,6 +89,9 @@ fn compute_future_value(
    if rate == 0.0 {
        return Ok(-pv - pmt * nper);
    }
+    if rate == -1.0 && nper < 0.0 {
+        return Err((Error::DIV, "Divide by zero".to_string()));
+    }

    let rate_nper = (1.0 + rate).powf(nper);
    let fv = if period_start {
@@ -194,16 +197,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
-    // They are really similar expect for small issues
-    fn get_array_of_numbers(
+    fn get_array_of_numbers_generic(
        &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 +223,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 +231,46 @@ impl Model {
                if row1 == 1 && row2 == LAST_ROW {
                    row2 = self
                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .worksheet(sheet)
+                        .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)
-                        .expect("Sheet expected during evaluation.")
+                        .worksheet(sheet)
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{}'", sheet),
+                            )
+                        })?
                        .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);
-                            }
+                for row in row1..=row2 {
+                    for column in column1..=column2 {
+                        let cell_ref = CellReferenceIndex { sheet, row, column };
+                        match self.evaluate_cell(cell_ref) {
+                            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 +278,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();
-        match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) => values.push(value),
-            CalcResult::Range { left, right } => {
-                if left.sheet != right.sheet {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        *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,
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            true, // accept_number_node
+            || {
+                Err(CalcResult::new_error(
+                    Error::NUM,
                    *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 +330,19 @@ impl Model {
        arg: &Node,
        cell: &CellReferenceIndex,
    ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
-        match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Range { left, right } => {
-                if left.sheet != right.sheet {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        *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 => 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(
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            false,            // Do not accept a single number node
+            || Ok(Some(0.0)), // Treat empty cells as zero
+            || {
+                Err(CalcResult::new_error(
                    Error::VALUE,
                    *cell,
                    "Expected number".to_string(),
-                ));
-            }
-        };
-        Ok(values)
+                ))
+            },
+        )
    }

    /// PMT(rate, nper, pv, [fv], [type])
@@ -862,20 +801,28 @@ impl Model {
                    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;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    for row in row1..row2 + 1 {
                        for column in column1..(column2 + 1) {
@@ -1393,21 +1340,21 @@ impl Model {
        CalcResult::Number(result)
    }

-    /// This next three functions deal with Treasure Bills or T-Bills for short
-    /// They are zero-coupon that mature in one year or less.
-    ///  Definitions:
-    ///    $r$ be the discount rate
-    ///    $v$ the face value of the Bill
-    ///    $p$ the price of the Bill
-    ///    $d_m$ is the number of days from the settlement to maturity
-    /// Then:
-    ///   $$ 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:
-    /// $$ 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.
-    /// 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) $$
-    /// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
+    // This next three functions deal with Treasure Bills or T-Bills for short
+    // They are zero-coupon that mature in one year or less.
+    //  Definitions:
+    //    $r$ be the discount rate
+    //    $v$ the face value of the Bill
+    //    $p$ the price of the Bill
+    //    $d_m$ is the number of days from the settlement to maturity
+    // Then:
+    //   $$ 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:
+    // $$ 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.
+    // 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) $$
+    // 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 {
--- a/base/src/functions/information.rs
+++ b/base/src/functions/information.rs
@@ -247,45 +247,67 @@ impl Model {
            return CalcResult::Number(cell.sheet as f64 + 1.0);
        }
        // The arg could be a defined name or a table
-        let arg = &args[0];
-        if let Node::VariableKind(name) = arg {
-            // Let's see if it is a defined name
-            if let Some(defined_name) = self.parsed_defined_names.get(&(None, name.to_lowercase()))
-            {
-                match defined_name {
-                    ParsedDefinedName::CellReference(reference) => {
-                        return CalcResult::Number(reference.sheet as f64 + 1.0)
+        // let  = &args[0];
+        match &args[0] {
+            Node::DefinedNameKind((name, scope)) => {
+                // Let's see if it is a defined name
+                if let Some(defined_name) = self
+                    .parsed_defined_names
+                    .get(&(*scope, name.to_lowercase()))
+                {
+                    match defined_name {
+                        ParsedDefinedName::CellReference(reference) => {
+                            return CalcResult::Number(reference.sheet as f64 + 1.0)
+                        }
+                        ParsedDefinedName::RangeReference(range) => {
+                            return CalcResult::Number(range.left.sheet as f64 + 1.0)
+                        }
+                        ParsedDefinedName::InvalidDefinedNameFormula => {
+                            return CalcResult::Error {
+                                error: Error::ERROR,
+                                origin: cell,
+                                message: "Invalid name".to_string(),
+                            };
+                        }
                    }
-                    ParsedDefinedName::RangeReference(range) => {
-                        return CalcResult::Number(range.left.sheet as f64 + 1.0)
-                    }
-                    ParsedDefinedName::InvalidDefinedNameFormula => {
-                        return CalcResult::Error {
-                            error: Error::NA,
-                            origin: cell,
-                            message: "Invalid name".to_string(),
-                        };
+                } else {
+                    // This should never happen
+                    return CalcResult::Error {
+                        error: Error::ERROR,
+                        origin: cell,
+                        message: "Invalid name".to_string(),
+                    };
+                }
+            }
+            Node::TableNameKind(name) => {
+                // Now let's see if it is a table
+                for (table_name, table) in &self.workbook.tables {
+                    if table_name == name {
+                        if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
+                            return CalcResult::Number(sheet_index as f64 + 1.0);
+                        } else {
+                            break;
+                        }
                    }
                }
            }
-            // Now let's see if it is a table
-            for (table_name, table) in &self.workbook.tables {
-                if table_name == name {
-                    if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
-                        return CalcResult::Number(sheet_index as f64 + 1.0);
-                    } else {
-                        break;
-                    }
+            Node::WrongVariableKind(name) => {
+                return CalcResult::Error {
+                    error: Error::NAME,
+                    origin: cell,
+                    message: format!("Name not found: {name}"),
+                }
+            }
+            arg => {
+                // Now it should be the name of a sheet
+                let sheet_name = match self.get_string(arg, cell) {
+                    Ok(s) => s,
+                    Err(e) => return e,
+                };
+                if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
+                    return CalcResult::Number(sheet_index as f64 + 1.0);
                }
            }
-        }
-        // Now it should be the name of a sheet
-        let sheet_name = match self.get_string(arg, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-        if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
-            return CalcResult::Number(sheet_index as f64 + 1.0);
        }
        CalcResult::Error {
            error: Error::NA,
--- a/base/src/functions/logical.rs
+++ b/base/src/functions/logical.rs
@@ -66,88 +66,61 @@ impl Model {
    }

    pub(crate) fn fn_and(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut true_count = 0;
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(b) => {
-                    if !b {
-                        return CalcResult::Boolean(false);
-                    }
-                    true_count += 1;
-                }
-                CalcResult::Number(value) => {
-                    if value == 0.0 {
-                        return CalcResult::Boolean(false);
-                    }
-                    true_count += 1;
-                }
-                CalcResult::String(_value) => {
-                    true_count += 1;
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Boolean(b) => {
-                                    if !b {
-                                        return CalcResult::Boolean(false);
-                                    }
-                                    true_count += 1;
-                                }
-                                CalcResult::Number(value) => {
-                                    if value == 0.0 {
-                                        return CalcResult::Boolean(false);
-                                    }
-                                    true_count += 1;
-                                }
-                                CalcResult::String(_value) => {
-                                    true_count += 1;
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {}
-                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-            };
-        }
-        if true_count == 0 {
-            return CalcResult::new_error(
-                Error::VALUE,
-                cell,
-                "Boolean values not found".to_string(),
-            );
-        }
-        CalcResult::Boolean(true)
+        self.logical_nary(
+            args,
+            cell,
+            |acc, value| acc.unwrap_or(true) && value,
+            Some(false),
+        )
    }

    pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut result = false;
+        self.logical_nary(
+            args,
+            cell,
+            |acc, value| acc.unwrap_or(false) || value,
+            Some(true),
+        )
+    }
+
+    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.logical_nary(args, cell, |acc, value| acc.unwrap_or(false) ^ value, None)
+    }
+
+    /// Base function for AND, OR, XOR. These are all n-ary functions that perform a boolean operation on a series of
+    /// boolean values. These boolean values are sourced from `args`. Note that there is not a 1-1 relationship between
+    /// arguments and boolean values evaluated (see how Ranges are handled for example).
+    ///
+    /// Each argument in `args` is evaluated and the resulting value is interpreted as a boolean as follows:
+    /// - Boolean: The value is used directly.
+    /// - Number: 0 is FALSE, all other values are TRUE.
+    /// - Range: Each cell in the range is evaluated as if they were individual arguments with some caveats
+    /// - Empty arg: FALSE
+    /// - Empty cell & String: Ignored, behaves exactly like the argument wasn't passed in at all
+    /// - Error: Propagated
+    ///
+    /// If no arguments are provided, or all arguments are ignored, the function returns a #VALUE! error
+    ///
+    /// **`fold_fn`:** The function that combines the running result with the next value boolean value. The running result
+    /// starts as `None`.
+    ///
+    /// **`short_circuit_value`:** If the running result reaches `short_circuit_value`, the function returns early.
+    fn logical_nary(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+        fold_fn: fn(Option<bool>, bool) -> bool,
+        short_circuit_value: Option<bool>,
+    ) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let mut result = None;
        for arg in args {
            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(value) => result = value || result,
-                CalcResult::Number(value) => {
-                    if value != 0.0 {
-                        return CalcResult::Boolean(true);
-                    }
-                }
-                CalcResult::String(_value) => {
-                    return CalcResult::Boolean(true);
-                }
+                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
+                CalcResult::Number(value) => result = Some(fold_fn(result, value != 0.0)),
                CalcResult::Range { left, right } => {
                    if left.sheet != right.sheet {
                        return CalcResult::new_error(
@@ -163,94 +136,58 @@ impl Model {
                                row,
                                column,
                            }) {
-                                CalcResult::Boolean(value) => {
-                                    result = value || result;
-                                }
+                                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
                                CalcResult::Number(value) => {
-                                    if value != 0.0 {
-                                        return CalcResult::Boolean(true);
-                                    }
-                                }
-                                CalcResult::String(_value) => {
-                                    return CalcResult::Boolean(true);
+                                    result = Some(fold_fn(result, value != 0.0))
                                }
                                error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {}
-                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                                CalcResult::EmptyArg => {} // unreachable
+                                CalcResult::Range { .. }
+                                | CalcResult::String { .. }
+                                | CalcResult::EmptyCell => {}
+                            }
+                            if let (Some(current_result), Some(short_circuit_value)) =
+                                (result, short_circuit_value)
+                            {
+                                if current_result == short_circuit_value {
+                                    return CalcResult::Boolean(current_result);
+                                }
                            }
                        }
                    }
                }
                error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-            };
-        }
-        CalcResult::Boolean(result)
-    }
-
-    /// XOR(logical1, [logical]*,...)
-    /// Logical1 is required, subsequent logical values are optional. Can be logical values, arrays, or references.
-    /// The result of XOR is TRUE when the number of TRUE inputs is odd and FALSE when the number of TRUE inputs is even.
-    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut true_count = 0;
-        let mut false_count = 0;
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(b) => {
-                    if b {
-                        true_count += 1;
-                    } else {
-                        false_count += 1;
-                    }
-                }
-                CalcResult::Number(value) => {
-                    if value != 0.0 {
-                        true_count += 1;
-                    } else {
-                        false_count += 1;
-                    }
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Boolean(b) => {
-                                    if b {
-                                        true_count += 1;
-                                    } else {
-                                        false_count += 1;
-                                    }
-                                }
-                                CalcResult::Number(value) => {
-                                    if value != 0.0 {
-                                        true_count += 1;
-                                    } else {
-                                        false_count += 1;
-                                    }
-                                }
-                                _ => {}
-                            }
+                CalcResult::EmptyArg => result = Some(result.unwrap_or(false)),
+                // Strings are ignored unless they are "TRUE" or "FALSE" (case insensitive). EXCEPT if the string value
+                // comes from a reference, in which case it is always ignored regardless of its value.
+                CalcResult::String(..) => {
+                    if !matches!(arg, Node::ReferenceKind { .. }) {
+                        if let Ok(f) = self.get_boolean(arg, cell) {
+                            result = Some(fold_fn(result, f));
                        }
                    }
                }
-                _ => {}
-            };
+                // References to empty cells are ignored. If all args are ignored the result is #VALUE!
+                CalcResult::EmptyCell => {}
+            }
+
+            if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
+            {
+                if current_result == short_circuit_value {
+                    return CalcResult::Boolean(current_result);
+                }
+            }
        }
-        if true_count == 0 && false_count == 0 {
-            return CalcResult::new_error(Error::VALUE, cell, "No booleans found".to_string());
+
+        if let Some(result) = result {
+            CalcResult::Boolean(result)
+        } else {
+            CalcResult::new_error(
+                Error::VALUE,
+                cell,
+                "No logical values in argument list".to_string(),
+            )
        }
-        CalcResult::Boolean(true_count % 2 == 1)
    }

    /// =SWITCH(expression, case1, value1, [case, value]*, [default])
--- a/base/src/functions/lookup_and_reference.rs
+++ b/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(),
+            }
+        }
+    }
 }
--- a/base/src/functions/mathematical.rs
+++ b/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
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    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
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    for row in row1..row2 + 1 {
                        for column in column1..(column2 + 1) {
--- a/base/src/functions/mod.rs
+++ b/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,
@@ -138,6 +140,7 @@ pub enum Function {
    Countifs,
    Maxifs,
    Minifs,
+    Geomean,

    // Date and time
    Date,
@@ -246,7 +249,7 @@ pub enum Function {
 }

 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 192> {
+    pub fn into_iter() -> IntoIter<Function, 195> {
        [
            Function::And,
            Function::False,
@@ -316,6 +319,7 @@ impl Function {
            Function::Search,
            Function::Text,
            Function::Trim,
+            Function::Unicode,
            Function::Upper,
            Function::Isnumber,
            Function::Isnontext,
@@ -330,6 +334,7 @@ impl Function {
            Function::Isodd,
            Function::Iseven,
            Function::ErrorType,
+            Function::Formulatext,
            Function::Isformula,
            Function::Type,
            Function::Sheet,
@@ -344,6 +349,7 @@ impl Function {
            Function::Countifs,
            Function::Maxifs,
            Function::Minifs,
+            Function::Geomean,
            Function::Year,
            Function::Day,
            Function::Month,
@@ -460,6 +466,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 +486,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 +575,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 +597,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),
@@ -603,6 +613,7 @@ impl Function {
            "COUNTIFS" => Some(Function::Countifs),
            "MAXIFS" | "_XLFN.MAXIFS" => Some(Function::Maxifs),
            "MINIFS" | "_XLFN.MINIFS" => Some(Function::Minifs),
+            "GEOMEAN" => Some(Function::Geomean),
            // Date and Time
            "YEAR" => Some(Function::Year),
            "DAY" => Some(Function::Day),
@@ -779,6 +790,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 +805,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"),
@@ -808,6 +821,7 @@ impl fmt::Display for Function {
            Function::Countifs => write!(f, "COUNTIFS"),
            Function::Maxifs => write!(f, "MAXIFS"),
            Function::Minifs => write!(f, "MINIFS"),
+            Function::Geomean => write!(f, "GEOMEAN"),
            Function::Year => write!(f, "YEAR"),
            Function::Day => write!(f, "DAY"),
            Function::Month => write!(f, "MONTH"),
@@ -1012,6 +1026,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 +1042,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),
@@ -1042,6 +1058,7 @@ impl Model {
            Function::Countifs => self.fn_countifs(args, cell),
            Function::Maxifs => self.fn_maxifs(args, cell),
            Function::Minifs => self.fn_minifs(args, cell),
+            Function::Geomean => self.fn_geomean(args, cell),
            // Date and Time
            Function::Year => self.fn_year(args, cell),
            Function::Day => self.fn_day(args, cell),
@@ -1148,6 +1165,7 @@ impl Model {

 #[cfg(test)]
 mod tests {
+    #![allow(clippy::unwrap_used)]
    use std::{
        fs::File,
        io::{BufRead, BufReader},
--- a/base/src/functions/statistical.rs
+++ b/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
-            .workbook
-            .worksheet(first_range.left.sheet)
-            .expect("Sheet expected during evaluation.")
-            .dimension();
+        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
+            Ok(s) => s.dimension(),
+            Err(_) => {
+                return CalcResult::new_error(
+                    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
-                .workbook
-                .worksheet(sum_range.left.sheet)
-                .expect("Sheet expected during evaluation.")
-                .dimension()
-                .max_row;
+            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_row,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
        }
        if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = self
-                .workbook
-                .worksheet(sum_range.left.sheet)
-                .expect("Sheet expected during evaluation.")
-                .dimension()
-                .max_column;
+            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_column,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
        }

        for row in left_row..right_row + 1 {
@@ -622,4 +635,85 @@ impl Model {
        }
        CalcResult::Number(max)
    }
+
+    pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut product = 1.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    product *= value;
+                }
+                CalcResult::Boolean(b) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                    } else {
+                        product *= if b { 1.0 } else { 0.0 };
+                        count += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    product *= value;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        product *= t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(product.powf(1.0 / count))
+    }
 }
--- a/base/src/functions/subtotal.rs
+++ b/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 {
-        let worksheet = self.workbook.worksheet(sheet_index).expect("");
+    fn cell_hidden_status(
+        &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;
                                }
--- a/base/src/functions/text.rs
+++ b/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
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                    }
                    for row in row1..row2 + 1 {
                        for column in column1..(column2 + 1) {
--- a/base/src/functions/util.rs
+++ b/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.
-/// 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.
+// 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
+// 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.
--- a/base/src/functions/xlookup.rs
+++ b/base/src/functions/xlookup.rs
@@ -251,20 +251,28 @@ impl Model {
                        let column1 = left.column;

                        if row1 == 1 && row2 == LAST_ROW {
-                            row2 = self
-                                .workbook
-                                .worksheet(left.sheet)
-                                .expect("Sheet expected during evaluation.")
-                                .dimension()
-                                .max_row;
+                            row2 = match self.workbook.worksheet(left.sheet) {
+                                Ok(s) => s.dimension().max_row,
+                                Err(_) => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                        }
                        if column1 == 1 && column2 == LAST_COLUMN {
-                            column2 = self
-                                .workbook
-                                .worksheet(left.sheet)
-                                .expect("Sheet expected during evaluation.")
-                                .dimension()
-                                .max_column;
+                            column2 = match self.workbook.worksheet(left.sheet) {
+                                Ok(s) => s.dimension().max_column,
+                                Err(_) => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                        }
                        let left = CellReferenceIndex {
                            sheet: left.sheet,
--- a/base/src/language/mod.rs
+++ b/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")
 });
--- a/base/src/lib.rs
+++ b/base/src/lib.rs
@@ -25,6 +25,8 @@
 #![doc = include_str!("../examples/formulas_and_errors.rs")]
 //! ```

+#![warn(clippy::print_stdout)]
+
 pub mod calc_result;
 pub mod cell;
 pub mod expressions;
--- a/base/src/locale/mod.rs
+++ b/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"));

--- a/base/src/model.rs
+++ b/base/src/model.rs
@@ -8,14 +8,15 @@ use crate::{
    cell::CellValue,
    constants::{self, LAST_COLUMN, LAST_ROW},
    expressions::{
+        lexer::LexerMode,
        parser::{
            move_formula::{move_formula, MoveContext},
-            stringify::{to_rc_format, to_string},
+            stringify::{rename_defined_name_in_node, to_rc_format, to_string},
            Node, Parser,
        },
        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_identifier, is_valid_row},
    },
    formatter::{
        format::{format_number, parse_formatted_number},
@@ -41,6 +42,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()
@@ -71,6 +73,7 @@ pub(crate) enum CellState {
 }

 /// A parsed formula for a defined name
+#[derive(Clone)]
 pub(crate) enum ParsedDefinedName {
    /// CellReference (`=C4`)
    CellReference(CellReferenceIndex),
@@ -78,9 +81,6 @@ pub(crate) enum ParsedDefinedName {
    RangeReference(Range),
    /// `=SomethingElse`
    InvalidDefinedNameFormula,
-    // TODO: Support constants in defined names
-    // TODO: Support formulas in defined names
-    // TODO: Support tables in defined names
 }

 /// A dynamical IronCalc model.
@@ -90,11 +90,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,
@@ -416,38 +416,40 @@ impl Model {
                // TODO: NOT IMPLEMENTED
                CalcResult::new_error(Error::NIMPL, cell, "Arrays not implemented".to_string())
            }
-            VariableKind(defined_name) => {
-                let parsed_defined_name = self
-                    .parsed_defined_names
-                    .get(&(Some(cell.sheet), defined_name.to_lowercase())) // try getting local defined name
-                    .or_else(|| {
-                        self.parsed_defined_names
-                            .get(&(None, defined_name.to_lowercase()))
-                    }); // fallback to global
-
-                if let Some(parsed_defined_name) = parsed_defined_name {
+            DefinedNameKind((name, scope)) => {
+                if let Ok(Some(parsed_defined_name)) = self.get_parsed_defined_name(name, *scope) {
                    match parsed_defined_name {
                        ParsedDefinedName::CellReference(reference) => {
-                            self.evaluate_cell(*reference)
+                            self.evaluate_cell(reference)
                        }
                        ParsedDefinedName::RangeReference(range) => CalcResult::Range {
                            left: range.left,
                            right: range.right,
                        },
                        ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error(
-                            Error::NIMPL,
+                            Error::NAME,
                            cell,
-                            format!("Defined name \"{}\" is not a reference.", defined_name),
+                            format!("Defined name \"{}\" is not a reference.", name),
                        ),
                    }
                } else {
                    CalcResult::new_error(
                        Error::NAME,
                        cell,
-                        format!("Defined name \"{}\" not found.", defined_name),
+                        format!("Defined name \"{}\" not found.", name),
                    )
                }
            }
+            TableNameKind(s) => CalcResult::new_error(
+                Error::NAME,
+                cell,
+                format!("table name \"{}\" not supported.", s),
+            ),
+            WrongVariableKind(s) => CalcResult::new_error(
+                Error::NAME,
+                cell,
+                format!("Variable name \"{}\" not found.", s),
+            ),
            CompareKind { kind, left, right } => {
                let l = self.evaluate_node_in_context(left, cell);
                if l.is_error() {
@@ -529,6 +531,7 @@ impl Model {
        }
    }

+    #[allow(clippy::expect_used)]
    fn cell_reference_to_string(
        &self,
        cell_reference: &CellReferenceIndex,
@@ -544,6 +547,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];
@@ -679,6 +683,13 @@ impl Model {
        Err(format!("Invalid color: {}", color))
    }

+    /// Changes the visibility of a sheet
+    pub fn set_sheet_state(&mut self, sheet: u32, state: SheetState) -> Result<(), String> {
+        let worksheet = self.workbook.worksheet_mut(sheet)?;
+        worksheet.state = state;
+        Ok(())
+    }
+
    /// Makes the grid lines in the sheet visible (`true`) or hidden (`false`)
    pub fn set_show_grid_lines(&mut self, sheet: u32, show_grid_lines: bool) -> Result<(), String> {
        let worksheet = self.workbook.worksheet_mut(sheet)?;
@@ -854,6 +865,11 @@ impl Model {

        let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();

+        let defined_names = workbook
+            .get_defined_names_with_scope()
+            .iter()
+            .map(|s| (s.0.to_owned(), s.1))
+            .collect();
        // add all tables
        // let mut tables = Vec::new();
        // for worksheet in worksheets {
@@ -863,7 +879,7 @@ impl Model {
        //     }
        //     tables.push(tables_in_sheet);
        // }
-        let parser = Parser::new(worksheet_names, workbook.tables.clone());
+        let parser = Parser::new(worksheet_names, defined_names, workbook.tables.clone());
        let cells = HashMap::new();
        let locale = get_locale(&workbook.settings.locale)
            .map_err(|_| "Invalid locale".to_string())?
@@ -875,6 +891,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() {
@@ -1023,7 +1040,7 @@ impl Model {
                column: source.column,
            };
            let formula_str = move_formula(
-                &self.parser.parse(formula, &Some(cell_reference)),
+                &self.parser.parse(formula, &cell_reference),
                &MoveContext {
                    source_sheet_name: &source_sheet_name,
                    row: source.row,
@@ -1131,7 +1148,7 @@ impl Model {
                row: source.row,
                column: source.column,
            };
-            let formula = &self.parser.parse(formula_str, &Some(cell_reference));
+            let formula = &self.parser.parse(formula_str, &cell_reference);
            let cell_reference = CellReferenceRC {
                sheet: target_sheet_name,
                row: target.row,
@@ -1507,13 +1524,11 @@ impl Model {
            column,
        };
        let shared_formulas = &mut worksheet.shared_formulas;
-        let mut parsed_formula = self.parser.parse(formula, &Some(cell_reference.clone()));
+        let mut parsed_formula = self.parser.parse(formula, &cell_reference);
        // If the formula fails to parse try adding a parenthesis
        // SUM(A1:A3  => SUM(A1:A3)
        if let Node::ParseErrorKind { .. } = parsed_formula {
-            let new_parsed_formula = self
-                .parser
-                .parse(&format!("{})", formula), &Some(cell_reference));
+            let new_parsed_formula = self.parser.parse(&format!("{})", formula), &cell_reference);
            match new_parsed_formula {
                Node::ParseErrorKind { .. } => {}
                _ => parsed_formula = new_parsed_formula,
@@ -1592,6 +1607,42 @@ impl Model {
            .set_cell_with_number(row, column, value, style)
    }

+    // Helper function that returns a defined name given the name and scope
+    fn get_parsed_defined_name(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+    ) -> Result<Option<ParsedDefinedName>, String> {
+        let name_upper = name.to_uppercase();
+
+        for (key, df) in &self.parsed_defined_names {
+            if key.1.to_uppercase() == name_upper && key.0 == scope {
+                return Ok(Some(df.clone()));
+            }
+        }
+        Ok(None)
+    }
+
+    // Returns the formula for a defined name
+    pub(crate) fn get_defined_name_formula(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+    ) -> Result<String, String> {
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                return Ok(df.formula.clone());
+            }
+        }
+        Err("Defined name not found".to_string())
+    }
+
    /// Gets the Excel Value (Bool, Number, String) of a cell
    ///
    /// See also:
@@ -1982,10 +2033,142 @@ impl Model {
            .worksheet_mut(sheet)?
            .set_row_height(column, height)
    }
+
+    /// Adds a new defined name
+    pub fn new_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<(), String> {
+        if !is_valid_identifier(name) {
+            return Err("Invalid defined name".to_string());
+        };
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        // if the defined name already exist return error
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                return Err("Defined name already exists".to_string());
+            }
+        }
+        self.workbook.defined_names.push(DefinedName {
+            name: name.to_string(),
+            formula: formula.to_string(),
+            sheet_id,
+        });
+        self.reset_parsed_structures();
+
+        Ok(())
+    }
+
+    /// Delete defined name of name and scope
+    pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        let mut index = None;
+        for (i, df) in defined_names.iter().enumerate() {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                index = Some(i);
+            }
+        }
+        if let Some(i) = index {
+            self.workbook.defined_names.remove(i);
+            self.reset_parsed_structures();
+            Ok(())
+        } else {
+            Err("Defined name not found".to_string())
+        }
+    }
+
+    /// Update defined name
+    pub fn update_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        new_name: &str,
+        new_scope: Option<u32>,
+        new_formula: &str,
+    ) -> Result<(), String> {
+        if !is_valid_identifier(new_name) {
+            return Err("Invalid defined name".to_string());
+        };
+        let name_upper = name.to_uppercase();
+        let new_name_upper = new_name.to_uppercase();
+
+        if name_upper != new_name_upper || scope != new_scope {
+            for key in self.parsed_defined_names.keys() {
+                if key.1.to_uppercase() == new_name_upper && key.0 == new_scope {
+                    return Err("Defined name already exists".to_string());
+                }
+            }
+        }
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+
+        let new_sheet_id = match new_scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+
+        let mut index = None;
+        for (i, df) in defined_names.iter().enumerate() {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                index = Some(i);
+            }
+        }
+        if let Some(i) = index {
+            if let Some(df) = self.workbook.defined_names.get_mut(i) {
+                if new_name != df.name {
+                    // We need to rename the name in every formula:
+
+                    // Parse all formulas with the old name
+                    // All internal formulas are R1C1
+                    self.parser.set_lexer_mode(LexerMode::R1C1);
+                    let worksheets = &mut self.workbook.worksheets;
+                    for worksheet in worksheets {
+                        let cell_reference = CellReferenceRC {
+                            sheet: worksheet.get_name(),
+                            row: 1,
+                            column: 1,
+                        };
+                        let mut formulas = Vec::new();
+                        for formula in &worksheet.shared_formulas {
+                            let mut t = self.parser.parse(formula, &cell_reference);
+                            rename_defined_name_in_node(&mut t, name, scope, new_name);
+                            formulas.push(to_rc_format(&t));
+                        }
+                        worksheet.shared_formulas = formulas;
+                    }
+                    // Se the mode back to A1
+                    self.parser.set_lexer_mode(LexerMode::A1);
+                }
+                df.name = new_name.to_string();
+                df.sheet_id = new_sheet_id;
+                df.formula = new_formula.to_string();
+                self.reset_parsed_structures();
+            }
+            Ok(())
+        } else {
+            Err("Defined name 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};

--- a/base/src/new_empty.rs
+++ b/base/src/new_empty.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;

 use crate::{
    calc_result::Range,
-    constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
+    constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
    expressions::{
        lexer::LexerMode,
        parser::{
@@ -85,14 +85,14 @@ impl Model {
        let worksheets = &self.workbook.worksheets;
        for worksheet in worksheets {
            let shared_formulas = &worksheet.shared_formulas;
-            let cell_reference = &Some(CellReferenceRC {
+            let cell_reference = CellReferenceRC {
                sheet: worksheet.get_name(),
                row: 1,
                column: 1,
-            });
+            };
            let mut parse_formula = Vec::new();
            for formula in shared_formulas {
-                let t = self.parser.parse(formula, cell_reference);
+                let t = self.parser.parse(formula, &cell_reference);
                parse_formula.push(t);
            }
            self.parsed_formulas.push(parse_formula);
@@ -144,8 +144,14 @@ impl Model {

    /// Reparses all formulas and defined names
    pub(crate) fn reset_parsed_structures(&mut self) {
+        let defined_names = self
+            .workbook
+            .get_defined_names_with_scope()
+            .iter()
+            .map(|s| (s.0.to_owned(), s.1))
+            .collect();
        self.parser
-            .set_worksheets(self.workbook.get_worksheet_names());
+            .set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
        self.parsed_formulas = vec![];
        self.parse_formulas();
        self.parsed_defined_names = HashMap::new();
@@ -262,11 +268,11 @@ impl Model {
        // We use iter because the default would be a mut_iter and we don't need a mutable reference
        let worksheets = &mut self.workbook.worksheets;
        for worksheet in worksheets {
-            let cell_reference = &Some(CellReferenceRC {
+            let cell_reference = &CellReferenceRC {
                sheet: worksheet.get_name(),
                row: 1,
                column: 1,
-            });
+            };
            let mut formulas = Vec::new();
            for formula in &worksheet.shared_formulas {
                let mut t = self.parser.parse(formula, cell_reference);
@@ -359,7 +365,7 @@ impl Model {
            WorkbookView {
                sheet: 0,
                window_width: DEFAULT_WINDOW_WIDTH,
-                window_height: DEFAULT_WINDOW_HEIGH,
+                window_height: DEFAULT_WINDOW_HEIGHT,
            },
        );

@@ -388,10 +394,11 @@ impl Model {
        let parsed_formulas = Vec::new();
        let worksheets = &workbook.worksheets;
        let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
-        let parser = Parser::new(worksheet_names, HashMap::new());
+        let parser = Parser::new(worksheet_names, vec![], HashMap::new());
        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 {
--- a/base/src/test/mod.rs
+++ b/base/src/test/mod.rs
@@ -15,15 +15,18 @@ 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;
+mod test_fn_or_xor;
 mod test_fn_product;
 mod test_fn_rept;
 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;
@@ -48,9 +51,12 @@ mod test_number_format;

 mod test_escape_quotes;
 mod test_extend;
+mod test_fn_fv;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
+mod test_geomean;
 mod test_get_cell_content;
+mod test_issue_155;
 mod test_percentage;
 mod test_set_functions_error_handling;
 mod test_today;
--- a/base/src/test/test_column_width.rs
+++ b/base/src/test/test_column_width.rs
@@ -82,3 +82,21 @@ fn test_column_width_higher_edge() {
    assert!((worksheet.get_column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(1));
 }
+
+#[test]
+fn test_column_width_negative() {
+    let mut model = new_empty_model();
+    let result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_column_width(16, -1.0);
+    assert_eq!(result, Err("Can not set a negative width: -1".to_string()));
+    assert_eq!(model.workbook.worksheets[0].cols.len(), 0);
+    let worksheet = model.workbook.worksheet(0).unwrap();
+    assert_eq!(
+        (worksheet.get_column_width(16).unwrap()),
+        DEFAULT_COLUMN_WIDTH
+    );
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(0));
+}
--- a/base/src/test/test_error_propagation.rs
+++ b/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;
--- a/base/src/test/test_fn_formulatext.rs
+++ b/base/src/test/test_fn_formulatext.rs
@@ -0,0 +1,44 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[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!");
+}
--- a/base/src/test/test_fn_fv.rs
+++ b/base/src/test/test_fn_fv.rs
@@ -0,0 +1,36 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn computation() {
+    let i2 = "=-C2*(1+D2)^E2-F2*((D2+1)*((1+D2)^E2-1))/D2";
+
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", i2);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-183");
+    assert_eq!(model._get_formula("I2"), i2);
+}
+
+#[test]
+fn format_as_currency() {
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", "=FV(D2,E2,F2,C2,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-$183.00");
+}
--- a/base/src/test/test_fn_or_xor.rs
+++ b/base/src/test/test_fn_or_xor.rs
@@ -0,0 +1,204 @@
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::print_stdout)]
+use crate::test::util::new_empty_model;
+
+// These tests are grouped because in many cases XOR and OR have similar behaviour.
+
+// Test specific to xor
+#[test]
+fn fn_xor() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=XOR(1, 1, 1, 0, 0)");
+    model._set("A2", "=XOR(1, 1, 0, 0, 0)");
+    model._set("A3", "=XOR(TRUE, TRUE, TRUE, FALSE, FALSE)");
+    model._set("A4", "=XOR(TRUE, TRUE, FALSE, FALSE, FALSE)");
+    model._set("A5", "=XOR(FALSE, FALSE, FALSE, FALSE, FALSE)");
+    model._set("A6", "=XOR(TRUE, TRUE)");
+    model._set("A7", "=XOR(0,0,0)");
+    model._set("A8", "=XOR(0,0,1)");
+    model._set("A9", "=XOR(0,1,0)");
+    model._set("A10", "=XOR(0,1,1)");
+    model._set("A11", "=XOR(1,0,0)");
+    model._set("A12", "=XOR(1,0,1)");
+    model._set("A13", "=XOR(1,1,0)");
+    model._set("A14", "=XOR(1,1,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"FALSE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"FALSE");
+    assert_eq!(model._get_text("A5"), *"FALSE");
+    assert_eq!(model._get_text("A6"), *"FALSE");
+    assert_eq!(model._get_text("A7"), *"FALSE");
+    assert_eq!(model._get_text("A8"), *"TRUE");
+    assert_eq!(model._get_text("A9"), *"TRUE");
+    assert_eq!(model._get_text("A10"), *"FALSE");
+    assert_eq!(model._get_text("A11"), *"TRUE");
+    assert_eq!(model._get_text("A12"), *"FALSE");
+    assert_eq!(model._get_text("A13"), *"FALSE");
+    assert_eq!(model._get_text("A14"), *"TRUE");
+}
+
+#[test]
+fn fn_or() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=OR(1, 1, 1, 0, 0)");
+    model._set("A2", "=OR(1, 1, 0, 0, 0)");
+    model._set("A3", "=OR(TRUE, TRUE, TRUE, FALSE, FALSE)");
+    model._set("A4", "=OR(TRUE, TRUE, FALSE, FALSE, FALSE)");
+    model._set("A5", "=OR(FALSE, FALSE, FALSE, FALSE, FALSE)");
+    model._set("A6", "=OR(TRUE, TRUE)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"TRUE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"TRUE");
+    assert_eq!(model._get_text("A5"), *"FALSE");
+    assert_eq!(model._get_text("A6"), *"TRUE");
+}
+
+#[test]
+fn fn_or_xor() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+
+        // Text args
+        model._set("A1", &format!(r#"={func}("")"#));
+        model._set("A2", &format!(r#"={func}("", "")"#));
+        model._set("A3", &format!(r#"={func}("", TRUE)"#));
+        model._set("A4", &format!(r#"={func}("", FALSE)"#));
+
+        model._set("A5", &format!("={func}(FALSE, TRUE)"));
+        model._set("A6", &format!("={func}(FALSE, FALSE)"));
+        model._set("A7", &format!("={func}(TRUE, FALSE)"));
+
+        // Reference to empty cell, plus true argument
+        model._set("A8", &format!("={func}(Z99, 1)"));
+
+        // Reference to empty cell/range
+        model._set("A9", &format!("={func}(Z99)"));
+        model._set("A10", &format!("={func}(X99:Z99"));
+
+        // Reference to cell with reference to empty range
+        model._set("B11", "=X99:Z99");
+        model._set("A11", &format!("={func}(B11)"));
+
+        // Reference to cell with non-empty range
+        model._set("X12", "1");
+        model._set("B12", "=X12:Z12");
+        model._set("A12", &format!("={func}(B12)"));
+
+        // Reference to text cell
+        model._set("B13", "some_text");
+        model._set("A13", &format!("={func}(B13)"));
+        model._set("A14", &format!("={func}(B13, 0)"));
+        model._set("A15", &format!("={func}(B13, 1)"));
+
+        // Reference to Implicit intersection
+        model._set("X16", "1");
+        model._set("B16", "=@X15:X16");
+        model._set("A16", &format!("={func}(B16)"));
+
+        // Non-empty range
+        model._set("B17", "1");
+        model._set("A17", &format!("={func}(B17:C17)"));
+
+        // Non-empty range with text
+        model._set("B18", "text");
+        model._set("A18", &format!("={func}(B18:C18)"));
+
+        // Non-empty range with text and number
+        model._set("B19", "text");
+        model._set("C19", "1");
+        model._set("A19", &format!("={func}(B19:C19)"));
+
+        // range with error
+        model._set("B20", "=1/0");
+        model._set("A20", &format!("={func}(B20:C20)"));
+
+        model.evaluate();
+
+        assert_eq!(model._get_text("A1"), *"#VALUE!");
+        assert_eq!(model._get_text("A2"), *"#VALUE!");
+        assert_eq!(model._get_text("A3"), *"TRUE");
+        assert_eq!(model._get_text("A4"), *"FALSE");
+
+        assert_eq!(model._get_text("A5"), *"TRUE");
+        assert_eq!(model._get_text("A6"), *"FALSE");
+        assert_eq!(model._get_text("A7"), *"TRUE");
+
+        assert_eq!(model._get_text("A8"), *"TRUE");
+
+        assert_eq!(model._get_text("A9"), *"#VALUE!");
+        assert_eq!(model._get_text("A10"), *"#VALUE!");
+
+        assert_eq!(model._get_text("A11"), *"#VALUE!");
+
+        // TODO: This one depends on spill behaviour which isn't implemented yet
+        // assert_eq!(model._get_text("A12"), *"TRUE");
+
+        assert_eq!(model._get_text("A13"), *"#VALUE!");
+        assert_eq!(model._get_text("A14"), *"FALSE");
+        assert_eq!(model._get_text("A15"), *"TRUE");
+
+        // TODO: This one depends on @ implicit intersection behaviour which isn't implemented yet
+        // assert_eq!(model._get_text("A16"), *"TRUE");
+
+        assert_eq!(model._get_text("A17"), *"TRUE");
+
+        assert_eq!(model._get_text("A18"), *"#VALUE!");
+
+        assert_eq!(model._get_text("A19"), *"TRUE");
+
+        assert_eq!(model._get_text("A20"), *"#DIV/0!");
+    }
+}
+
+#[test]
+fn fn_or_xor_no_arguments() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+        model._set("A1", &format!("={}()", func));
+        model.evaluate();
+        assert_eq!(model._get_text("A1"), *"#ERROR!");
+    }
+}
+
+#[test]
+fn fn_or_xor_missing_arguments() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+        model._set("A1", &format!("={func}(,)"));
+        model._set("A2", &format!("={func}(,1)"));
+        model._set("A3", &format!("={func}(1,)"));
+        model._set("A4", &format!("={func}(,B1)"));
+        model._set("A5", &format!("={func}(,B1:B4)"));
+        model.evaluate();
+        assert_eq!(model._get_text("A1"), *"FALSE");
+        assert_eq!(model._get_text("A2"), *"TRUE");
+        assert_eq!(model._get_text("A3"), *"TRUE");
+        assert_eq!(model._get_text("A4"), *"FALSE");
+        assert_eq!(model._get_text("A5"), *"FALSE");
+    }
+}
--- a/base/src/test/test_fn_unicode.rs
+++ b/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!");
+}
--- a/base/src/test/test_general.rs
+++ b/base/src/test/test_general.rs
@@ -1,5 +1,7 @@
 #![allow(clippy::unwrap_used)]

+use crate::constants::DEFAULT_ROW_HEIGHT;
+
 use crate::cell::CellValue;

 use crate::number_format::to_excel_precision_str;
@@ -113,6 +115,15 @@ fn test_set_row_height() {
    worksheet.set_row_height(5, 5.0).unwrap();
    let worksheet = model.workbook.worksheet(0).unwrap();
    assert!((5.0 - worksheet.row_height(5).unwrap()).abs() < f64::EPSILON);
+
+    let worksheet = model.workbook.worksheet_mut(0).unwrap();
+    let result = worksheet.set_row_height(6, -1.0);
+    assert_eq!(result, Err("Can not set a negative height: -1".to_string()));
+
+    assert_eq!(worksheet.row_height(6).unwrap(), DEFAULT_ROW_HEIGHT);
+
+    worksheet.set_row_height(6, 0.0).unwrap();
+    assert_eq!(worksheet.row_height(6).unwrap(), 0.0);
 }

 #[test]
--- a/base/src/test/test_geomean.rs
+++ b/base/src/test/test_geomean.rs
@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_fn_geomean_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=GEOMEAN()");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn test_fn_geomean_minimal() {
+    let mut model = new_empty_model();
+    model._set("B1", "1");
+    model._set("B2", "2");
+    model._set("B3", "3");
+    model._set("B4", "'2");
+    // B5 is empty
+    model._set("B6", "true");
+    model._set("A1", "=GEOMEAN(B1:B6)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1.817120593");
+}
--- a/base/src/test/test_issue_155.rs
+++ b/base/src/test/test_issue_155.rs
@@ -0,0 +1,14 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn issue_155() {
+    let mut model = new_empty_model();
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("B2", "=A$1:A2");
+    model.evaluate();
+
+    assert_eq!(model._get_formula("B2"), "=A$1:A2".to_string());
+}
--- a/base/src/test/test_metadata.rs
+++ b/base/src/test/test_metadata.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::test::util::new_empty_model;

 #[test]
--- a/base/src/test/test_set_functions_error_handling.rs
+++ b/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]
--- a/base/src/test/user_model/mod.rs
+++ b/base/src/test/user_model/mod.rs
@@ -3,6 +3,7 @@ mod test_autofill_columns;
 mod test_autofill_rows;
 mod test_border;
 mod test_clear_cells;
+mod test_defined_names;
 mod test_diff_queue;
 mod test_evaluation;
 mod test_general;
@@ -14,8 +15,10 @@ mod test_on_paste_styles;
 mod test_paste_csv;
 mod test_rename_sheet;
 mod test_row_column;
+mod test_sheet_state;
 mod test_styles;
 mod test_to_from_bytes;
 mod test_undo_redo;
 mod test_view;
 mod test_window_size;
+mod util;
--- a/base/src/test/user_model/test_border.rs
+++ b/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();
@@ -129,6 +229,8 @@ fn borders_all() {
        }
    }

+    check_borders(&model);
+
    // Lets remove all of them:
    let border_area: BorderArea = serde_json::from_str(
        r##"{
@@ -156,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,
@@ -183,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 {
@@ -269,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();
@@ -412,6 +519,7 @@ 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();
@@ -419,13 +527,18 @@ fn borders_top() {
                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: None,
+                bottom,
                diagonal: None,
            };
            assert_eq!(style.border, expected_border);
@@ -497,6 +610,8 @@ fn borders_top() {
            assert_eq!(style.border, expected_border);
        }
    }
+    assert!(model.undo().is_ok());
+    check_no_borders(&model);
 }

 #[test]
@@ -524,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,
-                right: Some(border_item.clone()),
+                left,
+                right,
                top: None,
                bottom: None,
                diagonal: None,
@@ -570,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();
@@ -577,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,
            };
@@ -616,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()),
-                right: None,
+                left,
+                right,
                top: None,
                bottom: None,
                diagonal: None,
@@ -636,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));
+}
--- a/base/src/test/user_model/test_defined_names.rs
+++ b/base/src/test/user_model/test_defined_names.rs
@@ -0,0 +1,398 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::UserModel;
+
+#[test]
+fn create_defined_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model
+        .new_defined_name("myName", None, "Sheet1!$A$1")
+        .unwrap();
+    model.set_user_input(0, 5, 7, "=myName").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+
+    assert_eq!(
+        model.get_defined_name_list(),
+        vec![("myName".to_string(), None, "Sheet1!$A$1".to_string())]
+    );
+
+    // delete it
+    model.delete_defined_name("myName", None).unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("#NAME?".to_string())
+    );
+
+    assert_eq!(model.get_defined_name_list().len(), 0);
+
+    model.undo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+}
+
+#[test]
+fn scopes() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+
+    // Global
+    model
+        .new_defined_name("myName", None, "Sheet1!$A$1")
+        .unwrap();
+    model.set_user_input(0, 5, 7, "=myName").unwrap();
+
+    // Local to Sheet2
+    model.new_sheet().unwrap();
+    model.set_user_input(1, 2, 1, "145").unwrap();
+    model
+        .new_defined_name("myName", Some(1), "Sheet2!$A$2")
+        .unwrap();
+    model.set_user_input(1, 8, 8, "=myName").unwrap();
+
+    // Sheet 3
+    model.new_sheet().unwrap();
+    model.set_user_input(2, 2, 2, "=myName").unwrap();
+
+    // Global
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(1, 8, 8),
+        Ok("145".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(2, 2, 2),
+        Ok("42".to_string())
+    );
+}
+
+#[test]
+fn delete_sheet() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
+        .unwrap();
+    model.new_sheet().unwrap();
+    model
+        .new_defined_name("myName", Some(1), "Sheet1!$A$1")
+        .unwrap();
+    model
+        .set_user_input(1, 2, 1, r#"=CONCATENATE(MyName, " my world!")"#)
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("#NAME?".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(1, 2, 1),
+        Ok("Hello my world!".to_string())
+    );
+
+    model.delete_sheet(0).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("#NAME?".to_string())
+    );
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok(r#"=CONCATENATE(MyName," my world!")"#.to_string())
+    );
+}
+
+#[test]
+fn change_scope() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
+        .unwrap();
+    model.new_sheet().unwrap();
+    model
+        .new_defined_name("myName", Some(1), "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("#NAME?".to_string())
+    );
+
+    model
+        .update_defined_name("myName", Some(1), "myName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("Hello world!".to_string())
+    );
+}
+
+#[test]
+fn rename_defined_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
+        .unwrap();
+    model.new_sheet().unwrap();
+    model
+        .new_defined_name("myName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("Hello world!".to_string())
+    );
+
+    model
+        .update_defined_name("myName", None, "newName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("Hello world!".to_string())
+    );
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok(r#"=CONCATENATE(newName," world!")"#.to_string())
+    );
+}
+
+#[test]
+fn rename_defined_name_operations() {
+    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, "123").unwrap();
+
+    model
+        .new_defined_name("answer", None, "Sheet1!$A$1")
+        .unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "=IF(answer<2, answer*2, answer^2)")
+        .unwrap();
+
+    model
+        .set_user_input(0, 3, 1, "=badDunction(-answer)")
+        .unwrap();
+
+    model.new_sheet().unwrap();
+    model.set_user_input(1, 1, 1, "78").unwrap();
+    model
+        .new_defined_name("answer", Some(1), "Sheet1!$A$1")
+        .unwrap();
+
+    model.set_user_input(1, 3, 1, "=answer").unwrap();
+
+    model
+        .update_defined_name("answer", None, "respuesta", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok("=IF(respuesta<2,respuesta*2,respuesta^2)".to_string())
+    );
+
+    assert_eq!(
+        model.get_cell_content(0, 3, 1),
+        Ok("=badDunction(-respuesta)".to_string())
+    );
+
+    // A defined name with the same name but different scope
+    assert_eq!(model.get_cell_content(1, 3, 1), Ok("=answer".to_string()));
+}
+
+#[test]
+fn rename_defined_name_string_operations() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model.set_user_input(0, 1, 2, "World").unwrap();
+
+    model
+        .new_defined_name("hello", None, "Sheet1!$A$1")
+        .unwrap();
+
+    model
+        .new_defined_name("world", None, "Sheet1!$B$1")
+        .unwrap();
+
+    model.set_user_input(0, 2, 1, "=hello&world").unwrap();
+
+    model
+        .update_defined_name("hello", None, "HolaS", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok("=HolaS&world".to_string())
+    );
+}
+
+#[test]
+fn invalid_names() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    // spaces
+    assert_eq!(
+        model.new_defined_name("A real", None, "Sheet1!$A$1"),
+        Err("Invalid defined name".to_string())
+    );
+
+    // Starts with number
+    assert_eq!(
+        model.new_defined_name("2real", None, "Sheet1!$A$1"),
+        Err("Invalid defined name".to_string())
+    );
+
+    // Updating also fails
+    assert_eq!(
+        model.update_defined_name("MyName", None, "My Name", None, "Sheet1!$A$1"),
+        Err("Invalid defined name".to_string())
+    );
+}
+
+#[test]
+fn already_existing() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+    model
+        .new_defined_name("Another", None, "Sheet1!$A$1")
+        .unwrap();
+
+    // Can't create a new name with the same name
+    assert_eq!(
+        model.new_defined_name("MyName", None, "Sheet1!$A$2"),
+        Err("Defined name already exists".to_string())
+    );
+
+    // Can't update one into an existing
+    assert_eq!(
+        model.update_defined_name("Another", None, "MyName", None, "Sheet1!$A$1"),
+        Err("Defined name already exists".to_string())
+    );
+}
+
+#[test]
+fn invalid_sheet() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.new_defined_name("Mything", Some(2), "Sheet1!$A$1"),
+        Err("Invalid sheet index".to_string())
+    );
+
+    assert_eq!(
+        model.update_defined_name("MyName", None, "MyName", Some(2), "Sheet1!$A$1"),
+        Err("Invalid sheet index".to_string())
+    );
+
+    assert_eq!(
+        model.update_defined_name("MyName", Some(9), "YourName", None, "Sheet1!$A$1"),
+        Err("Invalid sheet index".to_string())
+    );
+}
+
+#[test]
+fn invalid_formula() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model.new_defined_name("MyName", None, "A1").unwrap();
+
+    model.set_user_input(0, 1, 2, "=MyName").unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("#NAME?".to_string())
+    );
+}
+
+#[test]
+fn undo_redo() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model.set_user_input(0, 2, 1, "Hola").unwrap();
+    model.set_user_input(0, 1, 2, r#"=MyName&"!""#).unwrap();
+
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello!".to_string())
+    );
+    model.undo().unwrap();
+    assert_eq!(model.get_defined_name_list().len(), 0);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("#NAME?".to_string())
+    );
+    model.redo().unwrap();
+
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello!".to_string())
+    );
+
+    model
+        .update_defined_name("MyName", None, "MyName", None, "Sheet1!$A$2")
+        .unwrap();
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hola!".to_string())
+    );
+    model.undo().unwrap();
+
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello!".to_string())
+    );
+
+    model.redo().unwrap();
+
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hola!".to_string())
+    );
+
+    let send_queue = model.flush_send_queue();
+
+    let mut model2 = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(model2.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 1, 2),
+        Ok("Hola!".to_string())
+    );
+}
--- a/base/src/test/user_model/test_diff_queue.rs
+++ b/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,
--- a/base/src/test/user_model/test_general.rs
+++ b/base/src/test/user_model/test_general.rs
@@ -91,7 +91,6 @@ fn insert_remove_columns() {
    let mut model = UserModel::from_model(model);
    // column E
    let column_width = model.get_column_width(0, 5).unwrap();
-    println!("{column_width}");

    // Insert some data in row 5 (and change the style) in E1
    assert!(model.set_user_input(0, 1, 5, "100$").is_ok());
--- a/base/src/test/user_model/test_keyboard_navigation.rs
+++ b/base/src/test/user_model/test_keyboard_navigation.rs
@@ -2,7 +2,7 @@

 use crate::{
    constants::{
-        DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH,
+        DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH,
        LAST_COLUMN,
    },
    test::util::new_empty_model,
@@ -87,7 +87,7 @@ fn last_colum() {
 fn page_down() {
    let model = new_empty_model();
    let mut model = UserModel::from_model(model);
-    let window_height = DEFAULT_WINDOW_HEIGH as f64;
+    let window_height = DEFAULT_WINDOW_HEIGHT as f64;
    let row_height = DEFAULT_ROW_HEIGHT;
    let row_count = f64::floor(window_height / row_height) as i32;
    model.on_page_down().unwrap();
--- a/base/src/test/user_model/test_paste_csv.rs
+++ b/base/src/test/user_model/test_paste_csv.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::{expressions::types::Area, UserModel};

 #[test]
@@ -7,7 +9,7 @@ fn csv_paste() {
    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));

    // paste some numbers in B4:C7
-    let csv = "1,2,3\n4,5,6";
+    let csv = "1\t2\t3\n4\t5\t6";
    let area = Area {
        sheet: 0,
        row: 4,
@@ -24,6 +26,27 @@ fn csv_paste() {
    );
 }

+#[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();
@@ -65,7 +88,7 @@ fn cut_paste() {
    model.update_range_style(&range, "font.b", "true").unwrap();

    model
-        .set_user_input(0, 2, 1, "A season of faith, \"perfection\"")
+        .set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
        .unwrap();

    // Select A1:B2 and copy
@@ -76,7 +99,7 @@ fn cut_paste() {

    // paste in cell D4 (4, 4)
    model
-        .paste_from_clipboard((1, 1, 2, 2), &copy.data, true)
+        .paste_from_clipboard(0, (1, 1, 2, 2), &copy.data, true)
        .unwrap();

    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
@@ -96,6 +119,26 @@ fn cut_paste() {
    assert_eq!(model.get_cell_content(0, 2, 2), Ok("".to_string()));
 }

+#[test]
+fn cut_paste_different_sheet() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+
+    model.set_selected_range(1, 1, 1, 1).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+    model.new_sheet().unwrap();
+    model.set_selected_sheet(1).unwrap();
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4) of Sheet2
+    model
+        .paste_from_clipboard(0, (1, 1, 1, 1), &copy.data, true)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(1, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("".to_string()));
+}
+
 #[test]
 fn copy_paste_internal() {
    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
@@ -113,7 +156,7 @@ fn copy_paste_internal() {
    model.update_range_style(&range, "font.b", "true").unwrap();

    model
-        .set_user_input(0, 2, 1, "A season of faith, \"perfection\"")
+        .set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
        .unwrap();

    // Select A1:B2 and copy
@@ -121,7 +164,7 @@ fn copy_paste_internal() {
    let copy = model.copy_to_clipboard().unwrap();
    assert_eq!(
        copy.csv,
-        "42,127\n\"A season of faith, \"\"perfection\"\"\",\n"
+        "42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
    );
    assert_eq!(copy.range, (1, 1, 2, 2));

@@ -129,7 +172,7 @@ fn copy_paste_internal() {

    // paste in cell D4 (4, 4)
    model
-        .paste_from_clipboard((1, 1, 2, 2), &copy.data, false)
+        .paste_from_clipboard(0, (1, 1, 2, 2), &copy.data, false)
        .unwrap();

    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
--- a/base/src/test/user_model/test_sheet_state.rs
+++ b/base/src/test/user_model/test_sheet_state.rs
@@ -0,0 +1,57 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+use crate::UserModel;
+
+#[test]
+fn basic_tests() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    // add three more sheets
+    model.new_sheet().unwrap();
+    model.new_sheet().unwrap();
+    model.new_sheet().unwrap();
+
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.len(), 4);
+    for sheet in &info {
+        assert_eq!(sheet.state, "visible".to_string());
+    }
+
+    model.set_selected_sheet(2).unwrap();
+    assert_eq!(info.get(2).unwrap().name, "Sheet3".to_string());
+
+    model.hide_sheet(2).unwrap();
+
+    let info = model.get_worksheets_properties();
+    assert_eq!(model.get_selected_sheet(), 3);
+    assert_eq!(info.get(2).unwrap().state, "hidden".to_string());
+
+    model.undo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(2).unwrap().state, "visible".to_string());
+    model.redo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(2).unwrap().state, "hidden".to_string());
+
+    model.set_selected_sheet(3).unwrap();
+    model.hide_sheet(3).unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+
+    model.unhide_sheet(2).unwrap();
+    model.unhide_sheet(3).unwrap();
+
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.len(), 4);
+    for sheet in &info {
+        assert_eq!(sheet.state, "visible".to_string());
+    }
+
+    model.undo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(3).unwrap().state, "hidden".to_string());
+    model.redo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(3).unwrap().state, "visible".to_string());
+}
--- a/base/src/test/user_model/test_styles.rs
+++ b/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,
 };

@@ -229,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();
@@ -567,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();
--- a/base/src/test/user_model/test_window_size.rs
+++ b/base/src/test/user_model/test_window_size.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::unwrap_used)]

 use crate::{
-    constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
+    constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
    test::util::new_empty_model,
    UserModel,
 };
@@ -11,7 +11,7 @@ fn basic_test() {
    let model = new_empty_model();
    let mut model = UserModel::from_model(model);
    let window_height = model.get_window_height().unwrap();
-    assert_eq!(window_height, DEFAULT_WINDOW_HEIGH);
+    assert_eq!(window_height, DEFAULT_WINDOW_HEIGHT);

    let window_width = model.get_window_width().unwrap();
    assert_eq!(window_width, DEFAULT_WINDOW_WIDTH);
--- a/base/src/test/user_model/util.rs
+++ b/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
+    }
+}
--- a/base/src/test/util.rs
+++ b/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 {
--- a/base/src/types.rs
+++ b/base/src/types.rs
@@ -35,7 +35,7 @@ pub struct WorkbookView {
    pub sheet: u32,
    /// The current width of the window
    pub window_width: i64,
-    /// The current heigh of the window
+    /// The current height of the window
    pub window_height: i64,
 }

@@ -578,7 +578,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,
--- a/base/src/units.rs
+++ b/base/src/units.rs
@@ -293,7 +293,9 @@ impl Model {
            Node::EmptyArgKind => None,
            Node::InvalidFunctionKind { .. } => None,
            Node::ArrayKind(_) => None,
-            Node::VariableKind(_) => None,
+            Node::DefinedNameKind(_) => None,
+            Node::TableNameKind(_) => None,
+            Node::WrongVariableKind(_) => None,
            Node::CompareKind { .. } => None,
            Node::OpPowerKind { .. } => None,
        }
@@ -309,6 +311,7 @@ impl Model {
            Function::Sum => self.units_fn_sum_like(args, cell),
            Function::Average => self.units_fn_sum_like(args, cell),
            Function::Pmt => self.units_fn_currency(args, cell),
+            Function::Fv => self.units_fn_currency(args, cell),
            Function::Nper => self.units_fn_currency(args, cell),
            Function::Npv => self.units_fn_currency(args, cell),
            Function::Irr => self.units_fn_percentage(args, cell),
--- a/base/src/user_model/border_utils.rs
+++ b/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"));
+    }
+}
--- a/base/src/user_model/common.rs
+++ b/base/src/user_model/common.rs
@@ -3,7 +3,6 @@
 use std::{collections::HashMap, fmt::Debug, io::Cursor};

 use csv::{ReaderBuilder, WriterBuilder};
-use csv_sniffer::Sniffer;
 use serde::{Deserialize, Serialize};

 use crate::{
@@ -14,7 +13,7 @@ use crate::{
    },
    model::Model,
    types::{
-        Alignment, BorderItem, BorderStyle, CellType, Col, HorizontalAlignment, SheetProperties,
+        Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, SheetState,
        Style, VerticalAlignment,
    },
    utils::is_valid_hex_color,
@@ -23,6 +22,8 @@ use crate::{
 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>>;

@@ -38,6 +39,7 @@ pub struct ClipboardCell {
 pub struct Clipboard {
    pub(crate) csv: String,
    pub(crate) data: ClipboardData,
+    pub(crate) sheet: u32,
    pub(crate) range: (i32, i32, i32, i32),
 }

@@ -80,37 +82,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),
@@ -372,7 +343,7 @@ impl UserModel {
            old_value: Box::new(old_value),
        }];

-        let line_count = value.split("\n").count();
+        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 {
@@ -469,6 +440,48 @@ impl UserModel {
        Ok(())
    }

+    /// Hides sheet by index
+    ///
+    /// See also:
+    /// * [Model::set_sheet_state]
+    /// * [UserModel::unhide_sheet]
+    pub fn hide_sheet(&mut self, sheet: u32) -> Result<(), String> {
+        let sheet_count = self.model.workbook.worksheets.len() as u32;
+        for index in 1..sheet_count {
+            let sheet_index = (sheet + index) % sheet_count;
+            if self.model.workbook.worksheet(sheet_index)?.state == SheetState::Visible {
+                if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+                    view.sheet = sheet_index;
+                };
+                break;
+            }
+        }
+        let old_value = self.model.workbook.worksheet(sheet)?.state.clone();
+        self.push_diff_list(vec![Diff::SetSheetState {
+            index: sheet,
+            new_value: SheetState::Hidden,
+            old_value,
+        }]);
+        self.model.set_sheet_state(sheet, SheetState::Hidden)?;
+        Ok(())
+    }
+
+    /// Un hides sheet by index
+    ///
+    /// See also:
+    /// * [Model::set_sheet_state]
+    /// * [UserModel::hide_sheet]
+    pub fn unhide_sheet(&mut self, sheet: u32) -> Result<(), String> {
+        let old_value = self.model.workbook.worksheet(sheet)?.state.clone();
+        self.push_diff_list(vec![Diff::SetSheetState {
+            index: sheet,
+            new_value: SheetState::Visible,
+            old_value,
+        }]);
+        self.model.set_sheet_state(sheet, SheetState::Visible)?;
+        Ok(())
+    }
+
    /// Sets sheet color
    ///
    /// Note: an empty string will remove the color
@@ -571,7 +584,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,
@@ -740,7 +756,7 @@ impl UserModel {

    /// Paste `styles` in the selected area
    pub fn on_paste_styles(&mut self, styles: &[Vec<Style>]) -> Result<(), String> {
-        let styles_heigh = styles.len() as i32;
+        let styles_height = styles.len() as i32;
        let styles_width = styles[0].len() as i32;
        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
            view.sheet
@@ -759,13 +775,13 @@ impl UserModel {

        // If the pasted area is smaller than the selected area we increase it
        let [row_start, column_start, row_end, column_end] = range;
-        let last_row = row_end.max(row_start + styles_heigh - 1);
+        let last_row = row_end.max(row_start + styles_height - 1);
        let last_column = column_end.max(column_start + styles_width - 1);

        let mut diff_list = Vec::new();
        for row in row_start..=last_row {
            for column in column_start..=last_column {
-                let row_index = ((row - row_start) % styles_heigh) as usize;
+                let row_index = ((row - row_start) % styles_height) as usize;
                let column_index = ((column - column_start) % styles_width) as usize;
                let style = &styles[row_index][column_index];
                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
@@ -790,7 +806,9 @@ 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,
@@ -803,195 +821,309 @@ 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();

                match border_area.r#type {
                    BorderType::All => {
-                        style.border.top = Some(border_area.item.clone());
-                        style.border.right = Some(border_area.item.clone());
-                        style.border.bottom = Some(border_area.item.clone());
-                        style.border.left = Some(border_area.item.clone());
+                        new_value.border.top = Some(border_area.item.clone());
+                        new_value.border.right = Some(border_area.item.clone());
+                        new_value.border.bottom = 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 => {
-                        style.border.top = None;
-                        style.border.right = None;
-                        style.border.bottom = None;
-                        style.border.left = None;
+                        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::Top,
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-            ]
-            .contains(&border_area.r#type)
+            && [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)?;
-                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());
+                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),
+                    });
                }
-                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::Right,
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-            ]
-            .contains(&border_area.r#type)
+            && [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)?;
-                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());
+                // 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),
+                    });
                }
-                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::Bottom,
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-            ]
-            .contains(&border_area.r#type)
+            && [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)?;
-                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());
+                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),
+                    });
                }
-                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::Left,
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-            ]
-            .contains(&border_area.r#type)
+            && [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)?;
-                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());
+                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.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),
-                });
            }
        }

@@ -1041,18 +1173,6 @@ impl UserModel {
                    "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}'."));
@@ -1109,11 +1229,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> {
-        self.model.get_style_for_cell(sheet, row, column)
+        let mut style = 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`.
@@ -1222,27 +1400,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 column1 = source_area.column;
-        let width1 = source_area.width;
-        let height1 = source_area.height;
+        let first_row = source_area.row;
+        let first_column = source_area.column;
+        let last_column = first_column + source_area.width - 1;
+        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) {
-            return Err(format!("Invalid column: '{column1}'"));
+        if !is_valid_column_number(first_column) {
+            return Err(format!("Invalid column: '{first_column}'"));
        }
-        if !is_valid_row(row1) {
-            return Err(format!("Invalid row: '{row1}'"));
+        if !is_valid_row(first_row) {
+            return Err(format!("Invalid row: '{first_row}'"));
        }
-        if !is_valid_column_number(column1 + width1 - 1) {
-            return Err(format!("Invalid column: '{}'", column1 + width1 - 1));
+        if !is_valid_column_number(last_column) {
+            return Err(format!("Invalid column: '{}'", last_column));
        }
-        if !is_valid_row(row1 + height1 - 1) {
-            return Err(format!("Invalid row: '{}'", row1 + height1 - 1));
+        if !is_valid_row(last_row) {
+            return Err(format!("Invalid row: '{}'", last_row));
        }

        if !is_valid_row(to_column) {
@@ -1255,21 +1433,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();
-        } else if to_column < column1 {
+            column_range = (last_column + 1..to_column + 1).collect();
+        } 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;
@@ -1290,8 +1468,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
@@ -1302,6 +1481,7 @@ impl UserModel {
                    old_value: Box::new(old_style),
                    new_value: Box::new(new_style),
                });
+
                diff_list.push(Diff::SetCellValue {
                    sheet,
                    row,
@@ -1310,7 +1490,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);
@@ -1349,7 +1529,7 @@ impl UserModel {
    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().from_writer(vec![]);
+        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;
@@ -1359,7 +1539,7 @@ impl UserModel {
            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.get_cell_style(sheet, row, column)?;
+                let style = self.model.get_style_for_cell(sheet, row, column)?;
                data_row.insert(
                    column,
                    ClipboardCell {
@@ -1369,15 +1549,21 @@ impl UserModel {
                );
                text_row.push(text);
            }
-            wtr.write_record(text_row).unwrap();
+            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().unwrap()).unwrap();
+        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,
+            sheet,
            range: (row_start, column_start, row_end, column_end),
        })
    }
@@ -1385,6 +1571,7 @@ impl UserModel {
    /// Paste text that we copied
    pub fn paste_from_clipboard(
        &mut self,
+        source_sheet: u32,
        source_range: ClipboardTuple,
        clipboard: &ClipboardData,
        is_cut: bool,
@@ -1475,16 +1662,17 @@ impl UserModel {
                    let old_value = self
                        .model
                        .workbook
-                        .worksheet(sheet)?
+                        .worksheet(source_sheet)?
                        .cell(row, column)
                        .cloned();
+
                    diff_list.push(Diff::CellClearContents {
-                        sheet,
+                        sheet: source_sheet,
                        row,
                        column,
                        old_value: Box::new(old_value),
                    });
-                    self.model.cell_clear_contents(sheet, row, column)?;
+                    self.model.cell_clear_contents(source_sheet, row, column)?;
                }
            }
        }
@@ -1501,18 +1689,10 @@ impl UserModel {
        let sheet = area.sheet;
        let mut row = area.row;
        let mut column = area.column;
-        // Create a sniffer with default settings
-        let mut sniffer = Sniffer::new();
        let mut csv_reader = Cursor::new(csv);
-
-        // Sniff the CSV metadata
-        let metadata = sniffer
-            .sniff_reader(&mut csv_reader)
-            .map_err(|_| "Failed")?;
-        // Reset the cursor to the beginning after sniffing
        csv_reader.set_position(0);
        let mut reader = ReaderBuilder::new()
-            .delimiter(metadata.dialect.delimiter)
+            .delimiter(b'\t')
            .has_headers(false)
            .from_reader(csv_reader);
        for record in reader.records() {
@@ -1554,6 +1734,68 @@ impl UserModel {
        Ok(())
    }

+    /// Returns the list of defined names
+    pub fn get_defined_name_list(&self) -> Vec<(String, Option<u32>, String)> {
+        self.model.workbook.get_defined_names_with_scope()
+    }
+
+    /// Delete an existing defined name
+    pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
+        let old_value = self.model.get_defined_name_formula(name, scope)?;
+        let diff_list = vec![Diff::DeleteDefinedName {
+            name: name.to_string(),
+            scope,
+            old_value,
+        }];
+        self.push_diff_list(diff_list);
+        self.model.delete_defined_name(name, scope)?;
+        self.evaluate_if_not_paused();
+        Ok(())
+    }
+
+    /// Create a new defined name
+    pub fn new_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<(), String> {
+        self.model.new_defined_name(name, scope, formula)?;
+        let diff_list = vec![Diff::CreateDefinedName {
+            name: name.to_string(),
+            scope,
+            value: formula.to_string(),
+        }];
+        self.push_diff_list(diff_list);
+        self.evaluate_if_not_paused();
+        Ok(())
+    }
+
+    /// Updates a defined name
+    pub fn update_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        new_name: &str,
+        new_scope: Option<u32>,
+        new_formula: &str,
+    ) -> Result<(), String> {
+        let old_formula = self.model.get_defined_name_formula(name, scope)?;
+        let diff_list = vec![Diff::UpdateDefinedName {
+            name: name.to_string(),
+            scope,
+            old_formula: old_formula.to_string(),
+            new_name: new_name.to_string(),
+            new_scope,
+            new_formula: new_formula.to_string(),
+        }];
+        self.push_diff_list(diff_list);
+        self.model
+            .update_defined_name(name, scope, new_name, new_scope, new_formula)?;
+        self.evaluate_if_not_paused();
+        Ok(())
+    }
+
    // **** Private methods ****** //

    fn push_diff_list(&mut self, diff_list: DiffList) {
@@ -1572,7 +1814,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,
@@ -1724,6 +1966,41 @@ impl UserModel {
                } => {
                    self.model.set_show_grid_lines(*sheet, *old_value)?;
                }
+                Diff::CreateDefinedName {
+                    name,
+                    scope,
+                    value: _,
+                } => {
+                    self.model.delete_defined_name(name, *scope)?;
+                }
+                Diff::DeleteDefinedName {
+                    name,
+                    scope,
+                    old_value,
+                } => {
+                    self.model.new_defined_name(name, *scope, old_value)?;
+                }
+                Diff::UpdateDefinedName {
+                    name,
+                    scope,
+                    old_formula,
+                    new_name,
+                    new_scope,
+                    new_formula: _,
+                } => {
+                    self.model.update_defined_name(
+                        new_name,
+                        *new_scope,
+                        name,
+                        *scope,
+                        old_formula,
+                    )?;
+                }
+                Diff::SetSheetState {
+                    index,
+                    old_value,
+                    new_value: _,
+                } => self.model.set_sheet_state(*index, old_value.clone())?,
            }
        }
        if needs_evaluation {
@@ -1851,6 +2128,33 @@ impl UserModel {
                } => {
                    self.model.set_show_grid_lines(*sheet, *new_value)?;
                }
+                Diff::CreateDefinedName { name, scope, value } => {
+                    self.model.new_defined_name(name, *scope, value)?
+                }
+                Diff::DeleteDefinedName {
+                    name,
+                    scope,
+                    old_value: _,
+                } => self.model.delete_defined_name(name, *scope)?,
+                Diff::UpdateDefinedName {
+                    name,
+                    scope,
+                    old_formula: _,
+                    new_name,
+                    new_scope,
+                    new_formula,
+                } => self.model.update_defined_name(
+                    name,
+                    *scope,
+                    new_name,
+                    *new_scope,
+                    new_formula,
+                )?,
+                Diff::SetSheetState {
+                    index,
+                    old_value: _,
+                    new_value,
+                } => self.model.set_sheet_state(*index, new_value.clone())?,
            }
        }

--- a/base/src/user_model/history.rs
+++ b/base/src/user_model/history.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;

 use bitcode::{Decode, Encode};

-use crate::types::{Cell, Col, Row, Style};
+use crate::types::{Cell, Col, Row, SheetState, Style};

 #[derive(Clone, Encode, Decode)]
 pub(crate) struct RowData {
@@ -104,11 +104,35 @@ pub(crate) enum Diff {
        old_value: String,
        new_value: String,
    },
+    SetSheetState {
+        index: u32,
+        old_value: SheetState,
+        new_value: SheetState,
+    },
    SetShowGridLines {
        sheet: u32,
        old_value: bool,
        new_value: bool,
-    }, // FIXME: we are missing SetViewDiffs
+    },
+    CreateDefinedName {
+        name: String,
+        scope: Option<u32>,
+        value: String,
+    },
+    DeleteDefinedName {
+        name: String,
+        scope: Option<u32>,
+        old_value: String,
+    },
+    UpdateDefinedName {
+        name: String,
+        scope: Option<u32>,
+        old_formula: String,
+        new_name: String,
+        new_scope: Option<u32>,
+        new_formula: String,
+    },
+    // FIXME: we are missing SetViewDiffs
 }

 pub(crate) type DiffList = Vec<Diff>;
--- a/base/src/user_model/mod.rs
+++ b/base/src/user_model/mod.rs
@@ -1,5 +1,6 @@
 #![deny(missing_docs)]

+mod border_utils;
 mod common;
 mod history;
 mod ui;
--- a/base/src/utils.rs
+++ b/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};
--- a/base/src/workbook.rs
+++ b/base/src/workbook.rs
@@ -27,4 +27,27 @@ impl Workbook {
            .get_mut(worksheet_index as usize)
            .ok_or_else(|| "Invalid sheet index".to_string())
    }
+
+    /// Returns the a list of defined names in the workbook with their scope
+    pub(crate) fn get_defined_names_with_scope(&self) -> Vec<(String, Option<u32>, String)> {
+        let sheet_id_index: Vec<u32> = self.worksheets.iter().map(|s| s.sheet_id).collect();
+
+        let defined_names = self
+            .defined_names
+            .iter()
+            .map(|dn| {
+                let index = dn
+                    .sheet_id
+                    .and_then(|sheet_id| {
+                        // returns an Option<usize>
+                        sheet_id_index.iter().position(|&x| x == sheet_id)
+                    })
+                    // convert Option<usize> to Option<u32>
+                    .map(|pos| pos as u32);
+
+                (dn.name.clone(), index, dn.formula.clone())
+            })
+            .collect::<Vec<_>>();
+        defined_names
+    }
 }
--- a/base/src/worksheet.rs
+++ b/base/src/worksheet.rs
@@ -254,11 +254,15 @@ 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.
+    ///
+    /// Fails if row index is outside allowed range or height is negative.
    pub fn set_row_height(&mut self, row: i32, height: f64) -> Result<(), String> {
        if !is_valid_row(row) {
            return Err(format!("Row number '{row}' is not valid."));
        }
+        if height < 0.0 {
+            return Err(format!("Can not set a negative height: {height}"));
+        }

        let rows = &mut self.rows;
        for r in rows.iter_mut() {
@@ -282,7 +286,8 @@ 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.
+    ///
+    /// Fails if column index is outside allowed range or width is negative.
    pub fn set_column_width(&mut self, column: i32, width: f64) -> Result<(), String> {
        self.set_column_width_and_style(column, width, None)
    }
@@ -296,6 +301,9 @@ impl Worksheet {
        if !is_valid_column_number(column) {
            return Err(format!("Column number '{column}' is not valid."));
        }
+        if width < 0.0 {
+            return Err(format!("Can not set a negative width: {width}"));
+        }
        let cols = &mut self.cols;
        let mut col = Col {
            min: column,
--- a/bindings/python/Cargo.toml
+++ b/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"]
--- a/bindings/python/run_examples.sh
+++ b/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
--- a/bindings/python/src/lib.rs
+++ b/bindings/python/src/lib.rs
@@ -10,6 +10,8 @@ use xlsx::import;

 mod types;

+use crate::types::PyCellType;
+
 create_exception!(_ironcalc, WorkbookError, PyException);

 /// This is a model implementing the 'raw' API
@@ -58,6 +60,21 @@ impl PyModel {

    // Get values

+    /// Get raw value
+    pub fn get_cell_content(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
+        self.model
+            .get_cell_content(sheet, row, column)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    /// Get cell type
+    pub fn get_cell_type(&self, sheet: u32, row: i32, column: i32) -> PyResult<PyCellType> {
+        self.model
+            .get_cell_type(sheet, row, column)
+            .map(|cell_type| cell_type.into())
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
    /// Get formatted value
    pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
        self.model
@@ -208,12 +225,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 +258,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");
 }
--- a/bindings/python/src/types.rs
+++ b/bindings/python/src/types.rs
@@ -1,7 +1,7 @@
 use pyo3::prelude::*;
 use xlsx::base::types::{
-    Alignment, Border, BorderItem, BorderStyle, Fill, Font, FontScheme, HorizontalAlignment, Style,
-    VerticalAlignment,
+    Alignment, Border, BorderItem, BorderStyle, CellType, Fill, Font, FontScheme,
+    HorizontalAlignment, Style, VerticalAlignment,
 };

 #[derive(Clone)]
@@ -161,6 +161,17 @@ pub struct PyFill {
    pub bg_color: Option<String>,
 }

+#[pyclass(eq, eq_int)]
+#[derive(PartialEq, Clone)]
+pub enum PyCellType {
+    Number = 1,
+    Text = 2,
+    LogicalValue = 4,
+    ErrorValue = 16,
+    Array = 64,
+    CompoundData = 128,
+}
+
 // Conversions from references to Py* types to non-Py types

 // Enums
@@ -426,3 +437,31 @@ impl From<Style> for PyStyle {
        }
    }
 }
+
+// Conversion from PyCellType to CellType
+impl From<PyCellType> for CellType {
+    fn from(py_cell_type: PyCellType) -> Self {
+        match py_cell_type {
+            PyCellType::Number => CellType::Number,
+            PyCellType::Text => CellType::Text,
+            PyCellType::LogicalValue => CellType::LogicalValue,
+            PyCellType::ErrorValue => CellType::ErrorValue,
+            PyCellType::Array => CellType::Array,
+            PyCellType::CompoundData => CellType::CompoundData,
+        }
+    }
+}
+
+// Conversion from CellType to PyCellType
+impl From<CellType> for PyCellType {
+    fn from(cell_type: CellType) -> Self {
+        match cell_type {
+            CellType::Number => PyCellType::Number,
+            CellType::Text => PyCellType::Text,
+            CellType::LogicalValue => PyCellType::LogicalValue,
+            CellType::ErrorValue => PyCellType::ErrorValue,
+            CellType::Array => PyCellType::Array,
+            CellType::CompoundData => PyCellType::CompoundData,
+        }
+    }
+}
--- a/bindings/wasm/Cargo.toml
+++ b/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"
--- a/bindings/wasm/fix_types.py
+++ b/bindings/wasm/fix_types.py
@@ -169,20 +169,36 @@ clipboard_types = r"""

 paste_from_clipboard = r"""
 /**
+* @param {number} source_sheet
 * @param {any} source_range
 * @param {any} clipboard
 * @param {boolean} is_cut
 */
-  pasteFromClipboard(source_range: any, clipboard: any, is_cut: boolean): void;
+  pasteFromClipboard(source_sheet: number, source_range: any, clipboard: any, is_cut: boolean): void;
 """

 paste_from_clipboard_types = r"""
 /**
+* @param {number} source_sheet
 * @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;
+  pasteFromClipboard(source_sheet: number, source_range: [number, number, number, number], clipboard: ClipboardData, is_cut: boolean): void;
+"""
+
+defined_name_list = r"""
+/**
+* @returns {any}
+*/
+  getDefinedNameList(): any;
+"""
+
+defined_name_list_types = r"""
+/**
+* @returns {DefinedName[]}
+*/
+  getDefinedNameList(): DefinedName[];
 """

 def fix_types(text):
@@ -198,6 +214,7 @@ def fix_types(text):
    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)
+    text = text.replace(defined_name_list, defined_name_list_types)
    with open("types.ts") as f:
        types_str = f.read()
        header_types = "{}\n\n{}".format(header, types_str)
--- a/bindings/wasm/src/lib.rs
+++ b/bindings/wasm/src/lib.rs
@@ -1,3 +1,4 @@
+use serde::Serialize;
 use wasm_bindgen::{
    prelude::{wasm_bindgen, JsError},
    JsValue,
@@ -29,6 +30,13 @@ pub fn column_name_from_number(column: i32) -> Result<String, JsError> {
    }
 }

+#[derive(Serialize)]
+struct DefinedName {
+    name: String,
+    scope: Option<u32>,
+    formula: String,
+}
+
 #[wasm_bindgen]
 pub struct Model {
    model: BaseModel,
@@ -106,6 +114,16 @@ impl Model {
        self.model.delete_sheet(sheet).map_err(to_js_error)
    }

+    #[wasm_bindgen(js_name = "hideSheet")]
+    pub fn hide_sheet(&mut self, sheet: u32) -> Result<(), JsError> {
+        self.model.hide_sheet(sheet).map_err(to_js_error)
+    }
+
+    #[wasm_bindgen(js_name = "unhideSheet")]
+    pub fn unhide_sheet(&mut self, sheet: u32) -> Result<(), JsError> {
+        self.model.unhide_sheet(sheet).map_err(to_js_error)
+    }
+
    #[wasm_bindgen(js_name = "renameSheet")]
    pub fn rename_sheet(&mut self, sheet: u32, name: &str) -> Result<(), JsError> {
        self.model.rename_sheet(sheet, name).map_err(to_js_error)
@@ -274,15 +292,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(|x| serde_wasm_bindgen::to_value(&x).unwrap())
+            .map_err(to_js_error)?;
+
+        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 +325,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 +344,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()
    }
@@ -503,13 +530,15 @@ impl Model {
        let data = self
            .model
            .copy_to_clipboard()
-            .map_err(|e| to_js_error(e.to_string()));
-        data.map(|x| serde_wasm_bindgen::to_value(&x).unwrap())
+            .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_sheet: u32,
        source_range: JsValue,
        clipboard: JsValue,
        is_cut: bool,
@@ -519,7 +548,7 @@ impl Model {
        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)
+            .paste_from_clipboard(source_sheet, source_range, &clipboard, is_cut)
            .map_err(|e| to_js_error(e.to_string()))
    }

@@ -531,4 +560,52 @@ impl Model {
            .paste_csv_string(&range, csv)
            .map_err(|e| to_js_error(e.to_string()))
    }
+
+    #[wasm_bindgen(js_name = "getDefinedNameList")]
+    pub fn get_defined_name_list(&self) -> Result<JsValue, JsError> {
+        let data: Vec<DefinedName> = self
+            .model
+            .get_defined_name_list()
+            .iter()
+            .map(|s| DefinedName {
+                name: s.0.to_owned(),
+                scope: s.1,
+                formula: s.2.to_owned(),
+            })
+            .collect();
+        serde_wasm_bindgen::to_value(&data).map_err(|e| to_js_error(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "newDefinedName")]
+    pub fn new_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<(), JsError> {
+        self.model
+            .new_defined_name(name, scope, formula)
+            .map_err(|e| to_js_error(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "updateDefinedName")]
+    pub fn update_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        new_name: &str,
+        new_scope: Option<u32>,
+        new_formula: &str,
+    ) -> Result<(), JsError> {
+        self.model
+            .update_defined_name(name, scope, new_name, new_scope, new_formula)
+            .map_err(|e| to_js_error(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "deleteDefinedName")]
+    pub fn delete_definedname(&mut self, name: &str, scope: Option<u32>) -> Result<(), JsError> {
+        self.model
+            .delete_defined_name(name, scope)
+            .map_err(|e| to_js_error(e.to_string()))
+    }
 }
--- a/bindings/wasm/types.ts
+++ b/bindings/wasm/types.ts
@@ -113,6 +113,7 @@ export interface WorksheetProperties {
  name: string;
  color: string;
  sheet_id: number;
+  state: string;
 }

 interface CellStyleFill {
@@ -143,10 +144,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 {
@@ -224,4 +227,10 @@ export interface Clipboard {
  csv: string;
  data: ClipboardData;
  range: [number, number, number, number];
+}
+
+export interface DefinedName {
+  name: string;
+  scope?: number;
+  formula: string;
 }
--- a/docs/.gitignore
+++ b/docs/.gitignore
@@ -0,0 +1,3 @@
+src/.vitepress/cache/*
+src/.vitepress/dist/*
+node_modules/*
--- a/docs/README.md
+++ b/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`
+
--- a/docs/package-lock.json
+++ b/docs/package-lock.json
--- a/docs/package.json
+++ b/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"
+  }
+}
--- a/docs/src/.vitepress/config.mts
+++ b/docs/src/.vitepress/config.mts
--- a/docs/src/.vitepress/theme/index.ts
+++ b/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;
--- a/docs/src/.vitepress/theme/style.css
+++ b/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;
+}
--- a/docs/src/.vitepress/theme/vars.css
+++ b/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);
+}
--- a/docs/src/contributing/how-to-contribute.md
+++ b/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).
--- a/docs/src/desktop/about.md
+++ b/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)
+:::
--- a/docs/src/favicon-32x32.png
+++ b/docs/src/favicon-32x32.png
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nicolás Hatcher	ae661f8e93	WIP	2024-12-30 11:46:46 +01:00
francisco aloi	e5265ce3ad	refactored NameManager logic for new design	2024-12-29 18:12:00 +01:00
francisco aloi	17ba7a5f84	NamedRanges changes	2024-12-28 12:32:40 +01:00
Gian Hancock	655d663590	FIX: Make XOR, OR, AND functions more consistent with Excel The way these functions interpret their arguments is inconsistent with Excel in a few ways: - EmptyCell: Excel ignores arguments evaluating to these types of values, treating them as if they didn't exist. - Text: Text cells are ignored unless they are "TRUE" or "FALSE" (case insensitive). EXCEPT if the string value comes from a reference, in which case it is always ignored regardless of its value. - Error if no args: Excel returns a #VALUE! error for these functions if no arguments are provided, or if all arguments are ignored (see above). - EmptyArg: Bizarrely, Unlike EmptyCell, EmptyArg is not ignored and is treated as if it were FALSE by Excel. - ErrorPropagation: Excel propagates errors in the arguments and in cells belonging to any Range arguments. Additionally, these functions are not consistent with each other, XOR, OR, AND vary in how they handle the cases mentioned above. Rectify these consistency issues by re-implementing them all in terms of a single base function which is more consistent with Excel behavior.	2024-12-26 15:06:54 +01:00
Gian Hancock	8ba30fde33	Add more tests for OR and XOR Some of these tests fail due to inconsistencies with Excel cleanup	2024-12-26 15:06:54 +01:00
Nicolás Hatcher	690032c811	FIX: Remove optional context in parser The context was optional because I thought that paring an RC formula did not need context. You at least need the sheet in which you are parsing For instance toknow if a defined name is local	2024-12-26 10:21:21 +01:00
Nicolás Hatcher	86213a8434	FIX: Add test for get_defined_name_list Also uses the scope instead of the opaque sheet_id	2024-12-26 10:21:21 +01:00
Nicolás Hatcher	2ed5fb9bbc	FIX: Adds some validation and tests	2024-12-26 10:21:21 +01:00
Nicolás Hatcher	e455ed14ea	UPDATE: API for defined names	2024-12-26 10:21:21 +01:00
Daniel	ad2efad3ae	FIX: Remove tabIndex and onKeyDown as they were not used	2024-12-25 20:04:48 +01:00
Daniel	40461b897b	FIX: Adds crossRef back to UploadFileDialog	2024-12-25 20:04:48 +01:00
Daniel	2e7410552f	FIX: Apply useTranslation on dialog tooltips	2024-12-25 20:04:48 +01:00
Daniel	095002710b	Fix: Removed unnecessary ref	2024-12-25 20:04:48 +01:00
Daniel	8ba131011e	FIX: Replace SVG "X" icons with Lucide icons for consistency in dialogs	2024-12-25 20:04:48 +01:00
Nicolás Hatcher Andrés	dbddc027fb	Update test-coverage.yaml	2024-12-25 16:57:54 +01:00
Steve Fanning	de997f38f5	Minor updates to Error Types and Value Types documentation	2024-12-25 13:47:21 +01:00
Steve Fanning	df4b4ca353	Update to FV description and associated pages in the Features area.	2024-12-25 13:47:21 +01:00
Daniel	3b944cd659	FIX: Use the right icon for paste format action	2024-12-20 20:13:25 +01:00
Nicolás Hatcher Andrés	d1f2b2acdd	Update test-coverage.yaml	2024-12-20 14:10:02 +01:00
Daniel González-Albo	36f915b193	Merge pull request #207 from ironcalc/feature/nicolas-hidden UPDATE: Hide/Unhide sheets	2024-12-20 10:14:09 +01:00
Nicolás Hatcher	5d8e6255a3	UPDATE: Hide/Unhide sheets	2024-12-20 00:49:33 +01:00
Daniel González-Albo	73f3c06203	Merge pull request #205 from ironcalc/bugfix/nico-dialog-fixes FIX[WebApp]: Some fixes to the DeleteWorkbook and Import dialogs	2024-12-20 00:16:42 +01:00
Nicolás Hatcher	13b1157c61	FIX[WebApp]: Some fixes to the DeleteWorkbook and Import dialogs	2024-12-19 21:14:05 +01:00
Daniel	44f7929f4e	FIX: responsiveness	2024-12-19 17:48:54 +01:00
Daniel	23643f0fae	UPDATE: connect FileMenu button to open confirmation modal	2024-12-19 17:48:54 +01:00
Daniel	ad91d47db0	UPDATE: add confirmation modal for deleting workbooks	2024-12-19 17:48:54 +01:00
Daniel	8f36a1f750	FIX: make grid header colors consistent	2024-12-19 17:37:10 +01:00
Sinan Yumurtaci	8ad407432f	lint	2024-12-19 17:36:27 +01:00
Sinan Yumurtaci	ebc31780ab	FIX[WebApp]: Disable delete for sheet if it is the last one	2024-12-19 17:36:27 +01:00
Daniel	6e8c47d4f6	UPDATE: Replace one preset color from color picker	2024-12-18 20:00:52 +01:00
Daniel González-Albo	ed42667e87	Merge pull request #198 from ironcalc/bugfix/nicolas-modal-fixes FIX[UI]: Rename modal dialog fixes	2024-12-16 22:35:49 +01:00
Nicolás Hatcher	0cd3470a97	FIX[UI]: Rename modal dialog fixes This will be a standard "Prompt" widget * ESC closes the dialog without changes * Can copy/cut paste	2024-12-16 21:24:41 +01:00
Daniel	ab3f9c276d	FIX: Border picker cosmetics	2024-12-16 17:33:34 +01:00
Nicolás Hatcher	e098105531	FIX: When cut and paste to a different sheet origin is removed Fixes #193	2024-12-16 08:01:51 +01:00
Daniel	a5919d837f	UPDATE: Better active states on Sheet Nav + Double click to rename sheets	2024-12-15 21:29:10 +01:00
Daniel	f214070299	FIX: Several cosmetic changes to make the toolbar look like the figmas	2024-12-15 19:18:51 +01:00
Daniel	0b2de92053	FIX: Made menu on SheetTab consistent with Figmas	2024-12-15 19:15:34 +01:00
Nicolás Hatcher	98dc1f3b06	FIX[WebApp]: Rename navigation => SheetTabBar Also rename all widgets in that folder to more standard names	2024-12-15 12:12:14 +01:00
Nicolás Hatcher	fb764fed1c	FIX[WebApp]: Splits the menu.tsx in two files This is so that SheetListMenu and SheetRenameDialog are on its own files. Also renamed isOpen => open and close => onClose	2024-12-15 12:12:14 +01:00
Nicolás Hatcher	23814ec18c	FIX: Several fixes on the FV function (1+x)^(1+y) was stringifyfied incorrectly We still need work on this FV now returns currency FV(-1,-2,1) should return #DIV/0! not #NUM!	2024-12-14 22:08:44 +01:00
Daniel	8c6aaf2af0	FIX: Replace inline styles with StyledMenu component for improved readability	2024-12-14 18:34:13 +01:00
Daniel González-Albo	ed24e57555	Merge pull request #185 from ironcalc/fix/dani-webapp-navigator FIX: remove legacy scrollbar styles	2024-12-14 18:14:17 +01:00
Daniel González-Albo	e8ced73b9c	Merge pull request #186 from ironcalc/fix/dani-rename-sheet-dialog FIX: Makes styling in Rename Sheet Dialog consistent with rest of dia…	2024-12-14 18:13:50 +01:00
Daniel	7ba002aca4	FIX: Makes footer/navigator scrollable when there are too many sheets	2024-12-14 18:04:35 +01:00
Daniel	b0e72321b4	FIX: Makes styling in Rename Sheet Dialog consistent with rest of dialogs	2024-12-13 20:43:38 +01:00
Nicolás Hatcher	41350fbd73	FIX: Run tests again and disable GEOMEAN test	2024-12-13 16:08:46 +01:00
Gian Hancock	17cd1fee96	Validate arg count for OR function To be compatible with Excel, at least 1 argument is required. Fixes #175	2024-12-12 13:06:12 +01:00
Gian Hancock	c59148bdf6	Add tests for OR function Tests currently fail due to issue #175	2024-12-12 13:06:12 +01:00
Andrew Fillmore	d4a2289826	Add GEOMEAN .xlsx, Update .md files, and Run `cargo fmt`	2024-12-12 05:58:20 +01:00
Andrew Fillmore	e5aff48e36	Add GEOMEAN Tests	2024-12-12 05:58:20 +01:00
Andrew Fillmore	4c3374c0de	Add GEOMEAN to Functions	2024-12-12 05:58:20 +01:00
Sinan Yumurtacı	5f3856350b	ugh	2024-12-12 05:49:25 +01:00
Sinan Yumurtaci	7058a59c45	two other typos	2024-12-12 05:49:25 +01:00
Sinan Yumurtaci	075760b7ba	typo	2024-12-12 05:49:25 +01:00
Nicolás Hatcher	8669962904	FIX: Apply biome "usafe" changes	2024-12-12 05:34:49 +01:00
Nicolás Hatcher	7b30736792	FIX: Make biome happy	2024-12-12 05:34:49 +01:00
Daniel	40c7fc8f80	FIX: Makes styling in Format Dialog consistent with Figmas	2024-12-12 05:34:49 +01:00
Daniel González-Albo	d8d694dd4a	FIX: Makes styling in Format Menu consistent with Figmas (#179 )	2024-12-12 05:13:07 +01:00
Daniel González-Albo	4b848f26dd	FIX: Makes footer/navigator scrollable when there are too many sheets (#180 )	2024-12-12 05:09:30 +01:00
Gian Hancock	2f660f85a7	Fix clippy lint (#177 )	2024-12-11 11:45:24 +01:00
Sinan Yumurtacı	eee40c1b9a	FIX: Prevent negative column width, row height (#167 ) * Prevent negative column width / row height in rust * prevent in front-end	2024-12-11 00:07:06 +01:00
Nicolás Hatcher Andrés	56915ce0b1	Merge pull request #173 from ironcalc/bugfix/nicolas-format-issue Bugfix/nicolas format issue	2024-12-10 00:39:30 +01:00
Nicolás Hatcher	a4a3b11858	FIX: Avoid freezing the app on frozen columns or rows	2024-12-09 22:33:22 +01:00
Nicolás Hatcher	65f1738473	FIX: Use unicode code points in getFormulaHTML function	2024-12-09 21:46:03 +01:00
Nicolás Hatcher	a05ff18e40	FIX: Stop propagation in Rename window We will need to do this in every widget in a more efficient manner	2024-12-09 19:51:28 +01:00
Nicolás Hatcher	4ef8a6882f	FIX[Format-parser]: Parse [$€]#,##0.00 correctly We will need to have a look at the format parser sooner rather than later though	2024-12-09 19:50:41 +01:00
Nicolás Hatcher Andrés	2f2a5e4fba	Merge pull request #172 from ironcalc/feature/dani-color-picker UPDATE: Color picker changes	2024-12-08 22:32:14 +01:00
Daniel	c39540a747	UPDATE: Changing the color picker to look like in the Figmas	2024-12-08 22:22:17 +01:00
Daniel	0fa69045f9	UPDATE: WIP	2024-12-08 22:22:17 +01:00
Nicolás Hatcher Andrés	23e958af0c	Merge pull request #171 from ironcalc/bugfix/dani-button-borders UPDATE: Moved Border button next to Background color button	2024-12-08 22:16:25 +01:00
Daniel	057835627b	UPDATE: Moved Border button next to Background color button	2024-12-08 21:54:34 +01:00
Nicolás Hatcher Andrés	4d6fdf9a4a	Merge pull request #170 from ironcalc/feature/nicolas-disable-coverage FIX: Disable coverage as it is failing for all	2024-12-08 17:15:23 +01:00
Nicolás Hatcher	5731b5cc27	FIX: Disable coverage as it is failing for all I have send them an email, maybe I can fix this	2024-12-08 17:08:25 +01:00
Nicolás Hatcher Andrés	592ef2415d	Merge pull request #169 from ironcalc/update/nicolas-fv-documentation Update/nicolas fv documentation	2024-12-08 16:21:56 +01:00
Nicolás Hatcher	cb6685f72a	FIX: Fv documentation. Some updates to the text	2024-12-08 11:11:48 +01:00
Nicolás Hatcher	8402bb0935	FIX: correct links in fv documentation	2024-12-08 01:55:34 +01:00
Nicolás Hatcher	91df91c425	FIX: Make biome happy	2024-12-07 12:45:49 +01:00
Daniel	4aa770c118	UPDATE: Makes 'File' button the same as 'Help', makes manu consistent	2024-12-07 12:45:49 +01:00
Daniel	c92c065073	UPDATE: Added a Help button	2024-12-07 12:45:49 +01:00
Daniel	6f124185b2	UPDATE: Cosmetic changes on file bar	2024-12-07 12:45:49 +01:00
stevethesleeve	17cf519d41	Update fv files (#162 ) * Files updated for FV function documentation. * Further FV changes	2024-12-07 12:25:57 +01:00
Sylvain Zimmer	bd1a1e3c97	Fix typo	2024-12-06 20:51:32 +01:00
Andrew Grosser	3d517a4af4	added updates from cargo fmt	2024-12-05 23:29:40 +01:00
Andrew Grosser	1734fd5740	added missing api functions for get_cell*	2024-12-05 23:29:40 +01:00
Daniel	d9dbd3bf14	UPDATE: Small fixes in Upload file Dialog	2024-12-05 00:11:41 +01:00
Nicolás Hatcher	d8a5c29e2f	FIX: Make Biome happy	2024-12-01 20:14:38 +01:00
Daniel	85cd7ab6a3	UPDATE: design adjustments in 'File' menu	2024-12-01 20:14:38 +01:00
Nicolás Hatcher	4b806c357a	FIX[parser]: Check the order (row, column) in range before transforming Fixes #155	2024-11-30 14:37:06 +01:00
Steve Fanning	3270d587ac	Minor update to the README file in docs.	2024-11-29 21:22:00 +01:00
Nicolás Hatcher	e065477b5a	FIX: Make clippy happy This is mostly Rust 1.83	2024-11-29 19:55:12 +01:00
Nicolás Hatcher	1f5f575e7a	UPDATE: Update chrono-tzand bitcode crate versions	2024-11-29 19:55:12 +01:00
Nicolás Hatcher	472740f296	UPDATE: Use regex-lite crate instead of of regex This removes almost 1Mb form the generated wasm(!!!)	2024-11-29 19:55:12 +01:00
Jonathan S	430b420435	Update about.md	2024-11-29 19:00:01 +01:00
Steve Fanning	48fd51fc8a	Minor improvements to CONTRIBUTING.md	2024-11-29 11:49:02 +01:00
Nicolás Hatcher	614d71b61c	UPDATE: Adds CONTRIBUTING guide an documentation	2024-11-28 22:42:14 +01:00
Nicolás Hatcher	38e21b9639	FIX: Small fix in app routing	2024-11-28 22:42:14 +01:00
Nicolás Hatcher	d6a462dbe3	FIX: Added changelog entry	2024-11-28 22:42:14 +01:00
Nicolás Hatcher	c1df2cec0b	FIX: Issues with paste Copy/Paste is always with tab separated values not "," or others. Maybe we can add that?	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	283a44e109	FIX: Aaahhh! Make the linter happy	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	f7dac8b015	FIX: fmt issues	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	df0aa51d14	FIX: Adds some tests	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	411c5de59b	FIX: Another round a borders Only test are missing(!)	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	0df132d5c2	FIX: Work undone We are not going to follow this path, but I will leave this commit as part of the git history	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	8cdb3b8c60	FIX: Removes ununsed borders code	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	d08fe32f97	FIX: color picker and border issues	2024-11-27 22:55:39 +01:00
Nicolás Hatcher	47acd0d600	FIX: Some fixes to the doumentation	2024-11-27 22:28:07 +01:00
Nicolás Hatcher	d70ab85396	FIX: Adds some more tests fro FORMULATEXT	2024-11-27 22:28:07 +01:00
Nicolás Hatcher	65b959cb1c	FIX: Forgotten file :S, adds documentation and CHANGELOG	2024-11-27 22:28:07 +01:00
Nicolás Hatcher	726fc1399d	UPDATE: Adds FORMULATEXT for Steve	2024-11-27 22:28:07 +01:00
Nicolás Hatcher	8ed0ab25f6	FIX: Fix run of python examples This needs to be properly fixed	2024-11-26 20:13:41 +01:00
Nicolás Hatcher	949eafc97f	FIX: Removes the csv-sniffer in favour of a simple guess This removes 500Kb form the was build so it is worth it. We were using a very old version of the sniffer, the last one might not have this bug though	2024-11-26 20:13:41 +01:00
Nicolás Hatcher	1f1fd24334	UPDATE: Reorder links. Add desktop app	2024-11-25 19:10:41 +01:00
Nicolás Hatcher	2b0c24de55	UPDATE: Adds bluesky link	2024-11-25 19:10:41 +01:00
Nicolás Hatcher	1aa9b6a220	FIX: Proper path for "Edit GitHub"	2024-11-25 19:10:41 +01:00
Nicolás Hatcher	94ebf33656	UPDATE: Remove docs artifacts that are not needed anymore generate_docs.rs was used to bootstrap the documentatio effords Unlikely to be used on a regular basis	2024-11-25 19:10:41 +01:00
Nicolás Hatcher	b3d4c479f6	UPDATE: CHANGELOG for the document server	2024-11-25 19:10:41 +01:00
Nicolás Hatcher	67aaa85a9a	FIX: Rename folder (fix typo)	2024-11-25 19:10:41 +01:00
Nicolás Hatcher	5d2953b894	FIX: Incorrect filename. Fixes #141	2024-11-25 08:32:21 +01:00
Nicolás Hatcher	b84aeb8bb9	FIX: Make Biome happy	2024-11-24 23:08:52 +01:00
Nicolás Hatcher	c5576af81b	FIX: Fixes according to design	2024-11-24 23:08:52 +01:00
Daniel	cb38eff899	UPDATE: text changes in some sections, adds placeholder pages	2024-11-24 23:08:52 +01:00
Nicolás Hatcher	16212b1518	FIX: Fixes broken links, rewording	2024-11-24 23:08:52 +01:00
Nicolás Hatcher	8243e231ab	UPDATE: Add placeholders for all functions	2024-11-24 23:08:52 +01:00
Nicolás Hatcher	48afb45eb9	UPDATE: Documents reorganization and some additions	2024-11-24 23:08:52 +01:00
Daniel	97846041e5	UPDATE: Adjusted settings, styling and basic content pages	2024-11-24 23:08:52 +01:00
Daniel	c1be1e47cb	UPDATE: First commit with the new documentation	2024-11-24 23:08:52 +01:00
Nicolás Hatcher	7efdbede3c	UPDATE: Add entry in CHANGELOG for UNICODE function 🚀	2024-11-17 17:08:22 +01:00
Bruno Carvalhal	be6819fec3	Remove unwrap logic	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	e130f784fd	add missing test case for multiple arguments in UNICODE	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	c2a2983937	Add missing UNICODE to to_xlsx_string	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	3c49f9a606	Add error cases	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	63817e2d50	Also accept _xlfn.UNICODE	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	028ae1ce98	Change output formatting of UNICODE to Number	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	a4a40c6fd0	Add test workbook for UNICODE	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	0ed2984358	Add code coverage	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	0b1199056f	Remove unneeded comment	2024-11-17 16:49:41 +01:00
Bruno Carvalhal	726bf677ed	Implement UNICODE function	2024-11-17 16:49:41 +01:00
Nicolás Hatcher	d681f63b25	FIX: Test also full rows and columns in IRR function This means functions like `=IRR(A:A)` or `=IRR(1:1)`	2024-11-17 11:59:10 +01:00
Nicolás Hatcher	ba5869420b	FIX: Run covergae also on merge in main	2024-11-17 11:59:10 +01:00
Nicolás Hatcher	420ea9829c	FIX: Refactor some finatial functions to use common code	2024-11-17 11:59:10 +01:00
Nicolás Hatcher	49ae2d8915	FIX: Forbid unwrap, expect and panic in the base code	2024-11-17 11:59:10 +01:00
Nicolás Hatcher	bdd2c8fe04	FIX: Fix several indentation issues in comments Thanks clippy!	2024-11-17 11:59:10 +01:00