UPDATE: Webapp

FIX: Initial browse mode within sheets
FIX: Minimal implementation of browse mode
2024-10-06 16:06:56 +02:00 · 2024-09-28 15:26:55 +02:00 · 2024-09-28 13:55:52 +02:00 · 2024-09-27 19:25:26 +02:00 · 2024-09-26 19:08:16 +02:00
945 changed files with 12445 additions and 55251 deletions
--- a/.github/workflows/npm.yml
+++ b/.github/workflows/npm.yml
@@ -1,443 +0,0 @@
-name: nodejs
-env:
-  DEBUG: napi:*
-  APP_NAME: nodejs
-  MACOSX_DEPLOYMENT_TARGET: '10.13'
-permissions:
-  contents: write
-  id-token: write
-'on':
-  workflow_dispatch:
-    inputs:
-      publish:
-        description: "Publish to npm"
-        required: true
-        type: boolean
-defaults:
-  run:
-    working-directory: ./bindings/nodejs
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-            build: yarn build --target x86_64-apple-darwin
-          - host: windows-latest
-            build: yarn build --target x86_64-pc-windows-msvc
-            target: x86_64-pc-windows-msvc
-          - host: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
-            build: |
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              yarn build --target x86_64-unknown-linux-gnu
-          - host: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: |
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              yarn build --target x86_64-unknown-linux-musl
-          - host: macos-latest
-            target: aarch64-apple-darwin
-            build: |
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              yarn build --target aarch64-apple-darwin
-          - host: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
-            build: |
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              rustup target add aarch64-unknown-linux-gnu &&
-              yarn build --target aarch64-unknown-linux-gnu
-          - host: ubuntu-latest
-            target: armv7-unknown-linux-gnueabihf
-            setup: |
-              sudo apt-get update
-              sudo apt-get install -y gcc-arm-linux-gnueabihf libc6-dev-armhf-cross
-            build: |
-              set -e
-              rustup toolchain install 1.90.0
-              rustup default 1.90.0
-              export CC_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc
-              export AR_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-ar
-              export CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc
-              export PKG_CONFIG_ALLOW_CROSS=1
-              yarn build --target armv7-unknown-linux-gnueabihf
-          # - host: ubuntu-latest
-          #   target: armv7-unknown-linux-musleabihf
-          #   build: |
-          #     set -e
-          #     rustup toolchain install 1.90.0
-          #     rustup default 1.90.0
-          #     # Use Zig as the MUSL cross C toolchain
-          #     export CC_armv7_unknown_linux_musleabihf="zig cc -target armv7-linux-musleabihf -mfpu=vfpv3-d16 -mfloat-abi=hard"
-          #     export CARGO_TARGET_ARMV7_UNKNOWN_LINUX_MUSLEABIHF_LINKER="zig cc -target armv7-linux-musleabihf -mfpu=vfpv3-d16 -mfloat-abi=hard"
-          #     export AR_armv7_unknown_linux_musleabihf="zig ar"
-          #     export PKG_CONFIG_ALLOW_CROSS=1
-          #     yarn build --target armv7-unknown-linux-musleabihf
-          - host: ubuntu-latest
-            target: aarch64-linux-android
-            build: |
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              yarn build --target aarch64-linux-android
-          - host: ubuntu-latest
-            target: armv7-linux-androideabi
-            build: |
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              yarn build --target armv7-linux-androideabi
-          - host: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: |-
-              set -e &&
-              rustup toolchain install 1.90.0 &&
-              rustup default 1.90.0 &&
-              rustup target add aarch64-unknown-linux-musl &&
-              yarn build --target aarch64-unknown-linux-musl
-          - host: windows-latest
-            target: aarch64-pc-windows-msvc
-            build: yarn build --target aarch64-pc-windows-msvc
-          - host: ubuntu-latest
-            target: riscv64gc-unknown-linux-gnu
-            setup: |
-              sudo apt-get update
-              sudo apt-get install gcc-riscv64-linux-gnu -y
-            build: yarn build --target riscv64gc-unknown-linux-gnu
-    name: stable - ${{ matrix.settings.target }} - node@20
-    runs-on: ${{ matrix.settings.host }}
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        if: ${{ !matrix.settings.docker }}
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install
-        uses: dtolnay/rust-toolchain@stable
-        if: ${{ !matrix.settings.docker }}
-        with:
-          toolchain: 1.90.0
-          targets: ${{ matrix.settings.target }}
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            .cargo-cache
-            target/
-          key: ${{ matrix.settings.target }}-cargo-${{ matrix.settings.host }}
-      - uses: goto-bus-stop/setup-zig@v2
-        if: ${{ matrix.settings.target == 'armv7-unknown-linux-gnueabihf' || matrix.settings.target == 'armv7-unknown-linux-musleabihf' }}
-        with:
-          version: 0.13.0
-      - name: Setup toolchain
-        run: ${{ matrix.settings.setup }}
-        if: ${{ matrix.settings.setup }}
-        shell: bash
-      - name: Install dependencies
-        run: yarn install
-      - name: Build in docker
-        uses: addnab/docker-run-action@v3
-        if: ${{ matrix.settings.docker }}
-        with:
-          image: ${{ matrix.settings.docker }}
-          options: '--user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: ${{ matrix.settings.build }}
-      - name: Build
-        run: ${{ matrix.settings.build }}
-        if: ${{ !matrix.settings.docker }}
-        shell: bash
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bindings-${{ matrix.settings.target }}
-          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
-          if-no-files-found: error
-  test-macOS-windows-binding:
-    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-          - host: windows-latest
-            target: x86_64-pc-windows-msvc
-        node:
-          - '20'
-    runs-on: ${{ matrix.settings.host }}
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-          architecture: x64
-      - name: Install dependencies
-        run: yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-${{ matrix.settings.target }}
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: yarn test
-  test-linux-x64-gnu-binding:
-    name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-unknown-linux-gnu
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-slim yarn test
-  test-linux-x64-musl-binding:
-    name: Test bindings on x86_64-unknown-linux-musl - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.libc "musl"
-          yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-unknown-linux-musl
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-alpine yarn test
-  test-linux-aarch64-gnu-binding:
-    name: Test bindings on aarch64-unknown-linux-gnu - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-unknown-linux-gnu
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm64"
-          yarn config set supportedArchitectures.libc "glibc"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:${{ matrix.node }}-slim
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-            ls -la
-  test-linux-aarch64-musl-binding:
-    name: Test bindings on aarch64-unknown-linux-musl - node@${{ matrix.node }}
-    needs:
-      - build
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-unknown-linux-musl
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm64"
-          yarn config set supportedArchitectures.libc "musl"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:lts-alpine
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-  universal-macOS:
-    name: Build universal macOS binary
-    needs:
-      - build
-    runs-on: macos-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download macOS x64 artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-apple-darwin
-          path: bindings/nodejs/artifacts
-      - name: Download macOS arm64 artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-apple-darwin
-          path: bindings/nodejs/artifacts
-      - name: Combine binaries
-        run: yarn universal
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bindings-universal-apple-darwin
-          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
-          if-no-files-found: error
-  publish:
-    name: Publish
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    needs:
-      - test-macOS-windows-binding
-      - test-linux-x64-gnu-binding
-      - test-linux-x64-musl-binding
-      - test-linux-aarch64-gnu-binding
-      - test-linux-aarch64-musl-binding
-      - universal-macOS
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: bindings/nodejs/artifacts
-      - name: Move artifacts
-        run: yarn artifacts
-      - name: List packages
-        run: ls -R ./npm
-        shell: bash
-      - name: Publish
-        run: |
-          echo "${{ github.event.inputs.publish }}"
-          if [ "${{ github.event.inputs.publish }}" = "true" ]; then
-            echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
-            npm publish --access public
-            echo "Published to npm"
-          else
-            echo "Not a release, skipping publish"
-          fi
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/publish-wiki.yml
+++ b/.github/workflows/publish-wiki.yml
@@ -0,0 +1,18 @@
+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/pypi.yml
+++ b/.github/workflows/pypi.yml
@@ -1,141 +0,0 @@
-name: Upload component to Python Package Index
-
-on:
-  workflow_dispatch:
-    inputs:
-      release:
-        type: boolean
-        default: false
-        required: false
-        description: "Release? If false, publish to test.pypi.org, if true, publish to pypi.org"
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          manylinux: auto
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-${{ matrix.target }}
-          path: bindings/python/dist
-
-  windows:
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        target: [x64, x86]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-          architecture: ${{ matrix.target }}
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-${{ matrix.target }}
-          path: bindings/python/dist
-
-  macos:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        target: [x86_64, aarch64]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-${{ matrix.target }}
-          path: bindings/python/dist
-
-  sdist:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Build sdist
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist
-          working-directory: bindings/python
-      - name: Upload sdist
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-sdist
-          path: bindings/python/dist
-
-  publish-to-test-pypi:
-    if: ${{ github.event.inputs.release != 'true' }}
-    name: >-
-        Publish Python 🐍 distribution 📦 to Test PyPI
-    runs-on: ubuntu-latest
-    needs: [linux, windows, macos, sdist]
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          path: bindings/python/
-      - name: Publish distribution 📦 to Test PyPI
-        uses: PyO3/maturin-action@v1
-        env:
-          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_TEST_API_TOKEN }}
-          MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
-        with:
-          command: upload
-          args: "--skip-existing **/*.whl **/*.tar.gz"
-          working-directory: bindings/python
-
-  publish-pypi:
-    if: ${{ github.event.inputs.release == 'true' }}
-    name: >-
-        Publish Python 🐍 distribution 📦 to PyPI
-    runs-on: ubuntu-latest
-    needs: [linux, windows, macos, sdist]
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          path: bindings/python/
-      - name: Publish distribution 📦 to PyPI
-        uses: PyO3/maturin-action@v1
-        env:
-          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
-          MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
-        with:
-          command: upload
-          args: "--skip-existing **/*.whl **/*.tar.gz"
-          working-directory: bindings/python
--- a/.github/workflows/test-coverage.yaml
+++ b/.github/workflows/test-coverage.yaml
@@ -1,7 +1,6 @@
 name: Coverage

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

 jobs:
  coverage:
@@ -17,9 +16,8 @@ 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@v5
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        uses: codecov/codecov-action@v3
        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
          files: lcov.info
          fail_ci_if_error: true
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,2 @@
 target/*
-**/node_modules/**
 .DS_Store
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,36 +0,0 @@
-# CHANGELOG
-
-## Unreleased
-
-### Added
-
- New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
- New document server (Thanks Dani!)
- New function FORMULATEXT
- Name Manager ([#212](https://github.com/ironcalc/IronCalc/pull/212) [#220](https://github.com/ironcalc/IronCalc/pull/220))
- Add context menu. We can now insert rows and columns. Freeze and unfreeze rows and columns. Delete rows and columns [#271]
- Add nodejs bindings [#254]
- Add python bindings for all platforms
- Add is split into the product and widget
- Add Python documentation [#260]
-
-### 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
- Undo/redo when add/delete sheet now works [#270]
- Numerous small fixes
- Multiple fixes to the documentation
-
-## [0.2.0] - 2024-11-06 (The HN release)
-
-### Added
-
- Rust crate ironcalc_base
- Rust crate ironcalc
- Minimal Python bindings (only Linux)
- JavaScript bindings
- React WebApp
-
-[0.2.0]: https://github.com/IronCalc/ironcalc/releases/tag/v0.2.0
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,73 +0,0 @@
-# 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 = 4
+version = 3

 [[package]]
 name = "adler"
@@ -43,12 +43,6 @@ 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"
@@ -63,34 +57,25 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"

 [[package]]
 name = "bitcode"
-version = "0.6.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee1bce7608560cd4bf0296a4262d0dbf13e6bcec5ff2105724c8ab88cc7fc784"
+checksum = "48bc1c27654127a24c476d40198746860ef56475f41a601bfa5c4d0f832968f0"
 dependencies = [
- "arrayvec",
 "bitcode_derive",
 "bytemuck",
- "glam",
- "serde",
 ]

 [[package]]
 name = "bitcode_derive"
-version = "0.6.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a539389a13af092cd345a2b47ae7dec12deb306d660b2223d25cd3419b253ebe"
+checksum = "2966755a19aad59ee2aae91e2d48842c667a99d818ec72168efdab07200701cc"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]

-[[package]]
-name = "bitflags"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
-
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -157,9 +142,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
 dependencies = [
 "android-tzdata",
 "iana-time-zone",
@@ -171,9 +156,9 @@ dependencies = [

 [[package]]
 name = "chrono-tz"
-version = "0.10.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd6dd8046d00723a59a2f8c5f295c515b9bb9a331ee4f8f3d4dd49e428acd3b6"
+checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb"
 dependencies = [
 "chrono",
 "chrono-tz-build",
@@ -182,11 +167,12 @@ dependencies = [

 [[package]]
 name = "chrono-tz-build"
-version = "0.4.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94fea34d77a245229e7746bd2beb786cd2a896f306ff491fb8cecb3074b10a7"
+checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1"
 dependencies = [
 "parse-zoneinfo",
+ "phf",
 "phf_codegen",
 ]

@@ -216,15 +202,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"

-[[package]]
-name = "convert_case"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.6"
@@ -265,43 +242,6 @@ dependencies = [
 "typenum",
 ]

-[[package]]
-name = "csv"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
-dependencies = [
- "csv-core",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "ctor"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67773048316103656a637612c4a62477603b777d91d9c62ff2290f9cde178fdb"
-dependencies = [
- "ctor-proc-macro",
- "dtor",
-]
-
-[[package]]
-name = "ctor-proc-macro"
-version = "0.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2931af7e13dc045d8e9d26afccc6fa115d64e115c9c84b1166288b46f6782c2"
-
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -322,21 +262,6 @@ dependencies = [
 "subtle",
 ]

-[[package]]
-name = "dtor"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e58a0764cddb55ab28955347b45be00ade43d4d6f3ba4bf3dc354e4ec9432934"
-dependencies = [
- "dtor-proc-macro",
-]
-
-[[package]]
-name = "dtor-proc-macro"
-version = "0.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
-
 [[package]]
 name = "either"
 version = "1.10.0"
@@ -374,12 +299,6 @@ 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"
@@ -435,7 +354,7 @@ dependencies = [

 [[package]]
 name = "ironcalc"
-version = "0.6.0"
+version = "0.2.0"
 dependencies = [
 "bitcode",
 "chrono",
@@ -451,32 +370,20 @@ dependencies = [

 [[package]]
 name = "ironcalc_base"
-version = "0.6.0"
+version = "0.2.0"
 dependencies = [
 "bitcode",
 "chrono",
 "chrono-tz",
- "csv",
 "js-sys",
+ "once_cell",
 "rand",
 "regex",
- "regex-lite",
 "ryu",
 "serde",
 "serde_json",
 ]

-[[package]]
-name = "ironcalc_nodejs"
-version = "0.6.0"
-dependencies = [
- "ironcalc",
- "napi",
- "napi-build",
- "napi-derive",
- "serde",
-]
-
 [[package]]
 name = "itertools"
 version = "0.12.1"
@@ -516,16 +423,6 @@ version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"

-[[package]]
-name = "libloading"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
-dependencies = [
- "cfg-if",
- "windows-targets",
-]
-
 [[package]]
 name = "log"
 version = "0.4.21"
@@ -556,70 +453,6 @@ dependencies = [
 "adler",
 ]

-[[package]]
-name = "napi"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b74e3dce5230795bb4d2821b941706dee733c7308752507254b0497f39cad7"
-dependencies = [
- "bitflags",
- "ctor",
- "napi-build",
- "napi-sys",
- "nohash-hasher",
- "rustc-hash",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "napi-build"
-version = "2.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcae8ad5609d14afb3a3b91dee88c757016261b151e9dcecabf1b2a31a6cab14"
-
-[[package]]
-name = "napi-derive"
-version = "3.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7552d5a579b834614bbd496db5109f1b9f1c758f08224b0dee1e408333adf0d0"
-dependencies = [
- "convert_case",
- "ctor",
- "napi-derive-backend",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "napi-derive-backend"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6a81ac7486b70f2532a289603340862c06eea5a1e650c1ffeda2ce1238516a"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "semver",
- "syn",
-]
-
-[[package]]
-name = "napi-sys"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e4e7135a8f97aa0f1509cce21a8a1f9dcec1b50d8dee006b48a5adb69a9d64d"
-dependencies = [
- "libloading",
-]
-
-[[package]]
-name = "nohash-hasher"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
-
 [[package]]
 name = "num-conv"
 version = "0.1.0"
@@ -643,9 +476,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"

 [[package]]
 name = "parse-zoneinfo"
-version = "0.3.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
+checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
 dependencies = [
 "regex",
 ]
@@ -746,10 +579,11 @@ dependencies = [

 [[package]]
 name = "pyo3"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
+checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
 dependencies = [
+ "cfg-if",
 "indoc",
 "libc",
 "memoffset",
@@ -763,9 +597,9 @@ dependencies = [

 [[package]]
 name = "pyo3-build-config"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
+checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
 dependencies = [
 "once_cell",
 "target-lexicon",
@@ -773,9 +607,9 @@ dependencies = [

 [[package]]
 name = "pyo3-ffi"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
+checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
 dependencies = [
 "libc",
 "pyo3-build-config",
@@ -783,9 +617,9 @@ dependencies = [

 [[package]]
 name = "pyo3-macros"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
+checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
 dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
@@ -795,9 +629,9 @@ dependencies = [

 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
+checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
 dependencies = [
 "heck",
 "proc-macro2",
@@ -808,9 +642,8 @@ dependencies = [

 [[package]]
 name = "pyroncalc"
-version = "0.6.0"
+version = "0.1.2"
 dependencies = [
- "bitcode",
 "ironcalc",
 "pyo3",
 "serde",
@@ -879,12 +712,6 @@ dependencies = [
 "regex-syntax",
 ]

-[[package]]
-name = "regex-lite"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.3"
@@ -897,18 +724,6 @@ version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"

-[[package]]
-name = "rustc-hash"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
-
-[[package]]
-name = "rustversion"
-version = "1.0.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
-
 [[package]]
 name = "ryu"
 version = "1.0.17"
@@ -921,12 +736,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"

-[[package]]
-name = "semver"
-version = "1.0.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
-
 [[package]]
 name = "serde"
 version = "1.0.197"
@@ -1016,9 +825,9 @@ dependencies = [

 [[package]]
 name = "target-lexicon"
-version = "0.13.2"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"

 [[package]]
 name = "thiserror"
@@ -1071,12 +880,6 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

-[[package]]
-name = "unicode-segmentation"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
-
 [[package]]
 name = "unindent"
 version = "0.2.3"
@@ -1107,7 +910,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasm"
-version = "0.6.0"
+version = "0.1.3"
 dependencies = [
 "ironcalc_base",
 "serde",
@@ -1118,24 +921,23 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
 "cfg-if",
- "once_cell",
- "rustversion",
 "wasm-bindgen-macro",
 ]

 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
 "bumpalo",
 "log",
+ "once_cell",
 "proc-macro2",
 "quote",
 "syn",
@@ -1156,9 +958,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
@@ -1166,9 +968,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1179,12 +981,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
-dependencies = [
- "unicode-ident",
-]
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"

 [[package]]
 name = "wasm-bindgen-test"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,12 +6,10 @@ members = [
  "xlsx",
  "bindings/wasm",
  "bindings/python",
-  "bindings/nodejs",
 ]

 exclude = [
  "generate_locale",
-  "webapp/app.ironcalc.com/server",
 ]

 [profile.release]
--- a/93
+++ b/93
@@ -1,93 +0,0 @@
-FROM rust:latest AS builder
-
-WORKDIR /app
-COPY . .
-
-# Tools + wasm toolchain + Node via nvm
-RUN apt-get update && apt-get install -y --no-install-recommends \
-      bash curl ca-certificates make \
-    && rustup target add wasm32-unknown-unknown \
-    && cargo install wasm-pack \
-    && bash -lc "curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash -" \
-    && bash -lc '\
-         export NVM_DIR="$HOME/.nvm" && \
-         source "$NVM_DIR/nvm.sh" && \
-         nvm install 22 && nvm alias default 22 && \
-         nroot="$NVM_DIR/versions/node/$(nvm version default)/bin" && \
-         ln -sf "$nroot/node" /usr/local/bin/node && \
-         ln -sf "$nroot/npm"  /usr/local/bin/npm  && \
-         ln -sf "$nroot/npx"  /usr/local/bin/npx \
-       ' \
-    && npm install typescript \
-    && rm -rf /var/lib/apt/lists/*
-
-# build the server
-RUN cargo build --release --manifest-path webapp/app.ironcalc.com/server/Cargo.toml
-
-# build the wasm
-RUN make -C bindings/wasm
-
-# build the widget
-WORKDIR /app/webapp/IronCalc
-RUN npm install && npm run build
-
-# build the frontend app
-WORKDIR /app/webapp/app.ironcalc.com/frontend
-RUN npm install && npm run build
-
-# build the xlsx_2_icalc binary (we don't need the release version here)
-WORKDIR /app/xlsx
-RUN cargo build
-
-WORKDIR /app
-# copy the artifacts to a dist/ directory
-RUN mkdir dist
-RUN mkdir dist/frontend
-RUN cp -r webapp/app.ironcalc.com/frontend/dist/* dist/frontend/
-RUN mkdir dist/server
-RUN cp webapp/app.ironcalc.com/server/target/release/ironcalc_server dist/server/
-RUN cp webapp/app.ironcalc.com/server/Rocket.toml dist/server/
-RUN cp webapp/app.ironcalc.com/server/ironcalc.sqlite dist/server/
-
-# Create ic files in docs
-RUN mkdir -p dist/frontend/models
-
-# Loop over all xlsx files in xlsx/tests/docs & templates and convert them to .ic
-RUN bash -lc 'set -euo pipefail; \
-  mkdir -p dist/frontend/models; \
-  shopt -s nullglob; \
-  for xlsx_file in xlsx/tests/docs/*.xlsx; do \
-    base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
-    ./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
-  done; \
-  for xlsx_file in xlsx/tests/templates/*.xlsx; do \
-    base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
-    ./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
-  done'
-
-# ---------- server runtime ----------
-FROM debian:bookworm-slim AS server-runtime
-RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && \
-    rm -rf /var/lib/apt/lists/*
-WORKDIR /app
-# Copy EVERYTHING you put in dist/server (binary + Rocket.toml + DB)
-COPY --from=builder /app/dist/server/ ./
-# Make sure Rocket binds to the container IP; explicitly point to the config file
-ENV ROCKET_ADDRESS=0.0.0.0 \
-    ROCKET_PORT=8000 \
-    ROCKET_CONFIG=/app/Rocket.toml
-EXPOSE 8000
-# Run from /app so relative paths in Rocket.toml/DB work
-CMD ["./ironcalc_server"]
-
-# ---------- caddy runtime (serves frontend + reverse-proxy /api) ----------
-FROM caddy:latest AS caddy-runtime
-
-WORKDIR /srv
-
-# Copy the frontend build output to /srv
-COPY --from=builder /app/dist/frontend/ /srv/
-
-# Copy the Caddyfile
-COPY --from=builder /app/webapp/app.ironcalc.com/Caddyfile.compose /etc/caddy/Caddyfile
-
--- a/15
+++ b/15
@@ -1,9 +1,8 @@
 .PHONY: lint
 lint:
 	cargo fmt -- --check
-	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
-	cd webapp/IronCalc/ && npm install && npm run check
-	cd webapp/app.ironcalc.com/frontend/ && npm install && npm run check
+	cargo clippy --all-targets --all-features
+	cd webapp && npm install && npm run check

 .PHONY: format
 format:
@@ -12,11 +11,13 @@ 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.
 	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
-	cd webapp/IronCalc/ && npm run test
+	cd webapp && npm run test
 	cd bindings/python && ./run_tests.sh && ./run_examples.sh

 .PHONY: remove-artifacts
@@ -24,6 +25,7 @@ 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
@@ -41,6 +43,11 @@ 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/README.md
+++ b/README.md
@@ -31,17 +31,7 @@ This repository contains the main engine and the xlsx reader and writer.

 Programmed in Rust, you will be able to use it from a variety of programming languages like Python, JavaScript (wasm), nodejs and possibly R, Julia or Go.

-We will build different _skins_: in the terminal, as a desktop application or use it in your own web application.
-
-# Docker
-
-If you have docker installed just run:
-
-```bash
-docker compose up --build
-```
-
-head over to <http://localhost:2080> to test the application.
+We will build different _skins_: in the terminal, as a desktop application or use it in you own web application.

 # Building

@@ -87,14 +77,14 @@ And visit <http://0.0.0.0:8000/ironcalc/>
 Add the dependency to `Cargo.toml`:
 ```toml
 [dependencies]
-ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.5"}
+ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
 ```

 And then use this code in `main.rs`:

 ```rust
 use ironcalc::{
-    base::{expressions::utils::number_to_column, Model},
+    base::{expressions::utils::number_to_column, model::Model},
    export::save_to_xlsx,
 };

@@ -133,7 +123,7 @@ See https://github.com/ironcalc

 An early preview of the technology running entirely in your browser:

-https://app.ironcalc.com
+https://playground.ironcalc.com


 # Collaborators needed!. Call to action
--- a/base/Cargo.toml
+++ b/base/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 name = "ironcalc_base"
-version = "0.6.0"
+version = "0.2.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
 repository = "https://github.com/ironcalc/ironcalc/"
-description = "Open source spreadsheet engine"
+description = "The democratization of spreadsheets"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,16 +14,10 @@ readme = "README.md"
 serde = { version = "1.0", features = ["derive"] }
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.10"
-regex = { version = "1.0", optional = true}
-regex-lite = { version = "0.1.6", optional = true}
-bitcode = "0.6.3"
-csv = "1.3.0"
-
-[features]
-default = ["use_regex_full"]
-use_regex_full = ["regex"]
-use_regex_lite = ["regex-lite"]
+chrono-tz = "0.9"
+regex = "1.0"
+once_cell = "1.16.0"
+bitcode = "0.6.0"

 [dev-dependencies]
 serde_json = "1.0"
--- a/base/src/actions.rs
+++ b/base/src/actions.rs
@@ -1,6 +1,5 @@
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
-use crate::expressions::types::CellReferenceRC;
+use crate::expressions::parser::stringify::DisplaceData;
 use crate::model::Model;

 // NOTE: There is a difference with Excel behaviour when deleting cells/rows/columns
@@ -9,45 +8,16 @@ use crate::model::Model;
 // I feel this is unimportant for now.

 impl Model {
-    fn shift_cell_formula(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-        displace_data: &DisplaceData,
-    ) -> Result<(), String> {
-        if let Some(f) = self
-            .workbook
-            .worksheet(sheet)?
-            .cell(row, column)
-            .and_then(|c| c.get_formula())
-        {
-            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
-            let cell_reference = CellReferenceRC {
-                sheet: self.workbook.worksheets[sheet as usize].get_name(),
-                row,
-                column,
-            };
-            // FIXME: This is not a very performant way if the formula has changed :S.
-            let formula = to_string(node, &cell_reference);
-            let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
-            if formula != formula_displaced {
-                self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?;
-            }
-        }
-        Ok(())
-    }
    /// This function iterates over all cells in the model and shifts their formulas according to the displacement data.
    ///
    /// # Arguments
    ///
    /// * `displace_data` - A reference to `DisplaceData` describing the displacement's direction and magnitude.
-    fn displace_cells(&mut self, displace_data: &DisplaceData) -> Result<(), String> {
+    fn displace_cells(&mut self, displace_data: &DisplaceData) {
        let cells = self.get_all_cells();
        for cell in cells {
-            self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data)?;
+            self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data);
        }
-        Ok(())
    }

    /// Retrieves the column indices for a specific row in a given sheet, sorted in ascending or descending order.
@@ -164,34 +134,7 @@ impl Model {
                column,
                delta: column_count,
            }),
-        )?;
-
-        // In the list of columns:
-        // * Keep all the columns to the left
-        // * Displace all the columns to the right
-
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-
-        let mut new_columns = Vec::new();
-        for col in worksheet.cols.iter_mut() {
-            // range under study
-            let min = col.min;
-            let max = col.max;
-            if column > max {
-                // If the range under study is to our left, this is a noop
-            } else if column <= min {
-                // If the range under study is to our right, we displace it
-                col.min = min + column_count;
-                col.max = max + column_count;
-            } else {
-                // If the range under study is in the middle we augment it
-                col.max = max + column_count;
-            }
-            new_columns.push(col.clone());
-        }
-        // TODO: If in a row the cell to the right and left have the same style we should copy it
-
-        worksheet.cols = new_columns;
+        );

        Ok(())
    }
@@ -212,12 +155,6 @@ impl Model {
        if column_count <= 0 {
            return Err("Please use insert columns instead".to_string());
        }
-        if !(1..=LAST_COLUMN).contains(&column) {
-            return Err(format!("Column number '{column}' is not valid."));
-        }
-        if column + column_count - 1 > LAST_COLUMN {
-            return Err("Cannot delete columns beyond the last column of the sheet".to_string());
-        }

        // first column being deleted
        let column_start = column;
@@ -250,7 +187,7 @@ impl Model {
                column,
                delta: -column_count,
            }),
-        )?;
+        );
        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;

        // deletes all the column styles
@@ -374,7 +311,7 @@ impl Model {
                row,
                delta: row_count,
            }),
-        )?;
+        );

        Ok(())
    }
@@ -390,13 +327,6 @@ impl Model {
        if row_count <= 0 {
            return Err("Please use insert rows instead".to_string());
        }
-        if !(1..=LAST_ROW).contains(&row) {
-            return Err(format!("Row number '{row}' is not valid."));
-        }
-        if row + row_count - 1 > LAST_ROW {
-            return Err("Cannot delete rows beyond the last row of the sheet".to_string());
-        }
-
        // Move cells
        let worksheet = &self.workbook.worksheet(sheet)?;
        let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -442,7 +372,7 @@ impl Model {
                row,
                delta: -row_count,
            }),
-        )?;
+        );
        Ok(())
    }

@@ -457,86 +387,23 @@ impl Model {
    ///    * Column is one of the extremes of the range. The new extreme would be target_column.
    ///      Range is then normalized
    ///    * Any other case, range is left unchanged.
-    ///      NOTE: This moves the data and column styles along with the formulas
+    /// NOTE: This does NOT move the data in the columns or move the colum styles
    pub fn move_column_action(
        &mut self,
        sheet: u32,
        column: i32,
        delta: i32,
-    ) -> Result<(), String> {
+    ) -> Result<(), &'static str> {
        // Check boundaries
        let target_column = column + delta;
        if !(1..=LAST_COLUMN).contains(&target_column) {
-            return Err("Target column out of boundaries".to_string());
+            return Err("Target column out of boundaries");
        }
        if !(1..=LAST_COLUMN).contains(&column) {
-            return Err("Initial column out of boundaries".to_string());
+            return Err("Initial column out of boundaries");
        }

-        if delta == 0 {
-            return Ok(());
-        }
-
-        // Preserve cell contents, width and style of the column being moved
-        let original_refs = self
-            .workbook
-            .worksheet(sheet)?
-            .column_cell_references(column)?;
-        let mut original_cells = Vec::new();
-        for r in &original_refs {
-            let cell = self
-                .workbook
-                .worksheet(sheet)?
-                .cell(r.row, column)
-                .ok_or("Expected Cell to exist")?;
-            let style_idx = cell.get_style();
-            let formula_or_value = self
-                .get_cell_formula(sheet, r.row, column)?
-                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
-            original_cells.push((r.row, formula_or_value, style_idx));
-            self.cell_clear_all(sheet, r.row, column)?;
-        }
-
-        let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
-        let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
-
-        if delta > 0 {
-            for c in column + 1..=target_column {
-                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
-                for r in refs {
-                    self.move_cell(sheet, r.row, c, r.row, c - 1)?;
-                }
-
-                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
-                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .set_column_width_and_style(c - 1, w, s)?;
-            }
-        } else {
-            for c in (target_column..=column - 1).rev() {
-                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
-                for r in refs {
-                    self.move_cell(sheet, r.row, c, r.row, c + 1)?;
-                }
-
-                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
-                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .set_column_width_and_style(c + 1, w, s)?;
-            }
-        }
-
-        for (r, value, style_idx) in original_cells {
-            self.set_user_input(sheet, r, target_column, value)?;
-            self.workbook
-                .worksheet_mut(sheet)?
-                .set_cell_style(r, target_column, style_idx)?;
-        }
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_column_width_and_style(target_column, width, style)?;
+        // TODO: Add the actual displacement of data and styles

        // Update all formulas in the workbook
        self.displace_cells(
@@ -545,91 +412,7 @@ impl Model {
                column,
                delta,
            }),
-        )?;
-
-        Ok(())
-    }
-
-    /// Displaces cells due to a move row action
-    /// from initial_row to target_row = initial_row + row_delta
-    /// References will be updated following the same rules as move_column_action
-    /// NOTE: This moves the data and row styles along with the formulas
-    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
-        // Check boundaries
-        let target_row = row + delta;
-        if !(1..=LAST_ROW).contains(&target_row) {
-            return Err("Target row out of boundaries".to_string());
-        }
-        if !(1..=LAST_ROW).contains(&row) {
-            return Err("Initial row out of boundaries".to_string());
-        }
-
-        if delta == 0 {
-            return Ok(());
-        }
-
-        let original_cols = self.get_columns_for_row(sheet, row, false)?;
-        let mut original_cells = Vec::new();
-        for c in &original_cols {
-            let cell = self
-                .workbook
-                .worksheet(sheet)?
-                .cell(row, *c)
-                .ok_or("Expected Cell to exist")?;
-            let style_idx = cell.get_style();
-            let formula_or_value = self
-                .get_cell_formula(sheet, row, *c)?
-                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
-            original_cells.push((*c, formula_or_value, style_idx));
-            self.cell_clear_all(sheet, row, *c)?;
-        }
-
-        if delta > 0 {
-            for r in row + 1..=target_row {
-                let cols = self.get_columns_for_row(sheet, r, false)?;
-                for c in cols {
-                    self.move_cell(sheet, r, c, r - 1, c)?;
-                }
-            }
-        } else {
-            for r in (target_row..=row - 1).rev() {
-                let cols = self.get_columns_for_row(sheet, r, false)?;
-                for c in cols {
-                    self.move_cell(sheet, r, c, r + 1, c)?;
-                }
-            }
-        }
-
-        for (c, value, style_idx) in original_cells {
-            self.set_user_input(sheet, target_row, c, value)?;
-            self.workbook
-                .worksheet_mut(sheet)?
-                .set_cell_style(target_row, c, style_idx)?;
-        }
-
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-        let mut new_rows = Vec::new();
-        for r in worksheet.rows.iter() {
-            if r.r == row {
-                let mut nr = r.clone();
-                nr.r = target_row;
-                new_rows.push(nr);
-            } else if delta > 0 && r.r > row && r.r <= target_row {
-                let mut nr = r.clone();
-                nr.r -= 1;
-                new_rows.push(nr);
-            } else if delta < 0 && r.r < row && r.r >= target_row {
-                let mut nr = r.clone();
-                nr.r += 1;
-                new_rows.push(nr);
-            } else {
-                new_rows.push(r.clone());
-            }
-        }
-        worksheet.rows = new_rows;
-
-        // Update all formulas in the workbook
-        self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
+        );

        Ok(())
    }
--- a/base/src/arithmetic.rs
+++ b/base/src/arithmetic.rs
@@ -1,158 +0,0 @@
-use crate::{
-    calc_result::CalcResult,
-    cast::NumberOrArray,
-    expressions::{
-        parser::{ArrayNode, Node},
-        token::Error,
-        types::CellReferenceIndex,
-    },
-    model::Model,
-};
-
-/// Unify how we map booleans/strings to f64
-fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
-    match value {
-        ArrayNode::Number(f) => Ok(*f),
-        ArrayNode::Boolean(b) => Ok(if *b { 1.0 } else { 0.0 }),
-        ArrayNode::String(s) => match s.parse::<f64>() {
-            Ok(f) => Ok(f),
-            Err(_) => Err(Error::VALUE),
-        },
-        ArrayNode::Error(err) => Err(err.clone()),
-    }
-}
-
-impl Model {
-    /// Applies `op` element‐wise for arrays/numbers.
-    pub(crate) fn handle_arithmetic(
-        &mut self,
-        left: &Node,
-        right: &Node,
-        cell: CellReferenceIndex,
-        op: &dyn Fn(f64, f64) -> Result<f64, Error>,
-    ) -> CalcResult {
-        let l = match self.get_number_or_array(left, cell) {
-            Ok(f) => f,
-            Err(s) => {
-                return s;
-            }
-        };
-        let r = match self.get_number_or_array(right, cell) {
-            Ok(f) => f,
-            Err(s) => {
-                return s;
-            }
-        };
-        match (l, r) {
-            // -----------------------------------------------------
-            // Case 1: Both are numbers
-            // -----------------------------------------------------
-            (NumberOrArray::Number(f1), NumberOrArray::Number(f2)) => match op(f1, f2) {
-                Ok(x) => CalcResult::Number(x),
-                Err(Error::DIV) => CalcResult::Error {
-                    error: Error::DIV,
-                    origin: cell,
-                    message: "Divide by 0".to_string(),
-                },
-                Err(Error::VALUE) => CalcResult::Error {
-                    error: Error::VALUE,
-                    origin: cell,
-                    message: "Invalid number".to_string(),
-                },
-                Err(e) => CalcResult::Error {
-                    error: e,
-                    origin: cell,
-                    message: "Unknown error".to_string(),
-                },
-            },
-
-            // -----------------------------------------------------
-            // Case 2: left is Number, right is Array
-            // -----------------------------------------------------
-            (NumberOrArray::Number(f1), NumberOrArray::Array(a2)) => {
-                let mut array = Vec::new();
-                for row in a2 {
-                    let mut data_row = Vec::new();
-                    for node in row {
-                        match to_f64(&node) {
-                            Ok(f2) => match op(f1, f2) {
-                                Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
-                                Err(e) => data_row.push(ArrayNode::Error(e)),
-                            },
-                            Err(err) => data_row.push(ArrayNode::Error(err)),
-                        }
-                    }
-                    array.push(data_row);
-                }
-                CalcResult::Array(array)
-            }
-
-            // -----------------------------------------------------
-            // Case 3: left is Array, right is Number
-            // -----------------------------------------------------
-            (NumberOrArray::Array(a1), NumberOrArray::Number(f2)) => {
-                let mut array = Vec::new();
-                for row in a1 {
-                    let mut data_row = Vec::new();
-                    for node in row {
-                        match to_f64(&node) {
-                            Ok(f1) => match op(f1, f2) {
-                                Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
-                                Err(e) => data_row.push(ArrayNode::Error(e)),
-                            },
-                            Err(err) => data_row.push(ArrayNode::Error(err)),
-                        }
-                    }
-                    array.push(data_row);
-                }
-                CalcResult::Array(array)
-            }
-
-            // -----------------------------------------------------
-            // Case 4: Both are arrays
-            // -----------------------------------------------------
-            (NumberOrArray::Array(a1), NumberOrArray::Array(a2)) => {
-                let n1 = a1.len();
-                let m1 = a1.first().map(|r| r.len()).unwrap_or(0);
-                let n2 = a2.len();
-                let m2 = a2.first().map(|r| r.len()).unwrap_or(0);
-                let n = n1.max(n2);
-                let m = m1.max(m2);
-
-                let mut array = Vec::new();
-                for i in 0..n {
-                    let row1 = a1.get(i);
-                    let row2 = a2.get(i);
-
-                    let mut data_row = Vec::new();
-                    for j in 0..m {
-                        let val1 = row1.and_then(|r| r.get(j));
-                        let val2 = row2.and_then(|r| r.get(j));
-
-                        match (val1, val2) {
-                            (Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
-                                (Ok(f1), Ok(f2)) => match op(f1, f2) {
-                                    Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                    Err(Error::VALUE) => {
-                                        data_row.push(ArrayNode::Error(Error::VALUE))
-                                    }
-                                    Err(e) => data_row.push(ArrayNode::Error(e)),
-                                },
-                                (Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),
-                            },
-                            // Mismatched dimensions => #VALUE!
-                            _ => data_row.push(ArrayNode::Error(Error::VALUE)),
-                        }
-                    }
-                    array.push(data_row);
-                }
-                CalcResult::Array(array)
-            }
-        }
-    }
-}
--- a/base/src/calc_result.rs
+++ b/base/src/calc_result.rs
@@ -1,8 +1,7 @@
 use std::cmp::Ordering;

-use crate::expressions::{parser::ArrayNode, token::Error, types::CellReferenceIndex};
+use crate::expressions::{token::Error, types::CellReferenceIndex};

-#[derive(Clone)]
 pub struct Range {
    pub left: CellReferenceIndex,
    pub right: CellReferenceIndex,
@@ -24,7 +23,6 @@ pub(crate) enum CalcResult {
    },
    EmptyCell,
    EmptyArg,
-    Array(Vec<Vec<ArrayNode>>),
 }

 impl CalcResult {
--- a/base/src/cast.rs
+++ b/base/src/cast.rs
@@ -1,85 +1,11 @@
 use crate::{
    calc_result::{CalcResult, Range},
-    expressions::{
-        parser::{ArrayNode, Node},
-        token::Error,
-        types::CellReferenceIndex,
-    },
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
+    implicit_intersection::implicit_intersection,
    model::Model,
 };

-pub(crate) enum NumberOrArray {
-    Number(f64),
-    Array(Vec<Vec<ArrayNode>>),
-}
-
 impl Model {
-    pub(crate) fn get_number_or_array(
-        &mut self,
-        node: &Node,
-        cell: CellReferenceIndex,
-    ) -> Result<NumberOrArray, CalcResult> {
-        match self.evaluate_node_in_context(node, cell) {
-            CalcResult::Number(f) => Ok(NumberOrArray::Number(f)),
-            CalcResult::String(s) => match s.parse::<f64>() {
-                Ok(f) => Ok(NumberOrArray::Number(f)),
-                _ => Err(CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Expecting number".to_string(),
-                )),
-            },
-            CalcResult::Boolean(f) => {
-                if f {
-                    Ok(NumberOrArray::Number(1.0))
-                } else {
-                    Ok(NumberOrArray::Number(0.0))
-                }
-            }
-            CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(NumberOrArray::Number(0.0)),
-            CalcResult::Range { left, right } => {
-                let sheet = left.sheet;
-                if sheet != right.sheet {
-                    return Err(CalcResult::Error {
-                        error: Error::ERROR,
-                        origin: cell,
-                        message: "3D ranges are not allowed".to_string(),
-                    });
-                }
-                // we need to convert the range into an array
-                let mut array = Vec::new();
-                for row in left.row..=right.row {
-                    let mut row_data = Vec::new();
-                    for column in left.column..=right.column {
-                        let value =
-                            match self.evaluate_cell(CellReferenceIndex { sheet, column, row }) {
-                                CalcResult::String(s) => ArrayNode::String(s),
-                                CalcResult::Number(f) => ArrayNode::Number(f),
-                                CalcResult::Boolean(b) => ArrayNode::Boolean(b),
-                                CalcResult::Error { error, .. } => ArrayNode::Error(error),
-                                CalcResult::Range { .. } => {
-                                    // if we do things right this can never happen.
-                                    // the evaluation of a cell should never return a range
-                                    ArrayNode::Number(0.0)
-                                }
-                                CalcResult::EmptyCell => ArrayNode::Number(0.0),
-                                CalcResult::EmptyArg => ArrayNode::Number(0.0),
-                                CalcResult::Array(_) => {
-                                    // if we do things right this can never happen.
-                                    // the evaluation of a cell should never return an array
-                                    ArrayNode::Number(0.0)
-                                }
-                            };
-                        row_data.push(value);
-                    }
-                    array.push(row_data);
-                }
-                Ok(NumberOrArray::Array(array))
-            }
-            CalcResult::Array(s) => Ok(NumberOrArray::Array(s)),
-            error @ CalcResult::Error { .. } => Err(error),
-        }
-    }
    pub(crate) fn get_number(
        &mut self,
        node: &Node,
@@ -113,18 +39,21 @@ impl Model {
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(0.0),
            error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { .. } => Err(CalcResult::Error {
-                error: Error::NIMPL,
+            CalcResult::Range { left, right } => {
+                match implicit_intersection(&cell, &Range { left, right }) {
+                    Some(cell_reference) => {
+                        let result = self.evaluate_cell(cell_reference);
+                        self.cast_to_number(result, cell_reference)
+                    }
+                    None => Err(CalcResult::Error {
+                        error: Error::VALUE,
                        origin: cell,
-                message: "Arrays not supported yet".to_string(),
-            }),
-            CalcResult::Array(_) => Err(CalcResult::Error {
-                error: Error::NIMPL,
-                origin: cell,
-                message: "Arrays not supported yet".to_string(),
+                        message: "Invalid reference (number)".to_string(),
                    }),
                }
            }
+        }
+    }

    pub(crate) fn get_number_no_bools(
        &mut self,
@@ -159,7 +88,7 @@ impl Model {
        // FIXME: I think when casting a number we should convert it to_precision(x, 15)
        // See function Exact
        match result {
-            CalcResult::Number(f) => Ok(format!("{f}")),
+            CalcResult::Number(f) => Ok(format!("{}", f)),
            CalcResult::String(s) => Ok(s),
            CalcResult::Boolean(f) => {
                if f {
@@ -170,18 +99,21 @@ impl Model {
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => Ok("".to_string()),
            error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { .. } => Err(CalcResult::Error {
-                error: Error::NIMPL,
+            CalcResult::Range { left, right } => {
+                match implicit_intersection(&cell, &Range { left, right }) {
+                    Some(cell_reference) => {
+                        let result = self.evaluate_cell(cell_reference);
+                        self.cast_to_string(result, cell_reference)
+                    }
+                    None => Err(CalcResult::Error {
+                        error: Error::VALUE,
                        origin: cell,
-                message: "Arrays not supported yet".to_string(),
-            }),
-            CalcResult::Array(_) => Err(CalcResult::Error {
-                error: Error::NIMPL,
-                origin: cell,
-                message: "Arrays not supported yet".to_string(),
+                        message: "Invalid reference (string)".to_string(),
                    }),
                }
            }
+        }
+    }

    pub(crate) fn get_boolean(
        &mut self,
@@ -219,18 +151,21 @@ impl Model {
            CalcResult::Boolean(b) => Ok(b),
            CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(false),
            error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { .. } => Err(CalcResult::Error {
-                error: Error::NIMPL,
+            CalcResult::Range { left, right } => {
+                match implicit_intersection(&cell, &Range { left, right }) {
+                    Some(cell_reference) => {
+                        let result = self.evaluate_cell(cell_reference);
+                        self.cast_to_bool(result, cell_reference)
+                    }
+                    None => Err(CalcResult::Error {
+                        error: Error::VALUE,
                        origin: cell,
-                message: "Arrays not supported yet".to_string(),
-            }),
-            CalcResult::Array(_) => Err(CalcResult::Error {
-                error: Error::NIMPL,
-                origin: cell,
-                message: "Arrays not supported yet".to_string(),
+                        message: "Invalid reference (bool)".to_string(),
                    }),
                }
            }
+        }
+    }

    // tries to return a reference. That is either a reference or a formula that evaluates to a range/reference
    pub(crate) fn get_reference(
--- a/base/src/constants.rs
+++ b/base/src/constants.rs
@@ -2,11 +2,11 @@
 /// COLUMN_WIDTH and ROW_HEIGHT are pixel values
 /// A column width of Excel value `w` will result in `w * COLUMN_WIDTH_FACTOR` pixels
 /// Note that these constants are inlined
-pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
-pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
+pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.0;
 pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
 pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
-pub(crate) const DEFAULT_WINDOW_HEIGHT: i64 = 600;
+pub(crate) const DEFAULT_WINDOW_HEIGH: i64 = 600;
 pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;

 pub(crate) const LAST_COLUMN: i32 = 16_384;
@@ -16,10 +16,3 @@ pub(crate) const LAST_ROW: i32 = 1_048_576;
 // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
 // The 2 days offset is because of Excel 1900 bug
 pub(crate) const EXCEL_DATE_BASE: i32 = 693_594;
-
-// We do not support dates before 1899-12-31.
-pub(crate) const MINIMUM_DATE_SERIAL_NUMBER: i32 = 1;
-
-// Excel can handle dates until the year 9999-12-31
-// 2958465 is the number of days from 1900-01-01 to 9999-12-31
-pub(crate) const MAXIMUM_DATE_SERIAL_NUMBER: i32 = 2_958_465;
--- a/base/src/diffs.rs
+++ b/base/src/diffs.rs
@@ -0,0 +1,136 @@
+use crate::{
+    expressions::{
+        parser::{
+            move_formula::ref_is_in_area,
+            stringify::{to_string, to_string_displaced, DisplaceData},
+            walk::forward_references,
+        },
+        types::{Area, CellReferenceIndex, CellReferenceRC},
+    },
+    model::Model,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(untagged, deny_unknown_fields)]
+pub enum CellValue {
+    Value(String),
+    None,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct SetCellValue {
+    cell: CellReferenceIndex,
+    new_value: CellValue,
+    old_value: CellValue,
+}
+
+impl Model {
+    pub(crate) fn shift_cell_formula(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        displace_data: &DisplaceData,
+    ) {
+        if let Some(f) = self
+            .workbook
+            .worksheet(sheet)
+            .expect("Worksheet must exist")
+            .cell(row, column)
+            .expect("Cell must exist")
+            .get_formula()
+        {
+            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
+            let cell_reference = CellReferenceRC {
+                sheet: self.workbook.worksheets[sheet as usize].get_name(),
+                row,
+                column,
+            };
+            // FIXME: This is not a very performant way if the formula has changed :S.
+            let formula = to_string(node, &cell_reference);
+            let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
+            if formula != formula_displaced {
+                self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))
+                    .expect("Failed to shift cell formula");
+            }
+        }
+    }
+
+    pub fn forward_references(
+        &mut self,
+        source_area: &Area,
+        target: &CellReferenceIndex,
+    ) -> Result<Vec<SetCellValue>, String> {
+        let mut diff_list: Vec<SetCellValue> = Vec::new();
+        let target_area = &Area {
+            sheet: target.sheet,
+            row: target.row,
+            column: target.column,
+            width: source_area.width,
+            height: source_area.height,
+        };
+        // Walk over every formula
+        let cells = self.get_all_cells();
+        for cell in cells {
+            if let Some(f) = self
+                .workbook
+                .worksheet(cell.index)
+                .expect("Worksheet must exist")
+                .cell(cell.row, cell.column)
+                .expect("Cell must exist")
+                .get_formula()
+            {
+                let sheet = cell.index;
+                let row = cell.row;
+                let column = cell.column;
+
+                // If cell is in the source or target area, skip
+                if ref_is_in_area(sheet, row, column, source_area)
+                    || ref_is_in_area(sheet, row, column, target_area)
+                {
+                    continue;
+                }
+
+                // Get the formula
+                // Get a copy of the AST
+                let node = &mut self.parsed_formulas[sheet as usize][f as usize].clone();
+                let cell_reference = CellReferenceRC {
+                    sheet: self.workbook.worksheets[sheet as usize].get_name(),
+                    column: cell.column,
+                    row: cell.row,
+                };
+                let context = CellReferenceIndex { sheet, column, row };
+                let formula = to_string(node, &cell_reference);
+                let target_sheet_name = &self.workbook.worksheets[target.sheet as usize].name;
+                forward_references(
+                    node,
+                    &context,
+                    source_area,
+                    target.sheet,
+                    target_sheet_name,
+                    target.row,
+                    target.column,
+                );
+
+                // If the string representation of the formula has changed update the cell
+                let updated_formula = to_string(node, &cell_reference);
+                if formula != updated_formula {
+                    self.update_cell_with_formula(
+                        sheet,
+                        row,
+                        column,
+                        format!("={updated_formula}"),
+                    )?;
+                    // Update the diff list
+                    diff_list.push(SetCellValue {
+                        cell: CellReferenceIndex { sheet, column, row },
+                        new_value: CellValue::Value(format!("={}", updated_formula)),
+                        old_value: CellValue::Value(format!("={}", formula)),
+                    });
+                }
+            }
+        }
+        Ok(diff_list)
+    }
+}
--- a/base/src/expressions/lexer/mod.rs
+++ b/base/src/expressions/lexer/mod.rs
@@ -142,7 +142,7 @@ impl Lexer {
    pub fn expect(&mut self, tk: TokenType) -> Result<()> {
        let nt = self.next_token();
        if mem::discriminant(&nt) != mem::discriminant(&tk) {
-            return Err(self.set_error(&format!("Error, expected {tk:?}"), self.position));
+            return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position));
        }
        Ok(())
    }
@@ -187,7 +187,6 @@ impl Lexer {
                    ']' => TokenType::RightBracket,
                    ':' => TokenType::Colon,
                    ';' => TokenType::Semicolon,
-                    '@' => TokenType::At,
                    ',' => {
                        if self.locale.numbers.symbols.decimal == "," {
                            match self.consume_number(',') {
@@ -314,9 +313,6 @@ impl Lexer {
                            } else if name_upper == self.language.booleans.r#false {
                                return TokenType::Boolean(false);
                            }
-                            if self.peek_char() == Some('(') {
-                                return TokenType::Ident(name);
-                            }
                            if self.mode == LexerMode::A1 {
                                let parsed_reference = utils::parse_reference_a1(&name_upper);
                                if parsed_reference.is_some()
@@ -514,7 +510,7 @@ impl Lexer {
        self.position = position;
        chars.parse::<i32>().map_err(|_| LexerError {
            position,
-            message: format!("Failed to parse to int: {chars}"),
+            message: format!("Failed to parse to int: {}", chars),
        })
    }

@@ -575,7 +571,9 @@ impl Lexer {
        }
        self.position = position;
        match chars.parse::<f64>() {
-            Err(_) => Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)),
+            Err(_) => {
+                Err(self.set_error(&format!("Failed to parse to double: {}", chars), position))
+            }
            Ok(v) => Ok(v),
        }
    }
--- a/base/src/expressions/lexer/ranges.rs
+++ b/base/src/expressions/lexer/ranges.rs
@@ -148,16 +148,15 @@ impl Lexer {
                    let row_left = match row_left.parse::<i32>() {
                        Ok(n) => n,
                        Err(_) => {
-                            return Err(
-                                self.set_error(&format!("Failed parsing row {row_left}"), position)
-                            )
+                            return Err(self
+                                .set_error(&format!("Failed parsing row {}", row_left), position))
                        }
                    };
                    let row_right = match row_right.parse::<i32>() {
                        Ok(n) => n,
                        Err(_) => {
                            return Err(self
-                                .set_error(&format!("Failed parsing row {row_right}"), position))
+                                .set_error(&format!("Failed parsing row {}", row_right), position))
                        }
                    };
                    if row_left > LAST_ROW {
--- a/base/src/expressions/lexer/structured_references.rs
+++ b/base/src/expressions/lexer/structured_references.rs
@@ -23,19 +23,19 @@ impl Lexer {
            // TODO(TD): There are better ways of doing this :)
            let rest_of_formula: String = self.chars[self.position..self.len].iter().collect();
            let specifier = if rest_of_formula.starts_with("#This Row]") {
-                self.position += "#This Row]".len();
+                self.position += "#This Row]".bytes().len();
                TableSpecifier::ThisRow
            } else if rest_of_formula.starts_with("#All]") {
-                self.position += "#All]".len();
+                self.position += "#All]".bytes().len();
                TableSpecifier::All
            } else if rest_of_formula.starts_with("#Data]") {
-                self.position += "#Data]".len();
+                self.position += "#Data]".bytes().len();
                TableSpecifier::Data
            } else if rest_of_formula.starts_with("#Headers]") {
-                self.position += "#Headers]".len();
+                self.position += "#Headers]".bytes().len();
                TableSpecifier::Headers
            } else if rest_of_formula.starts_with("#Totals]") {
-                self.position += "#Totals]".len();
+                self.position += "#Totals]".bytes().len();
                TableSpecifier::Totals
            } else {
                return Err(LexerError {
--- a/base/src/expressions/lexer/test/mod.rs
+++ b/base/src/expressions/lexer/test/mod.rs
@@ -1,5 +1,4 @@
 mod test_common;
-mod test_implicit_intersection;
 mod test_language;
 mod test_locale;
 mod test_ranges;
--- a/base/src/expressions/lexer/test/test_common.rs
+++ b/base/src/expressions/lexer/test/test_common.rs
@@ -1,6 +1,5 @@
 #![allow(clippy::unwrap_used)]

-use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;

@@ -686,29 +685,3 @@ fn test_comparisons() {
    assert_eq!(lx.next_token(), Number(7.0));
    assert_eq!(lx.next_token(), EOF);
 }
-
-#[test]
-fn test_log10_is_cell_reference() {
-    let mut lx = new_lexer("LOG10", true);
-    assert_eq!(
-        lx.next_token(),
-        Reference {
-            sheet: None,
-            column: column_to_number("LOG").unwrap(),
-            row: 10,
-            absolute_column: false,
-            absolute_row: false,
-        }
-    );
-    assert_eq!(lx.next_token(), EOF);
-}
-
-#[test]
-fn test_log10_is_function() {
-    let mut lx = new_lexer("LOG10(100)", true);
-    assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
-    assert_eq!(lx.next_token(), LeftParenthesis);
-    assert_eq!(lx.next_token(), Number(100.0));
-    assert_eq!(lx.next_token(), RightParenthesis);
-    assert_eq!(lx.next_token(), EOF);
-}
--- a/base/src/expressions/lexer/test/test_implicit_intersection.rs
+++ b/base/src/expressions/lexer/test/test_implicit_intersection.rs
@@ -1,25 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::expressions::{
-    lexer::{Lexer, LexerMode},
-    token::TokenType::*,
-};
-use crate::language::get_language;
-use crate::locale::get_locale;
-
-fn new_lexer(formula: &str) -> Lexer {
-    let locale = get_locale("en").unwrap();
-    let language = get_language("en").unwrap();
-    Lexer::new(formula, LexerMode::A1, locale, language)
-}
-
-#[test]
-fn sum_implicit_intersection() {
-    let mut lx = new_lexer("sum(@A1:A3)");
-    assert_eq!(lx.next_token(), Ident("sum".to_string()));
-    assert_eq!(lx.next_token(), LeftParenthesis);
-    assert_eq!(lx.next_token(), At);
-    assert!(matches!(lx.next_token(), Range { .. }));
-    assert_eq!(lx.next_token(), RightParenthesis);
-    assert_eq!(lx.next_token(), EOF);
-}
--- a/base/src/expressions/lexer/test/test_util.rs
+++ b/base/src/expressions/lexer/test/test_util.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::expect_used)]
-
 use crate::expressions::{
    lexer::util::get_tokens,
    token::{OpCompare, OpSum, TokenType},
@@ -24,25 +22,6 @@ 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,9 +52,7 @@ 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
@@ -1,5 +1,5 @@
 /*!
-# GRAMMAR
+# GRAMAR

 <pre class="rust">
 opComp   => '=' | '<' | '>' | '<=' } '>=' | '<>'
@@ -12,8 +12,7 @@ term    => factor (opFactor factor)*
 factor  => prod (opProd prod)*
 prod    => power ('^' power)*
 power   => (unaryOp)* range '%'*
-range   => implicit (':' primary)?
-implicit=> '@' primary | primary
+range   => primary (':' primary)?
 primary => '(' expr ')'
        => number
        => function '(' f_args ')'
@@ -46,19 +45,25 @@ use super::utils::number_to_column;
 use token::OpCompare;

 pub mod move_formula;
-pub mod static_analysis;
 pub mod stringify;
+pub mod walk;

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

 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 {
@@ -82,9 +87,6 @@ fn get_table_column_by_name(table_column_name: &str, table: &Table) -> Option<i3
    None
 }

-// DefinedNameS is a tuple with the name of the defined name, the index of the sheet and the formula
-pub type DefinedNameS = (String, Option<u32>, String);
-
 pub(crate) struct Reference<'a> {
    sheet_name: &'a Option<String>,
    sheet_index: u32,
@@ -94,14 +96,6 @@ pub(crate) struct Reference<'a> {
    column: i32,
 }

-#[derive(PartialEq, Clone, Debug)]
-pub enum ArrayNode {
-    Boolean(bool),
-    Number(f64),
-    String(String),
-    Error(token::Error),
-}
-
 #[derive(PartialEq, Clone, Debug)]
 pub enum Node {
    BooleanKind(bool),
@@ -175,14 +169,8 @@ pub enum Node {
        name: String,
        args: Vec<Node>,
    },
-    ArrayKind(Vec<Vec<ArrayNode>>),
-    DefinedNameKind(DefinedNameS),
-    TableNameKind(String),
-    WrongVariableKind(String),
-    ImplicitIntersection {
-        automatic: bool,
-        child: Box<Node>,
-    },
+    ArrayKind(Vec<Node>),
+    VariableKind(String),
    CompareKind {
        kind: OpCompare,
        left: Box<Node>,
@@ -205,35 +193,22 @@ pub enum Node {
 pub struct Parser {
    lexer: lexer::Lexer,
    worksheets: Vec<String>,
-    defined_names: Vec<DefinedNameS>,
-    context: CellReferenceRC,
+    context: Option<CellReferenceRC>,
    tables: HashMap<String, Table>,
 }

 impl Parser {
-    pub fn new(
-        worksheets: Vec<String>,
-        defined_names: Vec<DefinedNameS>,
-        tables: HashMap<String, Table>,
-    ) -> Parser {
+    pub fn new(worksheets: Vec<String>, 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,
-            defined_names,
-            context,
+            context: None,
            tables,
        }
    }
@@ -241,18 +216,13 @@ impl Parser {
        self.lexer.set_lexer_mode(mode)
    }

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

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

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

-    // Returns:
-    //  * None: If there is no defined name by that name
-    //  * Some((Some(index), formula)): 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>, String)> {
-        for (df_name, df_scope, df_formula) in &self.defined_names {
-            if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
-                return Some((*df_scope, df_formula.to_owned()));
-            }
-        }
-        for (df_name, df_scope, df_formula) in &self.defined_names {
-            if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
-                return Some((None, df_formula.to_owned()));
-            }
-        }
-        None
-    }
-
    fn parse_expr(&mut self) -> Node {
        let mut t = self.parse_concat();
        if let Node::ParseErrorKind { .. } = t {
@@ -427,7 +379,7 @@ impl Parser {
    }

    fn parse_range(&mut self) -> Node {
-        let t = self.parse_implicit();
+        let t = self.parse_primary();
        if let Node::ParseErrorKind { .. } = t {
            return t;
        }
@@ -446,65 +398,6 @@ impl Parser {
        t
    }

-    fn parse_implicit(&mut self) -> Node {
-        let next_token = self.lexer.peek_token();
-        if next_token == TokenType::At {
-            self.lexer.advance_token();
-            let t = self.parse_primary();
-            if let Node::ParseErrorKind { .. } = t {
-                return t;
-            }
-            return Node::ImplicitIntersection {
-                automatic: false,
-                child: Box::new(t),
-            };
-        }
-        self.parse_primary()
-    }
-
-    fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
-        let mut row = Vec::new();
-        // and array can only have numbers, string or booleans
-        // otherwise it is a syntax error
-        let first_element = match self.parse_expr() {
-            Node::BooleanKind(s) => ArrayNode::Boolean(s),
-            Node::NumberKind(s) => ArrayNode::Number(s),
-            Node::StringKind(s) => ArrayNode::String(s),
-            Node::ErrorKind(kind) => ArrayNode::Error(kind),
-            error @ Node::ParseErrorKind { .. } => return Err(error),
-            _ => {
-                return Err(Node::ParseErrorKind {
-                    formula: self.lexer.get_formula(),
-                    message: "Invalid value in array".to_string(),
-                    position: self.lexer.get_position() as usize,
-                });
-            }
-        };
-        row.push(first_element);
-        let mut next_token = self.lexer.peek_token();
-        // FIXME: this is not respecting the locale
-        while next_token == TokenType::Comma {
-            self.lexer.advance_token();
-            let value = match self.parse_expr() {
-                Node::BooleanKind(s) => ArrayNode::Boolean(s),
-                Node::NumberKind(s) => ArrayNode::Number(s),
-                Node::StringKind(s) => ArrayNode::String(s),
-                Node::ErrorKind(kind) => ArrayNode::Error(kind),
-                error @ Node::ParseErrorKind { .. } => return Err(error),
-                _ => {
-                    return Err(Node::ParseErrorKind {
-                        formula: self.lexer.get_formula(),
-                        message: "Invalid value in array".to_string(),
-                        position: self.lexer.get_position() as usize,
-                    });
-                }
-            };
-            row.push(value);
-            next_token = self.lexer.peek_token();
-        }
-        Ok(row)
-    }
-
    fn parse_primary(&mut self) -> Node {
        let next_token = self.lexer.next_token();
        match next_token {
@@ -526,35 +419,21 @@ impl Parser {
            TokenType::Number(s) => Node::NumberKind(s),
            TokenType::String(s) => Node::StringKind(s),
            TokenType::LeftBrace => {
-                // It's an array. It's a collection of rows all of the same dimension
-
-                let first_row = match self.parse_array_row() {
-                    Ok(s) => s,
-                    Err(error) => return error,
-                };
-                let length = first_row.len();
-
-                let mut matrix = Vec::new();
-                matrix.push(first_row);
-                // FIXME: this is not respecting the locale
+                let t = self.parse_expr();
+                if let Node::ParseErrorKind { .. } = t {
+                    return t;
+                }
                let mut next_token = self.lexer.peek_token();
+                let mut args: Vec<Node> = vec![t];
                while next_token == TokenType::Semicolon {
                    self.lexer.advance_token();
-                    let row = match self.parse_array_row() {
-                        Ok(s) => s,
-                        Err(error) => return error,
-                    };
+                    let p = self.parse_expr();
+                    if let Node::ParseErrorKind { .. } = p {
+                        return p;
+                    }
                    next_token = self.lexer.peek_token();
-                    if row.len() != length {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "All rows in an array should be the same length".to_string(),
-                        };
+                    args.push(p);
                }
-                    matrix.push(row);
-                }
-
                if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
                    return Node::ParseErrorKind {
                        formula: self.lexer.get_formula(),
@@ -562,7 +441,7 @@ impl Parser {
                        message: err.message,
                    };
                }
-                Node::ArrayKind(matrix)
+                Node::ArrayKind(args)
            }
            TokenType::Reference {
                sheet,
@@ -571,7 +450,16 @@ impl Parser {
                absolute_column,
                absolute_row,
            } => {
-                let context = &self.context;
+                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 sheet_index = match &sheet {
                    Some(name) => self.get_sheet_index_by_name(name),
                    None => self.get_sheet_index_by_name(&context.sheet),
@@ -606,7 +494,16 @@ impl Parser {
                }
            }
            TokenType::Range { sheet, left, right } => {
-                let context = &self.context;
+                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 sheet_index = match &sheet {
                    Some(name) => self.get_sheet_index_by_name(name),
                    None => self.get_sheet_index_by_name(&context.sheet),
@@ -621,6 +518,20 @@ 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);
@@ -629,22 +540,6 @@ 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,
@@ -692,47 +587,11 @@ impl Parser {
                            kind: function_kind,
                            args,
                        };
-                    }
-                    if &name == "_xlfn.SINGLE" {
-                        if args.len() != 1 {
-                            return Node::ParseErrorKind {
-                                formula: self.lexer.get_formula(),
-                                position: self.lexer.get_position() as usize,
-                                message: "Implicit Intersection requires just one argument"
-                                    .to_string(),
-                            };
-                        }
-                        return Node::ImplicitIntersection {
-                            automatic: false,
-                            child: Box::new(args[0].clone()),
-                        };
-                    }
+                    } else {
                        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: format!("sheet not found: {}", context.sheet),
-                        };
                }
-                };
-
-                // Could be a defined name or a table
-                if let Some((scope, formula)) = self.get_defined_name(&name, context_sheet_index) {
-                    return Node::DefinedNameKind((name, scope, formula));
-                }
-                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::WrongVariableKind(name)
+                Node::VariableKind(name)
            }
            TokenType::Error(kind) => Node::ErrorKind(kind),
            TokenType::Illegal(error) => Node::ParseErrorKind {
@@ -745,38 +604,7 @@ impl Parser {
                position: 0,
                message: "Unexpected end of input.".to_string(),
            },
-            TokenType::Boolean(value) => {
-                // Could be a function call "TRUE()"
-                let next_token = self.lexer.peek_token();
-                if next_token == TokenType::LeftParenthesis {
-                    self.lexer.advance_token();
-                    // We parse all the arguments, although technically this is moot
-                    // But is has the upside of transforming `=TRUE( 4 )` into `=TRUE(4)`
-                    let args = match self.parse_function_args() {
-                        Ok(s) => s,
-                        Err(e) => return e,
-                    };
-                    if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: err.position,
-                            message: err.message,
-                        };
-                    }
-                    if value {
-                        return Node::FunctionKind {
-                            kind: Function::True,
-                            args,
-                        };
-                    } else {
-                        return Node::FunctionKind {
-                            kind: Function::False,
-                            args,
-                        };
-                    }
-                }
-                Node::BooleanKind(value)
-            }
+            TokenType::Boolean(value) => Node::BooleanKind(value),
            TokenType::Compare(_) => {
                // A primary Node cannot start with an operator
                Node::ParseErrorKind {
@@ -809,14 +637,6 @@ impl Parser {
                    message: "Unexpected token: 'POWER'".to_string(),
                }
            }
-            TokenType::At => {
-                // A primary Node cannot start with an operator
-                Node::ParseErrorKind {
-                    formula: self.lexer.get_formula(),
-                    position: 0,
-                    message: "Unexpected token: '@'".to_string(),
-                }
-            }
            TokenType::RightParenthesis
            | TokenType::RightBracket
            | TokenType::Colon
@@ -828,7 +648,7 @@ impl Parser {
            | TokenType::Percent => Node::ParseErrorKind {
                formula: self.lexer.get_formula(),
                position: 0,
-                message: format!("Unexpected token: '{next_token:?}'"),
+                message: format!("Unexpected token: '{:?}'", next_token),
            },
            TokenType::LeftBracket => Node::ParseErrorKind {
                formula: self.lexer.get_formula(),
@@ -843,42 +663,33 @@ 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
-                let context = &self.context;
+                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: format!("sheet not found: {}", context.sheet),
+                                message: "sheet not found".to_string(),
                            };
                        }
                    };
                    // table-name => table
-                let table = match self.tables.get(&table_name) {
-                    Some(t) => t,
-                    None => {
-                        let message = format!(
+                    let table = self.tables.get(&table_name).unwrap_or_else(|| {
+                        panic!(
                            "Table not found: '{table_name}' at '{}!{}{}'",
                            context.sheet,
-                            number_to_column(context.column)
-                                .unwrap_or(format!("{}", context.column)),
+                            number_to_column(context.column).expect(""),
                            context.row
-                        );
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: 0,
-                            message,
-                        };
-                    }
-                };
+                        )
+                    });
                    let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
                        Some(i) => i,
                        None => {
                            return Node::ParseErrorKind {
                                formula: self.lexer.get_formula(),
                                position: 0,
-                            message: format!("table sheet not found: {}", table.sheet_name),
+                                message: "sheet not found".to_string(),
                            };
                        }
                    };
@@ -890,7 +701,6 @@ impl Parser {
                    };

                    // context must be with tables.reference
-                #[allow(clippy::expect_used)]
                    let (column_start, mut row_start, column_end, mut row_end) =
                        parse_range(&table.reference).expect("Failed parsing range");

@@ -929,7 +739,8 @@ impl Parser {
                        }
                    }
                    match table_reference {
-                    None => Node::RangeKind {
+                        None => {
+                            return Node::RangeKind {
                                sheet_name,
                                sheet_index: table_sheet_index,
                                absolute_row1: true,
@@ -940,7 +751,8 @@ impl Parser {
                                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,
@@ -948,7 +760,9 @@ impl Parser {
                                    return Node::ParseErrorKind {
                                        formula: self.lexer.get_formula(),
                                        position: self.lexer.get_position() as usize,
-                                    message: format!("Expecting column: {s} in table {table_name}"),
+                                        message: format!(
+                                            "Expecting column: {s} in table {table_name}"
+                                        ),
                                    };
                                }
                            };
@@ -962,7 +776,7 @@ impl Parser {
                                    column: column_index,
                                };
                            }
-                        Node::RangeKind {
+                            return Node::RangeKind {
                                sheet_name,
                                sheet_index: table_sheet_index,
                                absolute_row1: true,
@@ -973,7 +787,7 @@ impl Parser {
                                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) {
@@ -1001,7 +815,7 @@ impl Parser {
                                    };
                                }
                            };
-                        Node::RangeKind {
+                            return Node::RangeKind {
                                sheet_name,
                                sheet_index: table_sheet_index,
                                absolute_row1: true,
@@ -1012,9 +826,15 @@ impl Parser {
                                absolute_column2: true,
                                row2: row_end,
                                column2: right_column_index,
+                            };
                        }
                    }
                }
+                Node::ParseErrorKind {
+                    formula: self.lexer.get_formula(),
+                    position: 0,
+                    message: "Structured references not supported in R1C1 mode".to_string(),
+                }
            }
        }
    }
--- a/base/src/expressions/parser/move_formula.rs
+++ b/base/src/expressions/parser/move_formula.rs
@@ -1,6 +1,6 @@
 use super::{
    stringify::{stringify_reference, DisplaceData},
-    ArrayNode, Node, Reference,
+    Node, Reference,
 };
 use crate::{
    constants::{LAST_COLUMN, LAST_ROW},
@@ -53,24 +53,15 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
            arguments = to_string_moved(el, move_context);
        }
    }
-    format!("{name}({arguments})")
-}
-
-pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
-    match node {
-        ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(),
-        ArrayNode::Number(number) => to_excel_precision_str(*number),
-        ArrayNode::String(value) => format!("\"{value}\""),
-        ArrayNode::Error(kind) => format!("{kind}"),
-    }
+    format!("{}({})", name, arguments)
 }

 fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
    use self::Node::*;
    match node {
-        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
+        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
        NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{value}\""),
+        StringKind(value) => format!("\"{}\"", value),
        ReferenceKind {
            sheet_name,
            sheet_index,
@@ -241,7 +232,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                full_row,
                full_column,
            );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
        }
        WrongReferenceKind {
            sheet_name,
@@ -325,7 +316,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                full_row,
                full_column,
            );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
        }
        OpRangeKind { left, right } => format!(
            "{}:{}",
@@ -358,7 +349,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                }
                _ => to_string_moved(right, move_context),
            };
-            format!("{x}{kind}{y}")
+            format!("{}{}{}", x, kind, y)
        }
        OpPowerKind { left, right } => format!(
            "{}^{}",
@@ -371,43 +362,20 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
            move_function(name, args, move_context)
        }
        ArrayKind(args) => {
-            let mut first_row = true;
-            let mut matrix_string = String::new();
-
-            // Each element in `args` is assumed to be one "row" (itself a `Vec<T>`).
-            for row in args {
-                if !first_row {
-                    matrix_string.push(',');
+            // This code is a placeholder. Arrays are not yet implemented
+            let mut first = true;
+            let mut arguments = "".to_string();
+            for el in args {
+                if !first {
+                    arguments = format!("{},{}", arguments, to_string_moved(el, move_context));
                } else {
-                    first_row = false;
+                    first = false;
+                    arguments = to_string_moved(el, move_context);
                }
-
-                // Build the string for the current row
-                let mut first_col = true;
-                let mut row_string = String::new();
-                for el in row {
-                    if !first_col {
-                        row_string.push(',');
-                    } else {
-                        first_col = false;
            }
-
-                    // Reuse your existing element-stringification function
-                    row_string.push_str(&to_string_array_node(el));
+            format!("{{{}}}", arguments)
        }
-
-                // Enclose the row in braces
-                matrix_string.push('{');
-                matrix_string.push_str(&row_string);
-                matrix_string.push('}');
-            }
-
-            // Enclose the whole matrix in braces
-            format!("{{{matrix_string}}}")
-        }
-        DefinedNameKind((name, ..)) => name.to_string(),
-        TableNameKind(name) => name.to_string(),
-        WrongVariableKind(name) => name.to_string(),
+        VariableKind(value) => value.to_string(),
        CompareKind { kind, left, right } => format!(
            "{}{}{}",
            to_string_moved(left, move_context),
@@ -418,18 +386,12 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
            OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)),
            OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)),
        },
-        ErrorKind(kind) => format!("{kind}"),
+        ErrorKind(kind) => format!("{}", kind),
        ParseErrorKind {
            formula,
            message: _,
            position: _,
        } => formula.to_string(),
        EmptyArgKind => "".to_string(),
-        ImplicitIntersection {
-            automatic: _,
-            child,
-        } => {
-            format!("@{}", to_string_moved(child, move_context))
-        }
    }
 }
--- a/base/src/expressions/parser/static_analysis.rs
+++ b/base/src/expressions/parser/static_analysis.rs
--- a/base/src/expressions/parser/stringify.rs
+++ b/base/src/expressions/parser/stringify.rs
@@ -1,8 +1,6 @@
 use super::{super::utils::quote_name, Node, Reference};
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::move_formula::to_string_array_node;
-use crate::expressions::parser::static_analysis::add_implicit_intersection;
-use crate::expressions::token::{OpSum, OpUnary};
+use crate::expressions::token::OpUnary;
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};

 pub enum DisplaceData {
@@ -28,11 +26,6 @@ pub enum DisplaceData {
        column: i32,
        delta: i32,
    },
-    RowMove {
-        sheet: u32,
-        row: i32,
-        delta: i32,
-    },
    ColumnMove {
        sheet: u32,
        column: i32,
@@ -41,21 +34,10 @@ pub enum DisplaceData {
    None,
 }

-/// This is the internal mode in IronCalc
 pub fn to_rc_format(node: &Node) -> String {
    stringify(node, None, &DisplaceData::None, false)
 }

-/// This is the mode used to display the formula in the UI
-pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
-    stringify(node, Some(context), &DisplaceData::None, false)
-}
-
-/// This is the mode used to export the formula to Excel
-pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
-    stringify(node, Some(context), &DisplaceData::None, true)
-}
-
 pub fn to_string_displaced(
    node: &Node,
    context: &CellReferenceRC,
@@ -64,10 +46,18 @@ pub fn to_string_displaced(
    stringify(node, Some(context), displace_data, false)
 }

+pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, false)
+}
+
+pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, true)
+}
+
 /// Converts a local reference to a string applying some displacement if needed.
 /// It uses A1 style if context is not None. If context is None it uses R1C1 style
 /// If full_row is true then the row details will be omitted in the A1 case
-/// If full_column is true then column details will be omitted.
+/// If full_colum is true then column details will be omitted.
 pub(crate) fn stringify_reference(
    context: Option<&CellReferenceRC>,
    displace_data: &DisplaceData,
@@ -164,29 +154,6 @@ pub(crate) fn stringify_reference(
                        }
                    }
                }
-                DisplaceData::RowMove {
-                    sheet,
-                    row: move_row,
-                    delta,
-                } => {
-                    if sheet_index == *sheet {
-                        if row == *move_row {
-                            row += *delta;
-                        } else if *delta > 0 {
-                            // Moving the row downwards
-                            if row > *move_row && row <= *move_row + *delta {
-                                // Intermediate rows move up by one position
-                                row -= 1;
-                            }
-                        } else if *delta < 0 {
-                            // Moving the row upwards
-                            if row < *move_row && row >= *move_row + *delta {
-                                // Intermediate rows move down by one position
-                                row += 1;
-                            }
-                        }
-                    }
-                }
                DisplaceData::ColumnMove {
                    sheet,
                    column: move_column,
@@ -195,18 +162,14 @@ pub(crate) fn stringify_reference(
                    if sheet_index == *sheet {
                        if column == *move_column {
                            column += *delta;
-                        } else if *delta > 0 {
-                            // Moving the column to the right
-                            if column > *move_column && column <= *move_column + *delta {
-                                // Intermediate columns move left by one position
-                                column -= 1;
-                            }
-                        } else if *delta < 0 {
-                            // Moving the column to the left
-                            if column < *move_column && column >= *move_column + *delta {
-                                // Intermediate columns move right by one position
-                                column += 1;
-                            }
+                        } else if (*delta > 0
+                            && column > *move_column
+                            && column <= *move_column + *delta)
+                            || (*delta < 0
+                                && column < *move_column
+                                && column >= *move_column + *delta)
+                        {
+                            column -= *delta;
                        }
                    }
                }
@@ -216,16 +179,16 @@ pub(crate) fn stringify_reference(
                return "#REF!".to_string();
            }
            let mut row_abs = if absolute_row {
-                format!("${row}")
+                format!("${}", row)
            } else {
-                format!("{row}")
+                format!("{}", row)
            };
            let column = match crate::expressions::utils::number_to_column(column) {
                Some(s) => s,
                None => return "#REF!".to_string(),
            };
            let mut col_abs = if absolute_column {
-                format!("${column}")
+                format!("${}", column)
            } else {
                column
            };
@@ -240,27 +203,27 @@ pub(crate) fn stringify_reference(
                    format!("{}!{}{}", quote_name(name), col_abs, row_abs)
                }
                None => {
-                    format!("{col_abs}{row_abs}")
+                    format!("{}{}", col_abs, row_abs)
                }
            }
        }
        None => {
            let row_abs = if absolute_row {
-                format!("R{row}")
+                format!("R{}", row)
            } else {
-                format!("R[{row}]")
+                format!("R[{}]", row)
            };
            let col_abs = if absolute_column {
-                format!("C{column}")
+                format!("C{}", column)
            } else {
-                format!("C[{column}]")
+                format!("C[{}]", column)
            };
            match &sheet_name {
                Some(name) => {
                    format!("{}!{}{}", quote_name(name), row_abs, col_abs)
                }
                None => {
-                    format!("{row_abs}{col_abs}")
+                    format!("{}{}", row_abs, col_abs)
                }
            }
        }
@@ -272,7 +235,7 @@ fn format_function(
    args: &Vec<Node>,
    context: Option<&CellReferenceRC>,
    displace_data: &DisplaceData,
-    export_to_excel: bool,
+    use_original_name: bool,
 ) -> String {
    let mut first = true;
    let mut arguments = "".to_string();
@@ -281,52 +244,27 @@ fn format_function(
            arguments = format!(
                "{},{}",
                arguments,
-                stringify(el, context, displace_data, export_to_excel)
+                stringify(el, context, displace_data, use_original_name)
            );
        } else {
            first = false;
-            arguments = stringify(el, context, displace_data, export_to_excel);
+            arguments = stringify(el, context, displace_data, use_original_name);
        }
    }
-    format!("{name}({arguments})")
+    format!("{}({})", name, arguments)
 }

-// There is just one representation in the AST (Abstract Syntax Tree) of a formula.
-// But three different ways to convert it to a string.
-//
-// To stringify a formula we need a "context", that is in which cell are we doing the "stringifying"
-//
-// But there are three ways to stringify a formula:
-//
-// * To show it to the IronCalc user
-// * To store internally
-// * To export to Excel
-//
-// There are, of course correspondingly three "modes" when parsing a formula.
-//
-// The internal representation is the more different as references are stored in the RC representation.
-// The the AST of the formula is kept close to this representation we don't need a context
-//
-// In the export to Excel representation certain things are different:
-// * We add a _xlfn. in front of some (more modern) functions
-// * We remove the Implicit Intersection operator when it is automatic and add _xlfn.SINGLE when it is not
-//
-// Examples:
-// * =A1+B2
-// * =RC+R1C1
-// * =A1+B1
-
 fn stringify(
    node: &Node,
    context: Option<&CellReferenceRC>,
    displace_data: &DisplaceData,
-    export_to_excel: bool,
+    use_original_name: bool,
 ) -> String {
    use self::Node::*;
    match node {
-        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
+        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
        NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{value}\""),
+        StringKind(value) => format!("\"{}\"", value),
        WrongReferenceKind {
            sheet_name,
            column,
@@ -416,7 +354,7 @@ fn stringify(
                full_row,
                full_column,
            );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
        }
        WrongRangeKind {
            sheet_name,
@@ -465,235 +403,114 @@ fn stringify(
                full_row,
                full_column,
            );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
        }
        OpRangeKind { left, right } => format!(
            "{}:{}",
-            stringify(left, context, displace_data, export_to_excel),
-            stringify(right, context, displace_data, export_to_excel)
+            stringify(left, context, displace_data, use_original_name),
+            stringify(right, context, displace_data, use_original_name)
        ),
        OpConcatenateKind { left, right } => format!(
            "{}&{}",
-            stringify(left, context, displace_data, export_to_excel),
-            stringify(right, context, displace_data, export_to_excel)
+            stringify(left, context, displace_data, use_original_name),
+            stringify(right, context, displace_data, use_original_name)
        ),
        CompareKind { kind, left, right } => format!(
            "{}{}{}",
-            stringify(left, context, displace_data, export_to_excel),
+            stringify(left, context, displace_data, use_original_name),
            kind,
-            stringify(right, context, displace_data, export_to_excel)
+            stringify(right, context, displace_data, use_original_name)
+        ),
+        OpSumKind { kind, left, right } => format!(
+            "{}{}{}",
+            stringify(left, context, displace_data, use_original_name),
+            kind,
+            stringify(right, context, displace_data, use_original_name)
        ),
-        OpSumKind { kind, left, right } => {
-            let left_str = stringify(left, context, displace_data, export_to_excel);
-            // if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
-            let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
-                | matches!(**right, CompareKind { .. })
-            {
-                format!(
-                    "({})",
-                    stringify(right, context, displace_data, export_to_excel)
-                )
-            } else {
-                stringify(right, context, displace_data, export_to_excel)
-            };
-
-            format!("{left_str}{kind}{right_str}")
-        }
        OpProductKind { kind, left, right } => {
            let x = match **left {
-                OpSumKind { .. } | CompareKind { .. } => format!(
+                OpSumKind { .. } => format!(
                    "({})",
-                    stringify(left, context, displace_data, export_to_excel)
+                    stringify(left, context, displace_data, use_original_name)
                ),
-                _ => stringify(left, context, displace_data, export_to_excel),
+                CompareKind { .. } => format!(
+                    "({})",
+                    stringify(left, context, displace_data, use_original_name)
+                ),
+                _ => stringify(left, context, displace_data, use_original_name),
            };
            let y = match **right {
-                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
+                OpSumKind { .. } => format!(
                    "({})",
-                    stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                ),
-                _ => stringify(right, context, displace_data, export_to_excel),
-            };
-            format!("{x}{kind}{y}")
-        }
-        OpPowerKind { left, right } => {
-            let x = match **left {
-                BooleanKind(_)
-                | NumberKind(_)
-                | StringKind(_)
-                | ReferenceKind { .. }
-                | RangeKind { .. }
-                | WrongReferenceKind { .. }
-                | DefinedNameKind(_)
-                | TableNameKind(_)
-                | WrongVariableKind(_)
-                | WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
-                OpRangeKind { .. }
-                | OpConcatenateKind { .. }
-                | OpProductKind { .. }
-                | OpPowerKind { .. }
-                | FunctionKind { .. }
-                | InvalidFunctionKind { .. }
-                | ArrayKind(_)
-                | UnaryKind { .. }
-                | ErrorKind(_)
-                | ParseErrorKind { .. }
-                | OpSumKind { .. }
-                | CompareKind { .. }
-                | ImplicitIntersection { .. }
-                | EmptyArgKind => format!(
+                CompareKind { .. } => format!(
                    "({})",
-                    stringify(left, context, displace_data, export_to_excel)
+                    stringify(right, 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, export_to_excel)
-                }
-                OpRangeKind { .. }
-                | OpConcatenateKind { .. }
-                | OpProductKind { .. }
-                | OpPowerKind { .. }
-                | FunctionKind { .. }
-                | InvalidFunctionKind { .. }
-                | ArrayKind(_)
-                | UnaryKind { .. }
-                | ErrorKind(_)
-                | ParseErrorKind { .. }
-                | OpSumKind { .. }
-                | CompareKind { .. }
-                | ImplicitIntersection { .. }
-                | EmptyArgKind => format!(
+                OpProductKind { .. } => format!(
                    "({})",
-                    stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                ),
+                _ => stringify(right, context, displace_data, use_original_name),
            };
-            format!("{x}^{y}")
+            format!("{}{}{}", x, kind, y)
        }
+        OpPowerKind { left, right } => format!(
+            "{}^{}",
+            stringify(left, context, displace_data, use_original_name),
+            stringify(right, context, displace_data, use_original_name)
+        ),
        InvalidFunctionKind { name, args } => {
-            format_function(name, args, context, displace_data, export_to_excel)
+            format_function(name, args, context, displace_data, use_original_name)
        }
        FunctionKind { kind, args } => {
-            let name = if export_to_excel {
+            let name = if use_original_name {
                kind.to_xlsx_string()
            } else {
                kind.to_string()
            };
-            format_function(&name, args, context, displace_data, export_to_excel)
+            format_function(&name, args, context, displace_data, use_original_name)
        }
        ArrayKind(args) => {
-            let mut first_row = true;
-            let mut matrix_string = String::new();
-
-            for row in args {
-                if !first_row {
-                    matrix_string.push(';');
+            let mut first = true;
+            let mut arguments = "".to_string();
+            for el in args {
+                if !first {
+                    arguments = format!(
+                        "{},{}",
+                        arguments,
+                        stringify(el, context, displace_data, use_original_name)
+                    );
                } else {
-                    first_row = false;
+                    first = false;
+                    arguments = stringify(el, context, displace_data, use_original_name);
                }
-                let mut first_column = true;
-                let mut row_string = String::new();
-                for el in row {
-                    if !first_column {
-                        row_string.push(',');
-                    } else {
-                        first_column = false;
            }
-                    row_string.push_str(&to_string_array_node(el));
+            format!("{{{}}}", arguments)
        }
-                matrix_string.push_str(&row_string);
-            }
-            format!("{{{matrix_string}}}")
-        }
-        TableNameKind(value) => value.to_string(),
-        DefinedNameKind((name, ..)) => name.to_string(),
-        WrongVariableKind(name) => name.to_string(),
+        VariableKind(value) => value.to_string(),
        UnaryKind { kind, right } => match kind {
            OpUnary::Minus => {
-                let needs_parentheses = match **right {
-                    BooleanKind(_)
-                    | NumberKind(_)
-                    | StringKind(_)
-                    | ReferenceKind { .. }
-                    | RangeKind { .. }
-                    | WrongReferenceKind { .. }
-                    | WrongRangeKind { .. }
-                    | OpRangeKind { .. }
-                    | OpConcatenateKind { .. }
-                    | OpProductKind { .. }
-                    | OpPowerKind { .. }
-                    | FunctionKind { .. }
-                    | InvalidFunctionKind { .. }
-                    | ArrayKind(_)
-                    | DefinedNameKind(_)
-                    | TableNameKind(_)
-                    | WrongVariableKind(_)
-                    | ImplicitIntersection { .. }
-                    | CompareKind { .. }
-                    | ErrorKind(_)
-                    | ParseErrorKind { .. }
-                    | EmptyArgKind => false,
-
-                    OpSumKind { .. } | UnaryKind { .. } => true,
-                };
-                if needs_parentheses {
-                    format!(
-                        "-({})",
-                        stringify(right, context, displace_data, export_to_excel)
-                    )
-                } else {
                format!(
                    "-{}",
-                        stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                )
            }
-            }
            OpUnary::Percentage => {
                format!(
                    "{}%",
-                    stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                )
            }
        },
-        ErrorKind(kind) => format!("{kind}"),
+        ErrorKind(kind) => format!("{}", kind),
        ParseErrorKind {
            formula,
            position: _,
            message: _,
        } => formula.to_string(),
        EmptyArgKind => "".to_string(),
-        ImplicitIntersection {
-            automatic: _,
-            child,
-        } => {
-            if export_to_excel {
-                // We need to check wether the II can be automatic or not
-                let mut new_node = child.as_ref().clone();
-
-                add_implicit_intersection(&mut new_node, true);
-                if matches!(&new_node, Node::ImplicitIntersection { .. }) {
-                    return stringify(child, context, displace_data, export_to_excel);
-                }
-
-                return format!(
-                    "_xlfn.SINGLE({})",
-                    stringify(child, context, displace_data, export_to_excel)
-                );
-            }
-            format!(
-                "@{}",
-                stringify(child, context, displace_data, export_to_excel)
-            )
-        }
    }
 }

@@ -781,12 +598,6 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
        Node::UnaryKind { kind: _, right } => {
            rename_sheet_in_node(right, sheet_index, new_name);
        }
-        Node::ImplicitIntersection {
-            automatic: _,
-            child,
-        } => {
-            rename_sheet_in_node(child, sheet_index, new_name);
-        }

        // Do nothing
        Node::BooleanKind(_) => {}
@@ -795,96 +606,7 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
        Node::ErrorKind(_) => {}
        Node::ParseErrorKind { .. } => {}
        Node::ArrayKind(_) => {}
-        Node::DefinedNameKind(_) => {}
-        Node::TableNameKind(_) => {}
-        Node::WrongVariableKind(_) => {}
+        Node::VariableKind(_) => {}
        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);
-        }
-        Node::ImplicitIntersection {
-            automatic: _,
-            child,
-        } => {
-            rename_defined_name_in_node(child, 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/test_general.rs
+++ b/base/src/expressions/parser/tests/test_general.rs
@@ -1,13 +1,17 @@
-#![allow(clippy::panic)]
-
 use std::collections::HashMap;

 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::{
-    to_rc_format, to_string, to_string_displaced, DisplaceData,
+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::{Node, Parser};
-use crate::expressions::types::CellReferenceRC;

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

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -25,14 +29,14 @@ fn test_parser_reference() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("A2", &cell_reference);
+    let t = parser.parse("A2", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -40,14 +44,14 @@ fn test_parser_absolute_column() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("$A1", &cell_reference);
+    let t = parser.parse("$A1", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -55,14 +59,14 @@ fn test_parser_absolute_row_col() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("$C$5", &cell_reference);
+    let t = parser.parse("$C$5", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

    // Reference cell is Sheet1!A1
    let cell_reference = CellReferenceRC {
@@ -70,14 +74,14 @@ fn test_parser_absolute_row_col_1() {
        row: 1,
        column: 1,
    };
-    let t = parser.parse("$A$1", &cell_reference);
+    let t = parser.parse("$A$1", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

-    let t = parser.parse("C3+Sheet2!D4", &cell_reference);
+    let t = parser.parse("C3+Sheet2!D4", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

-    let t = parser.parse("true", &cell_reference);
+    let t = parser.parse("true", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

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

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

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

    let formulas = vec![
        Formula {
@@ -259,11 +263,11 @@ fn test_parser_formulas() {
    for formula in formulas {
        let t = parser.parse(
            formula.initial,
-            &CellReferenceRC {
+            &Some(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);
@@ -273,7 +277,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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
    parser.set_lexer_mode(LexerMode::R1C1);

    let formulas = vec![
@@ -324,11 +328,11 @@ fn test_parser_r1c1_formulas() {
    for formula in formulas {
        let t = parser.parse(
            formula.initial,
-            &CellReferenceRC {
+            &Some(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);
@@ -338,7 +342,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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

-    let t = parser.parse("C3+'Second Sheet'!D4", &cell_reference);
+    let t = parser.parse("C3+'Second Sheet'!D4", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

-    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &cell_reference);
+    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

-    let t = parser.parse("(C3=\"Yes\")*5", &cell_reference);
+    let t = parser.parse("(C3=\"Yes\")*5", &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

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

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

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

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

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

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

-    let node = parser.parse("C3", context);
+    let node = parser.parse("C3", &Some(context.clone()));
    let displace_data = DisplaceData::Column {
        sheet: 0,
        column: 1,
--- a/base/src/expressions/parser/tests/test_move_formula.rs
+++ b/base/src/expressions/parser/tests/test_move_formula.rs
@@ -1,8 +1,10 @@
 use std::collections::HashMap;

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

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

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

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

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

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

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

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

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

    // Outside of the area. Not moved
-    let node = parser.parse("B2+B3+C1+G6+H5", context);
+    let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -168,7 +170,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", context);
+    let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -195,7 +197,7 @@ fn test_move_formula_ranges() {
        column,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

    let area = &Area {
        sheet: 0,
@@ -205,7 +207,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)", context);
+    let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -220,7 +222,7 @@ fn test_move_formula_ranges() {
    );
    assert_eq!(t, "SUM(M12:P15)");

-    let node = parser.parse("SUM($C$2:$F$5)", context);
+    let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -236,7 +238,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)", context);
+    let node = parser.parse("SUM(A1:B3)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -251,7 +253,7 @@ fn test_move_formula_ranges() {
    );
    assert_eq!(t, "SUM(A1:B3)");

-    let node = parser.parse("SUM($A$1:$B$3)", context);
+    let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -267,7 +269,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)", context);
+    let node = parser.parse("SUM(A1:F5)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -283,7 +285,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)", context);
+    let node = parser.parse("SUM(A1:X50)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -318,10 +320,10 @@ fn test_move_formula_wrong_reference() {
        height: 5,
    };
    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

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

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

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

-    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
+    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -417,7 +419,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)", context);
+    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
    let t = move_formula(
        &node,
        &MoveContext {
@@ -445,7 +447,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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());

    // Area is C2:F6
    let area = &Area {
@@ -457,7 +459,10 @@ 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)", context);
+    let node = parser.parse(
+        "AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
+        &Some(context.clone()),
+    );
    let t = move_formula(
        &node,
        &MoveContext {
@@ -475,77 +480,3 @@ fn test_move_formula_another_sheet() {
        "Sheet1!AB31*SUM(Sheet1!JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(M12:P16)"
    );
 }
-
-#[test]
-fn move_formula_implicit_intersetion() {
-    // context is E4
-    let row = 4;
-    let column = 5;
-    let context = &CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row,
-        column,
-    };
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    // Area is C2:F6
-    let area = &Area {
-        sheet: 0,
-        row: 2,
-        column: 3,
-        width: 4,
-        height: 5,
-    };
-    let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)", context);
-    let t = move_formula(
-        &node,
-        &MoveContext {
-            source_sheet_name: "Sheet1",
-            row,
-            column,
-            area,
-            target_sheet_name: "Sheet1",
-            row_delta: 10,
-            column_delta: 10,
-        },
-    );
-    assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)");
-}
-
-#[test]
-fn move_formula_implicit_intersetion_with_ranges() {
-    // context is E4
-    let row = 4;
-    let column = 5;
-    let context = &CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row,
-        column,
-    };
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    // Area is C2:F6
-    let area = &Area {
-        sheet: 0,
-        row: 2,
-        column: 3,
-        width: 4,
-        height: 5,
-    };
-    let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)+SUM(@A1, @X9, @$D$5)", context);
-    let t = move_formula(
-        &node,
-        &MoveContext {
-            source_sheet_name: "Sheet1",
-            row,
-            column,
-            area,
-            target_sheet_name: "Sheet1",
-            row_delta: 10,
-            column_delta: 10,
-        },
-    );
-    assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)+SUM(@A1,@X9,@$N$15)");
-}
--- 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 crate::expressions::parser::stringify::{to_rc_format, to_string};
-use crate::expressions::parser::Parser;
-use crate::expressions::types::CellReferenceRC;
+use super::super::parser::stringify::{to_rc_format, to_string};
+use super::super::types::CellReferenceRC;
+use super::Parser;

 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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, 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,
-            &CellReferenceRC {
+            &Some(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,
-            &CellReferenceRC {
+            &Some(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, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, 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)",
-        &cell_reference,
+        &Some(cell_reference.clone()),
    );
    assert_eq!(
        to_string(&t, &cell_reference),
--- a/base/src/expressions/parser/tests/test_tables.rs
+++ b/base/src/expressions/parser/tests/test_tables.rs
@@ -3,11 +3,12 @@
 use std::collections::HashMap;

 use crate::expressions::parser::stringify::to_string;
-use crate::expressions::parser::Parser;
-use crate::expressions::types::CellReferenceRC;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};

+use super::super::types::CellReferenceRC;
+use super::Parser;
+
 fn create_test_table(
    table_name: &str,
    column_names: &[&str],
@@ -62,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, vec![], tables);
+    let mut parser = Parser::new(worksheets, tables);
    // Reference cell is 'Sheet One'!F2
    let cell_reference = CellReferenceRC {
        sheet: "Sheet One".to_string(),
@@ -71,7 +72,7 @@ fn simple_table() {
    };

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

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

    // Cell A3 in 'Second Sheet'
@@ -91,7 +92,7 @@ fn simple_table() {
        column: 1,
    };
    let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &cell_reference);
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
    assert_eq!(
        to_string(&t, &cell_reference),
        "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"
--- a/base/src/expressions/parser/tests/mod.rs
+++ b/base/src/expressions/parser/tests/mod.rs
@@ -1,9 +0,0 @@
-mod test_add_implicit_intersection;
-mod test_arrays;
-mod test_general;
-mod test_implicit_intersection;
-mod test_issue_155;
-mod test_move_formula;
-mod test_ranges;
-mod test_stringify;
-mod test_tables;
--- a/base/src/expressions/parser/tests/test_add_implicit_intersection.rs
+++ b/base/src/expressions/parser/tests/test_add_implicit_intersection.rs
@@ -1,80 +0,0 @@
-use std::collections::HashMap;
-
-use crate::expressions::{
-    parser::{
-        stringify::{to_excel_string, to_string},
-        Parser,
-    },
-    types::CellReferenceRC,
-};
-
-use crate::expressions::parser::static_analysis::add_implicit_intersection;
-
-#[test]
-fn simple_test() {
-    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 cases = vec![
-        ("A1:A10*SUM(A1:A10)", "@A1:A10*SUM(A1:A10)"),
-        ("A1:A10", "@A1:A10"),
-        // Math and trigonometry functions
-        ("SUM(A1:A10)", "SUM(A1:A10)"),
-        ("SIN(A1:A10)", "SIN(@A1:A10)"),
-        ("COS(A1:A10)", "COS(@A1:A10)"),
-        ("TAN(A1:A10)", "TAN(@A1:A10)"),
-        ("ASIN(A1:A10)", "ASIN(@A1:A10)"),
-        ("ACOS(A1:A10)", "ACOS(@A1:A10)"),
-        ("ATAN(A1:A10)", "ATAN(@A1:A10)"),
-        ("SINH(A1:A10)", "SINH(@A1:A10)"),
-        ("COSH(A1:A10)", "COSH(@A1:A10)"),
-        ("TANH(A1:A10)", "TANH(@A1:A10)"),
-        ("ASINH(A1:A10)", "ASINH(@A1:A10)"),
-        ("ACOSH(A1:A10)", "ACOSH(@A1:A10)"),
-        ("ATANH(A1:A10)", "ATANH(@A1:A10)"),
-        ("ATAN2(A1:A10,B1:B10)", "ATAN2(@A1:A10,@B1:B10)"),
-        ("ATAN2(A1:A10,A1)", "ATAN2(@A1:A10,A1)"),
-        ("SQRT(A1:A10)", "SQRT(@A1:A10)"),
-        ("SQRTPI(A1:A10)", "SQRTPI(@A1:A10)"),
-        ("POWER(A1:A10,A1)", "POWER(@A1:A10,A1)"),
-        ("POWER(A1:A10,B1:B10)", "POWER(@A1:A10,@B1:B10)"),
-        ("MAX(A1:A10)", "MAX(A1:A10)"),
-        ("MIN(A1:A10)", "MIN(A1:A10)"),
-        ("ABS(A1:A10)", "ABS(@A1:A10)"),
-        ("FALSE()", "FALSE()"),
-        ("TRUE()", "TRUE()"),
-        // Defined names
-        ("BADNMAE", "@BADNMAE"),
-        // Logical
-        ("AND(A1:A10)", "AND(A1:A10)"),
-        ("OR(A1:A10)", "OR(A1:A10)"),
-        ("NOT(A1:A10)", "NOT(@A1:A10)"),
-        ("IF(A1:A10,B1:B10,C1:C10)", "IF(@A1:A10,@B1:B10,@C1:C10)"),
-        // Information
-        // ("ISBLANK(A1:A10)", "ISBLANK(A1:A10)"),
-        // ("ISERR(A1:A10)", "ISERR(A1:A10)"),
-        // ("ISERROR(A1:A10)", "ISERROR(A1:A10)"),
-        // ("ISEVEN(A1:A10)", "ISEVEN(A1:A10)"),
-        // ("ISLOGICAL(A1:A10)", "ISLOGICAL(A1:A10)"),
-        // ("ISNA(A1:A10)", "ISNA(A1:A10)"),
-        // ("ISNONTEXT(A1:A10)", "ISNONTEXT(A1:A10)"),
-        // ("ISNUMBER(A1:A10)", "ISNUMBER(A1:A10)"),
-        // ("ISODD(A1:A10)", "ISODD(A1:A10)"),
-        // ("ISREF(A1:A10)", "ISREF(A1:A10)"),
-        // ("ISTEXT(A1:A10)", "ISTEXT(A1:A10)"),
-    ];
-    for (formula, expected) in cases {
-        let mut t = parser.parse(formula, &cell_reference);
-        add_implicit_intersection(&mut t, true);
-        let r = to_string(&t, &cell_reference);
-        assert_eq!(r, expected);
-        let excel_formula = to_excel_string(&t, &cell_reference);
-        assert_eq!(excel_formula, formula);
-    }
-}
--- a/base/src/expressions/parser/tests/test_arrays.rs
+++ b/base/src/expressions/parser/tests/test_arrays.rs
@@ -1,92 +0,0 @@
-#![allow(clippy::panic)]
-
-use std::collections::HashMap;
-
-use crate::expressions::parser::stringify::{to_rc_format, to_string};
-use crate::expressions::parser::{ArrayNode, Node, Parser};
-use crate::expressions::types::CellReferenceRC;
-
-#[test]
-fn simple_horizontal() {
-    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 horizontal = parser.parse("{1, 2, 3}", &cell_reference);
-    assert_eq!(
-        horizontal,
-        Node::ArrayKind(vec![vec![
-            ArrayNode::Number(1.0),
-            ArrayNode::Number(2.0),
-            ArrayNode::Number(3.0)
-        ]])
-    );
-
-    assert_eq!(to_rc_format(&horizontal), "{1,2,3}");
-    assert_eq!(to_string(&horizontal, &cell_reference), "{1,2,3}");
-}
-
-#[test]
-fn simple_vertical() {
-    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 vertical = parser.parse("{1;2; 3}", &cell_reference);
-    assert_eq!(
-        vertical,
-        Node::ArrayKind(vec![
-            vec![ArrayNode::Number(1.0)],
-            vec![ArrayNode::Number(2.0)],
-            vec![ArrayNode::Number(3.0)]
-        ])
-    );
-    assert_eq!(to_rc_format(&vertical), "{1;2;3}");
-    assert_eq!(to_string(&vertical, &cell_reference), "{1;2;3}");
-}
-
-#[test]
-fn simple_matrix() {
-    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 matrix = parser.parse("{1,2,3; 4, 5, 6; 7,8,9}", &cell_reference);
-    assert_eq!(
-        matrix,
-        Node::ArrayKind(vec![
-            vec![
-                ArrayNode::Number(1.0),
-                ArrayNode::Number(2.0),
-                ArrayNode::Number(3.0)
-            ],
-            vec![
-                ArrayNode::Number(4.0),
-                ArrayNode::Number(5.0),
-                ArrayNode::Number(6.0)
-            ],
-            vec![
-                ArrayNode::Number(7.0),
-                ArrayNode::Number(8.0),
-                ArrayNode::Number(9.0)
-            ]
-        ])
-    );
-    assert_eq!(to_rc_format(&matrix), "{1,2,3;4,5,6;7,8,9}");
-    assert_eq!(to_string(&matrix, &cell_reference), "{1,2,3;4,5,6;7,8,9}");
-}
--- a/base/src/expressions/parser/tests/test_implicit_intersection.rs
+++ b/base/src/expressions/parser/tests/test_implicit_intersection.rs
@@ -1,75 +0,0 @@
-#![allow(clippy::panic)]
-
-use crate::expressions::parser::{Node, Parser};
-use crate::expressions::types::CellReferenceRC;
-use std::collections::HashMap;
-
-#[test]
-fn simple() {
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    // Reference cell is Sheet1!B3
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 3,
-        column: 2,
-    };
-    let t = parser.parse("@A1:A10", &cell_reference);
-    let child = Node::RangeKind {
-        sheet_name: None,
-        sheet_index: 0,
-        absolute_row1: false,
-        absolute_column1: false,
-        row1: -2,
-        column1: -1,
-        absolute_row2: false,
-        absolute_column2: false,
-        row2: 7,
-        column2: -1,
-    };
-    assert_eq!(
-        t,
-        Node::ImplicitIntersection {
-            automatic: false,
-            child: Box::new(child)
-        }
-    )
-}
-
-#[test]
-fn simple_add() {
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    // Reference cell is Sheet1!B3
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 3,
-        column: 2,
-    };
-    let t = parser.parse("@A1:A10+12", &cell_reference);
-    let child = Node::RangeKind {
-        sheet_name: None,
-        sheet_index: 0,
-        absolute_row1: false,
-        absolute_column1: false,
-        row1: -2,
-        column1: -1,
-        absolute_row2: false,
-        absolute_column2: false,
-        row2: 7,
-        column2: -1,
-    };
-    assert_eq!(
-        t,
-        Node::OpSumKind {
-            kind: crate::expressions::token::OpSum::Add,
-            left: Box::new(Node::ImplicitIntersection {
-                automatic: false,
-                child: Box::new(child)
-            }),
-            right: Box::new(Node::NumberKind(12.0))
-        }
-    )
-}
--- a/base/src/expressions/parser/tests/test_issue_155.rs
+++ b/base/src/expressions/parser/tests/test_issue_155.rs
@@ -1,69 +0,0 @@
-#![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_stringify.rs
+++ b/base/src/expressions/parser/tests/test_stringify.rs
@@ -1,70 +0,0 @@
-#![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");
-}
-
-#[test]
-fn correct_parenthesis() {
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 1,
-        column: 1,
-    };
-
-    let t = parser.parse("-(1 + 1)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
-
-    let t = parser.parse("1 - (3 + 4)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
-
-    let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
-    assert_eq!(
-        to_string(&t, &cell_reference),
-        "-(1.05*(0.0284+0.0046)-0.0284)"
-    );
-
-    let t = parser.parse("1 + (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1+3+5");
-
-    let t = parser.parse("1 - (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
-
-    let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
-
-    let t = parser.parse("1 + (3<5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
-}
--- a/base/src/expressions/parser/walk.rs
+++ b/base/src/expressions/parser/walk.rs
@@ -0,0 +1,276 @@
+use super::{move_formula::ref_is_in_area, Node};
+
+use crate::expressions::types::{Area, CellReferenceIndex};
+
+pub(crate) fn forward_references(
+    node: &mut Node,
+    context: &CellReferenceIndex,
+    source_area: &Area,
+    target_sheet: u32,
+    target_sheet_name: &str,
+    target_row: i32,
+    target_column: i32,
+) {
+    match node {
+        Node::ReferenceKind {
+            sheet_name,
+            sheet_index: reference_sheet,
+            absolute_row,
+            absolute_column,
+            row: reference_row,
+            column: reference_column,
+        } => {
+            let reference_row_absolute = if *absolute_row {
+                *reference_row
+            } else {
+                *reference_row + context.row
+            };
+            let reference_column_absolute = if *absolute_column {
+                *reference_column
+            } else {
+                *reference_column + context.column
+            };
+            if ref_is_in_area(
+                *reference_sheet,
+                reference_row_absolute,
+                reference_column_absolute,
+                source_area,
+            ) {
+                if *reference_sheet != target_sheet {
+                    *sheet_name = Some(target_sheet_name.to_string());
+                    *reference_sheet = target_sheet;
+                }
+                *reference_row = target_row + *reference_row - source_area.row;
+                *reference_column = target_column + *reference_column - source_area.column;
+            }
+        }
+        Node::RangeKind {
+            sheet_name,
+            sheet_index,
+            absolute_row1,
+            absolute_column1,
+            row1,
+            column1,
+            absolute_row2,
+            absolute_column2,
+            row2,
+            column2,
+        } => {
+            let reference_row1 = if *absolute_row1 {
+                *row1
+            } else {
+                *row1 + context.row
+            };
+            let reference_column1 = if *absolute_column1 {
+                *column1
+            } else {
+                *column1 + context.column
+            };
+
+            let reference_row2 = if *absolute_row2 {
+                *row2
+            } else {
+                *row2 + context.row
+            };
+            let reference_column2 = if *absolute_column2 {
+                *column2
+            } else {
+                *column2 + context.column
+            };
+            if ref_is_in_area(*sheet_index, reference_row1, reference_column1, source_area)
+                && ref_is_in_area(*sheet_index, reference_row2, reference_column2, source_area)
+            {
+                if *sheet_index != target_sheet {
+                    *sheet_index = target_sheet;
+                    *sheet_name = Some(target_sheet_name.to_string());
+                }
+                *row1 = target_row + *row1 - source_area.row;
+                *column1 = target_column + *column1 - source_area.column;
+                *row2 = target_row + *row2 - source_area.row;
+                *column2 = target_column + *column2 - source_area.column;
+            }
+        }
+        // Recurse
+        Node::OpRangeKind { left, right } => {
+            forward_references(
+                left,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        Node::OpConcatenateKind { left, right } => {
+            forward_references(
+                left,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        Node::OpSumKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            forward_references(
+                left,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        Node::OpProductKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            forward_references(
+                left,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        Node::OpPowerKind { left, right } => {
+            forward_references(
+                left,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        Node::FunctionKind { kind: _, args } => {
+            for arg in args {
+                forward_references(
+                    arg,
+                    context,
+                    source_area,
+                    target_sheet,
+                    target_sheet_name,
+                    target_row,
+                    target_column,
+                );
+            }
+        }
+        Node::InvalidFunctionKind { name: _, args } => {
+            for arg in args {
+                forward_references(
+                    arg,
+                    context,
+                    source_area,
+                    target_sheet,
+                    target_sheet_name,
+                    target_row,
+                    target_column,
+                );
+            }
+        }
+        Node::CompareKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            forward_references(
+                left,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        Node::UnaryKind { kind: _, right } => {
+            forward_references(
+                right,
+                context,
+                source_area,
+                target_sheet,
+                target_sheet_name,
+                target_row,
+                target_column,
+            );
+        }
+        // TODO: Not implemented
+        Node::ArrayKind(_) => {}
+        // Do nothing. Note: we could do a blanket _ => {}
+        Node::VariableKind(_) => {}
+        Node::ErrorKind(_) => {}
+        Node::ParseErrorKind { .. } => {}
+        Node::EmptyArgKind => {}
+        Node::BooleanKind(_) => {}
+        Node::NumberKind(_) => {}
+        Node::StringKind(_) => {}
+        Node::WrongReferenceKind { .. } => {}
+        Node::WrongRangeKind { .. } => {}
+    }
+}
--- a/base/src/expressions/token.rs
+++ b/base/src/expressions/token.rs
@@ -197,7 +197,7 @@ pub fn is_english_error_string(name: &str) -> bool {
        "#REF!", "#NAME?", "#VALUE!", "#DIV/0!", "#N/A", "#NUM!", "#ERROR!", "#N/IMPL!", "#SPILL!",
        "#CALC!", "#CIRC!", "#NULL!",
    ];
-    names.contains(&name)
+    names.iter().any(|e| *e == name)
 }

 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -240,7 +240,6 @@ pub enum TokenType {
    Bang,               // !
    Percent,            // %
    And,                // &
-    At,                 // @
    Reference {
        sheet: Option<String>,
        row: i32,
--- a/base/src/expressions/utils/test.rs
+++ b/base/src/expressions/utils/test.rs
@@ -211,6 +211,4 @@ fn test_names() {
    assert!(!is_valid_identifier("test€"));
    assert!(!is_valid_identifier("truñe"));
    assert!(!is_valid_identifier("tr&ue"));
-
-    assert!(!is_valid_identifier("LOG10"));
 }
--- a/base/src/formatter/dates.rs
+++ b/base/src/formatter/dates.rs
@@ -1,158 +1,17 @@
 use chrono::Datelike;
-use chrono::Days;
 use chrono::Duration;
-use chrono::Months;
 use chrono::NaiveDate;

 use crate::constants::EXCEL_DATE_BASE;
-use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
-use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;

-pub const DATE_OUT_OF_RANGE_MESSAGE: &str = "Out of range parameters for date";
-
-#[inline]
-fn convert_to_serial_number(date: NaiveDate) -> i32 {
-    date.num_days_from_ce() - EXCEL_DATE_BASE
-}
-
-fn is_date_within_range(date: NaiveDate) -> bool {
-    convert_to_serial_number(date) >= MINIMUM_DATE_SERIAL_NUMBER
-        && convert_to_serial_number(date) <= MAXIMUM_DATE_SERIAL_NUMBER
-}
-
-pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
-    if days < MINIMUM_DATE_SERIAL_NUMBER as i64 {
-        return Err(format!(
-            "Excel date must be greater than {MINIMUM_DATE_SERIAL_NUMBER}"
-        ));
-    };
-    if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
-        return Err(format!(
-            "Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}"
-        ));
-    };
-    #[allow(clippy::expect_used)]
+pub fn from_excel_date(days: i64) -> NaiveDate {
    let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
-    Ok(dt + Duration::days(days - 2))
+    dt + Duration::days(days - 2)
 }

 pub fn date_to_serial_number(day: u32, month: u32, year: i32) -> Result<i32, String> {
    match NaiveDate::from_ymd_opt(year, month, day) {
-        Some(native_date) => Ok(convert_to_serial_number(native_date)),
-        None => Err(DATE_OUT_OF_RANGE_MESSAGE.to_string()),
-    }
-}
-
-pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Result<i32, String> {
-    // Excel parses `DATE` very permissively. It allows not just for valid date values, but it
-    // allows for invalid dates as well. If you for example enter `DATE(1900, 1, 32)` it will
-    // return the date `1900-02-01`. Despite giving a day that is out of range it will just
-    // wrap the month and year around.
-    //
-    // This function applies that same logic to dates. And does it in the most compatible way as
-    // possible.
-
-    // Special case for the minimum date
-    if year == 1899 && month == 12 && day == 31 {
-        return Ok(MINIMUM_DATE_SERIAL_NUMBER);
-    }
-    let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
-        return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-    };
-
-    // One thing to note for example is that even if you started with a year out of range
-    // but tried to increment the months so that it wraps around into within range, excel
-    // would still return an error.
-    //
-    // I.E. DATE(0,13,-1) will return an error, despite it being equivalent to DATE(1,1,0) which
-    // is within range.
-    //
-    // As a result, we have to run range checks as we parse the date from the biggest unit to the
-    // smallest unit.
-    if !is_date_within_range(date) {
-        return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-    }
-
-    date = {
-        let month_diff = month - 1;
-        let abs_month = month_diff.unsigned_abs();
-        if month_diff <= 0 {
-            date = date - Months::new(abs_month);
-        } else {
-            date = date + Months::new(abs_month);
-        }
-        if !is_date_within_range(date) {
-            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-        }
-        date
-    };
-
-    date = {
-        let day_diff = day - 1;
-        let abs_day = day_diff.unsigned_abs() as u64;
-        if day_diff <= 0 {
-            date = date - Days::new(abs_day);
-        } else {
-            date = date + Days::new(abs_day);
-        }
-        if !is_date_within_range(date) {
-            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-        }
-        date
-    };
-
-    Ok(convert_to_serial_number(date))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_permissive_date_to_serial_number() {
-        assert_eq!(
-            permissive_date_to_serial_number(42, 42, 2002),
-            date_to_serial_number(12, 7, 2005)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 42, 2002),
-            date_to_serial_number(1, 6, 2005)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 15, 2000),
-            date_to_serial_number(1, 3, 2001)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 49, 2000),
-            date_to_serial_number(1, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 49, 2000),
-            date_to_serial_number(1, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(31, 49, 2000),
-            date_to_serial_number(31, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(256, 49, 2000),
-            date_to_serial_number(12, 9, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(256, 1, 2004),
-            date_to_serial_number(12, 9, 2004)
-        );
-    }
-
-    #[test]
-    fn test_max_and_min_dates() {
-        assert_eq!(
-            permissive_date_to_serial_number(31, 12, 9999),
-            Ok(MAXIMUM_DATE_SERIAL_NUMBER),
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(31, 12, 1899),
-            Ok(MINIMUM_DATE_SERIAL_NUMBER),
-        );
+        Some(native_date) => Ok(native_date.num_days_from_ce() - EXCEL_DATE_BASE),
+        None => Err("Out of range parameters for date".to_string()),
    }
 }
--- a/base/src/formatter/format.rs
+++ b/base/src/formatter/format.rs
@@ -120,7 +120,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
            // We should have different codepaths for general formatting and errors
            let value_abs = value.abs();
            if (1.0e-8..1.0e+11).contains(&value_abs) {
-                let mut text = format!("{value:.9}");
+                let mut text = format!("{:.9}", value);
                text = text.trim_end_matches('0').trim_end_matches('.').to_string();
                Formatted {
                    text,
@@ -138,7 +138,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                let exponent = value_abs.log10().floor();
                value /= 10.0_f64.powf(exponent);
                let sign = if exponent < 0.0 { '-' } else { '+' };
-                let s = format!("{value:.5}");
+                let s = format!("{:.5}", value);
                Formatted {
                    text: format!(
                        "{}E{}{:02}",
@@ -154,46 +154,45 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
        ParsePart::Date(p) => {
            let tokens = &p.tokens;
            let mut text = "".to_string();
-            let date = match from_excel_date(value as i64) {
-                Ok(d) => d,
-                Err(e) => {
+            if !(1.0..=2_958_465.0).contains(&value) {
+                // 2_958_465 is 31 December 9999
                return Formatted {
                    text: "#VALUE!".to_owned(),
                    color: None,
-                        error: Some(e),
-                    }
-                }
+                    error: Some("Date negative or too long".to_owned()),
                };
+            }
+            let date = from_excel_date(value as i64);
            for token in tokens {
                match token {
                    TextToken::Literal(c) => {
-                        text = format!("{text}{c}");
+                        text = format!("{}{}", text, c);
                    }
                    TextToken::Text(t) => {
-                        text = format!("{text}{t}");
+                        text = format!("{}{}", text, t);
                    }
                    TextToken::Ghost(_) => {
                        // we just leave a whitespace
                        // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                    }
                    TextToken::Spacer(_) => {
                        // we just leave a whitespace
                        // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                    }
                    TextToken::Raw => {
-                        text = format!("{text}{value}");
+                        text = format!("{}{}", text, value);
                    }
                    TextToken::Digit(_) => {}
                    TextToken::Period => {}
                    TextToken::Day => {
                        let day = date.day() as usize;
-                        text = format!("{text}{day}");
+                        text = format!("{}{}", text, day);
                    }
                    TextToken::DayPadded => {
                        let day = date.day() as usize;
-                        text = format!("{text}{day:02}");
+                        text = format!("{}{:02}", text, day);
                    }
                    TextToken::DayNameShort => {
                        let mut day = date.weekday().number_from_monday() as usize;
@@ -211,11 +210,11 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                    }
                    TextToken::Month => {
                        let month = date.month() as usize;
-                        text = format!("{text}{month}");
+                        text = format!("{}{}", text, month);
                    }
                    TextToken::MonthPadded => {
                        let month = date.month() as usize;
-                        text = format!("{text}{month:02}");
+                        text = format!("{}{:02}", text, month);
                    }
                    TextToken::MonthNameShort => {
                        let month = date.month() as usize;
@@ -228,7 +227,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                    TextToken::MonthLetter => {
                        let month = date.month() as usize;
                        let months_letter = &locale.dates.months_letter[month - 1];
-                        text = format!("{text}{months_letter}");
+                        text = format!("{}{}", text, months_letter);
                    }
                    TextToken::YearShort => {
                        text = format!("{}{}", text, date.format("%y"));
@@ -246,9 +245,6 @@ 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
@@ -295,26 +291,26 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
            for token in tokens {
                match token {
                    TextToken::Literal(c) => {
-                        text = format!("{text}{c}");
+                        text = format!("{}{}", text, c);
                    }
                    TextToken::Text(t) => {
-                        text = format!("{text}{t}");
+                        text = format!("{}{}", text, t);
                    }
                    TextToken::Ghost(_) => {
                        // we just leave a whitespace
                        // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                    }
                    TextToken::Spacer(_) => {
                        // we just leave a whitespace
                        // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                    }
                    TextToken::Raw => {
-                        text = format!("{text}{value}");
+                        text = format!("{}{}", text, value);
                    }
                    TextToken::Period => {
-                        text = format!("{text}{decimal_separator}");
+                        text = format!("{}{}", text, decimal_separator);
                    }
                    TextToken::Digit(digit) => {
                        if digit.number == 'i' {
@@ -322,7 +318,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                            let index = digit.index;
                            let number_index = ln - digit_count + index;
                            if index == 0 && is_negative {
-                                text = format!("-{text}");
+                                text = format!("-{}", text);
                            }
                            if ln <= digit_count {
                                // The number of digits is less or equal than the number of digit tokens
@@ -347,7 +343,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                    } else {
                                        ""
                                    };
-                                    text = format!("{text}{c}{sep}");
+                                    text = format!("{}{}{}", text, c, sep);
                                }
                                digit_index += 1;
                            } else {
@@ -373,18 +369,18 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                            if index < fract_part.len() {
                                text = format!("{}{}", text, fract_part[index]);
                            } else if digit.kind == '0' {
-                                text = format!("{text}0");
+                                text = format!("{}0", text);
                            } else if digit.kind == '?' {
-                                text = format!("{text} ");
+                                text = format!("{} ", text);
                            }
                        } else if digit.number == 'e' {
                            // 3. Exponent part
                            let index = digit.index;
                            if index == 0 {
                                if exponent_is_negative {
-                                    text = format!("{text}E-");
+                                    text = format!("{}E-", text);
                                } else {
-                                    text = format!("{text}E+");
+                                    text = format!("{}E+", text);
                                }
                            }
                            let number_index = l_exp - (p.exponent_digit_count - index);
@@ -400,7 +396,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                        exponent_part[number_index as usize]
                                    };

-                                    text = format!("{text}{c}");
+                                    text = format!("{}{}", text, c);
                                }
                            } else {
                                for i in 0..number_index + 1 {
@@ -614,7 +610,7 @@ pub(crate) fn parse_formatted_number(

    // check if it is a currency in currencies
    for currency in currencies {
-        if let Some(p) = value.strip_prefix(&format!("-{currency}")) {
+        if let Some(p) = value.strip_prefix(&format!("-{}", currency)) {
            let (f, options) = parse_number(p.trim())?;
            if options.is_scientific {
                return Ok((f, Some(scientific_format.to_string())));
--- a/base/src/formatter/lexer.rs
+++ b/base/src/formatter/lexer.rs
@@ -10,7 +10,6 @@ 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
@@ -178,7 +177,10 @@ impl Lexer {
            }
        }
        self.position = position;
-        chars.parse::<f64>().ok()
+        match chars.parse::<f64>() {
+            Err(_) => None,
+            Ok(v) => Some(v),
+        }
    }

    fn consume_condition(&mut self) -> Option<(Compare, f64)> {
@@ -272,15 +274,6 @@ 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() {
@@ -333,7 +326,7 @@ impl Lexer {
                        } else if s == '-' {
                            Token::ScientificMinus
                        } else {
-                            self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
+                            self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
                            Token::ILLEGAL
                        }
                    } else {
@@ -385,14 +378,14 @@ impl Lexer {
                    for c in "eneral".chars() {
                        let cc = self.read_next_char();
                        if Some(c) != cc {
-                            self.set_error(&format!("Unexpected character: {x}"));
+                            self.set_error(&format!("Unexpected character: {}", x));
                            return Token::ILLEGAL;
                        }
                    }
                    Token::General
                }
                _ => {
-                    self.set_error(&format!("Unexpected character: {x}"));
+                    self.set_error(&format!("Unexpected character: {}", x));
                    Token::ILLEGAL
                }
            },
--- a/base/src/formatter/mod.rs
+++ b/base/src/formatter/mod.rs
@@ -74,7 +74,6 @@ 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,7 +40,6 @@ pub struct NumberPart {
    pub is_scientific: bool,
    pub scientific_minus: bool,
    pub exponent_digit_count: i32,
-    pub currency: Option<char>,
 }

 pub struct DatePart {
@@ -115,7 +114,6 @@ 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();
@@ -172,9 +170,6 @@ impl Parser {
                Token::Condition(cmp, value) => {
                    condition = Some((cmp, value));
                }
-                Token::Currency(c) => {
-                    currency = Some(c);
-                }
                Token::QuestionMark => {
                    tokens.push(TextToken::Digit(Digit {
                        kind: '?',
@@ -296,7 +291,6 @@ 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,14 +76,6 @@ 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/date_and_time.rs
+++ b/base/src/functions/date_and_time.rs
--- a/base/src/functions/engineering/complex.rs
+++ b/base/src/functions/engineering/complex.rs
@@ -46,18 +46,18 @@ impl fmt::Display for Complex {
        // it is a bit weird what Excel does but it seems it uses general notation for
        // numbers > 1e-20 and scientific notation for the rest
        let y_str = if y.abs() <= 9e-20 {
-            format!("{y:E}")
+            format!("{:E}", y)
        } else if y == 1.0 {
            "".to_string()
        } else if y == -1.0 {
            "-".to_string()
        } else {
-            format!("{y}")
+            format!("{}", y)
        };
        let x_str = if x.abs() <= 9e-20 {
-            format!("{x:E}")
+            format!("{:E}", x)
        } else {
-            format!("{x}")
+            format!("{}", x)
        };
        if y == 0.0 && x == 0.0 {
            write!(f, "0")
@@ -188,7 +188,10 @@ impl Model {
        node: &Node,
        cell: CellReferenceIndex,
    ) -> Result<(f64, f64, Suffix), CalcResult> {
-        let value = self.get_string(node, cell)?;
+        let value = match self.get_string(node, cell) {
+            Ok(s) => s,
+            Err(s) => return Err(s),
+        };
        if value.is_empty() {
            return Ok((0.0, 0.0, Suffix::I));
        }
--- a/base/src/functions/engineering/number_basis.rs
+++ b/base/src/functions/engineering/number_basis.rs
@@ -76,7 +76,7 @@ impl Model {
        if value < 0 {
            CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9))
        } else {
-            let result = format!("{value:X}");
+            let result = format!("{:X}", value);
            if let Some(places) = places {
                if places < result.len() as i32 {
                    return CalcResult::new_error(
@@ -120,7 +120,7 @@ impl Model {
        if value < 0 {
            CalcResult::String(format!("{:0width$o}", OCT_MAX + value, width = 9))
        } else {
-            let result = format!("{value:o}");
+            let result = format!("{:o}", value);
            if let Some(places) = places {
                if places < result.len() as i32 {
                    return CalcResult::new_error(
@@ -163,7 +163,7 @@ impl Model {
        if value < 0 {
            value += 1024;
        }
-        let result = format!("{value:b}");
+        let result = format!("{:b}", value);
        if let Some(places) = places {
            if value_raw > 0.0 && places < result.len() as i32 {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -202,7 +202,7 @@ impl Model {
        if value < 0 {
            value += HEX_MAX;
        }
-        let result = format!("{value:X}");
+        let result = format!("{:X}", value);
        if let Some(places) = places {
            if value_raw > 0.0 && places < result.len() as i32 {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -242,7 +242,7 @@ impl Model {
        if value < 0 {
            value += OCT_MAX;
        }
-        let result = format!("{value:o}");
+        let result = format!("{:o}", value);
        if let Some(places) = places {
            if value_raw > 0.0 && places < result.len() as i32 {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -301,7 +301,7 @@ impl Model {
        if value < 0 {
            value += 1024;
        }
-        let result = format!("{value:b}");
+        let result = format!("{:b}", value);
        if let Some(places) = places {
            if places <= 0 || (value > 0 && places < result.len() as i32) {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -391,7 +391,7 @@ impl Model {
        if value < 0 {
            value += OCT_MAX;
        }
-        let result = format!("{value:o}");
+        let result = format!("{:o}", value);
        if let Some(places) = places {
            if places <= 0 || (value > 0 && places < result.len() as i32) {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -446,7 +446,7 @@ impl Model {
        if value < 0 {
            value += 1024;
        }
-        let result = format!("{value:b}");
+        let result = format!("{:b}", value);
        if let Some(places) = places {
            if value < 512 && places < result.len() as i32 {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -532,7 +532,7 @@ impl Model {
        if value < 0 {
            value += HEX_MAX;
        }
-        let result = format!("{value:X}");
+        let result = format!("{:X}", value);
        if let Some(places) = places {
            if value < HEX_MAX_HALF && places < result.len() as i32 {
                return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
--- 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
@@ -2,7 +2,7 @@ use chrono::Datelike;

 use crate::{
    calc_result::CalcResult,
-    constants::{LAST_COLUMN, LAST_ROW, MAXIMUM_DATE_SERIAL_NUMBER, MINIMUM_DATE_SERIAL_NUMBER},
+    constants::{LAST_COLUMN, LAST_ROW},
    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
    formatter::dates::from_excel_date,
    model::Model,
@@ -13,32 +13,37 @@ use super::financial_util::{compute_irr, compute_npv, compute_rate, compute_xirr
 // See:
 // https://github.com/apache/openoffice/blob/c014b5f2b55cff8d4b0c952d5c16d62ecde09ca1/main/scaddins/source/analysis/financial.cxx

-fn is_less_than_one_year(start_date: i64, end_date: i64) -> Result<bool, String> {
-    let end = from_excel_date(end_date)?;
-    let start = from_excel_date(start_date)?;
+// FIXME: Is this enough?
+fn is_valid_date(date: f64) -> bool {
+    date > 0.0
+}
+
+fn is_less_than_one_year(start_date: i64, end_date: i64) -> bool {
    if end_date - start_date < 365 {
-        return Ok(true);
+        return true;
    }
+    let end = from_excel_date(end_date);
+    let start = from_excel_date(start_date);
    let end_year = end.year();
    let start_year = start.year();
    if end_year == start_year {
-        return Ok(true);
+        return true;
    }
    if end_year != start_year + 1 {
-        return Ok(false);
+        return false;
    }
    let start_month = start.month();
    let end_month = end.month();
    if end_month < start_month {
-        return Ok(true);
+        return true;
    }
    if end_month > start_month {
-        return Ok(false);
+        return false;
    }
    // we are one year later same month
    let start_day = start.day();
    let end_day = end.day();
-    Ok(end_day <= start_day)
+    end_day <= start_day
 }

 fn compute_payment(
@@ -84,9 +89,6 @@ 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 {
@@ -192,24 +194,16 @@ fn compute_ppmt(
 // In these formulas the payment (pmt) is normally negative

 impl Model {
-    fn get_array_of_numbers_generic(
+    // 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(
        &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) if accept_number_node => values.push(value),
-            CalcResult::Number(_) => {
-                return Err(CalcResult::new_error(
-                    Error::VALUE,
-                    *cell,
-                    "Expected range of numbers".to_string(),
-                ));
-            }
+            CalcResult::Number(value) => values.push(value),
            CalcResult::Range { left, right } => {
                if left.sheet != right.sheet {
                    return Err(CalcResult::new_error(
@@ -218,7 +212,6 @@ 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;
@@ -226,46 +219,32 @@ impl Model {
                if row1 == 1 && row2 == LAST_ROW {
                    row2 = self
                        .workbook
-                        .worksheet(sheet)
-                        .map_err(|_| {
-                            CalcResult::new_error(
-                                Error::ERROR,
-                                *cell,
-                                format!("Invalid worksheet index: '{sheet}'"),
-                            )
-                        })?
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
                        .dimension()
                        .max_row;
                }
                if column1 == 1 && column2 == LAST_COLUMN {
                    column2 = self
                        .workbook
-                        .worksheet(sheet)
-                        .map_err(|_| {
-                            CalcResult::new_error(
-                                Error::ERROR,
-                                *cell,
-                                format!("Invalid worksheet index: '{sheet}'"),
-                            )
-                        })?
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
                        .dimension()
                        .max_column;
                }
-                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),
+                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 => {
-                                if let Some(value) = handle_empty_cell()? {
-                                    values.push(value);
-                                }
-                            }
                            _ => {
-                                if let Some(value) = handle_non_number_cell()? {
-                                    values.push(value);
-                                }
+                                // We ignore booleans and strings
                            }
                        }
                    }
@@ -273,51 +252,88 @@ impl Model {
            }
            error @ CalcResult::Error { .. } => return Err(error),
            _ => {
-                handle_non_number_cell()?;
-            }
+                // We ignore booleans and strings
            }
+        };
        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> {
-        self.get_array_of_numbers_generic(
-            arg,
-            cell,
-            true, // accept_number_node
-            || {
-                Err(CalcResult::new_error(
+        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(),
-                ))
-            },
-            || {
-                Err(CalcResult::new_error(
-                    error.clone(),
+                                ));
+                            }
+                            _ => {
+                                return Err(CalcResult::new_error(
+                                    error,
                                    *cell,
                                    "Expected number".to_string(),
-                ))
-            },
-        )
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+            error @ CalcResult::Error { .. } => return Err(error),
+            _ => {
+                return Err(CalcResult::new_error(
+                    error,
+                    *cell,
+                    "Expected number".to_string(),
+                ));
+            }
+        };
+        Ok(values)
    }

    fn get_array_of_numbers_xirr(
@@ -325,19 +341,69 @@ impl Model {
        arg: &Node,
        cell: &CellReferenceIndex,
    ) -> Result<Vec<f64>, CalcResult> {
-        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(
+        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(
+                    Error::VALUE,
+                    *cell,
+                    "Expected number".to_string(),
+                ));
+            }
+        };
+        Ok(values)
    }

    /// PMT(rate, nper, pv, [fv], [type])
@@ -431,7 +497,7 @@ impl Model {
        }
        if rate == -1.0 {
            return CalcResult::Error {
-                error: Error::DIV,
+                error: Error::NUM,
                origin: cell,
                message: "Rate must be != -1".to_string(),
            };
@@ -796,28 +862,20 @@ impl Model {
                    let column1 = left.column;
                    let mut column2 = right.column;
                    if row1 == 1 && row2 == LAST_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),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                    }
                    if column1 == 1 && column2 == LAST_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),
-                                );
-                            }
-                        };
+                        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) {
@@ -918,9 +976,7 @@ impl Model {
        }
        let first_date = dates[0];
        for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
+            if !is_valid_date(*date) {
                // Excel docs claim that if any number in dates is not a valid date,
                // XNPV returns the #VALUE! error value, but it seems to return #VALUE!
                return CalcResult::new_error(
@@ -986,9 +1042,7 @@ impl Model {
        }
        let first_date = dates[0];
        for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
+            if !is_valid_date(*date) {
                return CalcResult::new_error(
                    Error::NUM,
                    cell,
@@ -1339,21 +1393,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 {
@@ -1372,10 +1426,9 @@ impl Model {
            Ok(f) => f,
            Err(s) => return s,
        };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
        if settlement > maturity {
            return CalcResult::new_error(
                Error::NUM,
@@ -1383,7 +1436,7 @@ impl Model {
                "settlement should be <= maturity".to_string(),
            );
        }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
            return CalcResult::new_error(
                Error::NUM,
                cell,
@@ -1437,10 +1490,9 @@ impl Model {
            Ok(f) => f,
            Err(s) => return s,
        };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
        if settlement > maturity {
            return CalcResult::new_error(
                Error::NUM,
@@ -1448,7 +1500,7 @@ impl Model {
                "settlement should be <= maturity".to_string(),
            );
        }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
            return CalcResult::new_error(
                Error::NUM,
                cell,
@@ -1488,10 +1540,9 @@ impl Model {
            Ok(f) => f,
            Err(s) => return s,
        };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
        if settlement > maturity {
            return CalcResult::new_error(
                Error::NUM,
@@ -1499,7 +1550,7 @@ impl Model {
                "settlement should be <= maturity".to_string(),
            );
        }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
            return CalcResult::new_error(
                Error::NUM,
                cell,
--- a/base/src/functions/information.rs
+++ b/base/src/functions/information.rs
@@ -235,11 +235,6 @@ impl Model {
                // This cannot happen
                CalcResult::Number(1.0)
            }
-            CalcResult::Array(_) => CalcResult::Error {
-                error: Error::NIMPL,
-                origin: cell,
-                message: "Arrays not supported yet".to_string(),
-            },
        }
    }
    pub(crate) fn fn_sheet(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -252,13 +247,10 @@ impl Model {
            return CalcResult::Number(cell.sheet as f64 + 1.0);
        }
        // The arg could be a defined name or a table
-        // let  = &args[0];
-        match &args[0] {
-            Node::DefinedNameKind((name, scope, _)) => {
+        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(&(*scope, name.to_lowercase()))
+            if let Some(defined_name) = self.parsed_defined_names.get(&(None, name.to_lowercase()))
            {
                match defined_name {
                    ParsedDefinedName::CellReference(reference) => {
@@ -269,22 +261,13 @@ impl Model {
                    }
                    ParsedDefinedName::InvalidDefinedNameFormula => {
                        return CalcResult::Error {
-                                error: Error::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 {
@@ -296,14 +279,6 @@ impl Model {
                }
            }
        }
-            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,
@@ -312,8 +287,6 @@ impl Model {
        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,
            origin: cell,
--- a/base/src/functions/logical.rs
+++ b/base/src/functions/logical.rs
@@ -7,22 +7,6 @@ use crate::{
 use super::util::compare_values;

 impl Model {
-    pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            CalcResult::Boolean(true)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
-    pub(crate) fn fn_false(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            CalcResult::Boolean(false)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
    pub(crate) fn fn_if(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() == 2 || args.len() == 3 {
            let cond_result = self.get_boolean(&args[0], cell);
@@ -82,61 +66,24 @@ impl Model {
    }

    pub(crate) fn fn_and(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        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 {
-        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;
+        let mut true_count = 0;
        for arg in args {
            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
-                CalcResult::Number(value) => result = Some(fold_fn(result, value != 0.0)),
+                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(
@@ -152,72 +99,158 @@ impl Model {
                                row,
                                column,
                            }) {
-                                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
+                                CalcResult::Boolean(b) => {
+                                    if !b {
+                                        return CalcResult::Boolean(false);
+                                    }
+                                    true_count += 1;
+                                }
                                CalcResult::Number(value) => {
-                                    result = Some(fold_fn(result, value != 0.0))
+                                    if value == 0.0 {
+                                        return CalcResult::Boolean(false);
+                                    }
+                                    true_count += 1;
+                                }
+                                CalcResult::String(_value) => {
+                                    true_count += 1;
                                }
                                error @ CalcResult::Error { .. } => return error,
-                                CalcResult::EmptyArg => {} // unreachable
-                                CalcResult::Range { .. }
-                                | CalcResult::String { .. }
-                                | CalcResult::EmptyCell => {}
-                                CalcResult::Array(_) => {
-                                    return CalcResult::Error {
-                                        error: Error::NIMPL,
-                                        origin: cell,
-                                        message: "Arrays not supported yet".to_string(),
-                                    }
-                                }
-                            }
-                            if let (Some(current_result), Some(short_circuit_value)) =
-                                (result, short_circuit_value)
-                            {
-                                if current_result == short_circuit_value {
-                                    return CalcResult::Boolean(current_result);
-                                }
+                                CalcResult::Range { .. } => {}
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                            }
                        }
                    }
                }
                error @ CalcResult::Error { .. } => return error,
-                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));
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+            };
        }
-                    }
-                }
-                // References to empty cells are ignored. If all args are ignored the result is #VALUE!
-                CalcResult::EmptyCell => {}
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
-            }
-
-            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 let Some(result) = result {
-            CalcResult::Boolean(result)
-        } else {
-            CalcResult::new_error(
+        if true_count == 0 {
+            return CalcResult::new_error(
                Error::VALUE,
                cell,
-                "No logical values in argument list".to_string(),
-            )
+                "Boolean values not found".to_string(),
+            );
        }
+        CalcResult::Boolean(true)
+    }
+
+    pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let mut result = false;
+        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::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(value) => {
+                                    result = value || result;
+                                }
+                                CalcResult::Number(value) => {
+                                    if value != 0.0 {
+                                        return CalcResult::Boolean(true);
+                                    }
+                                }
+                                CalcResult::String(_value) => {
+                                    return CalcResult::Boolean(true);
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {}
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                            }
+                        }
+                    }
+                }
+                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;
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            };
+        }
+        if true_count == 0 && false_count == 0 {
+            return CalcResult::new_error(Error::VALUE, cell, "No booleans found".to_string());
+        }
+        CalcResult::Boolean(true_count % 2 == 1)
    }

    /// =SWITCH(expression, case1, value1, [case, value]*, [default])
@@ -246,7 +279,7 @@ impl Model {
        }
        // None of the cases matched so we return the default
        // If there is an even number of args is the last one otherwise is #N/A
-        if args_count.is_multiple_of(2) {
+        if args_count % 2 == 0 {
            return self.evaluate_node_in_context(&args[args_count - 1], cell);
        }
        CalcResult::Error {
@@ -262,7 +295,7 @@ impl Model {
        if args_count < 2 {
            return CalcResult::new_args_number_error(cell);
        }
-        if !args_count.is_multiple_of(2) {
+        if args_count % 2 != 0 {
            // Missing value for last condition
            return CalcResult::new_args_number_error(cell);
        }
--- a/base/src/functions/lookup_and_reference.rs
+++ b/base/src/functions/lookup_and_reference.rs
@@ -838,43 +838,4 @@ 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::NIMPL,
-                    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/macros.rs
+++ b/base/src/functions/macros.rs
@@ -1,100 +0,0 @@
-#[macro_export]
-macro_rules! single_number_fn {
-    // The macro takes:
-    //   1) A function name to define (e.g. fn_sin)
-    //   2) The operation to apply (e.g. f64::sin)
-    ($fn_name:ident, $op:expr) => {
-        pub(crate) fn $fn_name(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-            // 1) Check exactly one argument
-            if args.len() != 1 {
-                return CalcResult::new_args_number_error(cell);
-            }
-            // 2) Try to get a "NumberOrArray"
-            match self.get_number_or_array(&args[0], cell) {
-                // -----------------------------------------
-                // Case A: It's a single number
-                // -----------------------------------------
-                Ok(NumberOrArray::Number(f)) => match $op(f) {
-                    Ok(x) => CalcResult::Number(x),
-                    Err(Error::DIV) => CalcResult::Error {
-                        error: Error::DIV,
-                        origin: cell,
-                        message: "Divide by 0".to_string(),
-                    },
-                    Err(Error::VALUE) => CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid number".to_string(),
-                    },
-                    Err(e) => CalcResult::Error {
-                        error: e,
-                        origin: cell,
-                        message: "Unknown error".to_string(),
-                    },
-                },
-
-                // -----------------------------------------
-                // Case B: It's an array, so apply $op
-                // element-by-element.
-                // -----------------------------------------
-                Ok(NumberOrArray::Array(a)) => {
-                    let mut array = Vec::new();
-                    for row in a {
-                        let mut data_row = Vec::with_capacity(row.len());
-                        for value in row {
-                            match value {
-                                // If Boolean, treat as 0.0 or 1.0
-                                ArrayNode::Boolean(b) => {
-                                    let n = if b { 1.0 } else { 0.0 };
-                                    match $op(n) {
-                                        Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                        Err(Error::DIV) => {
-                                            data_row.push(ArrayNode::Error(Error::DIV))
-                                        }
-                                        Err(Error::VALUE) => {
-                                            data_row.push(ArrayNode::Error(Error::VALUE))
-                                        }
-                                        Err(e) => data_row.push(ArrayNode::Error(e)),
-                                    }
-                                }
-                                // If Number, apply directly
-                                ArrayNode::Number(n) => match $op(n) {
-                                    Ok(x) => data_row.push(ArrayNode::Number(x)),
-                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
-                                    Err(Error::VALUE) => {
-                                        data_row.push(ArrayNode::Error(Error::VALUE))
-                                    }
-                                    Err(e) => data_row.push(ArrayNode::Error(e)),
-                                },
-                                // If String, parse to f64 then apply or #VALUE! error
-                                ArrayNode::String(s) => {
-                                    let node = match s.parse::<f64>() {
-                                        Ok(f) => match $op(f) {
-                                            Ok(x) => ArrayNode::Number(x),
-                                            Err(Error::DIV) => ArrayNode::Error(Error::DIV),
-                                            Err(Error::VALUE) => ArrayNode::Error(Error::VALUE),
-                                            Err(e) => ArrayNode::Error(e),
-                                        },
-                                        Err(_) => ArrayNode::Error(Error::VALUE),
-                                    };
-                                    data_row.push(node);
-                                }
-                                // If Error, propagate the error
-                                e @ ArrayNode::Error(_) => {
-                                    data_row.push(e);
-                                }
-                            }
-                        }
-                        array.push(data_row);
-                    }
-                    CalcResult::Array(array)
-                }
-
-                // -----------------------------------------
-                // Case C: It's an Error => just return it
-                // -----------------------------------------
-                Err(err_result) => err_result,
-            }
-        }
-    };
-}
--- a/base/src/functions/mathematical.rs
+++ b/base/src/functions/mathematical.rs
@@ -1,9 +1,5 @@
-use crate::cast::NumberOrArray;
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::ArrayNode;
 use crate::expressions::types::CellReferenceIndex;
-use crate::number_format::to_precision;
-use crate::single_number_fn;
 use crate::{
    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
@@ -132,28 +128,20 @@ impl Model {
                    let column1 = left.column;
                    let mut column2 = right.column;
                    if row1 == 1 && row2 == LAST_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),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                    }
                    if column1 == 1 && column2 == LAST_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),
-                                );
-                            }
-                        };
+                        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) {
@@ -173,27 +161,6 @@ impl Model {
                        }
                    }
                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    result += value;
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // We ignore booleans and strings
-                                }
-                            }
-                        }
-                    }
-                }
                error @ CalcResult::Error { .. } => return error,
                _ => {
                    // We ignore booleans and strings
@@ -228,28 +195,20 @@ impl Model {
                    let column1 = left.column;
                    let mut column2 = right.column;
                    if row1 == 1 && row2 == LAST_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),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                    }
                    if column1 == 1 && column2 == LAST_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),
-                                );
-                            }
-                        };
+                        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) {
@@ -312,7 +271,7 @@ impl Model {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => to_precision(f, 15),
+            Ok(f) => f,
            Err(s) => return s,
        };
        let number_of_digits = match self.get_number(&args[1], cell) {
@@ -328,13 +287,12 @@ impl Model {
        let scale = 10.0_f64.powf(number_of_digits);
        CalcResult::Number((value * scale).round() / scale)
    }
-
    pub(crate) fn fn_roundup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => to_precision(f, 15),
+            Ok(f) => f,
            Err(s) => return s,
        };
        let number_of_digits = match self.get_number(&args[1], cell) {
@@ -354,13 +312,12 @@ impl Model {
            CalcResult::Number((value * scale).floor() / scale)
        }
    }
-
    pub(crate) fn fn_rounddown(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => to_precision(f, 15),
+            Ok(f) => f,
            Err(s) => return s,
        };
        let number_of_digits = match self.get_number(&args[1], cell) {
@@ -381,39 +338,187 @@ impl Model {
        }
    }

-    single_number_fn!(fn_log10, |f| if f <= 0.0 {
-        Err(Error::NUM)
-    } else {
-        Ok(f64::log10(f))
-    });
-    single_number_fn!(fn_ln, |f| if f <= 0.0 {
-        Err(Error::NUM)
-    } else {
-        Ok(f64::ln(f))
-    });
-    single_number_fn!(fn_sin, |f| Ok(f64::sin(f)));
-    single_number_fn!(fn_cos, |f| Ok(f64::cos(f)));
-    single_number_fn!(fn_tan, |f| Ok(f64::tan(f)));
-    single_number_fn!(fn_sinh, |f| Ok(f64::sinh(f)));
-    single_number_fn!(fn_cosh, |f| Ok(f64::cosh(f)));
-    single_number_fn!(fn_tanh, |f| Ok(f64::tanh(f)));
-    single_number_fn!(fn_asin, |f| Ok(f64::asin(f)));
-    single_number_fn!(fn_acos, |f| Ok(f64::acos(f)));
-    single_number_fn!(fn_atan, |f| Ok(f64::atan(f)));
-    single_number_fn!(fn_asinh, |f| Ok(f64::asinh(f)));
-    single_number_fn!(fn_acosh, |f| Ok(f64::acosh(f)));
-    single_number_fn!(fn_atanh, |f| Ok(f64::atanh(f)));
-    single_number_fn!(fn_abs, |f| Ok(f64::abs(f)));
-    single_number_fn!(fn_sqrt, |f| if f < 0.0 {
-        Err(Error::NUM)
-    } else {
-        Ok(f64::sqrt(f))
-    });
-    single_number_fn!(fn_sqrtpi, |f: f64| if f < 0.0 {
-        Err(Error::NUM)
-    } else {
-        Ok((f * PI).sqrt())
-    });
+    pub(crate) fn fn_sin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.sin();
+        CalcResult::Number(result)
+    }
+    pub(crate) fn fn_cos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.cos();
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_tan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.tan();
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_sinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.sinh();
+        CalcResult::Number(result)
+    }
+    pub(crate) fn fn_cosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.cosh();
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_tanh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.tanh();
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_asin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.asin();
+        if result.is_nan() || result.is_infinite() {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Invalid argument for ASIN".to_string(),
+            };
+        }
+        CalcResult::Number(result)
+    }
+    pub(crate) fn fn_acos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.acos();
+        if result.is_nan() || result.is_infinite() {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Invalid argument for COS".to_string(),
+            };
+        }
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_atan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.atan();
+        if result.is_nan() || result.is_infinite() {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Invalid argument for ATAN".to_string(),
+            };
+        }
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_asinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.asinh();
+        if result.is_nan() || result.is_infinite() {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Invalid argument for ASINH".to_string(),
+            };
+        }
+        CalcResult::Number(result)
+    }
+    pub(crate) fn fn_acosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.acosh();
+        if result.is_nan() || result.is_infinite() {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Invalid argument for ACOSH".to_string(),
+            };
+        }
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_atanh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let result = value.atanh();
+        if result.is_nan() || result.is_infinite() {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Invalid argument for ATANH".to_string(),
+            };
+        }
+        CalcResult::Number(result)
+    }

    pub(crate) fn fn_pi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if !args.is_empty() {
@@ -422,6 +527,53 @@ impl Model {
        CalcResult::Number(PI)
    }

+    pub(crate) fn fn_abs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        CalcResult::Number(value.abs())
+    }
+
+    pub(crate) fn fn_sqrtpi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        if value < 0.0 {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Argument of SQRTPI should be >= 0".to_string(),
+            };
+        }
+        CalcResult::Number((value * PI).sqrt())
+    }
+
+    pub(crate) fn fn_sqrt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        if value < 0.0 {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Argument of SQRT should be >= 0".to_string(),
+            };
+        }
+        CalcResult::Number(value.sqrt())
+    }
+
    pub(crate) fn fn_atan2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
@@ -444,47 +596,6 @@ impl Model {
        CalcResult::Number(f64::atan2(y, x))
    }

-    pub(crate) fn fn_log(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let n_args = args.len();
-        if !(1..=2).contains(&n_args) {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let x = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let y = if n_args == 1 {
-            10.0
-        } else {
-            match self.get_number(&args[1], cell) {
-                Ok(f) => f,
-                Err(s) => return s,
-            }
-        };
-        if x <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Number must be positive".to_string(),
-            };
-        }
-        if y == 1.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Logarithm base cannot be 1".to_string(),
-            };
-        }
-        if y <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Logarithm base must be positive".to_string(),
-            };
-        }
-        CalcResult::Number(f64::log(x, y))
-    }
-
    pub(crate) fn fn_power(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
--- a/base/src/functions/mod.rs
+++ b/base/src/functions/mod.rs
@@ -15,7 +15,6 @@ mod financial_util;
 mod information;
 mod logical;
 mod lookup_and_reference;
-mod macros;
 mod mathematical;
 mod statistical;
 mod subtotal;
@@ -54,9 +53,6 @@ pub enum Function {
    Columns,
    Cos,
    Cosh,
-    Log,
-    Log10,
-    Ln,
    Max,
    Min,
    Pi,
@@ -79,7 +75,6 @@ pub enum Function {

    // Information
    ErrorType,
-    Formulatext,
    Isblank,
    Iserr,
    Iserror,
@@ -127,7 +122,6 @@ pub enum Function {
    Textbefore,
    Textjoin,
    Trim,
-    Unicode,
    Upper,
    Value,
    Valuetotext,
@@ -144,34 +138,16 @@ pub enum Function {
    Countifs,
    Maxifs,
    Minifs,
-    Geomean,

    // Date and time
    Date,
-    Datedif,
-    Datevalue,
    Day,
    Edate,
    Eomonth,
    Month,
-    Time,
-    Timevalue,
-    Hour,
-    Minute,
-    Second,
    Now,
    Today,
    Year,
-    Networkdays,
-    NetworkdaysIntl,
-    Days,
-    Days360,
-    Weekday,
-    Weeknum,
-    Workday,
-    WorkdayIntl,
-    Yearfrac,
-    Isoweeknum,

    // Financial
    Cumipmt,
@@ -270,7 +246,7 @@ pub enum Function {
 }

 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 215> {
+    pub fn into_iter() -> IntoIter<Function, 192> {
        [
            Function::And,
            Function::False,
@@ -297,9 +273,6 @@ impl Function {
            Function::Atanh,
            Function::Abs,
            Function::Pi,
-            Function::Ln,
-            Function::Log,
-            Function::Log10,
            Function::Sqrt,
            Function::Sqrtpi,
            Function::Atan2,
@@ -343,7 +316,6 @@ impl Function {
            Function::Search,
            Function::Text,
            Function::Trim,
-            Function::Unicode,
            Function::Upper,
            Function::Isnumber,
            Function::Isnontext,
@@ -358,7 +330,6 @@ impl Function {
            Function::Isodd,
            Function::Iseven,
            Function::ErrorType,
-            Function::Formulatext,
            Function::Isformula,
            Function::Type,
            Function::Sheet,
@@ -373,32 +344,14 @@ impl Function {
            Function::Countifs,
            Function::Maxifs,
            Function::Minifs,
-            Function::Geomean,
            Function::Year,
            Function::Day,
            Function::Month,
            Function::Eomonth,
            Function::Date,
-            Function::Datedif,
-            Function::Datevalue,
            Function::Edate,
-            Function::Networkdays,
-            Function::NetworkdaysIntl,
-            Function::Time,
-            Function::Timevalue,
-            Function::Hour,
-            Function::Minute,
-            Function::Second,
            Function::Today,
            Function::Now,
-            Function::Days,
-            Function::Days360,
-            Function::Weekday,
-            Function::Weeknum,
-            Function::Workday,
-            Function::WorkdayIntl,
-            Function::Yearfrac,
-            Function::Isoweeknum,
            Function::Pmt,
            Function::Pv,
            Function::Rate,
@@ -507,7 +460,6 @@ 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(),
@@ -527,8 +479,6 @@ 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(),
-            Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
            _ => self.to_string(),
        }
    }
@@ -575,10 +525,6 @@ impl Function {
            "POWER" => Some(Function::Power),
            "ATAN2" => Some(Function::Atan2),

-            "LN" => Some(Function::Ln),
-            "LOG" => Some(Function::Log),
-            "LOG10" => Some(Function::Log10),
-
            "MAX" => Some(Function::Max),
            "MIN" => Some(Function::Min),
            "PRODUCT" => Some(Function::Product),
@@ -621,7 +567,6 @@ 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),
@@ -643,7 +588,6 @@ 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),
@@ -659,33 +603,15 @@ 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),
            "EOMONTH" => Some(Function::Eomonth),
            "MONTH" => Some(Function::Month),
            "DATE" => Some(Function::Date),
-            "DATEDIF" => Some(Function::Datedif),
-            "DATEVALUE" => Some(Function::Datevalue),
            "EDATE" => Some(Function::Edate),
-            "NETWORKDAYS" => Some(Function::Networkdays),
-            "NETWORKDAYS.INTL" => Some(Function::NetworkdaysIntl),
-            "TIME" => Some(Function::Time),
-            "TIMEVALUE" => Some(Function::Timevalue),
-            "HOUR" => Some(Function::Hour),
-            "MINUTE" => Some(Function::Minute),
-            "SECOND" => Some(Function::Second),
            "TODAY" => Some(Function::Today),
            "NOW" => Some(Function::Now),
-            "DAYS" | "_XLFN.DAYS" => Some(Function::Days),
-            "DAYS360" => Some(Function::Days360),
-            "WEEKDAY" => Some(Function::Weekday),
-            "WEEKNUM" => Some(Function::Weeknum),
-            "WORKDAY" => Some(Function::Workday),
-            "WORKDAY.INTL" => Some(Function::WorkdayIntl),
-            "YEARFRAC" => Some(Function::Yearfrac),
-            "ISOWEEKNUM" | "_XLFN.ISOWEEKNUM" => Some(Function::Isoweeknum),
            // Financial
            "PMT" => Some(Function::Pmt),
            "PV" => Some(Function::Pv),
@@ -796,9 +722,6 @@ impl fmt::Display for Function {
            Function::Switch => write!(f, "SWITCH"),
            Function::True => write!(f, "TRUE"),
            Function::Xor => write!(f, "XOR"),
-            Function::Log => write!(f, "LOG"),
-            Function::Log10 => write!(f, "LOG10"),
-            Function::Ln => write!(f, "LN"),
            Function::Sin => write!(f, "SIN"),
            Function::Cos => write!(f, "COS"),
            Function::Tan => write!(f, "TAN"),
@@ -856,7 +779,6 @@ 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"),
@@ -871,7 +793,6 @@ 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"),
@@ -887,32 +808,14 @@ 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"),
            Function::Eomonth => write!(f, "EOMONTH"),
            Function::Date => write!(f, "DATE"),
-            Function::Datedif => write!(f, "DATEDIF"),
-            Function::Datevalue => write!(f, "DATEVALUE"),
            Function::Edate => write!(f, "EDATE"),
-            Function::Networkdays => write!(f, "NETWORKDAYS"),
-            Function::NetworkdaysIntl => write!(f, "NETWORKDAYS.INTL"),
-            Function::Time => write!(f, "TIME"),
-            Function::Timevalue => write!(f, "TIMEVALUE"),
-            Function::Hour => write!(f, "HOUR"),
-            Function::Minute => write!(f, "MINUTE"),
-            Function::Second => write!(f, "SECOND"),
            Function::Today => write!(f, "TODAY"),
            Function::Now => write!(f, "NOW"),
-            Function::Days => write!(f, "DAYS"),
-            Function::Days360 => write!(f, "DAYS360"),
-            Function::Weekday => write!(f, "WEEKDAY"),
-            Function::Weeknum => write!(f, "WEEKNUM"),
-            Function::Workday => write!(f, "WORKDAY"),
-            Function::WorkdayIntl => write!(f, "WORKDAY.INTL"),
-            Function::Yearfrac => write!(f, "YEARFRAC"),
-            Function::Isoweeknum => write!(f, "ISOWEEKNUM"),
            Function::Pmt => write!(f, "PMT"),
            Function::Pv => write!(f, "PV"),
            Function::Rate => write!(f, "RATE"),
@@ -1032,7 +935,7 @@ impl Model {
        match kind {
            // Logical
            Function::And => self.fn_and(args, cell),
-            Function::False => self.fn_false(args, cell),
+            Function::False => CalcResult::Boolean(false),
            Function::If => self.fn_if(args, cell),
            Function::Iferror => self.fn_iferror(args, cell),
            Function::Ifna => self.fn_ifna(args, cell),
@@ -1040,12 +943,9 @@ impl Model {
            Function::Not => self.fn_not(args, cell),
            Function::Or => self.fn_or(args, cell),
            Function::Switch => self.fn_switch(args, cell),
-            Function::True => self.fn_true(args, cell),
+            Function::True => CalcResult::Boolean(true),
            Function::Xor => self.fn_xor(args, cell),
            // Math and trigonometry
-            Function::Log => self.fn_log(args, cell),
-            Function::Log10 => self.fn_log10(args, cell),
-            Function::Ln => self.fn_ln(args, cell),
            Function::Sin => self.fn_sin(args, cell),
            Function::Cos => self.fn_cos(args, cell),
            Function::Tan => self.fn_tan(args, cell),
@@ -1112,7 +1012,6 @@ 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),
@@ -1128,7 +1027,6 @@ 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),
@@ -1144,33 +1042,15 @@ 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),
            Function::Eomonth => self.fn_eomonth(args, cell),
            Function::Month => self.fn_month(args, cell),
            Function::Date => self.fn_date(args, cell),
-            Function::Datedif => self.fn_datedif(args, cell),
-            Function::Datevalue => self.fn_datevalue(args, cell),
            Function::Edate => self.fn_edate(args, cell),
-            Function::Networkdays => self.fn_networkdays(args, cell),
-            Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
-            Function::Time => self.fn_time(args, cell),
-            Function::Timevalue => self.fn_timevalue(args, cell),
-            Function::Hour => self.fn_hour(args, cell),
-            Function::Minute => self.fn_minute(args, cell),
-            Function::Second => self.fn_second(args, cell),
            Function::Today => self.fn_today(args, cell),
            Function::Now => self.fn_now(args, cell),
-            Function::Days => self.fn_days(args, cell),
-            Function::Days360 => self.fn_days360(args, cell),
-            Function::Weekday => self.fn_weekday(args, cell),
-            Function::Weeknum => self.fn_weeknum(args, cell),
-            Function::Workday => self.fn_workday(args, cell),
-            Function::WorkdayIntl => self.fn_workday_intl(args, cell),
-            Function::Yearfrac => self.fn_yearfrac(args, cell),
-            Function::Isoweeknum => self.fn_isoweeknum(args, cell),
            // Financial
            Function::Pmt => self.fn_pmt(args, cell),
            Function::Pv => self.fn_pv(args, cell),
@@ -1268,7 +1148,6 @@ impl Model {

 #[cfg(test)]
 mod tests {
-    #![allow(clippy::unwrap_used)]
    use std::{
        fs::File,
        io::{BufRead, BufReader},
@@ -1316,7 +1195,7 @@ mod tests {
        }
        // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
        let iter_list = Function::into_iter()
-            .map(|f| format!("{f}").replace('.', ""))
+            .map(|f| format!("{}", f).replace('.', ""))
            .collect::<Vec<_>>();

        let len = iter_list.len();
--- a/base/src/functions/statistical.rs
+++ b/base/src/functions/statistical.rs
@@ -134,13 +134,6 @@ impl Model {
                                    );
                                }
                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-                                CalcResult::Array(_) => {
-                                    return CalcResult::Error {
-                                        error: Error::NIMPL,
-                                        origin: cell,
-                                        message: "Arrays not supported yet".to_string(),
-                                    }
-                                }
                            }
                        }
                    }
@@ -172,13 +165,6 @@ impl Model {
                }
                error @ CalcResult::Error { .. } => return error,
                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
        }
        if count == 0.0 {
@@ -350,7 +336,7 @@ impl Model {
    // FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
    pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        let args_count = args.len();
-        if args_count < 2 || !args_count.is_multiple_of(2) {
+        if args_count < 2 || args_count % 2 == 1 {
            return CalcResult::new_args_number_error(cell);
        }

@@ -395,16 +381,11 @@ impl Model {
        let right_row = first_range.right.row;
        let right_column = first_range.right.column;

-        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 dimension = self
+            .workbook
+            .worksheet(first_range.left.sheet)
+            .expect("Sheet expected during evaluation.")
+            .dimension();
        let max_row = dimension.max_row;
        let max_column = dimension.max_column;

@@ -476,7 +457,7 @@ impl Model {
        F: FnMut(f64),
    {
        let args_count = args.len();
-        if args_count < 3 || args_count.is_multiple_of(2) {
+        if args_count < 3 || args_count % 2 == 0 {
            return Err(CalcResult::new_args_number_error(cell));
        }
        let arg_0 = self.evaluate_node_in_context(&args[0], cell);
@@ -545,28 +526,20 @@ impl Model {
        let mut right_column = sum_range.right.column;

        if left_row == 1 && right_row == LAST_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),
-                    ));
-                }
-            };
+            right_row = self
+                .workbook
+                .worksheet(sum_range.left.sheet)
+                .expect("Sheet expected during evaluation.")
+                .dimension()
+                .max_row;
        }
        if left_column == 1 && right_column == LAST_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),
-                    ));
-                }
-            };
+            right_column = self
+                .workbook
+                .worksheet(sum_range.left.sheet)
+                .expect("Sheet expected during evaluation.")
+                .dimension()
+                .max_column;
        }

        for row in left_row..right_row + 1 {
@@ -649,85 +622,4 @@ 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,13 +53,8 @@ impl Model {
        false
    }

-    fn cell_hidden_status(
-        &self,
-        sheet_index: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<CellTableStatus, String> {
-        let worksheet = self.workbook.worksheet(sheet_index)?;
+    fn cell_hidden_status(&self, sheet_index: u32, row: i32, column: i32) -> CellTableStatus {
+        let worksheet = self.workbook.worksheet(sheet_index).expect("");
        let mut hidden = false;
        for row_style in &worksheet.rows {
            if row_style.r == row {
@@ -68,13 +63,13 @@ impl Model {
            }
        }
        if !hidden {
-            return Ok(CellTableStatus::Normal);
+            return 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) {
-            Ok(CellTableStatus::Filtered)
+            CellTableStatus::Filtered
        } else {
-            Ok(CellTableStatus::Hidden)
+            CellTableStatus::Hidden
        }
    }

@@ -148,11 +143,7 @@ impl Model {
                            let column2 = right.column;

                            for row in row1..=row2 {
-                                let cell_status = self
-                                    .cell_hidden_status(left.sheet, row, column1)
-                                    .map_err(|message| {
-                                        CalcResult::new_error(Error::ERROR, cell, message)
-                                    })?;
+                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
                                if cell_status == CellTableStatus::Filtered {
                                    continue;
                                }
@@ -182,13 +173,6 @@ impl Model {
                            }
                        }
                        CalcResult::EmptyCell | CalcResult::EmptyArg => result.push(0.0),
-                        CalcResult::Array(_) => {
-                            return Err(CalcResult::Error {
-                                error: Error::NIMPL,
-                                origin: cell,
-                                message: "Arrays not supported yet".to_string(),
-                            })
-                        }
                    }
                }
            }
@@ -396,14 +380,7 @@ impl Model {
                            let column2 = right.column;

                            for row in row1..=row2 {
-                                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);
-                                    }
-                                };
+                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
                                if cell_status == CellTableStatus::Filtered {
                                    continue;
                                }
@@ -433,13 +410,6 @@ impl Model {
                        | CalcResult::Number(_)
                        | CalcResult::Boolean(_)
                        | CalcResult::Error { .. } => counta += 1,
-                        CalcResult::Array(_) => {
-                            return CalcResult::Error {
-                                error: Error::NIMPL,
-                                origin: cell,
-                                message: "Arrays not supported yet".to_string(),
-                            }
-                        }
                    }
                }
            }
@@ -479,14 +449,7 @@ impl Model {
                            let column2 = right.column;

                            for row in row1..=row2 {
-                                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);
-                                    }
-                                };
+                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
                                if cell_status == CellTableStatus::Filtered {
                                    continue;
                                }
--- a/base/src/functions/text.rs
+++ b/base/src/functions/text.rs
@@ -55,14 +55,14 @@ impl Model {
        let mut result = "".to_string();
        for arg in args {
            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::String(value) => result = format!("{result}{value}"),
-                CalcResult::Number(value) => result = format!("{result}{value}"),
+                CalcResult::String(value) => result = format!("{}{}", result, value),
+                CalcResult::Number(value) => result = format!("{}{}", result, value),
                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                CalcResult::Boolean(value) => {
                    if value {
-                        result = format!("{result}TRUE");
+                        result = format!("{}TRUE", result);
                    } else {
-                        result = format!("{result}FALSE");
+                        result = format!("{}FALSE", result);
                    }
                }
                error @ CalcResult::Error { .. } => return error,
@@ -82,37 +82,25 @@ impl Model {
                                column,
                            }) {
                                CalcResult::String(value) => {
-                                    result = format!("{result}{value}");
+                                    result = format!("{}{}", result, value);
+                                }
+                                CalcResult::Number(value) => {
+                                    result = format!("{}{}", result, value)
                                }
-                                CalcResult::Number(value) => result = format!("{result}{value}"),
                                CalcResult::Boolean(value) => {
                                    if value {
-                                        result = format!("{result}TRUE");
+                                        result = format!("{}TRUE", result);
                                    } else {
-                                        result = format!("{result}FALSE");
+                                        result = format!("{}FALSE", result);
                                    }
                                }
                                error @ CalcResult::Error { .. } => return error,
                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                                CalcResult::Range { .. } => {}
-                                CalcResult::Array(_) => {
-                                    return CalcResult::Error {
-                                        error: Error::NIMPL,
-                                        origin: cell,
-                                        message: "Arrays not supported yet".to_string(),
                            }
                        }
                    }
                }
-                    }
-                }
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
        }
        CalcResult::String(result)
@@ -137,13 +125,6 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
            let format_code = match self.get_string(&args[1], cell) {
                Ok(s) => s,
@@ -280,7 +261,7 @@ impl Model {
    pub(crate) fn fn_len(&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::Number(v) => format!("{}", v),
                CalcResult::String(v) => v,
                CalcResult::Boolean(b) => {
                    if b {
@@ -299,13 +280,6 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
            return CalcResult::Number(s.chars().count() as f64);
        }
@@ -315,7 +289,7 @@ impl Model {
    pub(crate) fn fn_trim(&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::Number(v) => format!("{}", v),
                CalcResult::String(v) => v,
                CalcResult::Boolean(b) => {
                    if b {
@@ -334,13 +308,6 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
            return CalcResult::String(s.trim().to_owned());
        }
@@ -350,7 +317,7 @@ impl Model {
    pub(crate) fn fn_lower(&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::Number(v) => format!("{}", v),
                CalcResult::String(v) => v,
                CalcResult::Boolean(b) => {
                    if b {
@@ -369,77 +336,16 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
            return CalcResult::String(s.to_lowercase());
        }
        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(),
-                    }
-                }
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".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) {
-                CalcResult::Number(v) => format!("{v}"),
+                CalcResult::Number(v) => format!("{}", v),
                CalcResult::String(v) => v,
                CalcResult::Boolean(b) => {
                    if b {
@@ -458,13 +364,6 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
            return CalcResult::String(s.to_uppercase());
        }
@@ -476,7 +375,7 @@ impl Model {
            return CalcResult::new_args_number_error(cell);
        }
        let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{v}"),
+            CalcResult::Number(v) => format!("{}", v),
            CalcResult::String(v) => v,
            CalcResult::Boolean(b) => {
                if b {
@@ -495,13 +394,6 @@ impl Model {
                };
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-            CalcResult::Array(_) => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                }
-            }
        };
        let num_chars = if args.len() == 2 {
            match self.evaluate_node_in_context(&args[1], cell) {
@@ -532,13 +424,6 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            }
        } else {
            1
@@ -558,7 +443,7 @@ impl Model {
            return CalcResult::new_args_number_error(cell);
        }
        let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{v}"),
+            CalcResult::Number(v) => format!("{}", v),
            CalcResult::String(v) => v,
            CalcResult::Boolean(b) => {
                if b {
@@ -577,13 +462,6 @@ impl Model {
                };
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-            CalcResult::Array(_) => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                }
-            }
        };
        let num_chars = if args.len() == 2 {
            match self.evaluate_node_in_context(&args[1], cell) {
@@ -614,13 +492,6 @@ impl Model {
                    };
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            }
        } else {
            1
@@ -632,7 +503,7 @@ impl Model {
            }
            result.push(ch);
        }
-        CalcResult::String(result.chars().rev().collect::<String>())
+        return CalcResult::String(result.chars().rev().collect::<String>());
    }

    pub(crate) fn fn_mid(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -640,7 +511,7 @@ impl Model {
            return CalcResult::new_args_number_error(cell);
        }
        let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{v}"),
+            CalcResult::Number(v) => format!("{}", v),
            CalcResult::String(v) => v,
            CalcResult::Boolean(b) => {
                if b {
@@ -659,13 +530,6 @@ impl Model {
                };
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-            CalcResult::Array(_) => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                }
-            }
        };
        let start_num = match self.evaluate_node_in_context(&args[1], cell) {
            CalcResult::Number(v) => {
@@ -730,13 +594,6 @@ impl Model {
                };
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
-            CalcResult::Array(_) => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                }
-            }
        };
        let mut result = "".to_string();
        let mut count: usize = 0;
@@ -1031,28 +888,20 @@ impl Model {
                    let column1 = left.column;
                    let mut column2 = right.column;
                    if row1 == 1 && row2 == LAST_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),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                    }
                    if column1 == 1 && column2 == LAST_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),
-                                );
-                            }
-                        };
+                        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) {
@@ -1079,13 +928,6 @@ impl Model {
                                }
                                error @ CalcResult::Error { .. } => return error,
                                CalcResult::EmptyArg | CalcResult::Range { .. } => {}
-                                CalcResult::Array(_) => {
-                                    return CalcResult::Error {
-                                        error: Error::NIMPL,
-                                        origin: cell,
-                                        message: "Arrays not supported yet".to_string(),
-                                    }
-                                }
                            }
                        }
                    }
@@ -1105,13 +947,6 @@ impl Model {
                    }
                }
                CalcResult::EmptyArg => {}
-                CalcResult::Array(_) => {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Arrays not supported yet".to_string(),
-                    }
-                }
            };
        }
        let result = values.join(&delimiter);
@@ -1235,11 +1070,6 @@ impl Model {
                }
            }
            CalcResult::EmptyCell | CalcResult::EmptyArg => CalcResult::Number(0.0),
-            CalcResult::Array(_) => CalcResult::Error {
-                error: Error::NIMPL,
-                origin: cell,
-                message: "Arrays not supported yet".to_string(),
-            },
        }
    }

--- a/base/src/functions/util.rs
+++ b/base/src/functions/util.rs
@@ -1,5 +1,4 @@
-#[cfg(feature = "use_regex_lite")]
-use regex_lite as regex;
+use regex::{escape, Regex};

 use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};

@@ -26,9 +25,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 {
@@ -87,7 +86,7 @@ pub(crate) fn from_wildcard_to_regex(
    exact: bool,
 ) -> Result<regex::Regex, regex::Error> {
    // 1. Escape all
-    let reg = &regex::escape(wildcard);
+    let reg = &escape(wildcard);

    // 2. We convert the escaped '?' into '.' (matches a single character)
    let reg = &reg.replace("\\?", ".");
@@ -110,13 +109,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::Regex::new(&format!("^{reg}$"));
+        return Regex::new(&format!("^{}$", reg));
    }
-    regex::Regex::new(reg)
+    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)
@@ -181,8 +180,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 {
@@ -199,12 +198,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::Regex) -> bool {
+pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &Regex) -> bool {
    match calc_result {
        CalcResult::String(s) => reg.is_match(&s.to_lowercase()),
        _ => false,
@@ -270,8 +269,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 {
@@ -287,8 +286,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.
@@ -393,8 +392,10 @@ pub(crate) fn build_criteria<'a>(value: &'a CalcResult) -> Box<dyn Fn(&CalcResul
            // An error will match an error (never a string that is an error)
            Box::new(move |x| result_is_equal_to_error(x, &error.to_string()))
        }
-        CalcResult::Range { left: _, right: _ } => Box::new(move |_x| false),
-        CalcResult::Array(_) => Box::new(move |_x| false),
+        CalcResult::Range { left: _, right: _ } => {
+            // TODO: Implicit Intersection
+            Box::new(move |_x| false)
+        }
        CalcResult::EmptyCell | CalcResult::EmptyArg => Box::new(result_is_equal_to_empty),
    }
 }
--- a/base/src/functions/xlookup.rs
+++ b/base/src/functions/xlookup.rs
@@ -251,28 +251,20 @@ impl Model {
                        let column1 = left.column;

                        if row1 == 1 && row2 == LAST_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),
-                                    );
-                                }
-                            };
+                            row2 = self
+                                .workbook
+                                .worksheet(left.sheet)
+                                .expect("Sheet expected during evaluation.")
+                                .dimension()
+                                .max_row;
                        }
                        if column1 == 1 && column2 == LAST_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),
-                                    );
-                                }
-                            };
+                            column2 = self
+                                .workbook
+                                .worksheet(left.sheet)
+                                .expect("Sheet expected during evaluation.")
+                                .dimension()
+                                .max_column;
                        }
                        let left = CellReferenceIndex {
                            sheet: left.sheet,
--- a/base/src/language/mod.rs
+++ b/base/src/language/mod.rs
@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::OnceLock};
+use std::collections::HashMap;

 use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;

 #[derive(Encode, Decode, Clone)]
 pub struct Booleans {
@@ -30,17 +31,13 @@ pub struct Language {
    pub errors: Errors,
 }

-static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
-
-#[allow(clippy::expect_used)]
-fn get_languages() -> &'static HashMap<String, Language> {
-    LANGUAGES.get_or_init(|| {
+static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
-    })
-}
+});

 pub fn get_language(id: &str) -> Result<&Language, String> {
-    get_languages()
+    let language = LANGUAGES
        .get(id)
-        .ok_or_else(|| format!("Language is not supported: '{id}'"))
+        .ok_or(format!("Language is not supported: '{}'", id))?;
+    Ok(language)
 }
--- a/base/src/lib.rs
+++ b/base/src/lib.rs
@@ -25,8 +25,6 @@
 #![doc = include_str!("../examples/formulas_and_errors.rs")]
 //! ```

-#![warn(clippy::print_stdout)]
-
 pub mod calc_result;
 pub mod cell;
 pub mod expressions;
@@ -39,9 +37,9 @@ pub mod types;
 pub mod worksheet;

 mod actions;
-mod arithmetic;
 mod cast;
 mod constants;
+mod diffs;
 mod functions;
 mod implicit_intersection;
 mod model;
@@ -60,5 +58,4 @@ pub mod mock_time;
 pub use model::get_milliseconds_since_epoch;
 pub use model::Model;
 pub use user_model::BorderArea;
-pub use user_model::ClipboardData;
 pub use user_model::UserModel;
--- a/base/src/locale/mod.rs
+++ b/base/src/locale/mod.rs
@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::OnceLock};
-
 use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
+
+use std::collections::HashMap;

 #[derive(Encode, Decode, Clone)]
 pub struct Locale {
@@ -64,17 +65,11 @@ pub struct DecimalFormats {
    pub standard: String,
 }

-static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
-
-#[allow(clippy::expect_used)]
-fn get_locales() -> &'static HashMap<String, Locale> {
-    LOCALES.get_or_init(|| {
-        bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
-    })
-}
+static LOCALES: Lazy<HashMap<String, Locale>> =
+    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));

 pub fn get_locale(id: &str) -> Result<&Locale, String> {
-    get_locales()
-        .get(id)
-        .ok_or_else(|| format!("Invalid locale: '{id}'"))
+    // TODO: pass the locale once we implement locales in Rust
+    let locale = LOCALES.get(id).ok_or("Invalid locale")?;
+    Ok(locale)
 }
--- a/base/src/model.rs
+++ b/base/src/model.rs
@@ -8,15 +8,14 @@ use crate::{
    cell::CellValue,
    constants::{self, LAST_COLUMN, LAST_ROW},
    expressions::{
-        lexer::LexerMode,
        parser::{
            move_formula::{move_formula, MoveContext},
-            stringify::{rename_defined_name_in_node, to_rc_format, to_string},
+            stringify::{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_identifier, is_valid_row},
+        utils::{self, is_valid_column_number, is_valid_row},
    },
    formatter::{
        format::{format_number, parse_formatted_number},
@@ -42,7 +41,6 @@ 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()
@@ -73,7 +71,6 @@ pub(crate) enum CellState {
 }

 /// A parsed formula for a defined name
-#[derive(Clone)]
 pub(crate) enum ParsedDefinedName {
    /// CellReference (`=C4`)
    CellReference(CellReferenceIndex),
@@ -81,6 +78,9 @@ 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.
@@ -106,15 +106,15 @@ pub struct Model {
    pub(crate) shared_strings: HashMap<String, usize>,
    /// An instance of the parser
    pub(crate) parser: Parser,
-    /// The list of cells with formulas that are evaluated or being evaluated
+    /// The list of cells with formulas that are evaluated of being evaluated
    pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
    /// The locale of the model
    pub(crate) locale: Locale,
-    /// The language used
+    /// Tha language used
    pub(crate) language: Language,
    /// The timezone used to evaluate the model
    pub(crate) tz: Tz,
-    /// The view id. A view consists of a selected sheet and ranges.
+    /// The view id. A view consist of a selected sheet and ranges.
    pub(crate) view_id: u32,
 }

@@ -207,17 +207,6 @@ impl Model {
                    },
                }
            }
-            Node::ImplicitIntersection {
-                automatic: _,
-                child,
-            } => match self.evaluate_node_with_reference(child, cell) {
-                CalcResult::Range { left, right } => CalcResult::Range { left, right },
-                _ => CalcResult::new_error(
-                    Error::ERROR,
-                    cell,
-                    format!("Error with Implicit Intersection in cell {cell:?}"),
-                ),
-            },
            _ => self.evaluate_node_in_context(node, cell),
        }
    }
@@ -267,10 +256,27 @@ impl Model {
    ) -> CalcResult {
        use Node::*;
        match node {
-            OpSumKind { kind, left, right } => match kind {
-                OpSum::Add => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 + f2)),
-                OpSum::Minus => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 - f2)),
-            },
+            OpSumKind { kind, left, right } => {
+                // In the future once the feature try trait stabilizes we could use the '?' operator for this :)
+                // See: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=236044e8321a1450988e6ffe5a27dab5
+                let l = match self.get_number(left, cell) {
+                    Ok(f) => f,
+                    Err(s) => {
+                        return s;
+                    }
+                };
+                let r = match self.get_number(right, cell) {
+                    Ok(f) => f,
+                    Err(s) => {
+                        return s;
+                    }
+                };
+                let result = match kind {
+                    OpSum::Add => l + r,
+                    OpSum::Minus => l - r,
+                };
+                CalcResult::Number(result)
+            }
            NumberKind(value) => CalcResult::Number(*value),
            StringKind(value) => CalcResult::String(value.replace(r#""""#, r#"""#)),
            BooleanKind(value) => CalcResult::Boolean(*value),
@@ -355,63 +361,93 @@ impl Model {
                        return s;
                    }
                };
-                let result = format!("{l}{r}");
+                let result = format!("{}{}", l, r);
                CalcResult::String(result)
            }
-            OpProductKind { kind, left, right } => match kind {
-                OpProduct::Times => {
-                    self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 * f2))
+            OpProductKind { kind, left, right } => {
+                let l = match self.get_number(left, cell) {
+                    Ok(f) => f,
+                    Err(s) => {
+                        return s;
                    }
-                OpProduct::Divide => self.handle_arithmetic(left, right, cell, &|f1, f2| {
-                    if f2 == 0.0 {
-                        Err(Error::DIV)
-                    } else {
-                        Ok(f1 / f2)
+                };
+                let r = match self.get_number(right, cell) {
+                    Ok(f) => f,
+                    Err(s) => {
+                        return s;
+                    }
+                };
+                let result = match kind {
+                    OpProduct::Times => l * r,
+                    OpProduct::Divide => {
+                        if r == 0.0 {
+                            return CalcResult::new_error(
+                                Error::DIV,
+                                cell,
+                                "Divide by Zero".to_string(),
+                            );
+                        }
+                        l / r
+                    }
+                };
+                CalcResult::Number(result)
            }
-                }),
-            },
            OpPowerKind { left, right } => {
-                self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1.powf(f2)))
+                let l = match self.get_number(left, cell) {
+                    Ok(f) => f,
+                    Err(s) => {
+                        return s;
+                    }
+                };
+                let r = match self.get_number(right, cell) {
+                    Ok(f) => f,
+                    Err(s) => {
+                        return s;
+                    }
+                };
+                // Deal with errors properly
+                CalcResult::Number(l.powf(r))
            }
            FunctionKind { kind, args } => self.evaluate_function(kind, args, cell),
            InvalidFunctionKind { name, args: _ } => {
-                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {name}"))
+                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {}", name))
            }
-            ArrayKind(s) => CalcResult::Array(s.to_owned()),
-            DefinedNameKind((name, scope, _)) => {
-                if let Ok(Some(parsed_defined_name)) = self.get_parsed_defined_name(name, *scope) {
+            ArrayKind(_) => {
+                // 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 {
                    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::NAME,
+                            Error::NIMPL,
                            cell,
-                            format!("Defined name \"{name}\" is not a reference."),
+                            format!("Defined name \"{}\" is not a reference.", defined_name),
                        ),
                    }
                } else {
                    CalcResult::new_error(
                        Error::NAME,
                        cell,
-                        format!("Defined name \"{name}\" not found."),
+                        format!("Defined name \"{}\" not found.", defined_name),
                    )
                }
            }
-            TableNameKind(s) => CalcResult::new_error(
-                Error::NAME,
-                cell,
-                format!("table name \"{s}\" not supported."),
-            ),
-            WrongVariableKind(s) => CalcResult::new_error(
-                Error::NAME,
-                cell,
-                format!("Variable name \"{s}\" not found."),
-            ),
            CompareKind { kind, left, right } => {
                let l = self.evaluate_node_in_context(left, cell);
                if l.is_error() {
@@ -487,29 +523,12 @@ impl Model {
            } => CalcResult::new_error(
                Error::ERROR,
                cell,
-                format!("Error parsing {formula}: {message}"),
+                format!("Error parsing {}: {}", formula, message),
            ),
            EmptyArgKind => CalcResult::EmptyArg,
-            ImplicitIntersection {
-                automatic: _,
-                child,
-            } => match self.evaluate_node_with_reference(child, cell) {
-                CalcResult::Range { left, right } => {
-                    match implicit_intersection(&cell, &Range { left, right }) {
-                        Some(cell_reference) => self.evaluate_cell(cell_reference),
-                        None => CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            format!("Error with Implicit Intersection in cell {cell:?}"),
-                        ),
-                    }
-                }
-                _ => self.evaluate_node_in_context(child, cell),
-            },
        }
    }

-    #[allow(clippy::expect_used)]
    fn cell_reference_to_string(
        &self,
        cell_reference: &CellReferenceIndex,
@@ -525,7 +544,6 @@ 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];
@@ -595,15 +613,12 @@ impl Model {
                    };
                }
                CalcResult::Range { left, right } => {
-                    if left.sheet == right.sheet
-                        && left.row == right.row
-                        && left.column == right.column
-                    {
-                        let intersection_cell = CellReferenceIndex {
-                            sheet: left.sheet,
-                            column: left.column,
-                            row: left.row,
+                    let range = Range {
+                        left: *left,
+                        right: *right,
                    };
+                    if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
+                    {
                        let v = self.evaluate_cell(intersection_cell);
                        self.set_cell_value(cell_reference, &v);
                    } else {
@@ -620,32 +635,10 @@ impl Model {
                            f,
                            s,
                            o,
-                            m: "Implicit Intersection not implemented".to_string(),
-                            ei: Error::NIMPL,
+                            m: "Invalid reference".to_string(),
+                            ei: Error::VALUE,
                        };
                    }
-                    // if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
-                    // {
-                    //     let v = self.evaluate_cell(intersection_cell);
-                    //     self.set_cell_value(cell_reference, &v);
-                    // } else {
-                    //     let o = match self.cell_reference_to_string(&cell_reference) {
-                    //         Ok(s) => s,
-                    //         Err(_) => "".to_string(),
-                    //     };
-                    //     *self.workbook.worksheets[sheet as usize]
-                    //         .sheet_data
-                    //         .get_mut(&row)
-                    //         .expect("expected a row")
-                    //         .get_mut(&column)
-                    //         .expect("expected a column") = Cell::CellFormulaError {
-                    //         f,
-                    //         s,
-                    //         o,
-                    //         m: "Invalid reference".to_string(),
-                    //         ei: Error::VALUE,
-                    //     };
-                    // }
                }
                CalcResult::EmptyCell | CalcResult::EmptyArg => {
                    *self.workbook.worksheets[sheet as usize]
@@ -655,20 +648,6 @@ impl Model {
                        .get_mut(&column)
                        .expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
                }
-                CalcResult::Array(_) => {
-                    *self.workbook.worksheets[sheet as usize]
-                        .sheet_data
-                        .get_mut(&row)
-                        .expect("expected a row")
-                        .get_mut(&column)
-                        .expect("expected a column") = Cell::CellFormulaError {
-                        f,
-                        s,
-                        o: "".to_string(),
-                        m: "Arrays not supported yet".to_string(),
-                        ei: Error::NIMPL,
-                    };
-                }
            }
        }
    }
@@ -697,14 +676,7 @@ impl Model {
            worksheet.color = Some(color.to_string());
            return Ok(());
        }
-        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(())
+        Err(format!("Invalid color: {}", color))
    }

    /// Makes the grid lines in the sheet visible (`true`) or hidden (`false`)
@@ -882,7 +854,6 @@ impl Model {

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

-        let defined_names = workbook.get_defined_names_with_scope();
        // add all tables
        // let mut tables = Vec::new();
        // for worksheet in worksheets {
@@ -892,7 +863,7 @@ impl Model {
        //     }
        //     tables.push(tables_in_sheet);
        // }
-        let parser = Parser::new(worksheet_names, defined_names, workbook.tables.clone());
+        let parser = Parser::new(worksheet_names, workbook.tables.clone());
        let cells = HashMap::new();
        let locale = get_locale(&workbook.settings.locale)
            .map_err(|_| "Invalid locale".to_string())?
@@ -904,7 +875,6 @@ 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() {
@@ -973,7 +943,10 @@ impl Model {
                }
            }
        }
-        let sheet = self.get_sheet_index_by_name(&sheet_name)?;
+        let sheet = match self.get_sheet_index_by_name(&sheet_name) {
+            Some(s) => s,
+            None => return None,
+        };
        let row = match row.parse::<i32>() {
            Ok(r) => r,
            Err(_) => return None,
@@ -1027,7 +1000,7 @@ impl Model {
        let source_sheet_name = self
            .workbook
            .worksheet(source.sheet)
-            .map_err(|e| format!("Could not find source worksheet: {e}"))?
+            .map_err(|e| format!("Could not find source worksheet: {}", e))?
            .get_name();
        if source.sheet != area.sheet {
            return Err("Source and area are in different sheets".to_string());
@@ -1041,7 +1014,7 @@ impl Model {
        let target_sheet_name = self
            .workbook
            .worksheet(target.sheet)
-            .map_err(|e| format!("Could not find target worksheet: {e}"))?
+            .map_err(|e| format!("Could not find target worksheet: {}", e))?
            .get_name();
        if let Some(formula) = value.strip_prefix('=') {
            let cell_reference = CellReferenceRC {
@@ -1050,7 +1023,7 @@ impl Model {
                column: source.column,
            };
            let formula_str = move_formula(
-                &self.parser.parse(formula, &cell_reference),
+                &self.parser.parse(formula, &Some(cell_reference)),
                &MoveContext {
                    source_sheet_name: &source_sheet_name,
                    row: source.row,
@@ -1061,7 +1034,7 @@ impl Model {
                    column_delta: target.column - source.column,
                },
            );
-            Ok(format!("={formula_str}"))
+            Ok(format!("={}", formula_str))
        } else {
            Ok(value.to_string())
        }
@@ -1158,7 +1131,7 @@ impl Model {
                row: source.row,
                column: source.column,
            };
-            let formula = &self.parser.parse(formula_str, &cell_reference);
+            let formula = &self.parser.parse(formula_str, &Some(cell_reference));
            let cell_reference = CellReferenceRC {
                sheet: target_sheet_name,
                row: target.row,
@@ -1534,11 +1507,13 @@ impl Model {
            column,
        };
        let shared_formulas = &mut worksheet.shared_formulas;
-        let mut parsed_formula = self.parser.parse(formula, &cell_reference);
+        let mut parsed_formula = self.parser.parse(formula, &Some(cell_reference.clone()));
        // 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})"), &cell_reference);
+            let new_parsed_formula = self
+                .parser
+                .parse(&format!("{})", formula), &Some(cell_reference));
            match new_parsed_formula {
                Node::ParseErrorKind { .. } => {}
                _ => parsed_formula = new_parsed_formula,
@@ -1617,42 +1592,6 @@ 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:
@@ -1885,29 +1824,12 @@ impl Model {
    }

    /// Returns the style for cell (`sheet`, `row`, `column`)
-    /// If the cell does not have a style defined we check the row, otherwise the column and finally a default
    pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
        let style_index = self.get_cell_style_index(sheet, row, column)?;
        let style = self.workbook.styles.get_style(style_index)?;
        Ok(style)
    }

-    /// Returns the style defined in a cell if any.
-    pub fn get_cell_style_or_none(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<Style>, String> {
-        let style = self
-            .workbook
-            .worksheet(sheet)?
-            .cell(row, column)
-            .map(|c| self.workbook.styles.get_style(c.get_style()))
-            .transpose();
-        style
-    }
-
    /// Returns an internal binary representation of the workbook
    ///
    /// See also:
@@ -2060,209 +1982,10 @@ 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())
-        }
-    }
-    /// Returns the style object of a column, if any
-    pub fn get_column_style(&self, sheet: u32, column: i32) -> Result<Option<Style>, String> {
-        if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
-            let cols = &worksheet.cols;
-            for col in cols {
-                if column >= col.min && column <= col.max {
-                    if let Some(style_index) = col.style {
-                        let style = self.workbook.styles.get_style(style_index)?;
-                        return Ok(Some(style));
-                    }
-                    return Ok(None);
-                }
-            }
-            Ok(None)
-        } else {
-            Err("Invalid sheet".to_string())
-        }
-    }
-
-    /// Returns the style object of a row, if any
-    pub fn get_row_style(&self, sheet: u32, row: i32) -> Result<Option<Style>, String> {
-        if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
-            let rows = &worksheet.rows;
-            for r in rows {
-                if row == r.r {
-                    let style = self.workbook.styles.get_style(r.s)?;
-                    return Ok(Some(style));
-                }
-            }
-            Ok(None)
-        } else {
-            Err("Invalid sheet".to_string())
-        }
-    }
-
-    /// Sets a column with style
-    pub fn set_column_style(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        style: &Style,
-    ) -> Result<(), String> {
-        let style_index = self.workbook.styles.get_style_index_or_create(style);
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_column_style(column, style_index)
-    }
-
-    /// Sets a row with style
-    pub fn set_row_style(&mut self, sheet: u32, row: i32, style: &Style) -> Result<(), String> {
-        let style_index = self.workbook.styles.get_style_index_or_create(style);
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_row_style(row, style_index)
-    }
-
-    /// Deletes the style of a column if the is any
-    pub fn delete_column_style(&mut self, sheet: u32, column: i32) -> Result<(), String> {
-        self.workbook
-            .worksheet_mut(sheet)?
-            .delete_column_style(column)
-    }
-
-    /// Deletes the style of a row if there is any
-    pub fn delete_row_style(&mut self, sheet: u32, row: i32) -> Result<(), String> {
-        self.workbook.worksheet_mut(sheet)?.delete_row_style(row)
-    }
 }

 #[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,11 +4,11 @@ use std::collections::HashMap;

 use crate::{
    calc_result::Range,
-    constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
+    constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
    expressions::{
        lexer::LexerMode,
        parser::{
-            stringify::{rename_sheet_in_node, to_rc_format, to_string},
+            stringify::{rename_sheet_in_node, to_rc_format},
            Parser,
        },
        types::CellReferenceRC,
@@ -17,8 +17,7 @@ use crate::{
    locale::get_locale,
    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
    types::{
-        DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
-        WorksheetView,
+        Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
    },
    utils::ParsedReference,
 };
@@ -86,14 +85,14 @@ impl Model {
        let worksheets = &self.workbook.worksheets;
        for worksheet in worksheets {
            let shared_formulas = &worksheet.shared_formulas;
-            let cell_reference = CellReferenceRC {
+            let cell_reference = &Some(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);
@@ -145,9 +144,8 @@ 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();
        self.parser
-            .set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
+            .set_worksheets(self.workbook.get_worksheet_names());
        self.parsed_formulas = vec![];
        self.parse_formulas();
        self.parsed_defined_names = HashMap::new();
@@ -168,11 +166,11 @@ impl Model {
            .get_worksheet_names()
            .iter()
            .map(|s| s.to_uppercase())
-            .any(|x| x == format!("{base_name_uppercase}{index}"))
+            .any(|x| x == format!("{}{}", base_name_uppercase, index))
        {
            index += 1;
        }
-        let sheet_name = format!("{base_name}{index}");
+        let sheet_name = format!("{}{}", base_name, index);
        // Now we need a sheet_id
        let sheet_id = self.get_new_sheet_id();
        let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
@@ -192,7 +190,7 @@ impl Model {
        sheet_id: Option<u32>,
    ) -> Result<(), String> {
        if !is_valid_sheet_name(sheet_name) {
-            return Err(format!("Invalid name for a sheet: '{sheet_name}'"));
+            return Err(format!("Invalid name for a sheet: '{}'", sheet_name));
        }
        if self
            .workbook
@@ -234,12 +232,12 @@ impl Model {
        if let Some(sheet_index) = self.get_sheet_index_by_name(old_name) {
            return self.rename_sheet_by_index(sheet_index, new_name);
        }
-        Err(format!("Could not find sheet {old_name}"))
+        Err(format!("Could not find sheet {}", old_name))
    }

    /// Renames a sheet and updates all existing references to that sheet.
    /// It can fail if:
-    ///   * The original index is out of bounds
+    ///   * The original index is too large
    ///   * The target sheet name already exists
    ///   * The target sheet name is invalid
    pub fn rename_sheet_by_index(
@@ -248,25 +246,27 @@ impl Model {
        new_name: &str,
    ) -> Result<(), String> {
        if !is_valid_sheet_name(new_name) {
-            return Err(format!("Invalid name for a sheet: '{new_name}'."));
+            return Err(format!("Invalid name for a sheet: '{}'.", new_name));
        }
        if self.get_sheet_index_by_name(new_name).is_some() {
-            return Err(format!("Sheet already exists: '{new_name}'."));
+            return Err(format!("Sheet already exists: '{}'.", new_name));
+        }
+        let worksheets = &self.workbook.worksheets;
+        let sheet_count = worksheets.len() as u32;
+        if sheet_index >= sheet_count {
+            return Err("Sheet index out of bounds".to_string());
        }
-        // Gets the new name and checks that a sheet with that index exists
-        let old_name = self.workbook.worksheet(sheet_index)?.get_name();
-
        // Parse all formulas with the old name
        // All internal formulas are R1C1
        self.parser.set_lexer_mode(LexerMode::R1C1);
-
-        for worksheet in &mut self.workbook.worksheets {
-            // R1C1 formulas are not tied to a cell (but are tied to a cell)
-            let cell_reference = &CellReferenceRC {
+        // 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 {
                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);
@@ -275,32 +275,11 @@ impl Model {
            }
            worksheet.shared_formulas = formulas;
        }
-
-        // Set the mode back to A1
+        // Se the mode back to A1
        self.parser.set_lexer_mode(LexerMode::A1);
-
-        // We reparse all the defined names formulas
-        let mut defined_names = Vec::new();
-        // Defined names do not have a context, we can use anything
-        let cell_reference = &CellReferenceRC {
-            sheet: old_name.clone(),
-            row: 1,
-            column: 1,
-        };
-        for defined_name in &mut self.workbook.defined_names {
-            let mut t = self.parser.parse(&defined_name.formula, cell_reference);
-            rename_sheet_in_node(&mut t, sheet_index, new_name);
-            let formula = to_string(&t, cell_reference);
-            defined_names.push(DefinedName {
-                name: defined_name.name.clone(),
-                formula,
-                sheet_id: defined_name.sheet_id,
-            });
-        }
-        self.workbook.defined_names = defined_names;
-
        // Update the name of the worksheet
-        self.workbook.worksheet_mut(sheet_index)?.set_name(new_name);
+        let worksheets = &mut self.workbook.worksheets;
+        worksheets[sheet_index as usize].set_name(new_name);
        self.reset_parsed_structures();
        Ok(())
    }
@@ -316,7 +295,7 @@ impl Model {
        };
        if sheet_index >= sheet_count {
            return Err("Sheet index too large".to_string());
-        };
+        }
        self.workbook.worksheets.remove(sheet_index as usize);
        self.reset_parsed_structures();
        Ok(())
@@ -362,14 +341,14 @@ impl Model {
        };
        let locale = match get_locale(locale_id) {
            Ok(l) => l.clone(),
-            Err(_) => return Err(format!("Invalid locale: {locale_id}")),
+            Err(_) => return Err(format!("Invalid locale: {}", locale_id)),
        };

        let milliseconds = get_milliseconds_since_epoch();
        let seconds = milliseconds / 1000;
        let dt = match DateTime::from_timestamp(seconds, 0) {
            Some(s) => s,
-            None => return Err(format!("Invalid timestamp: {milliseconds}")),
+            None => return Err(format!("Invalid timestamp: {}", milliseconds)),
        };
        // "2020-08-06T21:20:53Z
        let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
@@ -380,7 +359,7 @@ impl Model {
            WorkbookView {
                sheet: 0,
                window_width: DEFAULT_WINDOW_WIDTH,
-                window_height: DEFAULT_WINDOW_HEIGHT,
+                window_height: DEFAULT_WINDOW_HEIGH,
            },
        );

@@ -409,11 +388,10 @@ 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, vec![], HashMap::new());
+        let parser = Parser::new(worksheet_names, 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/number_format.rs
+++ b/base/src/number_format.rs
@@ -126,7 +126,7 @@ pub fn to_precision_str(value: f64, precision: usize) -> String {
    let exponent = value.abs().log10().floor();
    let base = value / 10.0_f64.powf(exponent);
    let base = format!("{0:.1$}", base, precision - 1);
-    let value = format!("{base}e{exponent}").parse::<f64>().unwrap_or({
+    let value = format!("{}e{}", base, exponent).parse::<f64>().unwrap_or({
        // TODO: do this in a way that does not require a possible error
        0.0
    });
--- a/base/src/styles.rs
+++ b/base/src/styles.rs
@@ -4,6 +4,8 @@ use crate::{
    types::{Border, CellStyles, CellXfs, Fill, Font, NumFmt, Style, Styles},
 };

+// TODO: Move Styles and all related types from crate::types here
+// Not doing it right now to not have conflicts with exporter branch
 impl Styles {
    fn get_font_index(&self, font: &Font) -> Option<i32> {
        for (font_index, item) in self.fonts.iter().enumerate() {
@@ -154,7 +156,7 @@ impl Styles {
                return Ok(cell_style.xf_id);
            }
        }
-        Err(format!("Style '{style_name}' not found"))
+        Err(format!("Style '{}' not found", style_name))
    }

    pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
--- a/base/src/test/mod.rs
+++ b/base/src/test/mod.rs
@@ -7,30 +7,24 @@ mod test_column_width;
 mod test_criteria;
 mod test_currency;
 mod test_date_and_time;
-mod test_datedif_leap_month_end;
-mod test_days360_month_end;
 mod test_error_propagation;
 mod test_fn_average;
 mod test_fn_averageifs;
 mod test_fn_choose;
 mod test_fn_concatenate;
 mod test_fn_count;
-mod test_fn_day;
 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_time;
-mod test_fn_unicode;
+mod test_forward_references;
 mod test_frozen_rows_columns;
 mod test_general;
 mod test_math;
@@ -39,39 +33,24 @@ mod test_model_cell_clear_all;
 mod test_model_is_empty_cell;
 mod test_move_formula;
 mod test_quote_prefix;
-mod test_row_column_styles;
 mod test_set_user_input;
 mod test_sheet_markup;
 mod test_sheets;
 mod test_styles;
 mod test_trigonometric;
-mod test_true_false;
-mod test_weekday_return_types;
-mod test_weeknum_return_types;
 mod test_workbook;
 mod test_worksheet;
-mod test_yearfrac_basis;
 pub(crate) mod util;

 mod engineering;
 mod test_fn_offset;
 mod test_number_format;

-mod test_arrays;
 mod test_escape_quotes;
 mod test_extend;
-mod test_fn_fv;
-mod test_fn_round;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
-mod test_geomean;
 mod test_get_cell_content;
-mod test_implicit_intersection;
-mod test_issue_155;
-mod test_ln;
-mod test_log;
-mod test_log10;
-mod test_networkdays;
 mod test_percentage;
 mod test_set_functions_error_handling;
 mod test_today;
--- a/base/src/test/test_actions.rs
+++ b/base/src/test/test_actions.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]

-use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
+use crate::constants::LAST_COLUMN;
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -87,8 +87,7 @@ fn test_insert_rows_styles() {
    let mut model = new_empty_model();

    assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
    );
    // sets height 42 in row 10
    model
@@ -107,8 +106,7 @@ fn test_insert_rows_styles() {

    // Row 10 has the default height
    assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
    );

    // Row 10 is now row 15
@@ -122,8 +120,7 @@ fn test_delete_rows_styles() {
    let mut model = new_empty_model();

    assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
    );
    // sets height 42 in row 10
    model
@@ -142,8 +139,7 @@ fn test_delete_rows_styles() {

    // Row 10 has the default height
    assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
    );

    // Row 10 is now row 5
@@ -508,10 +504,6 @@ fn test_move_column_right() {
    assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
    assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
    assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G1"), "1");
-    assert_eq!(model._get_text("H1"), "3");
 }

 #[test]
@@ -536,249 +528,5 @@ fn tets_move_column_error() {
    assert!(result.is_ok());
 }

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

-// Excel uses a serial date system where Jan 1, 1900 = 1 (though it treats 1900 as a leap year)
-// Most test dates are documented inline, but we define boundary values here:
-const EXCEL_MAX_DATE: f64 = 2958465.0; // Dec 31, 9999 - used in boundary tests
-const EXCEL_INVALID_DATE: f64 = 2958466.0; // One day past max - used in error tests
-
 #[test]
 fn test_fn_date_arguments() {
    let mut model = new_empty_model();
@@ -42,12 +37,12 @@ fn test_fn_date_arguments() {
    assert_eq!(model._get_text("A3"), *"#ERROR!");
    assert_eq!(model._get_text("A4"), *"#ERROR!");

-    assert_eq!(model._get_text("A5"), *"10/10/1974");
-    assert_eq!(model._get_text("A6"), *"21/01/1975");
-    assert_eq!(model._get_text("A7"), *"10/02/1976");
-    assert_eq!(model._get_text("A8"), *"02/03/1975");
+    assert_eq!(model._get_text("A5"), *"#NUM!");
+    assert_eq!(model._get_text("A6"), *"#NUM!");
+    assert_eq!(model._get_text("A7"), *"#NUM!");
+    assert_eq!(model._get_text("A8"), *"#NUM!");

-    assert_eq!(model._get_text("A9"), *"01/03/1975");
+    assert_eq!(model._get_text("A9"), *"#NUM!");
    assert_eq!(model._get_text("A10"), *"29/02/1976");
    assert_eq!(
        model.get_cell_value_by_ref("Sheet1!A10"),
@@ -69,18 +64,15 @@ fn test_date_out_of_range() {

    // year (actually years < 1900 don't really make sense)
    model._set("C1", "=DATE(-1, 5, 5)");
-    // excel is not compatible with years past 9999
-    model._set("C2", "=DATE(10000, 5, 5)");

    model.evaluate();

-    assert_eq!(model._get_text("A1"), *"10/12/2021");
-    assert_eq!(model._get_text("A2"), *"10/01/2023");
-    assert_eq!(model._get_text("B1"), *"30/04/2042");
-    assert_eq!(model._get_text("B2"), *"01/06/2025");
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");

    assert_eq!(model._get_text("C1"), *"#NUM!");
-    assert_eq!(model._get_text("C2"), *"#NUM!");
 }

 #[test]
@@ -137,7 +129,8 @@ fn test_day_small_serial() {
    model.evaluate();

    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
+    // This agrees with Google Docs and disagrees with Excel
+    assert_eq!(model._get_text("A2"), *"30");
    // Excel thinks is Feb 29, 1900
    assert_eq!(model._get_text("A3"), *"28");

@@ -157,7 +150,8 @@ fn test_month_small_serial() {
    model.evaluate();

    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
+    // This agrees with Google Docs and disagrees with Excel
+    assert_eq!(model._get_text("A2"), *"12");
    // We agree with Excel here (We are both in Feb)
    assert_eq!(model._get_text("A3"), *"2");

@@ -177,7 +171,8 @@ fn test_year_small_serial() {
    model.evaluate();

    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
+    // This agrees with Google Docs and disagrees with Excel
+    assert_eq!(model._get_text("A2"), *"1899");

    assert_eq!(model._get_text("A3"), *"1900");

@@ -209,10 +204,7 @@ fn test_date_early_dates() {
        model.get_cell_value_by_ref("Sheet1!A2"),
        Ok(CellValue::Number(60.0))
    );
-
-    // This does not agree with Excel, instead of mistakenly allowing
-    // for Feb 29, it will auto-wrap to the next day after Feb 28.
-    assert_eq!(model._get_text("B2"), *"01/03/1900");
+    assert_eq!(model._get_text("B2"), *"#NUM!");

    // This agrees with Excel from he onward
    assert_eq!(model._get_text("A3"), *"01/03/1900");
@@ -221,382 +213,3 @@ fn test_date_early_dates() {
        Ok(CellValue::Number(61.0))
    );
 }
-#[test]
-fn test_days_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality
-    model._set("A1", "=DAYS(44570,44561)");
-    model._set("A2", "=DAYS(44561,44570)"); // Reversed order
-    model._set("A3", "=DAYS(44561,44561)");
-
-    // Edge cases
-    model._set("A4", "=DAYS(1,2)"); // Early dates
-    model._set(
-        "A5",
-        &format!("=DAYS({},{})", EXCEL_MAX_DATE, EXCEL_MAX_DATE - 1.0),
-    ); // Near max date
-
-    // Error cases - wrong argument count
-    model._set("A6", "=DAYS()");
-    model._set("A7", "=DAYS(44561)");
-    model._set("A8", "=DAYS(44561,44570,1)");
-
-    // Error cases - invalid dates
-    model._set("A9", "=DAYS(-1,44561)");
-    model._set("A10", &format!("=DAYS(44561,{EXCEL_INVALID_DATE})"));
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"9");
-    assert_eq!(model._get_text("A2"), *"-9");
-    assert_eq!(model._get_text("A3"), *"0");
-    assert_eq!(model._get_text("A4"), *"-1"); // DAYS(1,2) = 1-2 = -1
-    assert_eq!(model._get_text("A5"), *"1");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#ERROR!");
-    assert_eq!(model._get_text("A9"), *"#NUM!");
-    assert_eq!(model._get_text("A10"), *"#NUM!");
-}
-
-#[test]
-fn test_days360_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality with different basis values
-    model._set("A1", "=DAYS360(44196,44560)"); // Default basis (US 30/360)
-    model._set("A2", "=DAYS360(44196,44560,FALSE)"); // US 30/360 explicitly
-    model._set("A3", "=DAYS360(44196,44560,TRUE)"); // European 30/360
-
-    // Same date
-    model._set("A4", "=DAYS360(44561,44561)");
-    model._set("A5", "=DAYS360(44561,44561,TRUE)");
-
-    // Reverse order (negative result)
-    model._set("A6", "=DAYS360(44560,44196)");
-    model._set("A7", "=DAYS360(44560,44196,TRUE)");
-
-    // Edge cases
-    model._set("A8", "=DAYS360(1,2)");
-    model._set("A9", "=DAYS360(1,2,FALSE)");
-
-    // Error cases - wrong argument count
-    model._set("A10", "=DAYS360()");
-    model._set("A11", "=DAYS360(44561)");
-    model._set("A12", "=DAYS360(44561,44570,TRUE,1)");
-
-    // Error cases - invalid dates
-    model._set("A13", "=DAYS360(-1,44561)");
-    model._set("A14", &format!("=DAYS360(44561,{EXCEL_INVALID_DATE})"));
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"360");
-    assert_eq!(model._get_text("A2"), *"360");
-    assert_eq!(model._get_text("A3"), *"360");
-    assert_eq!(model._get_text("A4"), *"0");
-    assert_eq!(model._get_text("A5"), *"0");
-    assert_eq!(model._get_text("A6"), *"-360");
-    assert_eq!(model._get_text("A7"), *"-360");
-    assert_eq!(model._get_text("A8"), *"1");
-    assert_eq!(model._get_text("A9"), *"1");
-    assert_eq!(model._get_text("A10"), *"#ERROR!");
-    assert_eq!(model._get_text("A11"), *"#ERROR!");
-    assert_eq!(model._get_text("A12"), *"#ERROR!");
-    assert_eq!(model._get_text("A13"), *"#NUM!");
-    assert_eq!(model._get_text("A14"), *"#NUM!");
-}
-
-#[test]
-fn test_weekday_function() {
-    let mut model = new_empty_model();
-
-    // Test return_type parameter variations with one known date (Friday 44561)
-    model._set("A1", "=WEEKDAY(44561)"); // Default: Sun=1, Fri=6
-    model._set("A2", "=WEEKDAY(44561,2)"); // Mon=1, Fri=5
-    model._set("A3", "=WEEKDAY(44561,3)"); // Mon=0, Fri=4
-
-    // Test boundary days (Sun/Mon) to verify return_type logic
-    model._set("A4", "=WEEKDAY(44556,1)"); // Sunday: should be 1
-    model._set("A5", "=WEEKDAY(44556,2)"); // Sunday: should be 7
-    model._set("A6", "=WEEKDAY(44557,2)"); // Monday: should be 1
-
-    // Error cases
-    model._set("A7", "=WEEKDAY()"); // Wrong arg count
-    model._set("A8", "=WEEKDAY(44561,0)"); // Invalid return_type
-    model._set("A9", "=WEEKDAY(-1)"); // Invalid date
-
-    model.evaluate();
-
-    // Core functionality
-    assert_eq!(model._get_text("A1"), *"6"); // Friday default
-    assert_eq!(model._get_text("A2"), *"5"); // Friday Mon=1
-    assert_eq!(model._get_text("A3"), *"4"); // Friday Mon=0
-
-    // Boundary verification
-    assert_eq!(model._get_text("A4"), *"1"); // Sunday Sun=1
-    assert_eq!(model._get_text("A5"), *"7"); // Sunday Mon=1
-    assert_eq!(model._get_text("A6"), *"1"); // Monday Mon=1
-
-    // Error cases
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#VALUE!");
-    assert_eq!(model._get_text("A9"), *"#NUM!");
-}
-
-#[test]
-fn test_weeknum_function() {
-    let mut model = new_empty_model();
-
-    // Test different return_type values (1=week starts Sunday, 2=week starts Monday)
-    model._set("A1", "=WEEKNUM(44561)"); // Default return_type=1
-    model._set("A2", "=WEEKNUM(44561,1)"); // Sunday start
-    model._set("A3", "=WEEKNUM(44561,2)"); // Monday start
-
-    // Test year boundaries
-    model._set("A4", "=WEEKNUM(43831,1)"); // Jan 1, 2020 (Wednesday)
-    model._set("A5", "=WEEKNUM(43831,2)"); // Jan 1, 2020 (Wednesday)
-    model._set("A6", "=WEEKNUM(44196,1)"); // Dec 31, 2020 (Thursday)
-    model._set("A7", "=WEEKNUM(44196,2)"); // Dec 31, 2020 (Thursday)
-
-    // Test first and last weeks of year
-    model._set("A8", "=WEEKNUM(44197,1)"); // Jan 1, 2021 (Friday)
-    model._set("A9", "=WEEKNUM(44197,2)"); // Jan 1, 2021 (Friday)
-    model._set("A10", "=WEEKNUM(44561,1)"); // Dec 31, 2021 (Friday)
-    model._set("A11", "=WEEKNUM(44561,2)"); // Dec 31, 2021 (Friday)
-
-    // Error cases - wrong argument count
-    model._set("A12", "=WEEKNUM()");
-    model._set("A13", "=WEEKNUM(44561,1,1)");
-
-    // Error cases - invalid return_type
-    model._set("A14", "=WEEKNUM(44561,0)");
-    model._set("A15", "=WEEKNUM(44561,3)");
-    model._set("A16", "=WEEKNUM(44561,-1)");
-
-    // Error cases - invalid dates
-    model._set("A17", "=WEEKNUM(-1)");
-    model._set("A18", &format!("=WEEKNUM({EXCEL_INVALID_DATE})"));
-
-    model.evaluate();
-
-    // Basic functionality
-    assert_eq!(model._get_text("A1"), *"53"); // Week 53
-    assert_eq!(model._get_text("A2"), *"53"); // Week 53 (Sunday start)
-    assert_eq!(model._get_text("A3"), *"53"); // Week 53 (Monday start)
-
-    // Year boundary tests
-    assert_eq!(model._get_text("A4"), *"1"); // Jan 1, 2020 (Sunday start)
-    assert_eq!(model._get_text("A5"), *"1"); // Jan 1, 2020 (Monday start)
-    assert_eq!(model._get_text("A6"), *"53"); // Dec 31, 2020 (Sunday start)
-    assert_eq!(model._get_text("A7"), *"53"); // Dec 31, 2020 (Monday start)
-
-    // 2021 tests
-    assert_eq!(model._get_text("A8"), *"1"); // Jan 1, 2021 (Sunday start)
-    assert_eq!(model._get_text("A9"), *"1"); // Jan 1, 2021 (Monday start)
-    assert_eq!(model._get_text("A10"), *"53"); // Dec 31, 2021 (Sunday start)
-    assert_eq!(model._get_text("A11"), *"53"); // Dec 31, 2021 (Monday start)
-
-    // Error cases
-    assert_eq!(model._get_text("A12"), *"#ERROR!");
-    assert_eq!(model._get_text("A13"), *"#ERROR!");
-    assert_eq!(model._get_text("A14"), *"#VALUE!");
-    assert_eq!(model._get_text("A15"), *"#VALUE!");
-    assert_eq!(model._get_text("A16"), *"#VALUE!");
-    assert_eq!(model._get_text("A17"), *"#NUM!");
-    assert_eq!(model._get_text("A18"), *"#NUM!");
-}
-
-#[test]
-fn test_workday_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality
-    model._set("A1", "=WORKDAY(44560,1)");
-    model._set("A2", "=WORKDAY(44561,-1)");
-    model._set("A3", "=WORKDAY(44561,0)");
-    model._set("A4", "=WORKDAY(44560,5)");
-
-    // Test with holidays
-    model._set("B1", "44561");
-    model._set("A5", "=WORKDAY(44560,1,B1)"); // Should skip the holiday
-    model._set("B2", "44562");
-    model._set("B3", "44563");
-    model._set("A6", "=WORKDAY(44560,3,B1:B3)"); // Multiple holidays
-
-    // Test starting on weekend
-    model._set("A7", "=WORKDAY(44562,1)"); // Saturday start
-    model._set("A8", "=WORKDAY(44563,1)"); // Sunday start
-
-    // Test negative workdays
-    model._set("A9", "=WORKDAY(44565,-3)"); // Go backwards 3 days
-    model._set("A10", "=WORKDAY(44565,-5,B1:B3)"); // Backwards with holidays
-
-    // Edge cases
-    model._set("A11", "=WORKDAY(1,1)"); // Early date
-    model._set("A12", "=WORKDAY(100000,10)"); // Large numbers
-
-    // Error cases - wrong argument count
-    model._set("A13", "=WORKDAY()");
-    model._set("A14", "=WORKDAY(44560)");
-    model._set("A15", "=WORKDAY(44560,1,B1,B2)");
-
-    // Error cases - invalid dates
-    model._set("A16", "=WORKDAY(-1,1)");
-    model._set("A17", &format!("=WORKDAY({EXCEL_INVALID_DATE},1)"));
-
-    // Error cases - invalid holiday dates
-    model._set("B4", "-1");
-    model._set("A18", "=WORKDAY(44560,1,B4)");
-
-    model.evaluate();
-
-    // Basic functionality
-    assert_eq!(model._get_text("A1"), *"44561"); // 1 day forward
-    assert_eq!(model._get_text("A2"), *"44560"); // 1 day backward
-    assert_eq!(model._get_text("A3"), *"44561"); // 0 days
-    assert_eq!(model._get_text("A4"), *"44567"); // 5 days forward
-
-    // With holidays
-    assert_eq!(model._get_text("A5"), *"44564"); // Skip holiday, go to Monday
-    assert_eq!(model._get_text("A6"), *"44566"); // Skip multiple holidays
-
-    // Weekend starts
-    assert_eq!(model._get_text("A7"), *"44564"); // From Saturday
-    assert_eq!(model._get_text("A8"), *"44564"); // From Sunday
-
-    // Negative workdays
-    assert_eq!(model._get_text("A9"), *"44560"); // 3 days back
-    assert_eq!(model._get_text("A10"), *"44557"); // 5 days back with holidays
-
-    // Edge cases
-    assert_eq!(model._get_text("A11"), *"2"); // Early date
-    assert_eq!(model._get_text("A12"), *"100014"); // Large numbers
-
-    // Error cases
-    assert_eq!(model._get_text("A13"), *"#ERROR!");
-    assert_eq!(model._get_text("A14"), *"#ERROR!");
-    assert_eq!(model._get_text("A15"), *"#ERROR!");
-    assert_eq!(model._get_text("A16"), *"#NUM!");
-    assert_eq!(model._get_text("A17"), *"#NUM!");
-    assert_eq!(model._get_text("A18"), *"#NUM!"); // Invalid holiday
-}
-
-#[test]
-fn test_workday_intl_function() {
-    let mut model = new_empty_model();
-
-    // Test key weekend mask types
-    model._set("A1", "=WORKDAY.INTL(44560,1,1)"); // Numeric: standard (Sat-Sun)
-    model._set("A2", "=WORKDAY.INTL(44560,1,2)"); // Numeric: Sun-Mon
-    model._set("A3", "=WORKDAY.INTL(44560,1,\"0000001\")"); // String: Sunday only
-    model._set("A4", "=WORKDAY.INTL(44560,1,\"1100000\")"); // String: Mon-Tue
-
-    // Test with holidays
-    model._set("B1", "44561");
-    model._set("A5", "=WORKDAY.INTL(44560,2,1,B1)"); // Standard + holiday
-    model._set("A6", "=WORKDAY.INTL(44560,2,7,B1)"); // Fri-Sat + holiday
-
-    // Basic edge cases
-    model._set("A7", "=WORKDAY.INTL(44561,0,1)"); // Zero days
-    model._set("A8", "=WORKDAY.INTL(44565,-1,1)"); // Negative days
-
-    // Error cases
-    model._set("A9", "=WORKDAY.INTL()"); // Wrong arg count
-    model._set("A10", "=WORKDAY.INTL(44560,1,0)"); // Invalid weekend mask
-    model._set("A11", "=WORKDAY.INTL(44560,1,\"123\")"); // Invalid string mask
-    model._set("A12", "=WORKDAY.INTL(-1,1,1)"); // Invalid date
-
-    model.evaluate();
-
-    // Weekend mask functionality
-    assert_eq!(model._get_text("A1"), *"44561"); // Standard weekend
-    assert_eq!(model._get_text("A2"), *"44561"); // Sun-Mon weekend
-    assert_eq!(model._get_text("A3"), *"44561"); // Sunday only
-    assert_eq!(model._get_text("A4"), *"44561"); // Mon-Tue weekend
-
-    // With holidays
-    assert_eq!(model._get_text("A5"), *"44565"); // Skip holiday + standard weekend
-    assert_eq!(model._get_text("A6"), *"44564"); // Skip holiday + Fri-Sat weekend
-
-    // Edge cases
-    assert_eq!(model._get_text("A7"), *"44561"); // Zero days
-    assert_eq!(model._get_text("A8"), *"44564"); // Negative days
-
-    // Error cases
-    assert_eq!(model._get_text("A9"), *"#ERROR!");
-    assert_eq!(model._get_text("A10"), *"#NUM!");
-    assert_eq!(model._get_text("A11"), *"#VALUE!");
-    assert_eq!(model._get_text("A12"), *"#NUM!");
-}
-
-#[test]
-fn test_yearfrac_function() {
-    let mut model = new_empty_model();
-
-    // Test key basis values (not exhaustive - just verify parameter works)
-    model._set("A1", "=YEARFRAC(44561,44926)"); // Default (30/360)
-    model._set("A2", "=YEARFRAC(44561,44926,1)"); // Actual/actual
-    model._set("A3", "=YEARFRAC(44561,44926,4)"); // European 30/360
-
-    // Edge cases
-    model._set("A4", "=YEARFRAC(44561,44561,1)"); // Same date = 0
-    model._set("A5", "=YEARFRAC(44926,44561,1)"); // Reverse = negative
-    model._set("A6", "=YEARFRAC(44197,44562,1)"); // Exact year (2021)
-
-    // Error cases
-    model._set("A7", "=YEARFRAC()"); // Wrong arg count
-    model._set("A8", "=YEARFRAC(44561,44926,5)"); // Invalid basis
-    model._set("A9", "=YEARFRAC(-1,44926,1)"); // Invalid date
-
-    model.evaluate();
-
-    // Basic functionality (approximate values expected)
-    assert_eq!(model._get_text("A1"), *"1"); // About 1 year
-    assert_eq!(model._get_text("A2"), *"1"); // About 1 year
-    assert_eq!(model._get_text("A3"), *"1"); // About 1 year
-
-    // Edge cases
-    assert_eq!(model._get_text("A4"), *"0"); // Same date
-    assert_eq!(model._get_text("A5"), *"-1"); // Negative
-    assert_eq!(model._get_text("A6"), *"1"); // Exact year
-
-    // Error cases
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#NUM!"); // Invalid basis should return #NUM!
-    assert_eq!(model._get_text("A9"), *"#NUM!");
-}
-
-#[test]
-fn test_isoweeknum_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality
-    model._set("A1", "=ISOWEEKNUM(44563)"); // Mid-week date
-    model._set("A2", "=ISOWEEKNUM(44561)"); // Year-end date
-
-    // Key ISO week boundaries (just critical cases)
-    model._set("A3", "=ISOWEEKNUM(44197)"); // Jan 1, 2021 (Fri) -> Week 53 of 2020
-    model._set("A4", "=ISOWEEKNUM(44200)"); // Jan 4, 2021 (Mon) -> Week 1 of 2021
-    model._set("A5", "=ISOWEEKNUM(44564)"); // Jan 3, 2022 (Mon) -> Week 1 of 2022
-
-    // Error cases
-    model._set("A6", "=ISOWEEKNUM()"); // Wrong arg count
-    model._set("A7", "=ISOWEEKNUM(-1)"); // Invalid date
-
-    model.evaluate();
-
-    // Basic functionality
-    assert_eq!(model._get_text("A1"), *"52");
-    assert_eq!(model._get_text("A2"), *"52");
-
-    // ISO week boundaries
-    assert_eq!(model._get_text("A3"), *"53"); // Week 53 of previous year
-    assert_eq!(model._get_text("A4"), *"1"); // Week 1 of current year
-    assert_eq!(model._get_text("A5"), *"1"); // Week 1 of next year
-
-    // Error cases
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-    assert_eq!(model._get_text("A7"), *"#NUM!");
-}
--- a/base/src/test/test_datedif_leap_month_end.rs
+++ b/base/src/test/test_datedif_leap_month_end.rs
@@ -1,33 +0,0 @@
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_datedif_yd_leap_year_edge_cases() {
-    let mut model = new_empty_model();
-
-    // 29 Feb 2020 → 28 Feb 2021   (should be 0 days)
-    model._set("A1", "=DATEDIF(\"29/2/2020\", \"28/2/2021\", \"YD\")");
-
-    // 29 Feb 2020 → 1 Mar 2021    (should be 1 day)
-    model._set("A2", "=DATEDIF(\"29/2/2020\", \"2021-03-01\", \"YD\")");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"0");
-    assert_eq!(model._get_text("A2"), *"1");
-}
-
-#[test]
-fn test_datedif_md_month_end_edge_cases() {
-    let mut model = new_empty_model();
-
-    // 31 Jan 2021 → 28 Feb 2021 (non-leap) => 28
-    model._set("B1", "=DATEDIF(\"31/1/2021\", \"28/2/2021\", \"MD\")");
-
-    // 31 Jan 2020 → 29 Feb 2020 (leap) => 29
-    model._set("B2", "=DATEDIF(\"31/1/2020\", \"29/2/2020\", \"MD\")");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"28");
-    assert_eq!(model._get_text("B2"), *"29");
-}
--- a/base/src/test/test_days360_month_end.rs
+++ b/base/src/test/test_days360_month_end.rs
@@ -1,43 +0,0 @@
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_days360_month_end_us() {
-    let mut model = new_empty_model();
-
-    // 31 Jan 2021 -> 28 Feb 2021 (non-leap)
-    model._set("A1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28))");
-
-    // 31 Jan 2020 -> 28 Feb 2020 (leap year – not last day of Feb)
-    model._set("A2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,28))");
-
-    // 28 Feb 2020 -> 31 Mar 2020 (leap year span crossing month ends)
-    model._set("A3", "=DAYS360(DATE(2020,2,28),DATE(2020,3,31))");
-
-    // 30 Apr 2021 -> 31 May 2021 (end-of-month adjustment rule)
-    model._set("A4", "=DAYS360(DATE(2021,4,30),DATE(2021,5,31))");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"30");
-    assert_eq!(model._get_text("A2"), *"28");
-    assert_eq!(model._get_text("A3"), *"33");
-    assert_eq!(model._get_text("A4"), *"30");
-}
-
-#[test]
-fn test_days360_month_end_european() {
-    let mut model = new_empty_model();
-
-    // European basis = TRUE (or 1)
-    model._set("B1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28),TRUE)");
-
-    model._set("B2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,29),TRUE)");
-
-    model._set("B3", "=DAYS360(DATE(2021,8,31),DATE(2021,9,30),TRUE)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"28");
-    assert_eq!(model._get_text("B2"), *"29");
-    assert_eq!(model._get_text("B3"), *"30");
-}
--- a/base/src/test/test_error_propagation.rs
+++ b/base/src/test/test_error_propagation.rs
@@ -1,5 +1,4 @@
 #![allow(clippy::unwrap_used)]
-#![allow(clippy::panic)]

 use crate::test::util::new_empty_model;
 use crate::types::Cell;
--- a/base/src/test/test_fn_concatenate.rs
+++ b/base/src/test/test_fn_concatenate.rs
@@ -22,14 +22,13 @@ fn fn_concatenate() {
    model._set("B1", r#"=CONCATENATE(A1, A2, A3, "!")"#);
    // This will break once we implement the implicit intersection operator
    // It should be:
-    model._set("C2", r#"=CONCATENATE(@A1:A3, "!")"#);
+    // model._set("B2", r#"=CONCATENATE(@A1:A3, "!")"#);
    model._set("B2", r#"=CONCATENATE(A1:A3, "!")"#);
    model._set("B3", r#"=CONCAT(A1:A3, "!")"#);

    model.evaluate();

    assert_eq!(model._get_text("B1"), *"Hello my World!");
-    assert_eq!(model._get_text("B2"), *"#N/IMPL!");
+    assert_eq!(model._get_text("B2"), *" my !");
    assert_eq!(model._get_text("B3"), *"Hello my World!");
-    assert_eq!(model._get_text("C2"), *" my !");
 }
--- a/base/src/test/test_fn_datevalue_datedif.rs
+++ b/base/src/test/test_fn_datevalue_datedif.rs
@@ -1,182 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-use crate::types::Cell;
-
-// Helper to evaluate a formula and return the formatted text
-fn eval_formula(formula: &str) -> String {
-    let mut model = new_empty_model();
-    model._set("A1", formula);
-    model.evaluate();
-    model._get_text("A1")
-}
-
-// Helper that evaluates a formula and returns the raw value of A1 as a Result<f64, String>
-fn eval_formula_raw_number(formula: &str) -> Result<f64, String> {
-    let mut model = new_empty_model();
-    model._set("A1", formula);
-    model.evaluate();
-    match model._get_cell("A1") {
-        Cell::NumberCell { v, .. } => Ok(*v),
-        Cell::BooleanCell { v, .. } => Ok(if *v { 1.0 } else { 0.0 }),
-        Cell::ErrorCell { ei, .. } => Err(format!("{}", ei)),
-        _ => Err(model._get_text("A1")),
-    }
-}
-
-#[test]
-fn test_datevalue_basic_numeric() {
-    // DATEVALUE should return the serial number representing the date, **not** a formatted date
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2/1/2023\")").unwrap(),
-        44958.0
-    );
-}
-
-#[test]
-fn test_datevalue_mmdd_with_leading_zero() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"02/01/2023\")").unwrap(),
-        44958.0
-    ); // 1-Feb-2023
-}
-
-#[test]
-fn test_datevalue_iso() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2023-01-02\")").unwrap(),
-        44928.0
-    );
-}
-
-#[test]
-fn test_datevalue_month_name() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2-Jan-23\")").unwrap(),
-        44928.0
-    );
-}
-
-#[test]
-fn test_datevalue_ambiguous_ddmm() {
-    // 01/02/2023 interpreted as MM/DD -> 2-Jan-2023
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"01/02/2023\")").unwrap(),
-        44929.0
-    );
-}
-
-#[test]
-fn test_datevalue_ddmm_unambiguous() {
-    // 15/01/2023 should be 15-Jan-2023 since 15 cannot be month
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"15/01/2023\")").unwrap(),
-        44941.0
-    );
-}
-
-#[test]
-fn test_datevalue_leap_day() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"29/02/2020\")").unwrap(),
-        43890.0
-    );
-}
-
-#[test]
-fn test_datevalue_year_first_text_month() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2023/Jan/15\")").unwrap(),
-        44941.0
-    );
-}
-
-#[test]
-fn test_datevalue_mmdd_with_day_gt_12() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"6/15/2021\")").unwrap(),
-        44373.0
-    );
-}
-
-#[test]
-fn test_datevalue_error_conditions() {
-    let cases = [
-        "=DATEVALUE(\"31/04/2023\")",   // invalid day (Apr has 30 days)
-        "=DATEVALUE(\"13/13/2023\")",   // invalid month
-        "=DATEVALUE(\"not a date\")",   // non-date text
-    ];
-    for formula in cases {
-        let result = eval_formula(formula);
-        assert_eq!(result, *"#VALUE!", "Expected #VALUE! for {}", formula);
-    }
-}
-
-// Helper to set and evaluate a single DATEDIF call
-fn eval_datedif(unit: &str) -> String {
-    let mut model = new_empty_model();
-    let formula = format!("=DATEDIF(\"2020-01-01\", \"2021-06-15\", \"{}\")", unit);
-    model._set("A1", &formula);
-    model.evaluate();
-    model._get_text("A1")
-}
-
-#[test]
-fn test_datedif_y() {
-    assert_eq!(eval_datedif("Y"), *"1");
-}
-
-#[test]
-fn test_datedif_m() {
-    assert_eq!(eval_datedif("M"), *"17");
-}
-
-#[test]
-fn test_datedif_d() {
-    assert_eq!(eval_datedif("D"), *"531");
-}
-
-#[test]
-fn test_datedif_ym() {
-    assert_eq!(eval_datedif("YM"), *"5");
-}
-
-#[test]
-fn test_datedif_yd() {
-    assert_eq!(eval_datedif("YD"), *"165");
-}
-
-#[test]
-fn test_datedif_md() {
-    assert_eq!(eval_datedif("MD"), *"14");
-}
-
-#[test]
-fn test_datedif_edge_and_error_cases() {
-    let mut model = new_empty_model();
-    // Leap-year spanning
-    model._set("A1", "=DATEDIF(\"28/2/2020\", \"1/3/2020\", \"D\")");
-    // End date before start date => #NUM!
-    model._set("A2", "=DATEDIF(\"1/2/2021\", \"1/1/2021\", \"D\")");
-    // Invalid unit => #VALUE!
-    model._set("A3", "=DATEDIF(\"1/1/2020\", \"1/1/2021\", \"Z\")");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
-    assert_eq!(model._get_text("A3"), *"#VALUE!");
-}
-
-#[test]
-fn test_datedif_mixed_case_unit() {
-    assert_eq!(eval_datedif("yD"), *"165"); // mixed-case should work
-}
-
-#[test]
-fn test_datedif_error_propagation() {
-    // Invalid date in arguments should propagate #VALUE!
-    let mut model = new_empty_model();
-    model._set("A1", "=DATEDIF(\"bad\", \"bad\", \"Y\")");
-    model.evaluate();
-    assert_eq!(model._get_text("A1"), *"#VALUE!");
-}
--- a/base/src/test/test_fn_day.rs
+++ b/base/src/test/test_fn_day.rs
@@ -1,15 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_fn_date_arguments() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=DAY(95051806)");
-    model._set("A2", "=DAY(2958465)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"31");
-}
--- a/base/src/test/test_fn_formulatext.rs
+++ b/base/src/test/test_fn_formulatext.rs
@@ -1,54 +0,0 @@
-#![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"), *"#N/IMPL!");
-    assert_eq!(model._get_text("A2"), *"#N/IMPL!");
-}
-
-#[test]
-fn implicit_intersection_operator() {
-    let mut model = new_empty_model();
-    model._set("A1", "=1 +  2");
-    model._set("B1", "=FORMULATEXT(@A:A)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"#N/IMPL!");
-}
-
-#[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
@@ -1,36 +0,0 @@
-#![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
@@ -1,204 +0,0 @@
-#![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_round.rs
+++ b/base/src/test/test_fn_round.rs
@@ -1,15 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn fn_round_approximation() {
-    let mut model = new_empty_model();
-    model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
-    model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"0.0063");
-    assert_eq!(model._get_text("A2"), *"0.00625");
-}
--- a/base/src/test/test_fn_sum.rs
+++ b/base/src/test/test_fn_sum.rs
@@ -17,19 +17,3 @@ fn test_fn_sum_arguments() {
    assert_eq!(model._get_text("A3"), *"1");
    assert_eq!(model._get_text("A4"), *"4");
 }
-
-#[test]
-fn arrays() {
-    let mut model = new_empty_model();
-    model._set("A1", "=SUM({1, 2, 3})");
-    model._set("A2", "=SUM({1; 2; 3})");
-    model._set("A3", "=SUM({1, 2; 3, 4})");
-    model._set("A4", "=SUM({1, 2; 3, 4; 5, 6})");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"6");
-    assert_eq!(model._get_text("A2"), *"6");
-    assert_eq!(model._get_text("A3"), *"10");
-    assert_eq!(model._get_text("A4"), *"21");
-}
--- a/base/src/test/test_fn_time.rs
+++ b/base/src/test/test_fn_time.rs
@@ -1,520 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-// Helper constants for common time values with detailed documentation
-const MIDNIGHT: &str = "0"; // 00:00:00 = 0/24 = 0
-const NOON: &str = "0.5"; // 12:00:00 = 12/24 = 0.5
-const TIME_14_30: &str = "0.604166667"; // 14:30:00 = 14.5/24 ≈ 0.604166667
-const TIME_14_30_45: &str = "0.6046875"; // 14:30:45 = 14.5125/24 = 0.6046875
-const TIME_14_30_59: &str = "0.604849537"; // 14:30:59 (from floored fractional inputs)
-const TIME_23_59_59: &str = "0.999988426"; // 23:59:59 = 23.99972.../24 ≈ 0.999988426
-
-// Excel documentation test values with explanations
-const TIME_2_24_AM: &str = "0.1"; // 2:24 AM = 2.4/24 = 0.1
-const TIME_2_PM: &str = "0.583333333"; // 2:00 PM = 14/24 ≈ 0.583333333
-const TIME_6_45_PM: &str = "0.78125"; // 6:45 PM = 18.75/24 = 0.78125
-const TIME_6_35_AM: &str = "0.274305556"; // 6:35 AM = 6.583333.../24 ≈ 0.274305556
-const TIME_2_30_AM: &str = "0.104166667"; // 2:30 AM = 2.5/24 ≈ 0.104166667
-const TIME_1_AM: &str = "0.041666667"; // 1:00 AM = 1/24 ≈ 0.041666667
-const TIME_9_PM: &str = "0.875"; // 9:00 PM = 21/24 = 0.875
-const TIME_2_AM: &str = "0.083333333"; // 2:00 AM = 2/24 ≈ 0.083333333
-                                       // Additional helper: 1-second past midnight (00:00:01)
-const TIME_00_00_01: &str = "0.000011574"; // 1 second = 1/86400 ≈ 0.000011574
-
-/// Helper function to set up and evaluate a model with time expressions
-fn test_time_expressions(expressions: &[(&str, &str)]) -> crate::model::Model {
-    let mut model = new_empty_model();
-    for (cell, formula) in expressions {
-        model._set(cell, formula);
-    }
-    model.evaluate();
-    model
-}
-
-/// Helper function to test component extraction for a given time value
-/// Returns (hour, minute, second) as strings
-fn test_component_extraction(time_value: &str) -> (String, String, String) {
-    let model = test_time_expressions(&[
-        ("A1", &format!("=HOUR({time_value})")),
-        ("B1", &format!("=MINUTE({time_value})")),
-        ("C1", &format!("=SECOND({time_value})")),
-    ]);
-    (
-        model._get_text("A1").to_string(),
-        model._get_text("B1").to_string(),
-        model._get_text("C1").to_string(),
-    )
-}
-
-#[test]
-fn test_excel_timevalue_compatibility() {
-    // Test cases based on Excel's official documentation and examples
-    let model = test_time_expressions(&[
-        // Excel documentation examples
-        ("A1", "=TIMEVALUE(\"2:24 AM\")"), // Should be 0.1
-        ("A2", "=TIMEVALUE(\"2 PM\")"),    // Should be 0.583333... (14/24)
-        ("A3", "=TIMEVALUE(\"6:45 PM\")"), // Should be 0.78125 (18.75/24)
-        ("A4", "=TIMEVALUE(\"18:45\")"),   // Same as above, 24-hour format
-        // Date-time format (date should be ignored)
-        ("B1", "=TIMEVALUE(\"22-Aug-2011 6:35 AM\")"), // Should be ~0.2743
-        ("B2", "=TIMEVALUE(\"2023-01-01 14:30:00\")"), // Should be 0.604166667
-        // Edge cases that Excel should support
-        ("C1", "=TIMEVALUE(\"12:00 AM\")"),    // Midnight: 0
-        ("C2", "=TIMEVALUE(\"12:00 PM\")"),    // Noon: 0.5
-        ("C3", "=TIMEVALUE(\"11:59:59 PM\")"), // Almost midnight: 0.999988426
-        // Single digit variations
-        ("D1", "=TIMEVALUE(\"1 AM\")"),  // 1:00 AM
-        ("D2", "=TIMEVALUE(\"9 PM\")"),  // 9:00 PM
-        ("D3", "=TIMEVALUE(\"12 AM\")"), // Midnight
-        ("D4", "=TIMEVALUE(\"12 PM\")"), // Noon
-    ]);
-
-    // Excel documentation examples - verify exact values
-    assert_eq!(model._get_text("A1"), *TIME_2_24_AM); // 2:24 AM
-    assert_eq!(model._get_text("A2"), *TIME_2_PM); // 2 PM = 14:00
-    assert_eq!(model._get_text("A3"), *TIME_6_45_PM); // 6:45 PM = 18:45
-    assert_eq!(model._get_text("A4"), *TIME_6_45_PM); // 18:45 (24-hour)
-
-    // Date-time formats (date ignored, extract time only)
-    assert_eq!(model._get_text("B1"), *TIME_6_35_AM); // 6:35 AM ≈ 0.2743
-    assert_eq!(model._get_text("B2"), *TIME_14_30); // 14:30:00
-
-    // Edge cases
-    assert_eq!(model._get_text("C1"), *MIDNIGHT); // 12:00 AM = 00:00
-    assert_eq!(model._get_text("C2"), *NOON); // 12:00 PM = 12:00
-    assert_eq!(model._get_text("C3"), *TIME_23_59_59); // 11:59:59 PM
-
-    // Single digit hours
-    assert_eq!(model._get_text("D1"), *TIME_1_AM); // 1:00 AM
-    assert_eq!(model._get_text("D2"), *TIME_9_PM); // 9:00 PM = 21:00
-    assert_eq!(model._get_text("D3"), *MIDNIGHT); // 12 AM = 00:00
-    assert_eq!(model._get_text("D4"), *NOON); // 12 PM = 12:00
-}
-
-#[test]
-fn test_time_function_basic_cases() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIME(0,0,0)"),    // Midnight
-        ("A2", "=TIME(12,0,0)"),   // Noon
-        ("A3", "=TIME(14,30,0)"),  // 2:30 PM
-        ("A4", "=TIME(23,59,59)"), // Max time
-    ]);
-
-    assert_eq!(model._get_text("A1"), *MIDNIGHT);
-    assert_eq!(model._get_text("A2"), *NOON);
-    assert_eq!(model._get_text("A3"), *TIME_14_30);
-    assert_eq!(model._get_text("A4"), *TIME_23_59_59);
-}
-
-#[test]
-fn test_time_function_normalization() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIME(25,0,0)"),         // Hours > 24 wrap around
-        ("A2", "=TIME(48,0,0)"),         // 48 hours = 0 (2 full days)
-        ("A3", "=TIME(0,90,0)"),         // 90 minutes = 1.5 hours
-        ("A4", "=TIME(0,0,90)"),         // 90 seconds = 1.5 minutes
-        ("A5", "=TIME(14.9,30.9,59.9)"), // Fractional inputs floored to 14:30:59
-    ]);
-
-    assert_eq!(model._get_text("A1"), *TIME_1_AM); // 1:00:00
-    assert_eq!(model._get_text("A2"), *MIDNIGHT); // 0:00:00
-    assert_eq!(model._get_text("A3"), *"0.0625"); // 1:30:00
-    assert_eq!(model._get_text("A4"), *"0.001041667"); // 0:01:30
-    assert_eq!(model._get_text("A5"), *TIME_14_30_59); // 14:30:59 (floored)
-}
-
-#[test]
-fn test_time_function_precision_edge_cases() {
-    let model = test_time_expressions(&[
-        // High precision fractional seconds
-        ("A1", "=TIME(14,30,45.999)"), // Fractional seconds should be floored
-        ("A2", "=SECOND(TIME(14,30,45.999))"), // Should extract 45, not 46
-        // Very large normalization values
-        ("B1", "=TIME(999,999,999)"), // Extreme normalization test
-        ("B2", "=HOUR(999.5)"),       // Multiple days, extract hour from fractional part
-        ("B3", "=MINUTE(999.75)"),    // Multiple days, extract minute
-        // Boundary conditions at rollover points
-        ("C1", "=TIME(24,60,60)"), // Should normalize to next day (00:01:00)
-        ("C2", "=HOUR(0.999999999)"), // Almost 24 hours should be 23
-        ("C3", "=MINUTE(0.999999999)"), // Almost 24 hours, extract minutes
-        ("C4", "=SECOND(0.999999999)"), // Almost 24 hours, extract seconds
-        // Precision at boundaries
-        ("D1", "=TIME(23,59,59.999)"), // Very close to midnight
-        ("D2", "=TIME(0,0,0.001)"),    // Just after midnight
-    ]);
-
-    // Fractional seconds are floored
-    assert_eq!(model._get_text("A2"), *"45"); // 45.999 floored to 45
-
-    // Multiple days should work with rem_euclid
-    assert_eq!(model._get_text("B2"), *"12"); // 999.5 days, hour = 12 (noon)
-
-    // Boundary normalization
-    assert_eq!(model._get_text("C1"), *"0.042361111"); // 24:60:60 = 01:01:00 (normalized)
-    assert_eq!(model._get_text("C2"), *"23"); // Almost 24 hours = 23:xx:xx
-
-    // High precision should be handled correctly
-    let result_d1 = model._get_text("D1").parse::<f64>().unwrap();
-    assert!(result_d1 < 1.0 && result_d1 > 0.999); // Very close to but less than 1.0
-}
-
-#[test]
-fn test_time_function_errors() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIME()"),          // Wrong arg count
-        ("A2", "=TIME(12)"),        // Wrong arg count
-        ("A3", "=TIME(12,30,0,0)"), // Wrong arg count
-        ("B1", "=TIME(-1,0,0)"),    // Negative hour
-        ("B2", "=TIME(0,-1,0)"),    // Negative minute
-        ("B3", "=TIME(0,0,-1)"),    // Negative second
-    ]);
-
-    // Wrong argument count
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-
-    // Negative values should return #NUM! error
-    assert_eq!(model._get_text("B1"), *"#NUM!");
-    assert_eq!(model._get_text("B2"), *"#NUM!");
-    assert_eq!(model._get_text("B3"), *"#NUM!");
-}
-
-#[test]
-fn test_timevalue_function_formats() {
-    let model = test_time_expressions(&[
-        // Basic formats
-        ("A1", "=TIMEVALUE(\"14:30\")"),
-        ("A2", "=TIMEVALUE(\"14:30:45\")"),
-        ("A3", "=TIMEVALUE(\"00:00:00\")"),
-        // AM/PM formats
-        ("B1", "=TIMEVALUE(\"2:30 PM\")"),
-        ("B2", "=TIMEVALUE(\"2:30 AM\")"),
-        ("B3", "=TIMEVALUE(\"12:00 PM\")"), // Noon
-        ("B4", "=TIMEVALUE(\"12:00 AM\")"), // Midnight
-        // Single hour with AM/PM (now supported!)
-        ("B5", "=TIMEVALUE(\"2 PM\")"),
-        ("B6", "=TIMEVALUE(\"2 AM\")"),
-        // Date-time formats (extract time only)
-        ("C1", "=TIMEVALUE(\"2023-01-01 14:30:00\")"),
-        ("C2", "=TIMEVALUE(\"2023-01-01T14:30:00\")"),
-        // Whitespace handling
-        ("D1", "=TIMEVALUE(\" 14:30 \")"),
-    ]);
-
-    // Basic formats
-    assert_eq!(model._get_text("A1"), *TIME_14_30);
-    assert_eq!(model._get_text("A2"), *TIME_14_30_45);
-    assert_eq!(model._get_text("A3"), *MIDNIGHT);
-
-    // AM/PM formats
-    assert_eq!(model._get_text("B1"), *TIME_14_30); // 2:30 PM = 14:30
-    assert_eq!(model._get_text("B2"), *TIME_2_30_AM); // 2:30 AM
-    assert_eq!(model._get_text("B3"), *NOON); // 12:00 PM = noon
-    assert_eq!(model._get_text("B4"), *MIDNIGHT); // 12:00 AM = midnight
-
-    // Single hour AM/PM formats (now supported!)
-    assert_eq!(model._get_text("B5"), *TIME_2_PM); // 2 PM = 14:00
-    assert_eq!(model._get_text("B6"), *TIME_2_AM); // 2 AM = 02:00
-
-    // Date-time formats
-    assert_eq!(model._get_text("C1"), *TIME_14_30);
-    assert_eq!(model._get_text("C2"), *TIME_14_30);
-
-    // Whitespace
-    assert_eq!(model._get_text("D1"), *TIME_14_30);
-}
-
-#[test]
-fn test_timevalue_function_errors() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIMEVALUE()"),                 // Wrong arg count
-        ("A2", "=TIMEVALUE(\"14:30\", \"x\")"), // Wrong arg count
-        ("B1", "=TIMEVALUE(\"invalid\")"),      // Invalid format
-        ("B2", "=TIMEVALUE(\"25:00\")"),        // Invalid hour
-        ("B3", "=TIMEVALUE(\"14:70\")"),        // Invalid minute
-        ("B4", "=TIMEVALUE(\"\")"),             // Empty string
-        ("B5", "=TIMEVALUE(\"2PM\")"),          // Missing space (still unsupported)
-    ]);
-
-    // Wrong argument count should return #ERROR!
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-
-    // Invalid formats should return #VALUE!
-    assert_eq!(model._get_text("B1"), *"#VALUE!");
-    assert_eq!(model._get_text("B2"), *"#VALUE!");
-    assert_eq!(model._get_text("B3"), *"#VALUE!");
-    assert_eq!(model._get_text("B4"), *"#VALUE!");
-    assert_eq!(model._get_text("B5"), *"#VALUE!"); // "2PM" no space - not supported
-}
-
-#[test]
-fn test_time_component_extraction_comprehensive() {
-    // Test component extraction using helper function for consistency
-
-    // Test basic time values
-    let test_cases = [
-        (MIDNIGHT, ("0", "0", "0")),         // 00:00:00
-        (NOON, ("12", "0", "0")),            // 12:00:00
-        (TIME_14_30, ("14", "30", "0")),     // 14:30:00
-        (TIME_23_59_59, ("23", "59", "59")), // 23:59:59
-    ];
-
-    for (time_value, expected) in test_cases {
-        let (hour, minute, second) = test_component_extraction(time_value);
-        assert_eq!(hour, expected.0, "Hour mismatch for {time_value}");
-        assert_eq!(minute, expected.1, "Minute mismatch for {time_value}");
-        assert_eq!(second, expected.2, "Second mismatch for {time_value}");
-    }
-
-    // Test multiple days (extract from fractional part)
-    let (hour, minute, second) = test_component_extraction("1.5"); // Day 2, 12:00
-    assert_eq!(
-        (hour, minute, second),
-        ("12".to_string(), "0".to_string(), "0".to_string())
-    );
-
-    let (hour, minute, second) = test_component_extraction("100.604166667"); // Day 101, 14:30
-    assert_eq!(
-        (hour, minute, second),
-        ("14".to_string(), "30".to_string(), "0".to_string())
-    );
-
-    // Test precision at boundaries
-    let (hour, _, _) = test_component_extraction("0.041666666"); // Just under 1:00 AM
-    assert_eq!(hour, "0");
-
-    let (hour, _, _) = test_component_extraction("0.041666667"); // Exactly 1:00 AM
-    assert_eq!(hour, "1");
-
-    let (hour, _, _) = test_component_extraction("0.041666668"); // Just over 1:00 AM
-    assert_eq!(hour, "1");
-
-    // Test very large day values
-    let (hour, minute, second) = test_component_extraction("1000000.25"); // Million days + 6 hours
-    assert_eq!(
-        (hour, minute, second),
-        ("6".to_string(), "0".to_string(), "0".to_string())
-    );
-}
-
-#[test]
-fn test_time_component_function_errors() {
-    let model = test_time_expressions(&[
-        // Wrong argument counts
-        ("A1", "=HOUR()"),       // No arguments
-        ("A2", "=MINUTE()"),     // No arguments
-        ("A3", "=SECOND()"),     // No arguments
-        ("A4", "=HOUR(1, 2)"),   // Too many arguments
-        ("A5", "=MINUTE(1, 2)"), // Too many arguments
-        ("A6", "=SECOND(1, 2)"), // Too many arguments
-        // Negative values should return #NUM!
-        ("B1", "=HOUR(-0.5)"),        // Negative value
-        ("B2", "=MINUTE(-1)"),        // Negative value
-        ("B3", "=SECOND(-1)"),        // Negative value
-        ("B4", "=HOUR(-0.000001)"),   // Slightly negative
-        ("B5", "=MINUTE(-0.000001)"), // Slightly negative
-        ("B6", "=SECOND(-0.000001)"), // Slightly negative
-    ]);
-
-    // Wrong argument count should return #ERROR!
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-
-    // Negative values should return #NUM!
-    assert_eq!(model._get_text("B1"), *"#NUM!");
-    assert_eq!(model._get_text("B2"), *"#NUM!");
-    assert_eq!(model._get_text("B3"), *"#NUM!");
-    assert_eq!(model._get_text("B4"), *"#NUM!");
-    assert_eq!(model._get_text("B5"), *"#NUM!");
-    assert_eq!(model._get_text("B6"), *"#NUM!");
-}
-
-#[test]
-fn test_time_functions_integration() {
-    // Test how TIME, TIMEVALUE and component extraction functions work together
-    let model = test_time_expressions(&[
-        // Create times with both functions
-        ("A1", "=TIME(14,30,45)"),
-        ("A2", "=TIMEVALUE(\"14:30:45\")"),
-        // Extract components from TIME function results
-        ("B1", "=HOUR(A1)"),
-        ("B2", "=MINUTE(A1)"),
-        ("B3", "=SECOND(A1)"),
-        // Extract components from TIMEVALUE function results
-        ("C1", "=HOUR(A2)"),
-        ("C2", "=MINUTE(A2)"),
-        ("C3", "=SECOND(A2)"),
-        // Test additional TIME variations
-        ("D1", "=TIME(14,0,0)"), // 14:00:00
-        ("E1", "=HOUR(D1)"),     // Extract hour from 14:00:00
-        ("E2", "=MINUTE(D1)"),   // Extract minute from 14:00:00
-        ("E3", "=SECOND(D1)"),   // Extract second from 14:00:00
-    ]);
-
-    // TIME and TIMEVALUE should produce equivalent results
-    assert_eq!(model._get_text("A1"), model._get_text("A2"));
-
-    // Extracting components should work consistently
-    assert_eq!(model._get_text("B1"), *"14");
-    assert_eq!(model._get_text("B2"), *"30");
-    assert_eq!(model._get_text("B3"), *"45");
-    assert_eq!(model._get_text("C1"), *"14");
-    assert_eq!(model._get_text("C2"), *"30");
-    assert_eq!(model._get_text("C3"), *"45");
-
-    // Components from TIME(14,0,0)
-    assert_eq!(model._get_text("E1"), *"14");
-    assert_eq!(model._get_text("E2"), *"0");
-    assert_eq!(model._get_text("E3"), *"0");
-}
-
-#[test]
-fn test_time_function_extreme_values() {
-    // Test missing edge cases: very large fractional inputs
-    let model = test_time_expressions(&[
-        // Extremely large fractional values to TIME function
-        ("A1", "=TIME(999999.9, 999999.9, 999999.9)"), // Very large fractional inputs
-        ("A2", "=TIME(1e6, 1e6, 1e6)"),                // Scientific notation inputs
-        ("A3", "=TIME(0.000001, 0.000001, 0.000001)"), // Very small fractional inputs
-        // Large day values for component extraction (stress test)
-        ("B1", "=HOUR(999999.999)"), // Almost a million days
-        ("B2", "=MINUTE(999999.999)"),
-        ("B3", "=SECOND(999999.999)"),
-        // Edge case: exactly 1.0 (should be midnight of next day)
-        ("C1", "=HOUR(1.0)"),
-        ("C2", "=MINUTE(1.0)"),
-        ("C3", "=SECOND(1.0)"),
-        // Very high precision values
-        ("D1", "=HOUR(0.999999999999)"), // Almost exactly 24:00:00
-        ("D2", "=MINUTE(0.999999999999)"),
-        ("D3", "=SECOND(0.999999999999)"),
-    ]);
-
-    // Large fractional inputs should be floored and normalized
-    let result_a1 = model._get_text("A1").parse::<f64>().unwrap();
-    assert!(
-        (0.0..1.0).contains(&result_a1),
-        "Result should be valid time fraction"
-    );
-
-    // Component extraction should work with very large values
-    let hour_b1 = model._get_text("B1").parse::<i32>().unwrap();
-    assert!((0..=23).contains(&hour_b1), "Hour should be 0-23");
-
-    // Exactly 1.0 should be midnight (start of next day)
-    assert_eq!(model._get_text("C1"), *"0");
-    assert_eq!(model._get_text("C2"), *"0");
-    assert_eq!(model._get_text("C3"), *"0");
-
-    // Very high precision should still extract valid components
-    let hour_d1 = model._get_text("D1").parse::<i32>().unwrap();
-    assert!((0..=23).contains(&hour_d1), "Hour should be 0-23");
-}
-
-#[test]
-fn test_timevalue_malformed_but_parseable() {
-    // Test missing edge case: malformed but potentially parseable strings
-    let model = test_time_expressions(&[
-        // Test various malformed but potentially parseable time strings
-        ("A1", "=TIMEVALUE(\"14:30:00.123\")"), // Milliseconds (might be truncated)
-        ("A2", "=TIMEVALUE(\"14:30:00.999\")"), // High precision milliseconds
-        ("A3", "=TIMEVALUE(\"02:30:00\")"),     // Leading zero hours
-        ("A4", "=TIMEVALUE(\"2:05:00\")"),      // Single digit hour, zero-padded minute
-        // Boundary cases for AM/PM parsing
-        ("B1", "=TIMEVALUE(\"11:59:59 PM\")"), // Just before midnight
-        ("B2", "=TIMEVALUE(\"12:00:01 AM\")"), // Just after midnight
-        ("B3", "=TIMEVALUE(\"12:00:01 PM\")"), // Just after noon
-        ("B4", "=TIMEVALUE(\"11:59:59 AM\")"), // Just before noon
-        // Test various date-time combinations
-        ("C1", "=TIMEVALUE(\"2023-12-31T23:59:59\")"), // ISO format at year end
-        ("C2", "=TIMEVALUE(\"2023-01-01 00:00:01\")"), // New year, just after midnight
-        // Test potential edge cases that might still be parseable
-        ("D1", "=TIMEVALUE(\"24:00:00\")"), // Should error (invalid hour)
-        ("D2", "=TIMEVALUE(\"23:60:00\")"), // Should error (invalid minute)
-        ("D3", "=TIMEVALUE(\"23:59:60\")"), // Should error (invalid second)
-    ]);
-
-    // Milliseconds are not supported, should return a #VALUE! error like Excel
-    assert_eq!(model._get_text("A1"), *"#VALUE!");
-    assert_eq!(model._get_text("A2"), *"#VALUE!");
-
-    // Leading zeros should work fine
-    assert_eq!(model._get_text("A3"), *TIME_2_30_AM); // 02:30:00 should parse as 2:30:00
-
-    // AM/PM boundary cases should work
-    let result_b1 = model._get_text("B1").parse::<f64>().unwrap();
-    assert!(
-        result_b1 > 0.99 && result_b1 < 1.0,
-        "11:59:59 PM should be very close to 1.0"
-    );
-
-    let result_b2 = model._get_text("B2").parse::<f64>().unwrap();
-    assert!(
-        result_b2 > 0.0 && result_b2 < 0.01,
-        "12:00:01 AM should be very close to 0.0"
-    );
-
-    // ISO 8601 format with "T" separator should be parsed correctly
-    assert_eq!(model._get_text("C1"), *TIME_23_59_59); // 23:59:59 → almost midnight
-    assert_eq!(model._get_text("C2"), *TIME_00_00_01); // 00:00:01 → one second past midnight
-
-    // Time parser normalizes edge cases to midnight (Excel compatibility)
-    assert_eq!(model._get_text("D1"), *"0"); // 24:00:00 = midnight of next day
-    assert_eq!(model._get_text("D2"), *"0"); // 23:60:00 normalizes to 24:00:00 = midnight
-    assert_eq!(model._get_text("D3"), *"0"); // 23:59:60 normalizes to 24:00:00 = midnight
-}
-
-#[test]
-fn test_performance_stress_with_extreme_values() {
-    // Test performance/stress cases with extreme values
-    let model = test_time_expressions(&[
-        // Very large numbers that should still work
-        ("A1", "=TIME(2147483647, 0, 0)"), // Max i32 hours
-        ("A2", "=TIME(0, 2147483647, 0)"), // Max i32 minutes
-        ("A3", "=TIME(0, 0, 2147483647)"), // Max i32 seconds
-        // Component extraction with extreme day values
-        ("B1", "=HOUR(1e15)"), // Very large day number
-        ("B2", "=MINUTE(1e15)"),
-        ("B3", "=SECOND(1e15)"),
-        // Edge of floating point precision
-        ("C1", "=HOUR(1.7976931348623157e+308)"), // Near max f64
-        ("C2", "=HOUR(2.2250738585072014e-308)"), // Near min positive f64
-        // Multiple TIME function calls with large values
-        ("D1", "=TIME(1000000, 1000000, 1000000)"), // Large normalized values
-        ("D2", "=HOUR(D1)"),                        // Extract from large TIME result
-        ("D3", "=MINUTE(D1)"),
-        ("D4", "=SECOND(D1)"),
-    ]);
-
-    // All results should be valid (not errors) even with extreme inputs
-    for cell in ["A1", "A2", "A3", "B1", "B2", "B3", "D1", "D2", "D3", "D4"] {
-        let result = model._get_text(cell);
-        assert!(
-            result != *"#ERROR!" && result != *"#NUM!" && result != *"#VALUE!",
-            "Cell {cell} should not error with extreme values: {result}",
-        );
-    }
-
-    // Results should be mathematically valid
-    let hour_b1 = model._get_text("B1").parse::<i32>().unwrap();
-    let minute_b2 = model._get_text("B2").parse::<i32>().unwrap();
-    let second_b3 = model._get_text("B3").parse::<i32>().unwrap();
-
-    assert!((0..=23).contains(&hour_b1));
-    assert!((0..=59).contains(&minute_b2));
-    assert!((0..=59).contains(&second_b3));
-
-    // TIME function results should be valid time fractions
-    let time_d1 = model._get_text("D1").parse::<f64>().unwrap();
-    assert!(
-        (0.0..1.0).contains(&time_d1),
-        "TIME result should be valid fraction"
-    );
-}
--- a/base/src/test/test_fn_unicode.rs
+++ b/base/src/test/test_fn_unicode.rs
@@ -1,63 +0,0 @@
-#![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_forward_references.rs
+++ b/base/src/test/test_forward_references.rs
@@ -0,0 +1,121 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::expressions::types::{Area, CellReferenceIndex};
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_forward_references() {
+    let mut model = new_empty_model();
+
+    // test single ref changed nd not changed
+    model._set("H8", "=F6*G9");
+    // tests areas
+    model._set("H9", "=SUM(D4:F6)");
+    // absolute coordinates
+    model._set("H10", "=$F$6");
+    // area larger than the source area
+    model._set("H11", "=SUM(D3:F6)");
+    // Test arguments and concat
+    model._set("H12", "=SUM(F6, D4:F6) & D4");
+    // Test range operator. This is syntax error for now.
+    // model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
+    // Test operations
+    model._set("H14", "=-D4+D5*F6/F5");
+
+    model.evaluate();
+
+    // Source Area is D4:F6
+    let source_area = &Area {
+        sheet: 0,
+        row: 4,
+        column: 4,
+        width: 3,
+        height: 3,
+    };
+
+    // We paste in B10
+    let target_row = 10;
+    let target_column = 2;
+    let result = model.forward_references(
+        source_area,
+        &CellReferenceIndex {
+            sheet: 0,
+            row: target_row,
+            column: target_column,
+        },
+    );
+    assert!(result.is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("H8"), "=D12*G9");
+    assert_eq!(model._get_formula("H9"), "=SUM(B10:D12)");
+    assert_eq!(model._get_formula("H10"), "=$D$12");
+
+    assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
+    assert_eq!(model._get_formula("H12"), "=SUM(D12,B10:D12)&B10");
+    // assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
+    assert_eq!(model._get_formula("H14"), "=-B10+B11*D12/D11");
+}
+
+#[test]
+fn test_different_sheet() {
+    let mut model = new_empty_model();
+
+    // test single ref changed not changed
+    model._set("H8", "=F6*G9");
+    // tests areas
+    model._set("H9", "=SUM(D4:F6)");
+    // absolute coordinates
+    model._set("H10", "=$F$6");
+    // area larger than the source area
+    model._set("H11", "=SUM(D3:F6)");
+    // Test arguments and concat
+    model._set("H12", "=SUM(F6, D4:F6) & D4");
+    // Test range operator. This is syntax error for now.
+    // model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
+    // Test operations
+    model._set("H14", "=-D4+D5*F6/F5");
+
+    // Adds a new sheet
+    assert!(model.add_sheet("Sheet2").is_ok());
+
+    model.evaluate();
+
+    // Source Area is D4:F6
+    let source_area = &Area {
+        sheet: 0,
+        row: 4,
+        column: 4,
+        width: 3,
+        height: 3,
+    };
+
+    // We paste in Sheet2!B10
+    let target_row = 10;
+    let target_column = 2;
+    let result = model.forward_references(
+        source_area,
+        &CellReferenceIndex {
+            sheet: 1,
+            row: target_row,
+            column: target_column,
+        },
+    );
+    assert!(result.is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("H8"), "=Sheet2!D12*G9");
+    assert_eq!(model._get_formula("H9"), "=SUM(Sheet2!B10:D12)");
+    assert_eq!(model._get_formula("H10"), "=Sheet2!$D$12");
+
+    assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
+    assert_eq!(
+        model._get_formula("H12"),
+        "=SUM(Sheet2!D12,Sheet2!B10:D12)&Sheet2!B10"
+    );
+    // assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
+    assert_eq!(
+        model._get_formula("H14"),
+        "=-Sheet2!B10+Sheet2!B11*Sheet2!D12/Sheet2!D11"
+    );
+}
--- a/base/src/test/test_general.rs
+++ b/base/src/test/test_general.rs
@@ -1,7 +1,5 @@
 #![allow(clippy::unwrap_used)]

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

 use crate::number_format::to_excel_precision_str;
@@ -115,15 +113,6 @@ 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
@@ -1,27 +0,0 @@
-#![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_implicit_intersection.rs
+++ b/base/src/test/test_implicit_intersection.rs
@@ -1,50 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn simple_colum() {
-    let mut model = new_empty_model();
-    // We populate cells A1 to A3
-    model._set("A1", "1");
-    model._set("A2", "2");
-    model._set("A3", "3");
-
-    model._set("C2", "=@A1:A3");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("C2"), "2".to_string());
-}
-
-#[test]
-fn return_of_array_is_n_impl() {
-    let mut model = new_empty_model();
-    // We populate cells A1 to A3
-    model._set("A1", "1");
-    model._set("A2", "2");
-    model._set("A3", "3");
-
-    model._set("C2", "=A1:A3");
-    model._set("D2", "=SUM(SIN(A:A)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("C2"), "#N/IMPL!".to_string());
-    assert_eq!(model._get_text("D2"), "1.89188842".to_string());
-}
-
-#[test]
-fn concat() {
-    let mut model = new_empty_model();
-    model._set("A1", "=CONCAT(@B1:B3)");
-    model._set("A2", "=CONCAT(B1:B3)");
-    model._set("B1", "Hello");
-    model._set("B2", " ");
-    model._set("B3", "world!");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"Hello");
-    assert_eq!(model._get_text("A2"), *"Hello world!");
-}
--- a/base/src/test/test_issue_155.rs
+++ b/base/src/test/test_issue_155.rs
@@ -1,14 +0,0 @@
-#![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_ln.rs
+++ b/base/src/test/test_ln.rs
@@ -1,17 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LN(100)");
-    model._set("A2", "=LN()");
-    model._set("A3", "=LN(100, 10)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"4.605170186");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-}
--- a/base/src/test/test_log.rs
+++ b/base/src/test/test_log.rs
@@ -1,19 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG(100)");
-    model._set("A2", "=LOG()");
-    model._set("A3", "=LOG(10000, 10)");
-    model._set("A4", "=LOG(100, 10, 1)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"4");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-}
--- a/base/src/test/test_log10.rs
+++ b/base/src/test/test_log10.rs
@@ -1,35 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG10(100)");
-    model._set("A2", "=LOG10()");
-    model._set("A3", "=LOG10(100, 10)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-}
-
-#[test]
-fn cell_and_function() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG10");
-
-    model.evaluate();
-
-    // This is the cell LOG10
-    assert_eq!(model._get_text("A1"), *"0");
-
-    model._set("LOG10", "1000");
-    model._set("A2", "=LOG10(LOG10)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"1000");
-    assert_eq!(model._get_text("A2"), *"3");
-}
--- a/base/src/test/test_metadata.rs
+++ b/base/src/test/test_metadata.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::unwrap_used)]
-
 use crate::test::util::new_empty_model;

 #[test]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nicolás Hatcher	c99aea7b3d	UPDATE: Webapp	2024-10-06 16:06:56 +02:00
Nicolás Hatcher	ac0567e897	FIX: Initial browse mode within sheets	2024-09-28 15:26:55 +02:00
Nicolás Hatcher	fde1e13ffb	FIX: Minimal implementation of browse mode	2024-09-28 13:55:52 +02:00
Nicolás Hatcher	90cf5f74f7	FIX: Do not loose focus when clicking on the formula we are editing	2024-09-27 19:25:26 +02:00
Nicolás Hatcher	f53b39b220	UPDATE: Adds cell and formula editing	2024-09-26 19:08:16 +02:00