fix: mobile adjustments

update: add data-storage warnings to the app

.github/workflows/npm.yml

@@ -31,82 +31,38 @@ jobs:
           - 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
+            build: 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
+            build: 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
+            build: 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
+            build: 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
+              sudo apt-get install gcc-arm-linux-gnueabihf -y
+            build: yarn build --target armv7-unknown-linux-gnueabihf
+          - host: ubuntu-latest
+            target: armv7-unknown-linux-musleabihf
+            build: 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
+            build: 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
+            build: 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
@@ -136,7 +92,7 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         if: ${{ !matrix.settings.docker }}
         with:
-          toolchain: 1.90.0
+          toolchain: stable
           targets: ${{ matrix.settings.target }}
       - name: Cache cargo
         uses: actions/cache@v4
@@ -188,6 +144,7 @@ jobs:
           - host: windows-latest
             target: x86_64-pc-windows-msvc
         node:
+          - '18'
           - '20'
     runs-on: ${{ matrix.settings.host }}
     defaults:
@@ -222,6 +179,7 @@ jobs:
       fail-fast: false
       matrix:
         node:
+          - '18'
           - '20'
     runs-on: ubuntu-latest
     defaults:
@@ -255,6 +213,7 @@ jobs:
       fail-fast: false
       matrix:
         node:
+          - '18'
           - '20'
     runs-on: ubuntu-latest
     defaults:
@@ -290,6 +249,7 @@ jobs:
       fail-fast: false
       matrix:
         node:
+          - '18'
           - '20'
     runs-on: ubuntu-latest
     defaults:
@@ -360,6 +320,48 @@ jobs:
           run: |
             set -e
             yarn test
+  test-linux-arm-gnueabihf-binding:
+    name: Test bindings on armv7-unknown-linux-gnueabihf - node@${{ matrix.node }}
+    needs:
+      - build
+    strategy:
+      fail-fast: false
+      matrix:
+        node:
+          - '18'
+          - '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-armv7-unknown-linux-gnueabihf
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Install dependencies
+        run: |
+          yarn config set supportedArchitectures.cpu "arm"
+          yarn install
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: arm
+      - 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 }}-bullseye-slim
+          options: '--platform linux/arm/v7 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
+          run: |
+            set -e
+            yarn test
+            ls -la
   universal-macOS:
     name: Build universal macOS binary
     needs:
@@ -408,6 +410,7 @@ jobs:
       - test-linux-x64-musl-binding
       - test-linux-aarch64-gnu-binding
       - test-linux-aarch64-musl-binding
+      - test-linux-arm-gnueabihf-binding
       - universal-macOS
     steps:
       - uses: actions/checkout@v4

Cargo.lock

@@ -43,6 +43,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -218,9 +227,9 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
 [[package]]
 name = "convert_case"
-version = "0.8.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
 dependencies = [
  "unicode-segmentation",
 ]
@@ -288,20 +297,14 @@ dependencies = [
 
 [[package]]
 name = "ctor"
-version = "0.5.0"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67773048316103656a637612c4a62477603b777d91d9c62ff2290f9cde178fdb"
+checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
 dependencies = [
- "ctor-proc-macro",
- "dtor",
+ "quote",
+ "syn",
 ]
 
-[[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 +325,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"
@@ -464,6 +452,7 @@ dependencies = [
  "ryu",
  "serde",
  "serde_json",
+ "statrs",
 ]
 
 [[package]]
@@ -558,34 +547,33 @@ dependencies = [
 
 [[package]]
 name = "napi"
-version = "3.3.0"
+version = "2.16.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b74e3dce5230795bb4d2821b941706dee733c7308752507254b0497f39cad7"
+checksum = "214f07a80874bb96a8433b3cdfc84980d56c7b02e1a0d7ba4ba0db5cef785e2b"
 dependencies = [
  "bitflags",
  "ctor",
- "napi-build",
+ "napi-derive",
  "napi-sys",
- "nohash-hasher",
- "rustc-hash",
+ "once_cell",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "napi-build"
-version = "2.2.3"
+version = "2.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcae8ad5609d14afb3a3b91dee88c757016261b151e9dcecabf1b2a31a6cab14"
+checksum = "db836caddef23662b94e16bf1f26c40eceb09d6aee5d5b06a7ac199320b69b19"
 
 [[package]]
 name = "napi-derive"
-version = "3.2.5"
+version = "2.16.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7552d5a579b834614bbd496db5109f1b9f1c758f08224b0dee1e408333adf0d0"
+checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
 dependencies = [
+ "cfg-if",
  "convert_case",
- "ctor",
  "napi-derive-backend",
  "proc-macro2",
  "quote",
@@ -594,32 +582,28 @@ dependencies = [
 
 [[package]]
 name = "napi-derive-backend"
-version = "2.2.0"
+version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6a81ac7486b70f2532a289603340862c06eea5a1e650c1ffeda2ce1238516a"
+checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
 dependencies = [
  "convert_case",
+ "once_cell",
  "proc-macro2",
  "quote",
+ "regex",
  "semver",
  "syn",
 ]
 
 [[package]]
 name = "napi-sys"
-version = "3.0.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e4e7135a8f97aa0f1509cce21a8a1f9dcec1b50d8dee006b48a5adb69a9d64d"
+checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
 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"
@@ -897,12 +881,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"
@@ -997,6 +975,16 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
+[[package]]
+name = "statrs"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e"
+dependencies = [
+ "approx",
+ "num-traits",
+]
+
 [[package]]
 name = "subtle"
 version = "2.5.0"

base/Cargo.toml

@@ -19,6 +19,7 @@ regex = { version = "1.0", optional = true}
 regex-lite = { version = "0.1.6", optional = true}
 bitcode = "0.6.3"
 csv = "1.3.0"
+statrs = { version = "0.18.0", default-features = false, features = [] }
 
 [features]
 default = ["use_regex_full"]

base/src/cast.rs

@@ -5,6 +5,7 @@ use crate::{
         token::Error,
         types::CellReferenceIndex,
     },
+    formatter::format::parse_formatted_number,
     model::Model,
 };
 
@@ -14,6 +15,23 @@ pub(crate) enum NumberOrArray {
 }
 
 impl Model {
+    pub(crate) fn cast_number(&self, s: &str) -> Option<f64> {
+        match s.trim().parse::<f64>() {
+            Ok(f) => Some(f),
+            _ => {
+                let currency = &self.locale.currency.symbol;
+                let mut currencies = vec!["$", "€"];
+                if !currencies.iter().any(|e| *e == currency) {
+                    currencies.push(currency);
+                }
+                // Try to parse as a formatted number (e.g., dates, currencies, percentages)
+                if let Ok((v, _number_format)) = parse_formatted_number(s, &currencies) {
+                    return Some(v);
+                }
+                None
+            }
+        }
+    }
     pub(crate) fn get_number_or_array(
         &mut self,
         node: &Node,
@@ -21,9 +39,9 @@ impl Model {
     ) -> 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(
+            CalcResult::String(s) => match self.cast_number(&s) {
+                Some(f) => Ok(NumberOrArray::Number(f)),
+                None => Err(CalcResult::new_error(
                     Error::VALUE,
                     cell,
                     "Expecting number".to_string(),
@@ -89,16 +107,16 @@ impl Model {
         self.cast_to_number(result, cell)
     }
 
-    fn cast_to_number(
+    pub(crate) fn cast_to_number(
         &mut self,
         result: CalcResult,
         cell: CellReferenceIndex,
     ) -> Result<f64, CalcResult> {
         match result {
             CalcResult::Number(f) => Ok(f),
-            CalcResult::String(s) => match s.parse::<f64>() {
-                Ok(f) => Ok(f),
-                _ => Err(CalcResult::new_error(
+            CalcResult::String(s) => match self.cast_number(&s) {
+                Some(f) => Ok(f),
+                None => Err(CalcResult::new_error(
                     Error::VALUE,
                     cell,
                     "Expecting number".to_string(),

base/src/expressions/parser/static_analysis.rs

@@ -834,6 +834,61 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Geomean => vec![Signature::Vector; arg_count],
         Function::Networkdays => args_signature_networkdays(arg_count),
         Function::NetworkdaysIntl => args_signature_networkdays_intl(arg_count),
+        Function::Acot => args_signature_scalars(arg_count, 1, 0),
+        Function::Acoth => args_signature_scalars(arg_count, 1, 0),
+        Function::Cot => args_signature_scalars(arg_count, 1, 0),
+        Function::Coth => args_signature_scalars(arg_count, 1, 0),
+        Function::Csc => args_signature_scalars(arg_count, 1, 0),
+        Function::Csch => args_signature_scalars(arg_count, 1, 0),
+        Function::Sec => args_signature_scalars(arg_count, 1, 0),
+        Function::Sech => args_signature_scalars(arg_count, 1, 0),
+        Function::Exp => args_signature_scalars(arg_count, 1, 0),
+        Function::Fact => args_signature_scalars(arg_count, 1, 0),
+        Function::Factdouble => args_signature_scalars(arg_count, 1, 0),
+        Function::Sign => args_signature_scalars(arg_count, 1, 0),
+        Function::Radians => args_signature_scalars(arg_count, 1, 0),
+        Function::Degrees => args_signature_scalars(arg_count, 1, 0),
+        Function::Int => args_signature_scalars(arg_count, 1, 0),
+        Function::Even => args_signature_scalars(arg_count, 1, 0),
+        Function::Odd => args_signature_scalars(arg_count, 1, 0),
+        Function::Ceiling => args_signature_scalars(arg_count, 2, 0),
+        Function::CeilingMath => args_signature_scalars(arg_count, 1, 2),
+        Function::CeilingPrecise => args_signature_scalars(arg_count, 1, 1),
+        Function::Floor => args_signature_scalars(arg_count, 2, 0),
+        Function::FloorMath => args_signature_scalars(arg_count, 1, 2),
+        Function::FloorPrecise => args_signature_scalars(arg_count, 1, 1),
+        Function::IsoCeiling => args_signature_scalars(arg_count, 1, 1),
+        Function::Mod => args_signature_scalars(arg_count, 2, 0),
+        Function::Quotient => args_signature_scalars(arg_count, 2, 0),
+        Function::Mround => args_signature_scalars(arg_count, 2, 0),
+        Function::Trunc => args_signature_scalars(arg_count, 1, 1),
+        Function::Gcd => vec![Signature::Vector; arg_count],
+        Function::Lcm => vec![Signature::Vector; arg_count],
+        Function::Base => args_signature_scalars(arg_count, 2, 1),
+        Function::Decimal => args_signature_scalars(arg_count, 2, 0),
+        Function::Roman => args_signature_scalars(arg_count, 1, 1),
+        Function::Arabic => args_signature_scalars(arg_count, 1, 0),
+        Function::Combin => args_signature_scalars(arg_count, 2, 0),
+        Function::Combina => args_signature_scalars(arg_count, 2, 0),
+        Function::Sumsq => vec![Signature::Vector; arg_count],
+
+        Function::N => args_signature_scalars(arg_count, 1, 0),
+        Function::Sheets => args_signature_scalars(arg_count, 0, 1),
+        Function::Cell => args_signature_scalars(arg_count, 1, 1),
+        Function::Info => args_signature_scalars(arg_count, 1, 1),
+
+        Function::Daverage => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dcount => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dget => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dmax => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dmin => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dsum => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dcounta => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dproduct => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dstdev => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dvar => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dvarp => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
+        Function::Dstdevp => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
     }
 }
 
@@ -1056,5 +1111,59 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Geomean => not_implemented(args),
         Function::Networkdays => not_implemented(args),
         Function::NetworkdaysIntl => not_implemented(args),
+        Function::Acot => scalar_arguments(args),
+        Function::Acoth => scalar_arguments(args),
+        Function::Cot => scalar_arguments(args),
+        Function::Coth => scalar_arguments(args),
+        Function::Csc => scalar_arguments(args),
+        Function::Csch => scalar_arguments(args),
+        Function::Sec => scalar_arguments(args),
+        Function::Sech => scalar_arguments(args),
+        Function::Exp => scalar_arguments(args),
+        Function::Fact => scalar_arguments(args),
+        Function::Factdouble => scalar_arguments(args),
+        Function::Sign => scalar_arguments(args),
+        Function::Radians => scalar_arguments(args),
+        Function::Degrees => scalar_arguments(args),
+        Function::Int => scalar_arguments(args),
+        Function::Even => scalar_arguments(args),
+        Function::Odd => scalar_arguments(args),
+        Function::Ceiling => scalar_arguments(args),
+        Function::CeilingMath => scalar_arguments(args),
+        Function::CeilingPrecise => scalar_arguments(args),
+        Function::Floor => scalar_arguments(args),
+        Function::FloorMath => scalar_arguments(args),
+        Function::FloorPrecise => scalar_arguments(args),
+        Function::IsoCeiling => scalar_arguments(args),
+        Function::Mod => scalar_arguments(args),
+        Function::Quotient => scalar_arguments(args),
+        Function::Mround => scalar_arguments(args),
+        Function::Trunc => scalar_arguments(args),
+        Function::Gcd => not_implemented(args),
+        Function::Lcm => not_implemented(args),
+        Function::Base => scalar_arguments(args),
+        Function::Decimal => scalar_arguments(args),
+        Function::Roman => scalar_arguments(args),
+        Function::Arabic => scalar_arguments(args),
+        Function::Combin => scalar_arguments(args),
+        Function::Combina => scalar_arguments(args),
+        Function::Sumsq => StaticResult::Scalar,
+        Function::N => scalar_arguments(args),
+        Function::Sheets => scalar_arguments(args),
+        Function::Cell => scalar_arguments(args),
+        Function::Info => scalar_arguments(args),
+
+        Function::Dget => not_implemented(args),
+        Function::Dmax => not_implemented(args),
+        Function::Dmin => not_implemented(args),
+        Function::Dcount => not_implemented(args),
+        Function::Daverage => not_implemented(args),
+        Function::Dsum => not_implemented(args),
+        Function::Dcounta => not_implemented(args),
+        Function::Dproduct => not_implemented(args),
+        Function::Dstdev => not_implemented(args),
+        Function::Dvar => not_implemented(args),
+        Function::Dvarp => not_implemented(args),
+        Function::Dstdevp => not_implemented(args),
     }
 }

base/src/expressions/parser/stringify.rs

@@ -520,6 +520,7 @@ fn stringify(
             let x = match **left {
                 BooleanKind(_)
                 | NumberKind(_)
+                | UnaryKind { .. }
                 | StringKind(_)
                 | ReferenceKind { .. }
                 | RangeKind { .. }
@@ -535,7 +536,6 @@ fn stringify(
                 | FunctionKind { .. }
                 | InvalidFunctionKind { .. }
                 | ArrayKind(_)
-                | UnaryKind { .. }
                 | ErrorKind(_)
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
@@ -630,7 +630,6 @@ fn stringify(
                     | OpRangeKind { .. }
                     | OpConcatenateKind { .. }
                     | OpProductKind { .. }
-                    | OpPowerKind { .. }
                     | FunctionKind { .. }
                     | InvalidFunctionKind { .. }
                     | ArrayKind(_)
@@ -643,7 +642,7 @@ fn stringify(
                     | ParseErrorKind { .. }
                     | EmptyArgKind => false,
 
-                    OpSumKind { .. } | UnaryKind { .. } => true,
+                    OpPowerKind { .. } | OpSumKind { .. } | UnaryKind { .. } => true,
                 };
                 if needs_parentheses {
                     format!(

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

@@ -3,6 +3,7 @@ mod test_arrays;
 mod test_general;
 mod test_implicit_intersection;
 mod test_issue_155;
+mod test_issue_483;
 mod test_move_formula;
 mod test_ranges;
 mod test_stringify;

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

@@ -0,0 +1,27 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn issue_483_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("-(A1^1.22)", &cell_reference);
+    assert!(matches!(t, Node::UnaryKind { .. }));
+    assert_eq!(to_string(&t, &cell_reference), "-(A1^1.22)");
+
+    let t = parser.parse("-A1^1.22", &cell_reference);
+    assert!(matches!(t, Node::OpPowerKind { .. }));
+    assert_eq!(to_string(&t, &cell_reference), "-A1^1.22");
+}

base/src/expressions/utils/mod.rs

@@ -211,15 +211,19 @@ pub fn parse_reference_a1(r: &str) -> Option<ParsedReference> {
 pub fn is_valid_identifier(name: &str) -> bool {
     // https://support.microsoft.com/en-us/office/names-in-formulas-fc2935f9-115d-4bef-a370-3aa8bb4c91f1
     // https://github.com/MartinTrummer/excel-names/
-    // NOTE: We are being much more restrictive than Excel.
-    // In particular we do not support non ascii characters.
     let upper = name.to_ascii_uppercase();
-    let bytes = upper.as_bytes();
-    let len = bytes.len();
+    // length of chars
+    let len = upper.chars().count();
+
+    let mut chars = upper.chars();
+
     if len > 255 || len == 0 {
         return false;
     }
-    let first = bytes[0] as char;
+    let first = match chars.next() {
+        Some(ch) => ch,
+        None => return false,
+    };
     // The first character of a name must be a letter, an underscore character (_), or a backslash (\).
     if !(first.is_ascii_alphabetic() || first == '_' || first == '\\') {
         return false;
@@ -237,20 +241,10 @@ pub fn is_valid_identifier(name: &str) -> bool {
     if parse_reference_r1c1(name).is_some() {
         return false;
     }
-    let mut i = 1;
-    while i < len {
-        let ch = bytes[i] as char;
-        match ch {
-            'a'..='z' => {}
-            'A'..='Z' => {}
-            '0'..='9' => {}
-            '_' => {}
-            '.' => {}
-            _ => {
-                return false;
-            }
+    for ch in chars {
+        if !(ch.is_alphanumeric() || ch == '_' || ch == '.') {
+            return false;
         }
-        i += 1;
     }
 
     true
@@ -259,15 +253,23 @@ pub fn is_valid_identifier(name: &str) -> bool {
 fn name_needs_quoting(name: &str) -> bool {
     let chars = name.chars();
     // it contains any of these characters: ()'$,;-+{} or space
-    for char in chars {
+    for (i, char) in chars.enumerate() {
         if [' ', '(', ')', '\'', '$', ',', ';', '-', '+', '{', '}'].contains(&char) {
             return true;
         }
+        // if it starts with a number
+        if i == 0 && char.is_ascii_digit() {
+            return true;
+        }
+    }
+    if parse_reference_a1(name).is_some() {
+        // cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
+        return true;
+    }
+    if parse_reference_r1c1(name).is_some() {
+        // cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
+        return true;
     }
-    // TODO:
-    // cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
-    // cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
-    // integers
     false
 }
 
@@ -279,3 +281,32 @@ pub fn quote_name(name: &str) -> String {
     };
     name.to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quote_name() {
+        assert_eq!(quote_name("Sheet1"), "Sheet1");
+        assert_eq!(quote_name("Sheet 1"), "'Sheet 1'");
+        // escape and quote
+        assert_eq!(quote_name("Sheet1'"), "'Sheet1'''");
+        assert_eq!(quote_name("Data(2024)"), "'Data(2024)'");
+        assert_eq!(quote_name("Data$2024"), "'Data$2024'");
+        assert_eq!(quote_name("Data-2024"), "'Data-2024'");
+        assert_eq!(quote_name("Data+2024"), "'Data+2024'");
+        assert_eq!(quote_name("Data,2024"), "'Data,2024'");
+        assert_eq!(quote_name("Data;2024"), "'Data;2024'");
+        assert_eq!(quote_name("Data{2024}"), "'Data{2024}'");
+
+        assert_eq!(quote_name("2024"), "'2024'");
+        assert_eq!(quote_name("1Data"), "'1Data'");
+        assert_eq!(quote_name("A1"), "'A1'");
+        assert_eq!(quote_name("R1C1"), "'R1C1'");
+        assert_eq!(quote_name("MySheet"), "MySheet");
+
+        assert_eq!(quote_name("B1048576"), "'B1048576'");
+        assert_eq!(quote_name("B1048577"), "B1048577");
+    }
+}

base/src/expressions/utils/test.rs

@@ -196,6 +196,7 @@ fn test_names() {
     assert!(is_valid_identifier("_."));
     assert!(is_valid_identifier("_1"));
     assert!(is_valid_identifier("\\."));
+    assert!(is_valid_identifier("truñe"));
 
     // invalid
     assert!(!is_valid_identifier("true"));
@@ -209,7 +210,6 @@ fn test_names() {
     assert!(!is_valid_identifier("1true"));
 
     assert!(!is_valid_identifier("test€"));
-    assert!(!is_valid_identifier("truñe"));
     assert!(!is_valid_identifier("tr&ue"));
 
     assert!(!is_valid_identifier("LOG10"));

base/src/formatter/format.rs

@@ -15,7 +15,7 @@ pub struct Formatted {
 
 /// Returns the vector of chars of the fractional part of a *positive* number:
 /// 3.1415926 ==> ['1', '4', '1', '5', '9', '2', '6']
-fn get_fract_part(value: f64, precision: i32) -> Vec<char> {
+fn get_fract_part(value: f64, precision: i32, int_len: usize) -> Vec<char> {
     let b = format!("{:.1$}", value.fract(), precision as usize)
         .chars()
         .collect::<Vec<char>>();
@@ -30,6 +30,12 @@ fn get_fract_part(value: f64, precision: i32) -> Vec<char> {
     if last_non_zero < 2 {
         return vec![];
     }
+    let max_len = if int_len > 15 {
+        2_usize
+    } else {
+        15_usize - int_len + 1
+    };
+    let last_non_zero = usize::min(last_non_zero, max_len + 1);
     b[2..last_non_zero].to_vec()
 }
 
@@ -154,16 +160,11 @@ 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) => {
-                    return Formatted {
-                        text: "#VALUE!".to_owned(),
-                        color: None,
-                        error: Some(e),
-                    }
-                }
-            };
+            let time_fract = value.fract();
+            let hours = (time_fract * 24.0).floor();
+            let minutes = ((time_fract * 24.0 - hours) * 60.0).floor();
+            let seconds = ((((time_fract * 24.0 - hours) * 60.0) - minutes) * 60.0).round();
+            let date = from_excel_date(value as i64).ok();
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
@@ -187,15 +188,44 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     }
                     TextToken::Digit(_) => {}
                     TextToken::Period => {}
-                    TextToken::Day => {
-                        let day = date.day() as usize;
-                        text = format!("{text}{day}");
-                    }
+                    TextToken::Day => match date {
+                        Some(date) => {
+                            let day = date.day() as usize;
+                            text = format!("{text}{day}");
+                        }
+                        None => {
+                            return Formatted {
+                                text: "#VALUE!".to_owned(),
+                                color: None,
+                                error: Some(format!("Invalid date value: '{value}'")),
+                            }
+                        }
+                    },
                     TextToken::DayPadded => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let day = date.day() as usize;
                         text = format!("{text}{day:02}");
                     }
                     TextToken::DayNameShort => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let mut day = date.weekday().number_from_monday() as usize;
                         if day == 7 {
                             day = 0;
@@ -203,6 +233,16 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                         text = format!("{}{}", text, &locale.dates.day_names_short[day]);
                     }
                     TextToken::DayName => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let mut day = date.weekday().number_from_monday() as usize;
                         if day == 7 {
                             day = 0;
@@ -210,32 +250,144 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                         text = format!("{}{}", text, &locale.dates.day_names[day]);
                     }
                     TextToken::Month => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{text}{month}");
                     }
                     TextToken::MonthPadded => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{text}{month:02}");
                     }
                     TextToken::MonthNameShort => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{}{}", text, &locale.dates.months_short[month - 1]);
                     }
                     TextToken::MonthName => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{}{}", text, &locale.dates.months[month - 1]);
                     }
                     TextToken::MonthLetter => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         let months_letter = &locale.dates.months_letter[month - 1];
                         text = format!("{text}{months_letter}");
                     }
                     TextToken::YearShort => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         text = format!("{}{}", text, date.format("%y"));
                     }
                     TextToken::Year => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         text = format!("{}{}", text, date.year());
                     }
+                    TextToken::Hour => {
+                        let mut hour = hours as i32;
+                        if p.use_ampm {
+                            if hour == 0 {
+                                hour = 12;
+                            } else if hour > 12 {
+                                hour -= 12;
+                            }
+                        }
+                        text = format!("{text}{hour}");
+                    }
+                    TextToken::HourPadded => {
+                        let mut hour = hours as i32;
+                        if p.use_ampm {
+                            if hour == 0 {
+                                hour = 12;
+                            } else if hour > 12 {
+                                hour -= 12;
+                            }
+                        }
+                        text = format!("{text}{hour:02}");
+                    }
+                    TextToken::Second => {
+                        let second = seconds as i32;
+                        text = format!("{text}{second}");
+                    }
+                    TextToken::SecondPadded => {
+                        let second = seconds as i32;
+                        text = format!("{text}{second:02}");
+                    }
+                    TextToken::AMPM => {
+                        let ampm = if hours < 12.0 { "AM" } else { "PM" };
+                        text = format!("{text}{ampm}");
+                    }
+                    TextToken::Minute => {
+                        let minute = minutes as i32;
+                        text = format!("{text}{minute}");
+                    }
+                    TextToken::MinutePadded => {
+                        let minute = minutes as i32;
+                        text = format!("{text}{minute:02}");
+                    }
                 }
             }
             Formatted {
@@ -277,7 +429,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             if value_abs as i64 == 0 {
                 int_part = vec![];
             }
-            let fract_part = get_fract_part(value_abs, p.precision);
+            let fract_part = get_fract_part(value_abs, p.precision, int_part.len());
             // ln is the number of digits of the integer part of the value
             let ln = int_part.len() as i32;
             // digit count is the number of digit tokens ('0', '?' and '#') to the left of the decimal point
@@ -422,6 +574,13 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     TextToken::MonthLetter => {}
                     TextToken::YearShort => {}
                     TextToken::Year => {}
+                    TextToken::Hour => {}
+                    TextToken::HourPadded => {}
+                    TextToken::Minute => {}
+                    TextToken::MinutePadded => {}
+                    TextToken::Second => {}
+                    TextToken::SecondPadded => {}
+                    TextToken::AMPM => {}
                 }
             }
             Formatted {
@@ -591,10 +750,10 @@ fn parse_date(value: &str) -> Result<(i32, String), String> {
 /// "30.34%" => (0.3034, "0.00%")
 /// 100€ => (100, "100€")
 pub(crate) fn parse_formatted_number(
-    value: &str,
+    original: &str,
     currencies: &[&str],
 ) -> Result<(f64, Option<String>), String> {
-    let value = value.trim();
+    let value = original.trim();
     let scientific_format = "0.00E+00";
 
     // Check if it is a percentage
@@ -646,7 +805,8 @@ pub(crate) fn parse_formatted_number(
         }
     }
 
-    if let Ok((serial_number, format)) = parse_date(value) {
+    // check if it is a date. NOTE: we don't trim the original here
+    if let Ok((serial_number, format)) = parse_date(original) {
         return Ok((serial_number as f64, Some(format)));
     }
 

base/src/formatter/lexer.rs

@@ -26,19 +26,23 @@ pub enum Token {
     Scientific,    // E+
     ScientificMinus, // E-
     General,       // General
-    // Dates
+    // Dates and time
     Day,            // d
     DayPadded,      // dd
     DayNameShort,   // ddd
     DayName,        // dddd+
-    Month,          // m
-    MonthPadded,    // mm
+    Month,          // m (or minute)
+    MonthPadded,    // mm (or minute padded)
     MonthNameShort, // mmm
     MonthName,      // mmmm or mmmmmm+
     MonthLetter,    // mmmmm
     YearShort,      // y or yy
     Year,           // yyy+
-    // TODO: Hours Minutes and Seconds
+    Hour,           // h
+    HourPadded,     // hh
+    Second,         // s
+    SecondPadded,   // ss
+    AMPM,           // AM/PM (or A/P)
     ILLEGAL,
     EOF,
 }
@@ -361,8 +365,8 @@ impl Lexer {
                         self.read_next_char();
                     }
                     match m {
-                        1 => Token::Month,
-                        2 => Token::MonthPadded,
+                        1 => Token::Month,       // (or minute)
+                        2 => Token::MonthPadded, // (or minute padded)
                         3 => Token::MonthNameShort,
                         4 => Token::MonthName,
                         5 => Token::MonthLetter,
@@ -381,6 +385,63 @@ impl Lexer {
                         Token::Year
                     }
                 }
+                'h' => {
+                    let mut h = 1;
+                    while let Some('h') = self.peek_char() {
+                        h += 1;
+                        self.read_next_char();
+                    }
+                    if h == 1 {
+                        Token::Hour
+                    } else if h == 2 {
+                        Token::HourPadded
+                    } else {
+                        self.set_error("Unexpected character after 'h'");
+                        Token::ILLEGAL
+                    }
+                }
+                's' => {
+                    let mut s = 1;
+                    while let Some('s') = self.peek_char() {
+                        s += 1;
+                        self.read_next_char();
+                    }
+                    if s == 1 {
+                        Token::Second
+                    } else if s == 2 {
+                        Token::SecondPadded
+                    } else {
+                        self.set_error("Unexpected character after 's'");
+                        Token::ILLEGAL
+                    }
+                }
+                'A' | 'a' => {
+                    if let Some('M') | Some('m') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'A'");
+                        return Token::ILLEGAL;
+                    }
+                    if let Some('/') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'AM'");
+                        return Token::ILLEGAL;
+                    }
+                    if let Some('P') | Some('p') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'AM'");
+                        return Token::ILLEGAL;
+                    }
+                    if let Some('M') | Some('m') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'AMP'");
+                        return Token::ILLEGAL;
+                    }
+                    Token::AMPM
+                }
                 'g' | 'G' => {
                     for c in "eneral".chars() {
                         let cc = self.read_next_char();

base/src/formatter/parser.rs

@@ -27,6 +27,13 @@ pub enum TextToken {
     MonthLetter,
     YearShort,
     Year,
+    Hour,
+    HourPadded,
+    Minute,
+    MinutePadded,
+    Second,
+    SecondPadded,
+    AMPM,
 }
 pub struct NumberPart {
     pub color: Option<i32>,
@@ -45,6 +52,7 @@ pub struct NumberPart {
 
 pub struct DatePart {
     pub color: Option<i32>,
+    pub use_ampm: bool,
     pub tokens: Vec<TextToken>,
 }
 
@@ -101,6 +109,7 @@ impl Parser {
         let mut digit_count = 0;
         let mut precision = 0;
         let mut is_date = false;
+        let mut use_ampm = false;
         let mut is_number = false;
         let mut found_decimal_dot = false;
         let mut use_thousands = false;
@@ -116,6 +125,7 @@ impl Parser {
         let mut number = 'i';
         let mut index = 0;
         let mut currency = None;
+        let mut is_time = false;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -200,6 +210,9 @@ impl Parser {
                     index += 1;
                 }
                 Token::Literal(value) => {
+                    if value == ':' {
+                        is_time = true;
+                    }
                     tokens.push(TextToken::Literal(value));
                 }
                 Token::Text(value) => {
@@ -236,12 +249,22 @@ impl Parser {
                     tokens.push(TextToken::MonthName);
                 }
                 Token::Month => {
-                    is_date = true;
-                    tokens.push(TextToken::Month);
+                    if is_time {
+                        // minute
+                        tokens.push(TextToken::Minute);
+                    } else {
+                        is_date = true;
+                        tokens.push(TextToken::Month);
+                    }
                 }
                 Token::MonthPadded => {
-                    is_date = true;
-                    tokens.push(TextToken::MonthPadded);
+                    if is_time {
+                        // minute padded
+                        tokens.push(TextToken::MinutePadded);
+                    } else {
+                        is_date = true;
+                        tokens.push(TextToken::MonthPadded);
+                    }
                 }
                 Token::MonthLetter => {
                     is_date = true;
@@ -255,6 +278,32 @@ impl Parser {
                     is_date = true;
                     tokens.push(TextToken::Year);
                 }
+                Token::Hour => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::Hour);
+                }
+                Token::HourPadded => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::HourPadded);
+                }
+                Token::Second => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::Second);
+                }
+                Token::SecondPadded => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::SecondPadded);
+                }
+
+                Token::AMPM => {
+                    is_date = true;
+                    use_ampm = true;
+                    tokens.push(TextToken::AMPM);
+                }
                 Token::Scientific => {
                     if !is_scientific {
                         index = 0;
@@ -282,7 +331,11 @@ impl Parser {
             if is_number {
                 return ParsePart::Error(ErrorPart {});
             }
-            ParsePart::Date(DatePart { color, tokens })
+            ParsePart::Date(DatePart {
+                color,
+                use_ampm,
+                tokens,
+            })
         } else {
             ParsePart::Number(NumberPart {
                 color,

base/src/formatter/test/mod.rs

@@ -1,2 +1,3 @@
 mod test_general;
 mod test_parse_formatted_number;
+mod test_time;

base/src/formatter/test/test_time.rs

@@ -0,0 +1,32 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    formatter::format::format_number,
+    locale::{get_locale, Locale},
+};
+
+fn get_default_locale() -> &'static Locale {
+    get_locale("en").unwrap()
+}
+
+#[test]
+fn simple_test() {
+    let locale = get_default_locale();
+    let format = "h:mm AM/PM";
+    let value = 16.001_423_611_111_11; // =1/86400 => 12:02 AM
+    let formatted = format_number(value, format, locale);
+    assert_eq!(formatted.text, "12:02 AM");
+}
+
+#[test]
+fn padded_vs_unpadded() {
+    let locale = get_default_locale();
+    let padded_format = "hh:mm:ss AM/PM";
+    let unpadded_format = "h:m:s AM/PM";
+    let value = 0.25351851851851853; // => 6:05:04 AM (21904/(24*60*60)) where 21904 = 6 * 3600 + 5*60 + 4
+    let formatted = format_number(value, padded_format, locale);
+    assert_eq!(formatted.text, "06:05:04 AM");
+
+    let formatted = format_number(value, unpadded_format, locale);
+    assert_eq!(formatted.text, "6:5:4 AM");
+}

base/src/functions/database.rs

@@ -0,0 +1,946 @@
+use chrono::Datelike;
+
+use crate::{
+    calc_result::CalcResult,
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
+    formatter::dates::date_to_serial_number,
+    Model,
+};
+
+use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex};
+
+impl Model {
+    // =DAVERAGE(database, field, criteria)
+    pub(crate) fn fn_daverage(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut sum = 0.0f64;
+        let mut count = 0usize;
+
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        sum += n;
+                        count += 1;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        if count == 0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "No numeric values matched criteria".to_string(),
+            };
+        }
+
+        CalcResult::Number(sum / count as f64)
+    }
+
+    // =DCOUNT(database, field, criteria)
+    // Counts numeric entries in the field for rows that match criteria
+    pub(crate) fn fn_dcount(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut count = 0usize;
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if matches!(v, CalcResult::Number(_)) {
+                    count += 1;
+                }
+            }
+            row += 1;
+        }
+
+        CalcResult::Number(count as f64)
+    }
+
+    // =DGET(database, field, criteria)
+    // Returns the (single) field value for the unique matching row
+    pub(crate) fn fn_dget(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut result: Option<CalcResult> = None;
+        let mut matches = 0usize;
+
+        let mut row = db_left.row + 1;
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                matches += 1;
+                if matches > 1 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "More than one matching record".to_string(),
+                    };
+                }
+                result = Some(self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                }));
+            }
+            row += 1;
+        }
+
+        match (matches, result) {
+            (0, _) | (_, None) => CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No matching record".to_string(),
+            },
+            (_, Some(v)) => v,
+        }
+    }
+
+    // =DMAX(database, field, criteria)
+    pub(crate) fn fn_dmax(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.db_extreme(args, cell, true)
+    }
+
+    // =DMIN(database, field, criteria)
+    pub(crate) fn fn_dmin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.db_extreme(args, cell, false)
+    }
+
+    // =DSUM(database, field, criteria)
+    pub(crate) fn fn_dsum(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut sum = 0.0;
+
+        // skip header
+        let mut row = db_left.row + 1;
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        sum += n;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        CalcResult::Number(sum)
+    }
+
+    // =DCOUNTA(database, field, criteria)
+    // Counts non-empty entries (any type) in the field for rows that match criteria
+    pub(crate) fn fn_dcounta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut count = 0;
+        for row in (db_left.row + 1)..=db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if !matches!(v, CalcResult::EmptyCell | CalcResult::EmptyArg) {
+                    count += 1;
+                }
+            }
+        }
+
+        CalcResult::Number(count as f64)
+    }
+
+    // =DPRODUCT(database, field, criteria)
+    pub(crate) fn fn_dproduct(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut product = 1.0f64;
+        let mut has_numeric = false;
+
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        product *= n;
+                        has_numeric = true;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        // Excel returns 0 when no rows / no numeric values match for DPRODUCT
+        if has_numeric {
+            CalcResult::Number(product)
+        } else {
+            CalcResult::Number(0.0)
+        }
+    }
+
+    // Small internal helper for DSTDEV / DVAR
+    // Collects sum, sum of squares, and count of numeric values in the field
+    // for rows that match the criteria.
+    fn db_numeric_stats(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+    ) -> Result<(f64, f64, usize), CalcResult> {
+        if args.len() != 3 {
+            return Err(CalcResult::new_args_number_error(cell));
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return Err(e),
+        };
+
+        let field_col = self.resolve_db_field_column(db_left, db_right, &args[1], cell)?;
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return Err(e),
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return Err(CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            });
+        }
+
+        let mut sum = 0.0f64;
+        let mut sumsq = 0.0f64;
+        let mut count = 0usize;
+
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        sum += n;
+                        sumsq += n * n;
+                        count += 1;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        Ok((sum, sumsq, count))
+    }
+
+    // =DSTDEV(database, field, criteria)
+    // Sample standard deviation of matching numeric values
+    pub(crate) fn fn_dstdev(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if 0 or 1 numeric values match
+        if count < 2 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Not enough numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / (n - 1.0);
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var.sqrt())
+    }
+
+    // =DVAR(database, field, criteria)
+    // Sample variance of matching numeric values
+    pub(crate) fn fn_dvar(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if 0 or 1 numeric values match
+        if count < 2 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Not enough numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / (n - 1.0);
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var)
+    }
+
+    // =DSTDEVP(database, field, criteria)
+    // Population standard deviation of matching numeric values
+    pub(crate) fn fn_dstdevp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if no numeric values match
+        if count == 0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "No numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / n;
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var.sqrt())
+    }
+
+    // =DVARP(database, field, criteria)
+    // Population variance of matching numeric values
+    pub(crate) fn fn_dvarp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if no numeric values match
+        if count == 0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "No numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / n;
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var)
+    }
+
+    /// Resolve the "field" (2nd arg) to an absolute column index (i32) within the sheet.
+    /// Field can be a number (1-based index) or a header name (case-insensitive).
+    /// Returns the absolute column index, not a 1-based offset within the database range.
+    fn resolve_db_field_column(
+        &mut self,
+        db_left: CellReferenceIndex,
+        db_right: CellReferenceIndex,
+        field_arg: &Node,
+        cell: CellReferenceIndex,
+    ) -> Result<i32, CalcResult> {
+        let field_column_name = match self.evaluate_node_in_context(field_arg, cell) {
+            CalcResult::String(s) => s.to_lowercase(),
+            CalcResult::Number(index) => {
+                let index = index.floor() as i32;
+                if index < 1 || db_left.column + index - 1 > db_right.column {
+                    return Err(CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Field index out of range".to_string(),
+                    });
+                }
+                return Ok(db_left.column + index - 1);
+            }
+            CalcResult::Boolean(b) => {
+                return if b {
+                    Ok(db_left.column)
+                } else {
+                    // Index 0 is out of range
+                    Err(CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Invalid field specifier".to_string(),
+                    })
+                };
+            }
+            error @ CalcResult::Error { .. } => {
+                return Err(error);
+            }
+            CalcResult::Range { .. } => {
+                return Err(CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                })
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return Err(CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                })
+            }
+        };
+
+        // We search in the database a column whose header matches field_column_name
+        for column in db_left.column..=db_right.column {
+            let v = self.evaluate_cell(CellReferenceIndex {
+                sheet: db_left.sheet,
+                row: db_left.row,
+                column,
+            });
+            match &v {
+                CalcResult::String(s) => {
+                    if s.to_lowercase() == field_column_name {
+                        return Ok(column);
+                    }
+                }
+                CalcResult::Number(n) => {
+                    if field_column_name == n.to_string() {
+                        return Ok(column);
+                    }
+                }
+                CalcResult::Boolean(b) => {
+                    if field_column_name == b.to_string() {
+                        return Ok(column);
+                    }
+                }
+                CalcResult::Error { .. }
+                | CalcResult::Range { .. }
+                | CalcResult::EmptyCell
+                | CalcResult::EmptyArg
+                | CalcResult::Array(_) => {}
+            }
+        }
+
+        Err(CalcResult::Error {
+            error: Error::VALUE,
+            origin: cell,
+            message: "Field header not found".to_string(),
+        })
+    }
+
+    /// Check whether a database row matches the criteria range.
+    /// Criteria logic: OR across criteria rows; AND across columns within a row.
+    fn db_row_matches_criteria(
+        &mut self,
+        db_left: CellReferenceIndex,
+        db_right: CellReferenceIndex,
+        row: i32,
+        criteria: (CellReferenceIndex, CellReferenceIndex),
+    ) -> bool {
+        let (c_left, c_right) = criteria;
+
+        // Read criteria headers (first row of criteria range)
+        // Map header name (lowercased) -> db column (if exists)
+        let mut crit_cols: Vec<i32> = Vec::new();
+        let mut header_count = 0;
+        // We cover the criteria table:
+        //  headerA | headerB | ...
+        //  critA1  | critA2  | ...
+        //  critB1  | critB2  | ...
+        //  ...
+        for column in c_left.column..=c_right.column {
+            let cell = CellReferenceIndex {
+                sheet: c_left.sheet,
+                row: c_left.row,
+                column,
+            };
+            let criteria_header = self.evaluate_cell(cell);
+            if let Ok(s) = self.cast_to_string(criteria_header, cell) {
+                // Non-empty string header. If the header is non string we skip it
+                header_count += 1;
+                let wanted = s.to_lowercase();
+
+                // Find corresponding Database column
+                let mut found = false;
+                for db_column in db_left.column..=db_right.column {
+                    let db_header = self.evaluate_cell(CellReferenceIndex {
+                        sheet: db_left.sheet,
+                        row: db_left.row,
+                        column: db_column,
+                    });
+                    if let Ok(hs) = self.cast_to_string(db_header, cell) {
+                        if hs.to_lowercase() == wanted {
+                            crit_cols.push(db_column);
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+                if !found {
+                    // that means the criteria column has no matching DB column
+                    // If the criteria condition is empty then we remove this condition
+                    // otherwise this condition can never be satisfied
+                    // We evaluate all criteria rows to see if any is non-empty
+                    let mut has_non_empty = false;
+                    for r in (c_left.row + 1)..=c_right.row {
+                        let ccell = self.evaluate_cell(CellReferenceIndex {
+                            sheet: c_left.sheet,
+                            row: r,
+                            column,
+                        });
+                        if !matches!(ccell, CalcResult::EmptyCell | CalcResult::EmptyArg) {
+                            has_non_empty = true;
+                            break;
+                        }
+                    }
+                    if has_non_empty {
+                        // This criteria column can never be satisfied
+                        header_count -= 1;
+                    }
+                }
+            };
+        }
+
+        if c_right.row <= c_left.row {
+            // If no criteria rows (only headers), everything matches
+            return true;
+        }
+
+        if header_count == 0 {
+            // If there are not "String" headers, nothing matches
+            // NB: There might be String headers that do not match any DB columns,
+            // in that case everything matches.
+            return false;
+        }
+
+        // Evaluate each criteria row (OR)
+        for r in (c_left.row + 1)..=c_right.row {
+            // AND across columns for this criteria row
+            let mut and_ok = true;
+
+            for (offset, db_col) in crit_cols.iter().enumerate() {
+                // Criteria cell
+                let ccell = self.evaluate_cell(CellReferenceIndex {
+                    sheet: c_left.sheet,
+                    row: r,
+                    column: c_left.column + offset as i32,
+                });
+
+                // Empty criteria cell -> ignored
+                if matches!(ccell, CalcResult::EmptyCell | CalcResult::EmptyArg) {
+                    continue;
+                }
+
+                // Database value for this row/column
+                let db_val = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: *db_col,
+                });
+
+                if !self.criteria_cell_matches(&db_val, &ccell) {
+                    and_ok = false;
+                    break;
+                }
+            }
+
+            if and_ok {
+                // This criteria row satisfied (OR)
+                return true;
+            }
+        }
+
+        // none matched
+        false
+    }
+
+    /// Implements Excel-like criteria matching for a single value.
+    /// Supports prefixes: <>, >=, <=, >, <, = ; wildcards * and ? for string equals.
+    fn criteria_cell_matches(&self, db_val: &CalcResult, crit_cell: &CalcResult) -> bool {
+        // Convert the criteria cell to a string for operator parsing if possible,
+        // otherwise fall back to equality via compare_values.
+
+        let mut criteria = match crit_cell {
+            CalcResult::String(s) => s.trim().to_string(),
+            CalcResult::Number(n) => {
+                // treat as equality with number
+                return match db_val {
+                    CalcResult::Number(v) => (*v - *n).abs() <= f64::EPSILON,
+                    _ => false,
+                };
+            }
+            CalcResult::Boolean(b) => {
+                // check equality with boolean
+                return match db_val {
+                    CalcResult::Boolean(v) => *v == *b,
+                    _ => false,
+                };
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Error { .. } => return false,
+            CalcResult::Range { .. } | CalcResult::Array(_) => return false,
+        };
+
+        // Detect operator prefix
+        let mut op = "="; // default equality (with wildcard semantics for strings)
+        let prefixes = ["<>", ">=", "<=", ">", "<", "="];
+        for p in prefixes.iter() {
+            if criteria.starts_with(p) {
+                op = p;
+                criteria = criteria[p.len()..].trim().to_string();
+                break;
+            }
+        }
+
+        // Is it a number?
+        let rhs_num = criteria.parse::<f64>().ok();
+
+        // Is it a date?
+        // FIXME: We should parse dates according to locale settings
+        let rhs_date = criteria.parse::<chrono::NaiveDate>().ok();
+
+        match op {
+            ">" | ">=" | "<" | "<=" => {
+                if let Some(d) = rhs_date {
+                    // date comparison
+                    let serial = match date_to_serial_number(d.day(), d.month(), d.year()) {
+                        Ok(sn) => sn as f64,
+                        Err(_) => return false,
+                    };
+
+                    if let CalcResult::Number(n) = db_val {
+                        match op {
+                            ">" => *n > serial,
+                            ">=" => *n >= serial,
+                            "<" => *n < serial,
+                            "<=" => *n <= serial,
+                            _ => false,
+                        }
+                    } else {
+                        false
+                    }
+                } else if let Some(t) = rhs_num {
+                    // numeric comparison
+                    if let CalcResult::Number(n) = db_val {
+                        match op {
+                            ">" => *n > t,
+                            ">=" => *n >= t,
+                            "<" => *n < t,
+                            "<=" => *n <= t,
+                            _ => false,
+                        }
+                    } else {
+                        false
+                    }
+                } else {
+                    // string comparison (case-insensitive) using compare_values semantics
+                    let rhs = CalcResult::String(criteria.to_lowercase());
+                    let lhs = match db_val {
+                        CalcResult::String(s) => CalcResult::String(s.to_lowercase()),
+                        x => x.clone(),
+                    };
+                    let c = compare_values(&lhs, &rhs);
+                    match op {
+                        ">" => c > 0,
+                        ">=" => c >= 0,
+                        "<" => c < 0,
+                        "<=" => c <= 0,
+                        _ => false,
+                    }
+                }
+            }
+            "<>" => {
+                // not equal (with wildcard semantics for strings)
+                // If rhs has wildcards and db_val is string, do regex; else use compare_values != 0
+                if let CalcResult::String(s) = db_val {
+                    if criteria.contains('*') || criteria.contains('?') {
+                        if let Ok(re) = from_wildcard_to_regex(&criteria.to_lowercase(), true) {
+                            return !result_matches_regex(
+                                &CalcResult::String(s.to_lowercase()),
+                                &re,
+                            );
+                        }
+                    }
+                }
+                let rhs = if let Some(n) = rhs_num {
+                    CalcResult::Number(n)
+                } else {
+                    CalcResult::String(criteria.to_lowercase())
+                };
+                let lhs = match db_val {
+                    CalcResult::String(s) => CalcResult::String(s.to_lowercase()),
+                    x => x.clone(),
+                };
+                compare_values(&lhs, &rhs) != 0
+            }
+            _ => {
+                // equality. For strings, support wildcards (*, ?)
+                if let Some(n) = rhs_num {
+                    // numeric equals
+                    if let CalcResult::Number(m) = db_val {
+                        (*m - n).abs() <= f64::EPSILON
+                    } else {
+                        compare_values(db_val, &CalcResult::Number(n)) == 0
+                    }
+                } else {
+                    // textual/boolean equals (case-insensitive), wildcard-enabled for strings
+                    if let CalcResult::String(s) = db_val {
+                        if criteria.contains('*') || criteria.contains('?') {
+                            if let Ok(re) = from_wildcard_to_regex(&criteria.to_lowercase(), true) {
+                                return result_matches_regex(
+                                    &CalcResult::String(s.to_lowercase()),
+                                    &re,
+                                );
+                            }
+                        }
+                        // This is weird but we only need to check if "starts with" for equality
+                        return s.to_lowercase().starts_with(&criteria.to_lowercase());
+                    }
+                    // Fallback: compare_values equality
+                    compare_values(db_val, &CalcResult::String(criteria.to_lowercase())) == 0
+                }
+            }
+        }
+    }
+
+    /// Shared implementation for DMAX/DMIN
+    fn db_extreme(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+        want_max: bool,
+    ) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut best: Option<f64> = None;
+
+        let mut row = db_left.row + 1;
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(value) = v {
+                    if value.is_finite() {
+                        best = Some(match best {
+                            None => value,
+                            Some(cur) => {
+                                if want_max {
+                                    value.max(cur)
+                                } else {
+                                    value.min(cur)
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        match best {
+            Some(v) => CalcResult::Number(v),
+            None => CalcResult::Number(0.0),
+        }
+    }
+}

base/src/functions/date_and_time.rs

@@ -8,6 +8,26 @@ use chrono::Timelike;
 const SECONDS_PER_DAY: i32 = 86_400;
 const SECONDS_PER_DAY_F64: f64 = SECONDS_PER_DAY as f64;
 
+fn is_leap_year(year: i32) -> bool {
+    (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)
+}
+
+fn is_feb_29_between_dates(start: chrono::NaiveDate, end: chrono::NaiveDate) -> bool {
+    let start_year = start.year();
+    let end_year = end.year();
+
+    for year in start_year..=end_year {
+        if is_leap_year(year)
+            && (year < end_year
+                || (year == end_year && end.month() > 2)
+                    && (year > start_year || (year == start_year && start.month() <= 2)))
+        {
+            return true;
+        }
+    }
+    false
+}
+
 // ---------------------------------------------------------------------------
 // Helper macros to eliminate boilerplate in date/time component extraction
 // functions (DAY, MONTH, YEAR, HOUR, MINUTE, SECOND).
@@ -1567,18 +1587,44 @@ impl Model {
                 }
             }
             1 => {
-                let year_days = if start_date.year() == end_date.year() {
-                    if (start_date.year() % 4 == 0 && start_date.year() % 100 != 0)
-                        || start_date.year() % 400 == 0
-                    {
-                        366.0
-                    } else {
-                        365.0
+                // Procedure E
+
+                let start_year = start_date.year();
+                let end_year = end_date.year();
+
+                let step_a = start_year != end_year;
+                let step_b = start_year + 1 != end_year;
+                let step_c = start_date.month() < end_date.month();
+                let step_d = start_date.month() == end_date.month();
+                let step_e = start_date.day() <= end_date.day();
+                let step_f = step_a && (step_b || step_c || (step_d && step_e));
+                if step_f {
+                    // 7.
+                    // return average of days in year between start_year and end_year, inclusive
+                    let mut total_days = 0;
+                    for year in start_year..=end_year {
+                        if is_leap_year(year) {
+                            total_days += 366;
+                        } else {
+                            total_days += 365;
+                        }
                     }
+                    days / (total_days as f64 / (end_year - start_year + 1) as f64)
+                } else if step_a && is_leap_year(start_year) {
+                    // 8.
+                    days / 366.0
+                } else if is_feb_29_between_dates(start_date, end_date) {
+                    // 9. If a February 29 occurs between date1 and date2 then return 366
+                    days / 366.0
+                } else if end_date.month() == 2 && end_date.day() == 29 {
+                    // 10. If date2 is February 29 then return 366
+                    days / 366.0
+                } else if !step_a && is_leap_year(start_year) {
+                    days / 366.0
                 } else {
-                    365.0
-                };
-                days / year_days
+                    // 11.
+                    days / 365.0
+                }
             }
             2 => days / 360.0,
             3 => days / 365.0,
@@ -1595,6 +1641,34 @@ impl Model {
             }
             _ => return CalcResult::new_error(Error::NUM, cell, "Invalid basis".to_string()),
         };
-        CalcResult::Number(result)
+        CalcResult::Number(result.abs())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+    use super::*;
+
+    #[test]
+    fn test_is_leap_year() {
+        assert!(is_leap_year(2000));
+        assert!(!is_leap_year(1900));
+        assert!(is_leap_year(2004));
+        assert!(!is_leap_year(2001));
+    }
+
+    #[test]
+    fn test_is_feb_29_between_dates() {
+        let d1 = chrono::NaiveDate::from_ymd_opt(2020, 2, 28).unwrap();
+        let d2 = chrono::NaiveDate::from_ymd_opt(2020, 3, 1).unwrap();
+        assert!(is_feb_29_between_dates(d1, d2));
+    }
+
+    #[test]
+    fn test_is_feb_29_between_dates_false() {
+        let d1 = chrono::NaiveDate::from_ymd_opt(2021, 2, 28).unwrap();
+        let d2 = chrono::NaiveDate::from_ymd_opt(2021, 3, 1).unwrap();
+        assert!(!is_feb_29_between_dates(d1, d2));
     }
 }

base/src/functions/engineering/bessel.rs

@@ -1,10 +1,12 @@
+use statrs::function::erf::{erf, erfc};
+
 use crate::{
     calc_result::CalcResult,
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     model::Model,
 };
 
-use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y, erf};
+use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y};
 // https://root.cern/doc/v610/TMath_8cxx_source.html
 
 // Notice that the parameters for Bessel functions in Excel and here have inverted order
@@ -160,7 +162,7 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(1.0 - erf(x))
+        CalcResult::Number(erfc(x))
     }
 
     pub(crate) fn fn_erfcprecise(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -171,6 +173,6 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(1.0 - erf(x))
+        CalcResult::Number(erfc(x))
     }
 }

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

@@ -1,53 +0,0 @@
-pub(crate) fn erf(x: f64) -> f64 {
-    let cof = vec![
-        -1.3026537197817094,
-        6.419_697_923_564_902e-1,
-        1.9476473204185836e-2,
-        -9.561_514_786_808_63e-3,
-        -9.46595344482036e-4,
-        3.66839497852761e-4,
-        4.2523324806907e-5,
-        -2.0278578112534e-5,
-        -1.624290004647e-6,
-        1.303655835580e-6,
-        1.5626441722e-8,
-        -8.5238095915e-8,
-        6.529054439e-9,
-        5.059343495e-9,
-        -9.91364156e-10,
-        -2.27365122e-10,
-        9.6467911e-11,
-        2.394038e-12,
-        -6.886027e-12,
-        8.94487e-13,
-        3.13092e-13,
-        -1.12708e-13,
-        3.81e-16,
-        7.106e-15,
-        -1.523e-15,
-        -9.4e-17,
-        1.21e-16,
-        -2.8e-17,
-    ];
-
-    let mut d = 0.0;
-    let mut dd = 0.0;
-
-    let x_abs = x.abs();
-
-    let t = 2.0 / (2.0 + x_abs);
-    let ty = 4.0 * t - 2.0;
-
-    for j in (1..=cof.len() - 1).rev() {
-        let tmp = d;
-        d = ty * d - dd + cof[j];
-        dd = tmp;
-    }
-
-    let res = t * f64::exp(-x_abs * x_abs + 0.5 * (cof[0] + ty * d) - dd);
-    if x < 0.0 {
-        res - 1.0
-    } else {
-        1.0 - res
-    }
-}

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

@@ -4,7 +4,6 @@ mod bessel_j1_y1;
 mod bessel_jn_yn;
 mod bessel_k;
 mod bessel_util;
-mod erf;
 
 #[cfg(test)]
 mod test_bessel;
@@ -13,4 +12,3 @@ pub(crate) use bessel_i::bessel_i;
 pub(crate) use bessel_jn_yn::jn as bessel_j;
 pub(crate) use bessel_jn_yn::yn as bessel_y;
 pub(crate) use bessel_k::bessel_k;
-pub(crate) use erf::erf;

base/src/functions/information.rs

@@ -1,6 +1,6 @@
 use crate::{
     calc_result::CalcResult,
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex, utils::number_to_column},
     model::{Model, ParsedDefinedName},
 };
 
@@ -320,4 +320,150 @@ impl Model {
             message: "Invalid name".to_string(),
         }
     }
+
+    pub(crate) fn fn_n(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let arg_count = args.len();
+        if arg_count != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.evaluate_node_in_context(&args[0], cell) {
+            CalcResult::Number(n) => n,
+            CalcResult::String(_) => 0.0,
+            CalcResult::Boolean(f) => {
+                if f {
+                    1.0
+                } else {
+                    0.0
+                }
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
+            error @ CalcResult::Error { .. } => return error,
+            CalcResult::Range { .. } => {
+                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::Number(value)
+    }
+
+    pub(crate) fn fn_sheets(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let arg_count = args.len();
+        if arg_count > 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        if arg_count == 1 {
+            return CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Sheets function with an argument is not implemented".to_string(),
+            };
+        }
+        let sheet_count = self.workbook.worksheets.len() as f64;
+        CalcResult::Number(sheet_count)
+    }
+
+    pub(crate) fn fn_cell(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let arg_count = args.len();
+        if arg_count == 0 || arg_count > 2 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let reference = if arg_count == 2 {
+            match self.evaluate_node_with_reference(&args[1], cell) {
+                CalcResult::Range { left, right: _ } => {
+                    // we just take the left cell of the range
+                    left
+                }
+                _ => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Argument must be a reference".to_string(),
+                    }
+                }
+            }
+        } else {
+            CellReferenceIndex {
+                sheet: cell.sheet,
+                row: cell.row,
+                column: cell.column,
+            }
+        };
+        let info_type = match self.get_string(&args[0], cell) {
+            Ok(s) => s.to_uppercase(),
+            Err(e) => return e,
+        };
+        match info_type.as_str() {
+            "ADDRESS" => {
+                if reference.sheet != cell.sheet {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "References to other sheets not implemented".to_string(),
+                    };
+                }
+                let column = match number_to_column(reference.column) {
+                    Some(c) => c,
+                    None => {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Invalid column".to_string(),
+                        }
+                    }
+                };
+                let address = format!("${}${}", column, reference.row);
+                CalcResult::String(address)
+            }
+            "COL" => CalcResult::Number(reference.column as f64),
+            "COLOR" | "FILENAME" | "FORMAT" | "PARENTHESES" | "PREFIX" | "PROTECT" | "WIDTH" => {
+                CalcResult::Error {
+                    error: Error::VALUE,
+                    origin: cell,
+                    message: "info_type not implemented".to_string(),
+                }
+            }
+            "CONTENTS" => self.evaluate_cell(reference),
+            "ROW" => CalcResult::Number(reference.row as f64),
+            "TYPE" => {
+                let cell_type = match self.evaluate_cell(reference) {
+                    CalcResult::EmptyCell => "b",
+                    CalcResult::String(_) => "l",
+                    CalcResult::Number(_) => "v",
+                    CalcResult::Boolean(_) => "v",
+                    CalcResult::Error { .. } => "v",
+                    CalcResult::Range { .. } => "v",
+                    CalcResult::EmptyArg => "v",
+                    CalcResult::Array(_) => "v",
+                };
+                CalcResult::String(cell_type.to_string())
+            }
+            _ => CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "Invalid info_type".to_string(),
+            },
+        }
+    }
+
+    pub(crate) fn fn_info(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() || args.len() > 2 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        CalcResult::Error {
+            error: Error::NIMPL,
+            origin: cell,
+            message: "Info function not implemented".to_string(),
+        }
+    }
 }

base/src/functions/macros.rs

@@ -68,14 +68,14 @@ macro_rules! single_number_fn {
                                 },
                                 // If String, parse to f64 then apply or #VALUE! error
                                 ArrayNode::String(s) => {
-                                    let node = match s.parse::<f64>() {
-                                        Ok(f) => match $op(f) {
+                                    let node = match self.cast_number(&s) {
+                                        Some(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),
+                                        None => ArrayNode::Error(Error::VALUE),
                                     };
                                     data_row.push(node);
                                 }

base/src/functions/math_util.rs

@@ -0,0 +1,200 @@
+/// Parse Roman (classic or Excel variants) → number
+pub fn from_roman(s: &str) -> Result<u32, String> {
+    if s.is_empty() {
+        return Err("empty numeral".into());
+    }
+    fn val(c: char) -> Option<u32> {
+        Some(match c {
+            'I' => 1,
+            'V' => 5,
+            'X' => 10,
+            'L' => 50,
+            'C' => 100,
+            'D' => 500,
+            'M' => 1000,
+            _ => return None,
+        })
+    }
+
+    // Accept the union of subtractive pairs used by the tables above (Excel-compatible).
+    fn allowed_subtractive(a: char, b: char) -> bool {
+        matches!(
+            (a, b),
+            // classic:
+            ('I','V')|('I','X')|('X','L')|('X','C')|('C','D')|('C','M')
+            // Excel forms:
+            |('V','L')|('L','D')|('L','M') // VL, LD, LM
+            |('X','D')|('X','M')          // XD, XM
+            |('V','M')                    // VM
+            |('I','L')|('I','C')|('I','D')|('I','M') // IL, IC, ID, IM
+            |('V','D')|('V','C') // VD, VC
+        )
+    }
+
+    let chars: Vec<char> = s.chars().map(|c| c.to_ascii_uppercase()).collect();
+    let mut total = 0u32;
+    let mut i = 0usize;
+
+    // Repetition rules similar to classic Romans:
+    // V, L, D cannot repeat; I, X, C, M max 3 in a row.
+    let mut last_char: Option<char> = None;
+    let mut run_len = 0usize;
+
+    while i < chars.len() {
+        let c = chars[i];
+        let v = val(c).ok_or_else(|| format!("invalid character '{c}'"))?;
+
+        if Some(c) == last_char {
+            run_len += 1;
+            match c {
+                'V' | 'L' | 'D' => return Err(format!("invalid repetition of '{c}'")),
+                _ if run_len >= 3 => return Err(format!("invalid repetition of '{c}'")),
+                _ => {}
+            }
+        } else {
+            last_char = Some(c);
+            run_len = 0;
+        }
+
+        if i + 1 < chars.len() {
+            let c2 = chars[i + 1];
+            let v2 = val(c2).ok_or_else(|| format!("invalid character '{c2}'"))?;
+            if v < v2 {
+                if !allowed_subtractive(c, c2) {
+                    return Err(format!("invalid subtractive pair '{c}{c2}'"));
+                }
+                // Disallow stacked subtractives like IIV, XXL:
+                if run_len > 0 {
+                    return Err(format!("malformed numeral near position {i}"));
+                }
+                total += v2 - v;
+                i += 2;
+                last_char = None;
+                run_len = 0;
+                continue;
+            }
+        }
+
+        total += v;
+        i += 1;
+    }
+    Ok(total)
+}
+
+/// Classic Roman (strict) encoder used as a base for all forms.
+fn to_roman(mut n: u32) -> Result<String, String> {
+    if !(1..=3999).contains(&n) {
+        return Err("value out of range (must be 1..=3999)".into());
+    }
+
+    const MAP: &[(u32, &str)] = &[
+        (1000, "M"),
+        (900, "CM"),
+        (500, "D"),
+        (400, "CD"),
+        (100, "C"),
+        (90, "XC"),
+        (50, "L"),
+        (40, "XL"),
+        (10, "X"),
+        (9, "IX"),
+        (5, "V"),
+        (4, "IV"),
+        (1, "I"),
+    ];
+
+    let mut out = String::with_capacity(15);
+    for &(val, sym) in MAP {
+        while n >= val {
+            out.push_str(sym);
+            n -= val;
+        }
+        if n == 0 {
+            break;
+        }
+    }
+    Ok(out)
+}
+
+/// Excel/Google Sheets compatible ROMAN(number, [form]) encoder.
+/// `form`: 0..=4 (0=Classic, 4=Simplified).
+pub fn to_roman_with_form(n: u32, form: i32) -> Result<String, String> {
+    let mut s = to_roman(n)?;
+    if form == 0 {
+        return Ok(s);
+    }
+    if !(0..=4).contains(&form) {
+        return Err("form must be between 0 and 4".into());
+    }
+
+    // Base rules (apply for all f >= 1)
+    let base_rules: &[(&str, &str)] = &[
+        // C(D|M)XC -> L$1XL
+        ("CDXC", "LDXL"),
+        ("CMXC", "LMXL"),
+        // C(D|M)L -> L$1
+        ("CDL", "LD"),
+        ("CML", "LM"),
+        // X(L|C)IX -> V$1IV
+        ("XLIX", "VLIV"),
+        ("XCIX", "VCIV"),
+        // X(L|C)V -> V$1
+        ("XLV", "VL"),
+        ("XCV", "VC"),
+    ];
+
+    // Level 2 extra rules
+    let lvl2_rules: &[(&str, &str)] = &[
+        // V(L|C)IV -> I$1
+        ("VLIV", "IL"),
+        ("VCIV", "IC"),
+        // L(D|M)XL -> X$1
+        ("LDXL", "XD"),
+        ("LMXL", "XM"),
+        // L(D|M)VL -> X$1V
+        ("LDVL", "XDV"),
+        ("LMVL", "XMV"),
+        // L(D|M)IL -> X$1IX
+        ("LDIL", "XDIX"),
+        ("LMIL", "XMIX"),
+    ];
+
+    // Level 3 extra rules
+    let lvl3_rules: &[(&str, &str)] = &[
+        // X(D|M)V -> V$1
+        ("XDV", "VD"),
+        ("XMV", "VM"),
+        // X(D|M)IX -> V$1IV
+        ("XDIX", "VDIV"),
+        ("XMIX", "VMIV"),
+    ];
+
+    // Level 4 extra rules
+    let lvl4_rules: &[(&str, &str)] = &[
+        // V(D|M)IV -> I$1
+        ("VDIV", "ID"),
+        ("VMIV", "IM"),
+    ];
+
+    // Helper to apply a batch of (from -> to) globally, in order.
+    fn apply_rules(mut t: String, rules: &[(&str, &str)]) -> String {
+        for (from, to) in rules {
+            if t.contains(from) {
+                t = t.replace(from, to);
+            }
+        }
+        t
+    }
+
+    s = apply_rules(s, base_rules);
+    if form >= 2 {
+        s = apply_rules(s, lvl2_rules);
+    }
+    if form >= 3 {
+        s = apply_rules(s, lvl3_rules);
+    }
+    if form >= 4 {
+        s = apply_rules(s, lvl4_rules);
+    }
+    Ok(s)
+}

base/src/functions/mod.rs

@@ -8,6 +8,7 @@ use crate::{
 };
 
 pub(crate) mod binary_search;
+mod database;
 mod date_and_time;
 mod engineering;
 mod financial;
@@ -16,6 +17,7 @@ mod information;
 mod logical;
 mod lookup_and_reference;
 mod macros;
+mod math_util;
 mod mathematical;
 mod statistical;
 mod subtotal;
@@ -76,6 +78,43 @@ pub enum Function {
     Sumifs,
     Tan,
     Tanh,
+    Acot,
+    Acoth,
+    Cot,
+    Coth,
+    Csc,
+    Csch,
+    Sec,
+    Sech,
+    Exp,
+    Fact,
+    Factdouble,
+    Sign,
+    Radians,
+    Degrees,
+    Int,
+    Even,
+    Odd,
+    Ceiling,
+    CeilingMath,
+    CeilingPrecise,
+    Floor,
+    FloorMath,
+    FloorPrecise,
+    IsoCeiling,
+    Mod,
+    Quotient,
+    Mround,
+    Trunc,
+    Gcd,
+    Lcm,
+    Base,
+    Decimal,
+    Roman,
+    Arabic,
+    Combin,
+    Combina,
+    Sumsq,
 
     // Information
     ErrorType,
@@ -96,6 +135,11 @@ pub enum Function {
     Sheet,
     Type,
 
+    Sheets,
+    N,
+    Cell,
+    Info,
+
     // Lookup and reference
     Hlookup,
     Index,
@@ -267,10 +311,24 @@ pub enum Function {
     Delta,
     Gestep,
     Subtotal,
+
+    // Database
+    Daverage,
+    Dcount,
+    Dget,
+    Dmax,
+    Dmin,
+    Dsum,
+    Dcounta,
+    Dproduct,
+    Dstdev,
+    Dvar,
+    Dvarp,
+    Dstdevp,
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 215> {
+    pub fn into_iter() -> IntoIter<Function, 268> {
         [
             Function::And,
             Function::False,
@@ -303,12 +361,44 @@ impl Function {
             Function::Sqrt,
             Function::Sqrtpi,
             Function::Atan2,
+            Function::Acot,
+            Function::Acoth,
+            Function::Cot,
+            Function::Coth,
+            Function::Csc,
+            Function::Csch,
+            Function::Sec,
+            Function::Sech,
             Function::Power,
+            Function::Exp,
+            Function::Fact,
+            Function::Factdouble,
+            Function::Sign,
+            Function::Int,
+            Function::Even,
+            Function::Odd,
+            Function::Ceiling,
+            Function::CeilingMath,
+            Function::CeilingPrecise,
+            Function::Floor,
+            Function::FloorMath,
+            Function::FloorPrecise,
+            Function::IsoCeiling,
+            Function::Mod,
+            Function::Quotient,
+            Function::Mround,
+            Function::Trunc,
+            Function::Gcd,
+            Function::Lcm,
+            Function::Base,
+            Function::Decimal,
             Function::Max,
             Function::Min,
             Function::Product,
             Function::Rand,
             Function::Randbetween,
+            Function::Radians,
+            Function::Degrees,
             Function::Round,
             Function::Rounddown,
             Function::Roundup,
@@ -487,6 +577,27 @@ impl Function {
             Function::Delta,
             Function::Gestep,
             Function::Subtotal,
+            Function::Roman,
+            Function::Arabic,
+            Function::Combin,
+            Function::Combina,
+            Function::Sumsq,
+            Function::N,
+            Function::Cell,
+            Function::Info,
+            Function::Sheets,
+            Function::Daverage,
+            Function::Dcount,
+            Function::Dget,
+            Function::Dmax,
+            Function::Dmin,
+            Function::Dsum,
+            Function::Dcounta,
+            Function::Dproduct,
+            Function::Dstdev,
+            Function::Dvar,
+            Function::Dvarp,
+            Function::Dstdevp,
         ]
         .into_iter()
     }
@@ -529,6 +640,26 @@ impl Function {
             Function::Sheet => "_xlfn.SHEET".to_string(),
             Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
             Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
+            Function::Ceiling => "_xlfn.CEILING".to_string(),
+            Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
+            Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
+            Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
+            Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
+            Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
+            Function::Base => "_xlfn.BASE".to_string(),
+            Function::Decimal => "_xlfn.DECIMAL".to_string(),
+            Function::Arabic => "_xlfn.ARABIC".to_string(),
+            Function::Combina => "_xlfn.COMBINA".to_string(),
+            Function::Sheets => "_xlfn.SHEETS".to_string(),
+            Function::Acoth => "_xlfn.ACOTH".to_string(),
+            Function::Cot => "_xlfn.COT".to_string(),
+            Function::Coth => "_xlfn.COTH".to_string(),
+            Function::Csc => "_xlfn.CSC".to_string(),
+            Function::Csch => "_xlfn.CSCH".to_string(),
+            Function::Sec => "_xlfn.SEC".to_string(),
+            Function::Sech => "_xlfn.SECH".to_string(),
+            Function::Acot => "_xlfn.ACOT".to_string(),
+
             _ => self.to_string(),
         }
     }
@@ -551,34 +682,61 @@ impl Function {
             "SWITCH" | "_XLFN.SWITCH" => Some(Function::Switch),
             "TRUE" => Some(Function::True),
             "XOR" | "_XLFN.XOR" => Some(Function::Xor),
-
             "SIN" => Some(Function::Sin),
             "COS" => Some(Function::Cos),
             "TAN" => Some(Function::Tan),
-
             "ASIN" => Some(Function::Asin),
             "ACOS" => Some(Function::Acos),
             "ATAN" => Some(Function::Atan),
-
             "SINH" => Some(Function::Sinh),
             "COSH" => Some(Function::Cosh),
             "TANH" => Some(Function::Tanh),
-
             "ASINH" => Some(Function::Asinh),
             "ACOSH" => Some(Function::Acosh),
             "ATANH" => Some(Function::Atanh),
-
+            "ACOT" | "_XLFN.ACOT" => Some(Function::Acot),
+            "COTH" | "_XLFN.COTH" => Some(Function::Coth),
+            "COT" | "_XLFN.COT" => Some(Function::Cot),
+            "CSC" | "_XLFN.CSC" => Some(Function::Csc),
+            "CSCH" | "_XLFN.CSCH" => Some(Function::Csch),
+            "SEC" | "_XLFN.SEC" => Some(Function::Sec),
+            "SECH" | "_XLFN.SECH" => Some(Function::Sech),
+            "ACOTH" | "_XLFN.ACOTH" => Some(Function::Acoth),
+            "FACT" => Some(Function::Fact),
+            "FACTDOUBLE" => Some(Function::Factdouble),
+            "EXP" => Some(Function::Exp),
+            "SIGN" => Some(Function::Sign),
+            "RADIANS" => Some(Function::Radians),
+            "DEGREES" => Some(Function::Degrees),
+            "INT" => Some(Function::Int),
+            "EVEN" => Some(Function::Even),
+            "ODD" => Some(Function::Odd),
+            "CEILING" | "_XLFN.CEILING" => Some(Function::Ceiling),
+            "CEILING.MATH" | "_XLFN.CEILING.MATH" => Some(Function::CeilingMath),
+            "CEILING.PRECISE" | "_XLFN.CEILING.PRECISE" => Some(Function::CeilingPrecise),
+            "FLOOR" => Some(Function::Floor),
+            "FLOOR.MATH" | "_XLFN.FLOOR.MATH" => Some(Function::FloorMath),
+            "FLOOR.PRECISE" | "_XLFN.FLOOR.PRECISE" => Some(Function::FloorPrecise),
+            "ISO.CEILING" | "_XLFN.ISO.CEILING" => Some(Function::IsoCeiling),
+            "MOD" => Some(Function::Mod),
+            "QUOTIENT" => Some(Function::Quotient),
+            "MROUND" => Some(Function::Mround),
+            "TRUNC" => Some(Function::Trunc),
+            "GCD" => Some(Function::Gcd),
+            "LCM" => Some(Function::Lcm),
+            "BASE" | "_XLFN.BASE" => Some(Function::Base),
+            "DECIMAL" | "_XLFN.DECIMAL" => Some(Function::Decimal),
+            "ROMAN" => Some(Function::Roman),
+            "ARABIC" | "_XLFN.ARABIC" => Some(Function::Arabic),
             "PI" => Some(Function::Pi),
             "ABS" => Some(Function::Abs),
             "SQRT" => Some(Function::Sqrt),
             "SQRTPI" => Some(Function::Sqrtpi),
             "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),
@@ -590,6 +748,9 @@ impl Function {
             "SUM" => Some(Function::Sum),
             "SUMIF" => Some(Function::Sumif),
             "SUMIFS" => Some(Function::Sumifs),
+            "COMBIN" => Some(Function::Combin),
+            "COMBINA" | "_XLFN.COMBINA" => Some(Function::Combina),
+            "SUMSQ" => Some(Function::Sumsq),
 
             // Lookup and Reference
             "CHOOSE" => Some(Function::Choose),
@@ -777,6 +938,25 @@ impl Function {
             "GESTEP" => Some(Function::Gestep),
 
             "SUBTOTAL" => Some(Function::Subtotal),
+
+            "N" => Some(Function::N),
+            "CELL" => Some(Function::Cell),
+            "INFO" => Some(Function::Info),
+            "SHEETS" | "_XLFN.SHEETS" => Some(Function::Sheets),
+
+            "DAVERAGE" => Some(Function::Daverage),
+            "DCOUNT" => Some(Function::Dcount),
+            "DGET" => Some(Function::Dget),
+            "DMAX" => Some(Function::Dmax),
+            "DMIN" => Some(Function::Dmin),
+            "DSUM" => Some(Function::Dsum),
+            "DCOUNTA" => Some(Function::Dcounta),
+            "DPRODUCT" => Some(Function::Dproduct),
+            "DSTDEV" => Some(Function::Dstdev),
+            "DVAR" => Some(Function::Dvar),
+            "DVARP" => Some(Function::Dvarp),
+            "DSTDEVP" => Some(Function::Dstdevp),
+
             _ => None,
         }
     }
@@ -811,6 +991,14 @@ impl fmt::Display for Function {
             Function::Asinh => write!(f, "ASINH"),
             Function::Acosh => write!(f, "ACOSH"),
             Function::Atanh => write!(f, "ATANH"),
+            Function::Acot => write!(f, "ACOT"),
+            Function::Acoth => write!(f, "ACOTH"),
+            Function::Cot => write!(f, "COT"),
+            Function::Coth => write!(f, "COTH"),
+            Function::Csc => write!(f, "CSC"),
+            Function::Csch => write!(f, "CSCH"),
+            Function::Sec => write!(f, "SEC"),
+            Function::Sech => write!(f, "SECH"),
             Function::Abs => write!(f, "ABS"),
             Function::Pi => write!(f, "PI"),
             Function::Sqrt => write!(f, "SQRT"),
@@ -875,7 +1063,6 @@ impl fmt::Display for Function {
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
-
             Function::Average => write!(f, "AVERAGE"),
             Function::Averagea => write!(f, "AVERAGEA"),
             Function::Averageif => write!(f, "AVERAGEIF"),
@@ -1000,8 +1187,53 @@ impl fmt::Display for Function {
             Function::Convert => write!(f, "CONVERT"),
             Function::Delta => write!(f, "DELTA"),
             Function::Gestep => write!(f, "GESTEP"),
-
             Function::Subtotal => write!(f, "SUBTOTAL"),
+            Function::Exp => write!(f, "EXP"),
+            Function::Fact => write!(f, "FACT"),
+            Function::Factdouble => write!(f, "FACTDOUBLE"),
+            Function::Sign => write!(f, "SIGN"),
+            Function::Radians => write!(f, "RADIANS"),
+            Function::Degrees => write!(f, "DEGREES"),
+            Function::Int => write!(f, "INT"),
+            Function::Even => write!(f, "EVEN"),
+            Function::Odd => write!(f, "ODD"),
+            Function::Ceiling => write!(f, "CEILING"),
+            Function::CeilingMath => write!(f, "CEILING.MATH"),
+            Function::CeilingPrecise => write!(f, "CEILING.PRECISE"),
+            Function::Floor => write!(f, "FLOOR"),
+            Function::FloorMath => write!(f, "FLOOR.MATH"),
+            Function::FloorPrecise => write!(f, "FLOOR.PRECISE"),
+            Function::IsoCeiling => write!(f, "ISO.CEILING"),
+            Function::Mod => write!(f, "MOD"),
+            Function::Quotient => write!(f, "QUOTIENT"),
+            Function::Mround => write!(f, "MROUND"),
+            Function::Trunc => write!(f, "TRUNC"),
+            Function::Gcd => write!(f, "GCD"),
+            Function::Lcm => write!(f, "LCM"),
+            Function::Base => write!(f, "BASE"),
+            Function::Decimal => write!(f, "DECIMAL"),
+            Function::Roman => write!(f, "ROMAN"),
+            Function::Arabic => write!(f, "ARABIC"),
+            Function::Combin => write!(f, "COMBIN"),
+            Function::Combina => write!(f, "COMBINA"),
+            Function::Sumsq => write!(f, "SUMSQ"),
+
+            Function::N => write!(f, "N"),
+            Function::Cell => write!(f, "CELL"),
+            Function::Info => write!(f, "INFO"),
+            Function::Sheets => write!(f, "SHEETS"),
+            Function::Daverage => write!(f, "DAVERAGE"),
+            Function::Dcount => write!(f, "DCOUNT"),
+            Function::Dget => write!(f, "DGET"),
+            Function::Dmax => write!(f, "DMAX"),
+            Function::Dmin => write!(f, "DMIN"),
+            Function::Dsum => write!(f, "DSUM"),
+            Function::Dcounta => write!(f, "DCOUNTA"),
+            Function::Dproduct => write!(f, "DPRODUCT"),
+            Function::Dstdev => write!(f, "DSTDEV"),
+            Function::Dvar => write!(f, "DVAR"),
+            Function::Dvarp => write!(f, "DVARP"),
+            Function::Dstdevp => write!(f, "DSTDEVP"),
         }
     }
 }
@@ -1030,7 +1262,6 @@ impl Model {
         cell: CellReferenceIndex,
     ) -> CalcResult {
         match kind {
-            // Logical
             Function::And => self.fn_and(args, cell),
             Function::False => self.fn_false(args, cell),
             Function::If => self.fn_if(args, cell),
@@ -1042,34 +1273,27 @@ impl Model {
             Function::Switch => self.fn_switch(args, cell),
             Function::True => self.fn_true(args, cell),
             Function::Xor => self.fn_xor(args, cell),
-            // Math and trigonometry
             Function::Log => self.fn_log(args, cell),
             Function::Log10 => self.fn_log10(args, cell),
             Function::Ln => self.fn_ln(args, cell),
             Function::Sin => self.fn_sin(args, cell),
             Function::Cos => self.fn_cos(args, cell),
             Function::Tan => self.fn_tan(args, cell),
-
             Function::Asin => self.fn_asin(args, cell),
             Function::Acos => self.fn_acos(args, cell),
             Function::Atan => self.fn_atan(args, cell),
-
             Function::Sinh => self.fn_sinh(args, cell),
             Function::Cosh => self.fn_cosh(args, cell),
             Function::Tanh => self.fn_tanh(args, cell),
-
             Function::Asinh => self.fn_asinh(args, cell),
             Function::Acosh => self.fn_acosh(args, cell),
             Function::Atanh => self.fn_atanh(args, cell),
-
             Function::Pi => self.fn_pi(args, cell),
             Function::Abs => self.fn_abs(args, cell),
-
             Function::Sqrt => self.fn_sqrt(args, cell),
             Function::Sqrtpi => self.fn_sqrtpi(args, cell),
             Function::Atan2 => self.fn_atan2(args, cell),
             Function::Power => self.fn_power(args, cell),
-
             Function::Max => self.fn_max(args, cell),
             Function::Min => self.fn_min(args, cell),
             Function::Product => self.fn_product(args, cell),
@@ -1081,8 +1305,6 @@ impl Model {
             Function::Sum => self.fn_sum(args, cell),
             Function::Sumif => self.fn_sumif(args, cell),
             Function::Sumifs => self.fn_sumifs(args, cell),
-
-            // Lookup and Reference
             Function::Choose => self.fn_choose(args, cell),
             Function::Column => self.fn_column(args, cell),
             Function::Columns => self.fn_columns(args, cell),
@@ -1096,7 +1318,6 @@ impl Model {
             Function::Rows => self.fn_rows(args, cell),
             Function::Vlookup => self.fn_vlookup(args, cell),
             Function::Xlookup => self.fn_xlookup(args, cell),
-            // Text
             Function::Concatenate => self.fn_concatenate(args, cell),
             Function::Exact => self.fn_exact(args, cell),
             Function::Value => self.fn_value(args, cell),
@@ -1114,7 +1335,6 @@ impl Model {
             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),
             Function::Isnontext => self.fn_isnontext(args, cell),
             Function::Istext => self.fn_istext(args, cell),
@@ -1132,7 +1352,6 @@ impl Model {
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
-            // Statistical
             Function::Average => self.fn_average(args, cell),
             Function::Averagea => self.fn_averagea(args, cell),
             Function::Averageif => self.fn_averageif(args, cell),
@@ -1145,7 +1364,6 @@ impl Model {
             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),
@@ -1171,7 +1389,6 @@ impl Model {
             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),
             Function::Rate => self.fn_rate(args, cell),
@@ -1205,7 +1422,6 @@ impl Model {
             Function::Db => self.fn_db(args, cell),
             Function::Cumprinc => self.fn_cumprinc(args, cell),
             Function::Cumipmt => self.fn_cumipmt(args, cell),
-            // Engineering
             Function::Besseli => self.fn_besseli(args, cell),
             Function::Besselj => self.fn_besselj(args, cell),
             Function::Besselk => self.fn_besselk(args, cell),
@@ -1260,8 +1476,60 @@ impl Model {
             Function::Convert => self.fn_convert(args, cell),
             Function::Delta => self.fn_delta(args, cell),
             Function::Gestep => self.fn_gestep(args, cell),
-
             Function::Subtotal => self.fn_subtotal(args, cell),
+            Function::Acot => self.fn_acot(args, cell),
+            Function::Acoth => self.fn_acoth(args, cell),
+            Function::Cot => self.fn_cot(args, cell),
+            Function::Coth => self.fn_coth(args, cell),
+            Function::Csc => self.fn_csc(args, cell),
+            Function::Csch => self.fn_csch(args, cell),
+            Function::Sec => self.fn_sec(args, cell),
+            Function::Sech => self.fn_sech(args, cell),
+            Function::Exp => self.fn_exp(args, cell),
+            Function::Fact => self.fn_fact(args, cell),
+            Function::Factdouble => self.fn_factdouble(args, cell),
+            Function::Sign => self.fn_sign(args, cell),
+            Function::Radians => self.fn_radians(args, cell),
+            Function::Degrees => self.fn_degrees(args, cell),
+            Function::Int => self.fn_int(args, cell),
+            Function::Even => self.fn_even(args, cell),
+            Function::Odd => self.fn_odd(args, cell),
+            Function::Ceiling => self.fn_ceiling(args, cell),
+            Function::CeilingMath => self.fn_ceiling_math(args, cell),
+            Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
+            Function::Floor => self.fn_floor(args, cell),
+            Function::FloorMath => self.fn_floor_math(args, cell),
+            Function::FloorPrecise => self.fn_floor_precise(args, cell),
+            Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
+            Function::Mod => self.fn_mod(args, cell),
+            Function::Quotient => self.fn_quotient(args, cell),
+            Function::Mround => self.fn_mround(args, cell),
+            Function::Trunc => self.fn_trunc(args, cell),
+            Function::Gcd => self.fn_gcd(args, cell),
+            Function::Lcm => self.fn_lcm(args, cell),
+            Function::Base => self.fn_base(args, cell),
+            Function::Decimal => self.fn_decimal(args, cell),
+            Function::Roman => self.fn_roman(args, cell),
+            Function::Arabic => self.fn_arabic(args, cell),
+            Function::Combin => self.fn_combin(args, cell),
+            Function::Combina => self.fn_combina(args, cell),
+            Function::Sumsq => self.fn_sumsq(args, cell),
+            Function::N => self.fn_n(args, cell),
+            Function::Cell => self.fn_cell(args, cell),
+            Function::Info => self.fn_info(args, cell),
+            Function::Sheets => self.fn_sheets(args, cell),
+            Function::Daverage => self.fn_daverage(args, cell),
+            Function::Dcount => self.fn_dcount(args, cell),
+            Function::Dget => self.fn_dget(args, cell),
+            Function::Dmax => self.fn_dmax(args, cell),
+            Function::Dmin => self.fn_dmin(args, cell),
+            Function::Dsum => self.fn_dsum(args, cell),
+            Function::Dcounta => self.fn_dcounta(args, cell),
+            Function::Dproduct => self.fn_dproduct(args, cell),
+            Function::Dstdev => self.fn_dstdev(args, cell),
+            Function::Dvar => self.fn_dvar(args, cell),
+            Function::Dvarp => self.fn_dvarp(args, cell),
+            Function::Dstdevp => self.fn_dstdevp(args, cell),
         }
     }
 }

base/src/functions/util.rs

@@ -1,7 +1,10 @@
 #[cfg(feature = "use_regex_lite")]
 use regex_lite as regex;
 
-use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
+use crate::{
+    calc_result::CalcResult, expressions::token::is_english_error_string,
+    number_format::to_excel_precision,
+};
 
 /// This test for exact match (modulo case).
 ///   * strings are not cast into bools or numbers
@@ -34,6 +37,8 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
     match (left, right) {
         (CalcResult::Number(value1), CalcResult::Number(value2)) => {
+            let value1 = to_excel_precision(*value1, 15);
+            let value2 = to_excel_precision(*value2, 15);
             if (value2 - value1).abs() < f64::EPSILON {
                 return 0;
             }

base/src/model.rs

@@ -2068,21 +2068,7 @@ impl Model {
         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());
-            }
-        }
+        let sheet_id = self.is_valid_defined_name(name, scope, formula)?;
         self.workbook.defined_names.push(DefinedName {
             name: name.to_string(),
             formula: formula.to_string(),
@@ -2093,6 +2079,48 @@ impl Model {
         Ok(())
     }
 
+    /// Validates if a defined name can be created
+    pub fn is_valid_defined_name(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<Option<u32>, String> {
+        if !is_valid_identifier(name) {
+            return Err("Name: 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) => match self.workbook.worksheet(index) {
+                Ok(ws) => Some(ws.sheet_id),
+                Err(_) => return Err("Scope: Invalid sheet index".to_string()),
+            },
+            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("Name: Defined name already exists".to_string());
+            }
+        }
+
+        // Make sure the formula is valid
+        match common::ParsedReference::parse_reference_formula(
+            None,
+            formula,
+            &self.locale,
+            |name| self.get_sheet_index_by_name(name),
+        ) {
+            Ok(_) => {}
+            Err(_) => {
+                return Err("Formula: Invalid defined name formula".to_string());
+            }
+        };
+
+        Ok(sheet_id)
+    }
+
     /// 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();
@@ -2126,7 +2154,7 @@ impl Model {
         new_formula: &str,
     ) -> Result<(), String> {
         if !is_valid_identifier(new_name) {
-            return Err("Invalid defined name".to_string());
+            return Err("Name: Invalid defined name".to_string());
         };
         let name_upper = name.to_uppercase();
         let new_name_upper = new_name.to_uppercase();
@@ -2134,18 +2162,28 @@ impl Model {
         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());
+                    return Err("Name: 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),
+            Some(index) => Some(
+                self.workbook
+                    .worksheet(index)
+                    .map_err(|_| "Scope: Invalid sheet index")?
+                    .sheet_id,
+            ),
             None => None,
         };
 
         let new_sheet_id = match new_scope {
-            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            Some(index) => Some(
+                self.workbook
+                    .worksheet(index)
+                    .map_err(|_| "Scope: Invalid sheet index")?
+                    .sheet_id,
+            ),
             None => None,
         };
 

base/src/number_format.rs

@@ -112,29 +112,36 @@ pub fn to_precision(value: f64, precision: usize) -> f64 {
 /// ```
 /// This intends to be equivalent to the js: `${parseFloat(value.toPrecision(precision)})`
 /// See ([ecma](https://tc39.es/ecma262/#sec-number.prototype.toprecision)).
-/// FIXME: There has to be a better algorithm :/
 pub fn to_excel_precision_str(value: f64) -> String {
     to_precision_str(value, 15)
 }
+
+pub fn to_excel_precision(value: f64, precision: usize) -> f64 {
+    if !value.is_finite() {
+        return value;
+    }
+
+    let s = format!("{:.*e}", precision.saturating_sub(1), value);
+    s.parse::<f64>().unwrap_or(value)
+}
+
 pub fn to_precision_str(value: f64, precision: usize) -> String {
-    if value.is_infinite() {
-        return "inf".to_string();
+    if !value.is_finite() {
+        if value.is_infinite() {
+            return "inf".to_string();
+        } else {
+            return "NaN".to_string();
+        }
     }
-    if value.is_nan() {
-        return "NaN".to_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({
-        // TODO: do this in a way that does not require a possible error
-        0.0
-    });
+
+    let s = format!("{:.*e}", precision.saturating_sub(1), value);
+    let parsed = s.parse::<f64>().unwrap_or(value);
+
     // I would love to use the std library. There is not a speed concern here
     // problem is it doesn't do the right thing
     // Also ryu is my favorite _modern_ algorithm
     let mut buffer = ryu::Buffer::new();
-    let text = buffer.format(value);
+    let text = buffer.format(parsed);
     // The above algorithm converts 2 to 2.0 regrettably
     if let Some(stripped) = text.strip_suffix(".0") {
         return stripped.to_string();

base/src/test/engineering/test_complex.rs

@@ -133,6 +133,7 @@ fn fn_imcot() {
     );
 }
 
+#[cfg_attr(target_os = "windows", ignore)]
 #[test]
 fn fn_imtan() {
     let mut model = new_empty_model();

base/src/test/mod.rs

@@ -9,6 +9,7 @@ mod test_currency;
 mod test_date_and_time;
 mod test_datedif_leap_month_end;
 mod test_days360_month_end;
+mod test_degrees_radians;
 mod test_error_propagation;
 mod test_fn_average;
 mod test_fn_averageifs;
@@ -68,12 +69,16 @@ mod test_geomean;
 mod test_get_cell_content;
 mod test_implicit_intersection;
 mod test_issue_155;
+mod test_issue_483;
 mod test_ln;
 mod test_log;
 mod test_log10;
+mod test_mod_quotient;
 mod test_networkdays;
+mod test_now;
 mod test_percentage;
 mod test_set_functions_error_handling;
+mod test_sheet_names;
 mod test_today;
 mod test_types;
 mod user_model;

base/src/test/test_arabic_roman

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=ARABIC()");
+    model._set("A2", "=ARABIC(V)");
+    model._set("A3", "=ARABIC(V, 2)");
+
+    model._set("A4", "=ROMAN()");
+    model._set("A5", "=ROMAN(5)");
+    model._set("A6", "=ROMAN(5, 0)");
+    model._set("A7", "=ROMAN(5, 0, 2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"5");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+    assert_eq!(model._get_text("A5"), *"V");
+    assert_eq!(model._get_text("A6"), *"V");
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+}

base/src/test/test_combin_combina

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=COMBIN(5,2)");
+    model._set("A2", "=COMBINA(5,2)");
+    model._set("A3", "=COMBIN()");
+    model._set("A4", "=COMBINA()");
+    model._set("A5", "=COMBIN(2)");
+    model._set("A6", "=COMBINA(2)");
+    model._set("A5", "=COMBIN(1, 2, 3)");
+    model._set("A6", "=COMBINA(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"10");
+    assert_eq!(model._get_text("A2"), *"15");
+    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!");
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+    assert_eq!(model._get_text("A8"), *"#ERROR!");
+}

base/src/test/test_date_and_time.rs

@@ -542,7 +542,6 @@ fn test_yearfrac_function() {
 
     // 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
@@ -559,7 +558,6 @@ fn test_yearfrac_function() {
 
     // 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

base/src/test/test_degrees_radians.rs

@@ -0,0 +1,22 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_degrees_radians_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEGREES()");
+    model._set("A2", "=RADIANS()");
+    model._set("A3", "=RADIANS(180)");
+    model._set("A4", "=RADIANS(180, 2)");
+    model._set("A5", "=DEGREES(RADIANS(180))");
+    model._set("A6", "=DEGREES(1, 2)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"3.141592654");
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+    assert_eq!(model._get_text("A5"), *"180");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+}

base/src/test/test_even_odd

@@ -0,0 +1,23 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=EVEN(2)");
+    model._set("A2", "=ODD(2)");
+    model._set("A3", "=EVEN()");
+    model._set("A4", "=ODD()");
+    model._set("A5", "=EVEN(1, 2)");
+    model._set("A6", "=ODD(1, 2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"2");
+    assert_eq!(model._get_text("A2"), *"3");
+    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!");
+}

base/src/test/test_exp_sign.rs

@@ -0,0 +1,26 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=EXP()");
+    model._set("A2", "=SIGN()");
+
+    model._set("A3", "=EXP(0)");
+    model._set("A4", "=SIGN(-10)");
+
+    model._set("A5", "=EXP(1, 2)");
+    model._set("A6", "=SIGN(1, 2)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A3"), *"1");
+    assert_eq!(model._get_text("A4"), *"-1");
+
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+}

base/src/test/test_fn_datevalue_timevalue.rs

@@ -0,0 +1,24 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn datevalue_timevalue_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATEVALUE()");
+    model._set("A2", "=TIMEVALUE()");
+    model._set("A3", "=DATEVALUE("2000-01-01")")
+    model._set("A4", "=TIMEVALUE("12:00:00")")
+    model._set("A5", "=DATEVALUE(1,2)");
+    model._set("A6", "=TIMEVALUE(1,2)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"36526");
+    assert_eq!(model._get_text("A4"), *"0.5");
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+}
+
+

base/src/test/test_issue_483.rs

@@ -0,0 +1,13 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn issue_155() {
+    let mut model = new_empty_model();
+    model._set("A1", "123");
+    model._set("D2", "=-(A1^1.22)");
+    model.evaluate();
+
+    assert_eq!(model._get_formula("D2"), "=-(A1^1.22)".to_string());
+}

base/src/test/test_mod_quotient.rs

@@ -0,0 +1,22 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=MOD(5,2)");
+    model._set("A2", "=MOD()");
+    model._set("A3", "=MOD(5, 2, 1)");
+    model._set("A4", "=QUOTIENT(5, 2)");
+    model._set("A5", "=QUOTIENT()");
+    model._set("A6", "=QUOTIENT(5, 2, 1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+    assert_eq!(model._get_text("A4"), *"2");
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+}

base/src/test/test_mround_trunc_int

@@ -0,0 +1,40 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=MROUND()");
+    model._set("A2", "=MROUND(10)");
+    model._set("A3", "=MROUND(10, 3)");
+    model._set("A4", "=MROUND(10, 3, 1)");
+
+    model._set("A5", "=TRUNC()");
+    model._set("A6", "=TRUNC(10)");
+    model._set("A7", "=TRUNC(10.22, 1)");
+    model._set("A8", "=TRUNC(10, 3, 1)");
+
+    model._set("A9", "=INT()");
+    model._set("A10", "=INT(10.22)");
+    model._set("A11", "=INT(10.22, 1)");
+    model._set("A12", "=INT(10.22, 1, 2)");
+
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"9");
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+    assert_eq!(model._get_text("A7"), *"10.2");
+    assert_eq!(model._get_text("A8"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A9"), *"#ERROR!");
+    assert_eq!(model._get_text("A10"), *"10");
+    assert_eq!(model._get_text("A11"), *"#ERROR!");
+    assert_eq!(model._get_text("A12"), *"#ERROR!");
+}

base/src/test/test_now.rs

@@ -0,0 +1,30 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{mock_time, test::util::new_empty_model};
+
+// 14:44 20 Mar 2023 Berlin
+const TIMESTAMP_2023: i64 = 1679319865208;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=NOW(1)");
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "#ERROR!",
+        "NOW should not accept arguments"
+    );
+}
+
+#[test]
+fn returns_date_time() {
+    mock_time::set_mock_time(TIMESTAMP_2023);
+    let mut model = new_empty_model();
+    model._set("A1", "=NOW()");
+    model.evaluate();
+    let text = model._get_text("A1");
+    assert_eq!(text, *"20/03/2023 13:44:25");
+}

base/src/test/test_number_format.rs

@@ -8,6 +8,15 @@ fn test_simple_format() {
     assert_eq!(formatted.text, "2.3".to_string());
 }
 
+#[test]
+fn test_maximum_zeros() {
+    let formatted = format_number(1.0 / 3.0, "#,##0.0000000000000000000", "en");
+    assert_eq!(formatted.text, "0.3333333333333330000".to_string());
+
+    let formatted = format_number(1234.0 + 1.0 / 3.0, "#,##0.0000000000000000000", "en");
+    assert_eq!(formatted.text, "1,234.3333333333300000000".to_string());
+}
+
 #[test]
 #[ignore = "not yet implemented"]
 fn test_wrong_locale() {

base/src/test/test_sheet_names.rs

@@ -0,0 +1,16 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn sheet_number_name() {
+    let mut model = new_empty_model();
+    model.new_sheet();
+    model._set("A1", "7");
+    model._set("A2", "=Sheet2!C3");
+    model.evaluate();
+    model.rename_sheet("Sheet2", "2024").unwrap();
+    model.evaluate();
+    assert_eq!(model.workbook.get_worksheet_names(), ["Sheet1", "2024"]);
+    assert_eq!(model._get_text("A2"), "0");
+}

base/src/test/test_today.rs

@@ -33,7 +33,8 @@ fn now_basic_utc() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"20/03/2023");
-    assert_eq!(model._get_text("A2"), *"45005.572511574");
+    // 45005.572511574
+    assert_eq!(model._get_text("A2"), *"20/03/2023 13:44:25");
 }
 
 #[test]
@@ -46,5 +47,5 @@ fn now_basic_europe_berlin() {
 
     assert_eq!(model._get_text("A1"), *"20/03/2023");
     // This is UTC + 1 hour: 45005.572511574 + 1/24
-    assert_eq!(model._get_text("A2"), *"45005.614178241");
+    assert_eq!(model._get_text("A2"), *"20/03/2023 14:44:25");
 }

base/src/test/test_trigonometric.rs

@@ -96,3 +96,14 @@ fn test_fn_tan_pi2() {
     // This is consistent with IEEE 754 but inconsistent with Excel
     assert_eq!(model._get_text("A1"), *"1.63312E+16");
 }
+
+#[test]
+fn test_trigonometric_identity() {
+    let mut model = new_empty_model();
+    model._set("A1", "=COTH(1)*CSCH(1)");
+    model._set("A2", "=COSH(1)/(SINH(1))^2");
+    model._set("A3", "=A1=A2");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A3"), *"TRUE");
+}

base/src/test/test_trigonometric_reciprocals.rs

@@ -0,0 +1,53 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=CSC()");
+    model._set("A2", "=SEC()");
+    model._set("A3", "=COT()");
+
+    model._set("A4", "=CSCH()");
+    model._set("A5", "=SECH()");
+    model._set("A6", "=COTH()");
+
+    model._set("A7", "=ACOT()");
+    model._set("A8", "=ACOTH()");
+
+    model._set("B1", "=CSC(1, 2)");
+    model._set("B2", "=SEC(1, 2)");
+    model._set("B3", "=COT(1, 2)");
+
+    model._set("B4", "=CSCH(1, 2)");
+    model._set("B5", "=SECH(1, 2)");
+    model._set("B6", "=COTH(1, 2)");
+
+    model._set("B7", "=ACOT(1, 2)");
+    model._set("B8", "=ACOTH(1, 2)");
+
+    model.evaluate();
+
+    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!");
+
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+    assert_eq!(model._get_text("A8"), *"#ERROR!");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("B4"), *"#ERROR!");
+    assert_eq!(model._get_text("B5"), *"#ERROR!");
+    assert_eq!(model._get_text("B6"), *"#ERROR!");
+
+    assert_eq!(model._get_text("B7"), *"#ERROR!");
+    assert_eq!(model._get_text("B8"), *"#ERROR!");
+}

base/src/test/test_yearfrac_basis.rs

@@ -26,8 +26,8 @@ fn test_yearfrac_basis_2_actual_360() {
         panic!("Expected numeric value in A2");
     }
 
-    // Negative symmetric of A1
-    assert_eq!(model._get_text("A3"), *"-1");
+    // always positive A1
+    assert_eq!(model._get_text("A3"), *"1");
 }
 
 #[test]

base/src/test/user_model/test_defined_names.rs

@@ -254,19 +254,19 @@ fn invalid_names() {
     // spaces
     assert_eq!(
         model.new_defined_name("A real", None, "Sheet1!$A$1"),
-        Err("Invalid defined name".to_string())
+        Err("Name: Invalid defined name".to_string())
     );
 
     // Starts with number
     assert_eq!(
         model.new_defined_name("2real", None, "Sheet1!$A$1"),
-        Err("Invalid defined name".to_string())
+        Err("Name: Invalid defined name".to_string())
     );
 
     // Updating also fails
     assert_eq!(
         model.update_defined_name("MyName", None, "My Name", None, "Sheet1!$A$1"),
-        Err("Invalid defined name".to_string())
+        Err("Name: Invalid defined name".to_string())
     );
 }
 
@@ -284,13 +284,13 @@ fn already_existing() {
     // Can't create a new name with the same name
     assert_eq!(
         model.new_defined_name("MyName", None, "Sheet1!$A$2"),
-        Err("Defined name already exists".to_string())
+        Err("Name: Defined name already exists".to_string())
     );
 
     // Can't update one into an existing
     assert_eq!(
         model.update_defined_name("Another", None, "MyName", None, "Sheet1!$A$1"),
-        Err("Defined name already exists".to_string())
+        Err("Name: Defined name already exists".to_string())
     );
 }
 
@@ -304,17 +304,17 @@ fn invalid_sheet() {
 
     assert_eq!(
         model.new_defined_name("Mything", Some(2), "Sheet1!$A$1"),
-        Err("Invalid sheet index".to_string())
+        Err("Scope: Invalid sheet index".to_string())
     );
 
     assert_eq!(
         model.update_defined_name("MyName", None, "MyName", Some(2), "Sheet1!$A$1"),
-        Err("Invalid sheet index".to_string())
+        Err("Scope: Invalid sheet index".to_string())
     );
 
     assert_eq!(
         model.update_defined_name("MyName", Some(9), "YourName", None, "Sheet1!$A$1"),
-        Err("Invalid sheet index".to_string())
+        Err("General: Failed to get old name".to_string())
     );
 }
 
@@ -322,7 +322,7 @@ fn invalid_sheet() {
 fn invalid_formula() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
     model.set_user_input(0, 1, 1, "Hello").unwrap();
-    model.new_defined_name("MyName", None, "A1").unwrap();
+    assert!(model.new_defined_name("MyName", None, "A1").is_err());
 
     model.set_user_input(0, 1, 2, "=MyName").unwrap();
 

base/src/types.rs

@@ -445,11 +445,13 @@ impl Default for Fill {
 
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 #[serde(rename_all = "lowercase")]
+#[derive(Default)]
 pub enum HorizontalAlignment {
     Center,
     CenterContinuous,
     Distributed,
     Fill,
+    #[default]
     General,
     Justify,
     Left,
@@ -457,11 +459,6 @@ pub enum HorizontalAlignment {
 }
 
 // Note that alignment in "General" depends on type
-impl Default for HorizontalAlignment {
-    fn default() -> Self {
-        Self::General
-    }
-}
 
 impl HorizontalAlignment {
     fn is_default(&self) -> bool {
@@ -487,7 +484,9 @@ impl Display for HorizontalAlignment {
 
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 #[serde(rename_all = "lowercase")]
+#[derive(Default)]
 pub enum VerticalAlignment {
+    #[default]
     Bottom,
     Center,
     Distributed,
@@ -501,12 +500,6 @@ impl VerticalAlignment {
     }
 }
 
-impl Default for VerticalAlignment {
-    fn default() -> Self {
-        Self::Bottom
-    }
-}
-
 impl Display for VerticalAlignment {
     fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {

base/src/units.rs

@@ -329,6 +329,7 @@ impl Model {
             Function::Tbillyield => self.units_fn_percentage_2(args, cell),
             Function::Date => self.units_fn_dates(args, cell),
             Function::Today => self.units_fn_dates(args, cell),
+            Function::Now => self.units_fn_date_times(args, cell),
             _ => None,
         }
     }
@@ -375,4 +376,8 @@ impl Model {
         // TODO: update locale and use it here
         Some(Units::Date("dd/mm/yyyy".to_string()))
     }
+
+    fn units_fn_date_times(&self, _args: &[Node], _cell: &CellReferenceIndex) -> Option<Units> {
+        Some(Units::Date("dd/mm/yyyy hh:mm:ss".to_string()))
+    }
 }

base/src/user_model/common.rs

@@ -2001,7 +2001,10 @@ impl UserModel {
         new_scope: Option<u32>,
         new_formula: &str,
     ) -> Result<(), String> {
-        let old_formula = self.model.get_defined_name_formula(name, scope)?;
+        let old_formula = self
+            .model
+            .get_defined_name_formula(name, scope)
+            .map_err(|_| "General: Failed to get old name")?;
         let diff_list = vec![Diff::UpdateDefinedName {
             name: name.to_string(),
             scope,
@@ -2017,6 +2020,16 @@ impl UserModel {
         Ok(())
     }
 
+    /// validates a new defined name
+    pub fn is_valid_defined_name(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<Option<u32>, String> {
+        self.model.is_valid_defined_name(name, scope, formula)
+    }
+
     // **** Private methods ****** //
 
     pub(crate) fn push_diff_list(&mut self, diff_list: DiffList) {

bindings/nodejs/Cargo.toml

@@ -8,8 +8,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
-napi = { version = "3.3", default-features = false, features = ["napi4", "serde-json"] }
-napi-derive = "3.2"
+napi = { version = "2.12.2", default-features = false, features = ["napi4", "serde-json"] }
+napi-derive = "2.12.2"
 ironcalc = { path = "../../xlsx", version = "0.6.0" }
 serde = { version = "1.0", features = ["derive"] }
 

bindings/nodejs/index.d.ts

@@ -1,5 +1,8 @@
-/* auto-generated by NAPI-RS */
+/* tslint:disable */
 /* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
 export declare class Model {
   constructor(name: string, locale: string, timezone: string)
   static fromXlsx(filePath: string, locale: string, tz: string): Model
@@ -36,10 +39,8 @@ export declare class Model {
   newDefinedName(name: string, scope: number | undefined | null, formula: string): void
   updateDefinedName(name: string, scope: number | undefined | null, newName: string, newScope: number | undefined | null, newFormula: string): void
   deleteDefinedName(name: string, scope?: number | undefined | null): void
-  moveColumn(sheet: number, column: number, delta: number): void
-  moveRow(sheet: number, row: number, delta: number): void
+  testPanic(): void
 }
-
 export declare class UserModel {
   constructor(name: string, locale: string, timezone: string)
   static fromBytes(bytes: Uint8Array): UserModel
@@ -58,13 +59,12 @@ export declare class UserModel {
   setSheetColor(sheet: number, color: string): void
   rangeClearAll(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
   rangeClearContents(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
-  rangeClearFormatting(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
   insertRows(sheet: number, row: number, rowCount: number): void
   insertColumns(sheet: number, column: number, columnCount: number): void
   deleteRows(sheet: number, row: number, rowCount: number): void
   deleteColumns(sheet: number, column: number, columnCount: number): void
-  setRowsHeight(sheet: number, rowStart: number, rowEnd: number, height: number): void
-  setColumnsWidth(sheet: number, columnStart: number, columnEnd: number, width: number): void
+  setRowHeight(sheet: number, row: number, height: number): void
+  setColumnWidth(sheet: number, column: number, width: number): void
   getRowHeight(sheet: number, row: number): number
   getColumnWidth(sheet: number, column: number): number
   setUserInput(sheet: number, row: number, column: number, input: string): void
@@ -112,6 +112,4 @@ export declare class UserModel {
   newDefinedName(name: string, scope: number | undefined | null, formula: string): void
   updateDefinedName(name: string, scope: number | undefined | null, newName: string, newScope: number | undefined | null, newFormula: string): void
   deleteDefinedName(name: string, scope?: number | undefined | null): void
-  moveColumn(sheet: number, column: number, delta: number): void
-  moveRow(sheet: number, row: number, delta: number): void
 }

bindings/nodejs/index.js

@@ -1,579 +1,316 @@
-// prettier-ignore
+/* tslint:disable */
 /* eslint-disable */
-// @ts-nocheck
+/* prettier-ignore */
+
 /* auto-generated by NAPI-RS */
 
-const { createRequire } = require('node:module')
-require = createRequire(__filename)
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
 
-const { readFileSync } = require('node:fs')
 let nativeBinding = null
-const loadErrors = []
+let localFileExisted = false
+let loadError = null
 
-const isMusl = () => {
-  let musl = false
-  if (process.platform === 'linux') {
-    musl = isMuslFromFilesystem()
-    if (musl === null) {
-      musl = isMuslFromReport()
-    }
-    if (musl === null) {
-      musl = isMuslFromChildProcess()
-    }
-  }
-  return musl
-}
-
-const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
-
-const isMuslFromFilesystem = () => {
-  try {
-    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
-  } catch {
-    return null
-  }
-}
-
-const isMuslFromReport = () => {
-  let report = null
-  if (typeof process.report?.getReport === 'function') {
-    process.report.excludeNetwork = true
-    report = process.report.getReport()
-  }
-  if (!report) {
-    return null
-  }
-  if (report.header && report.header.glibcVersionRuntime) {
-    return false
-  }
-  if (Array.isArray(report.sharedObjects)) {
-    if (report.sharedObjects.some(isFileMusl)) {
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
       return true
     }
-  }
-  return false
-}
-
-const isMuslFromChildProcess = () => {
-  try {
-    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
-  } catch (e) {
-    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
-    return false
-  }
-}
-
-function requireNative() {
-  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
-    try {
-      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
-    } catch (err) {
-      loadErrors.push(err)
-    }
-  } else if (process.platform === 'android') {
-    if (process.arch === 'arm64') {
-      try {
-        return require('./nodejs.android-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-android-arm64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-android-arm64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm') {
-      try {
-        return require('./nodejs.android-arm-eabi.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-android-arm-eabi')
-        const bindingPackageVersion = require('@ironcalc/nodejs-android-arm-eabi/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
-    }
-  } else if (process.platform === 'win32') {
-    if (process.arch === 'x64') {
-      if (process.report?.getReport?.()?.header?.osName?.startsWith?.('MINGW')) {
-        try {
-        return require('./nodejs.win32-x64-gnu.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-win32-x64-gnu')
-        const bindingPackageVersion = require('@ironcalc/nodejs-win32-x64-gnu/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      } else {
-        try {
-        return require('./nodejs.win32-x64-msvc.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-win32-x64-msvc')
-        const bindingPackageVersion = require('@ironcalc/nodejs-win32-x64-msvc/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      }
-    } else if (process.arch === 'ia32') {
-      try {
-        return require('./nodejs.win32-ia32-msvc.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-win32-ia32-msvc')
-        const bindingPackageVersion = require('@ironcalc/nodejs-win32-ia32-msvc/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm64') {
-      try {
-        return require('./nodejs.win32-arm64-msvc.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-win32-arm64-msvc')
-        const bindingPackageVersion = require('@ironcalc/nodejs-win32-arm64-msvc/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
-    }
-  } else if (process.platform === 'darwin') {
-    try {
-      return require('./nodejs.darwin-universal.node')
-    } catch (e) {
-      loadErrors.push(e)
-    }
-    try {
-      const binding = require('@ironcalc/nodejs-darwin-universal')
-      const bindingPackageVersion = require('@ironcalc/nodejs-darwin-universal/package.json').version
-      if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-        throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-      }
-      return binding
-    } catch (e) {
-      loadErrors.push(e)
-    }
-    if (process.arch === 'x64') {
-      try {
-        return require('./nodejs.darwin-x64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-darwin-x64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-darwin-x64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm64') {
-      try {
-        return require('./nodejs.darwin-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-darwin-arm64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-darwin-arm64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
-    }
-  } else if (process.platform === 'freebsd') {
-    if (process.arch === 'x64') {
-      try {
-        return require('./nodejs.freebsd-x64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-freebsd-x64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-freebsd-x64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm64') {
-      try {
-        return require('./nodejs.freebsd-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-freebsd-arm64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-freebsd-arm64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
-    }
-  } else if (process.platform === 'linux') {
-    if (process.arch === 'x64') {
-      if (isMusl()) {
-        try {
-          return require('./nodejs.linux-x64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-x64-musl')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-x64-musl/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./nodejs.linux-x64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-x64-gnu')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-x64-gnu/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'arm64') {
-      if (isMusl()) {
-        try {
-          return require('./nodejs.linux-arm64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-arm64-musl')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-arm64-musl/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./nodejs.linux-arm64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-arm64-gnu')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-arm64-gnu/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'arm') {
-      if (isMusl()) {
-        try {
-          return require('./nodejs.linux-arm-musleabihf.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-arm-musleabihf')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-arm-musleabihf/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./nodejs.linux-arm-gnueabihf.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-arm-gnueabihf')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-arm-gnueabihf/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'loong64') {
-      if (isMusl()) {
-        try {
-          return require('./nodejs.linux-loong64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-loong64-musl')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-loong64-musl/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./nodejs.linux-loong64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-loong64-gnu')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-loong64-gnu/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'riscv64') {
-      if (isMusl()) {
-        try {
-          return require('./nodejs.linux-riscv64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-riscv64-musl')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-riscv64-musl/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./nodejs.linux-riscv64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          const binding = require('@ironcalc/nodejs-linux-riscv64-gnu')
-          const bindingPackageVersion = require('@ironcalc/nodejs-linux-riscv64-gnu/package.json').version
-          if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-          }
-          return binding
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'ppc64') {
-      try {
-        return require('./nodejs.linux-ppc64-gnu.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-linux-ppc64-gnu')
-        const bindingPackageVersion = require('@ironcalc/nodejs-linux-ppc64-gnu/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 's390x') {
-      try {
-        return require('./nodejs.linux-s390x-gnu.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-linux-s390x-gnu')
-        const bindingPackageVersion = require('@ironcalc/nodejs-linux-s390x-gnu/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
-    }
-  } else if (process.platform === 'openharmony') {
-    if (process.arch === 'arm64') {
-      try {
-        return require('./nodejs.openharmony-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-openharmony-arm64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-openharmony-arm64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'x64') {
-      try {
-        return require('./nodejs.openharmony-x64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-openharmony-x64')
-        const bindingPackageVersion = require('@ironcalc/nodejs-openharmony-x64/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm') {
-      try {
-        return require('./nodejs.openharmony-arm.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        const binding = require('@ironcalc/nodejs-openharmony-arm')
-        const bindingPackageVersion = require('@ironcalc/nodejs-openharmony-arm/package.json').version
-        if (bindingPackageVersion !== '0.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 0.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
-        }
-        return binding
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
-    }
   } else {
-    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
   }
 }
 
-nativeBinding = requireNative()
-
-if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
-  let wasiBinding = null
-  let wasiBindingError = null
-  try {
-    wasiBinding = require('./nodejs.wasi.cjs')
-    nativeBinding = wasiBinding
-  } catch (err) {
-    if (process.env.NAPI_RS_FORCE_WASI) {
-      wasiBindingError = err
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'nodejs.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.android-arm64.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'nodejs.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
     }
-  }
-  if (!nativeBinding) {
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nodejs.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'nodejs.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nodejs.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'nodejs.darwin-universal.node'))
     try {
-      wasiBinding = require('@ironcalc/nodejs-wasm32-wasi')
-      nativeBinding = wasiBinding
-    } catch (err) {
-      if (process.env.NAPI_RS_FORCE_WASI) {
-        wasiBindingError.cause = err
-        loadErrors.push(err)
+      if (localFileExisted) {
+        nativeBinding = require('./nodejs.darwin-universal.node')
+      } else {
+        nativeBinding = require('@ironcalc/nodejs-darwin-universal')
       }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'nodejs.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.darwin-x64.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nodejs.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
     }
-  }
-  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
-    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
-    error.cause = wasiBindingError
-    throw error
-  }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'nodejs.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nodejs.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@ironcalc/nodejs-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nodejs.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nodejs.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@ironcalc/nodejs-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'nodejs.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nodejs.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@ironcalc/nodejs-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
 }
 
 if (!nativeBinding) {
-  if (loadErrors.length > 0) {
-    throw new Error(
-      `Cannot find native binding. ` +
-        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
-        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
-      {
-        cause: loadErrors.reduce((err, cur) => {
-          cur.cause = err
-          return cur
-        }),
-      },
-    )
+  if (loadError) {
+    throw loadError
   }
   throw new Error(`Failed to load native binding`)
 }
 
-module.exports = nativeBinding
-module.exports.Model = nativeBinding.Model
-module.exports.UserModel = nativeBinding.UserModel
+const { Model, UserModel } = nativeBinding
+
+module.exports.Model = Model
+module.exports.UserModel = UserModel

bindings/nodejs/npm/android-arm-eabi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-android-arm-eabi",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "android"
   ],

bindings/nodejs/npm/android-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-android-arm64",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "android"
   ],

bindings/nodejs/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-darwin-arm64",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "darwin"
   ],

bindings/nodejs/npm/darwin-universal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-darwin-universal",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "darwin"
   ],

bindings/nodejs/npm/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-darwin-x64",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "darwin"
   ],

bindings/nodejs/npm/linux-arm-gnueabihf/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-arm-gnueabihf",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/linux-arm-musleabihf/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-arm-musleabihf",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/linux-arm64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-arm64-gnu",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/linux-arm64-musl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-arm64-musl",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/linux-riscv64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-riscv64-gnu",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/linux-x64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-x64-gnu",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/linux-x64-musl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-linux-x64-musl",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "linux"
   ],

bindings/nodejs/npm/win32-arm64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-win32-arm64-msvc",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "win32"
   ],

bindings/nodejs/npm/win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcalc/nodejs-win32-x64-msvc",
-  "version": "0.6.0",
+  "version": "0.2.0",
   "os": [
     "win32"
   ],

bindings/nodejs/package.json

@@ -1,27 +1,29 @@
 {
   "name": "@ironcalc/nodejs",
-  "version": "0.6.0",
+  "version": "0.5.1",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
-    "binaryName": "nodejs",
-    "targets": [
-      "aarch64-apple-darwin",
-      "aarch64-linux-android",
-      "aarch64-unknown-linux-gnu",
-      "aarch64-unknown-linux-musl",
-      "aarch64-pc-windows-msvc",
-      "armv7-unknown-linux-gnueabihf",
-      "armv7-unknown-linux-musleabihf",
-      "x86_64-unknown-linux-musl",
-      "armv7-linux-androideabi",
-      "universal-apple-darwin",
-      "riscv64gc-unknown-linux-gnu"
-    ]
+    "name": "nodejs",
+    "triples": {
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-linux-android",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "aarch64-pc-windows-msvc",
+        "armv7-unknown-linux-gnueabihf",
+        "armv7-unknown-linux-musleabihf",
+        "x86_64-unknown-linux-musl",
+        "armv7-linux-androideabi",
+        "universal-apple-darwin",
+        "riscv64gc-unknown-linux-gnu"
+      ]
+    }
   },
   "license": "MIT",
   "devDependencies": {
-    "@napi-rs/cli": "^3.3",
+    "@napi-rs/cli": "^2.18.4",
     "ava": "^6.0.1"
   },
   "ava": {
@@ -36,7 +38,7 @@
     "build:debug": "napi build --platform",
     "prepublishOnly": "napi prepublish -t npm",
     "test": "ava",
-    "universal": "napi universalize",
+    "universal": "napi universal",
     "version": "napi version"
   }
-}
+}

bindings/nodejs/src/model.rs

@@ -1,6 +1,6 @@
 #![deny(clippy::all)]
 
-use napi::{self, bindgen_prelude::*, Result, Unknown};
+use napi::{self, bindgen_prelude::*, JsUnknown, Result};
 use serde::Serialize;
 
 use ironcalc::{
@@ -127,7 +127,7 @@ impl Model {
     sheet: u32,
     row: i32,
     column: i32,
-    style: Unknown,
+    style: JsUnknown,
   ) -> Result<()> {
     let style: Style = env
       .from_js_value(style)
@@ -140,12 +140,12 @@ impl Model {
 
   #[napi(js_name = "getCellStyle")]
   pub fn get_cell_style(
-    &'_ self,
+    &mut self,
     env: Env,
     sheet: u32,
     row: i32,
     column: i32,
-  ) -> Result<Unknown<'_>> {
+  ) -> Result<JsUnknown> {
     let style = self
       .model
       .get_style_for_cell(sheet, row, column)
@@ -246,11 +246,11 @@ impl Model {
       .map_err(to_js_error)
   }
 
-  // I don't _think_ serializing to Unknown can't fail
+  // I don't _think_ serializing to JsUnknown can't fail
   // FIXME: Remove this clippy directive
   #[napi(js_name = "getWorksheetsProperties")]
   #[allow(clippy::unwrap_used)]
-  pub fn get_worksheets_properties(&'_ self, env: Env) -> Unknown<'_> {
+  pub fn get_worksheets_properties(&self, env: Env) -> JsUnknown {
     env
       .to_js_value(&self.model.get_worksheets_properties())
       .unwrap()
@@ -288,7 +288,7 @@ impl Model {
   }
 
   #[napi(js_name = "getDefinedNameList")]
-  pub fn get_defined_name_list(&'_ self, env: Env) -> Result<Unknown<'_>> {
+  pub fn get_defined_name_list(&self, env: Env) -> Result<JsUnknown> {
     let data: Vec<DefinedName> = self
       .model
       .workbook

bindings/nodejs/src/user_model.rs

@@ -2,7 +2,7 @@
 
 use serde::Serialize;
 
-use napi::{self, bindgen_prelude::*, Result, Unknown};
+use napi::{self, bindgen_prelude::*, JsUnknown, Result};
 
 use ironcalc::base::{
   expressions::types::Area,
@@ -305,7 +305,7 @@ impl UserModel {
   pub fn update_range_style(
     &mut self,
     env: Env,
-    range: Unknown,
+    range: JsUnknown,
     style_path: String,
     value: String,
   ) -> Result<()> {
@@ -320,12 +320,12 @@ impl UserModel {
 
   #[napi(js_name = "getCellStyle")]
   pub fn get_cell_style(
-    &'_ mut self,
+    &mut self,
     env: Env,
     sheet: u32,
     row: i32,
     column: i32,
-  ) -> Result<Unknown<'_>> {
+  ) -> Result<JsUnknown> {
     let style = self
       .model
       .get_cell_style(sheet, row, column)
@@ -337,7 +337,7 @@ impl UserModel {
   }
 
   #[napi(js_name = "onPasteStyles")]
-  pub fn on_paste_styles(&mut self, env: Env, styles: Unknown) -> Result<()> {
+  pub fn on_paste_styles(&mut self, env: Env, styles: JsUnknown) -> Result<()> {
     let styles: &Vec<Vec<Style>> = &env
       .from_js_value(styles)
       .map_err(|e| to_js_error(e.to_string()))?;
@@ -362,11 +362,11 @@ impl UserModel {
     )
   }
 
-  // I don't _think_ serializing to Unknown can't fail
+  // I don't _think_ serializing to JsUnknown can't fail
   // FIXME: Remove this clippy directive
   #[napi(js_name = "getWorksheetsProperties")]
   #[allow(clippy::unwrap_used)]
-  pub fn get_worksheets_properties(&'_ self, env: Env) -> Unknown<'_> {
+  pub fn get_worksheets_properties(&self, env: Env) -> JsUnknown {
     env
       .to_js_value(&self.model.get_worksheets_properties())
       .unwrap()
@@ -383,11 +383,11 @@ impl UserModel {
     vec![sheet as i32, row, column]
   }
 
-  // I don't _think_ serializing to Unknown can't fail
+  // I don't _think_ serializing to JsUnknown can't fail
   // FIXME: Remove this clippy directive
   #[napi(js_name = "getSelectedView")]
   #[allow(clippy::unwrap_used)]
-  pub fn get_selected_view(&'_ self, env: Env) -> Unknown<'_> {
+  pub fn get_selected_view(&self, env: Env) -> JsUnknown {
     env.to_js_value(&self.model.get_selected_view()).unwrap()
   }
 
@@ -440,7 +440,7 @@ impl UserModel {
   }
 
   #[napi(js_name = "autoFillRows")]
-  pub fn auto_fill_rows(&mut self, env: Env, source_area: Unknown, to_row: i32) -> Result<()> {
+  pub fn auto_fill_rows(&mut self, env: Env, source_area: JsUnknown, to_row: i32) -> Result<()> {
     let area: Area = env
       .from_js_value(source_area)
       .map_err(|e| to_js_error(e.to_string()))?;
@@ -454,7 +454,7 @@ impl UserModel {
   pub fn auto_fill_columns(
     &mut self,
     env: Env,
-    source_area: Unknown,
+    source_area: JsUnknown,
     to_column: i32,
   ) -> Result<()> {
     let area: Area = env
@@ -536,8 +536,8 @@ impl UserModel {
   pub fn set_area_with_border(
     &mut self,
     env: Env,
-    area: Unknown,
-    border_area: Unknown,
+    area: JsUnknown,
+    border_area: JsUnknown,
   ) -> Result<()> {
     let range: Area = env
       .from_js_value(area)
@@ -568,7 +568,7 @@ impl UserModel {
   }
 
   #[napi(js_name = "copyToClipboard")]
-  pub fn copy_to_clipboard(&'_ self, env: Env) -> Result<Unknown<'_>> {
+  pub fn copy_to_clipboard(&self, env: Env) -> Result<JsUnknown> {
     let data = self
       .model
       .copy_to_clipboard()
@@ -584,8 +584,8 @@ impl UserModel {
     &mut self,
     env: Env,
     source_sheet: u32,
-    source_range: Unknown,
-    clipboard: Unknown,
+    source_range: JsUnknown,
+    clipboard: JsUnknown,
     is_cut: bool,
   ) -> Result<()> {
     let source_range: (i32, i32, i32, i32) = env
@@ -601,7 +601,7 @@ impl UserModel {
   }
 
   #[napi(js_name = "pasteCsvText")]
-  pub fn paste_csv_string(&mut self, env: Env, area: Unknown, csv: String) -> Result<()> {
+  pub fn paste_csv_string(&mut self, env: Env, area: JsUnknown, csv: String) -> Result<()> {
     let range: Area = env
       .from_js_value(area)
       .map_err(|e| to_js_error(e.to_string()))?;
@@ -612,7 +612,7 @@ impl UserModel {
   }
 
   #[napi(js_name = "getDefinedNameList")]
-  pub fn get_defined_name_list(&'_ self, env: Env) -> Result<Unknown<'_>> {
+  pub fn get_defined_name_list(&self, env: Env) -> Result<JsUnknown> {
     let data: Vec<DefinedName> = self
       .model
       .get_defined_name_list()

bindings/wasm/src/lib.rs

@@ -5,7 +5,11 @@ use wasm_bindgen::{
 };
 
 use ironcalc_base::{
-    expressions::{lexer::util::get_tokens as tokenizer, types::Area, utils::number_to_column},
+    expressions::{
+        lexer::util::get_tokens as tokenizer,
+        types::Area,
+        utils::{number_to_column, quote_name as quote_name_ic},
+    },
     types::{CellType, Style},
     worksheet::NavigationDirection,
     BorderArea, ClipboardData, UserModel as BaseModel,
@@ -31,6 +35,11 @@ pub fn column_name_from_number(column: i32) -> Result<String, JsError> {
     }
 }
 
+#[wasm_bindgen(js_name = "quoteName")]
+pub fn quote_name(name: &str) -> String {
+    quote_name_ic(name)
+}
+
 #[derive(Serialize)]
 struct DefinedName {
     name: String,
@@ -766,4 +775,17 @@ impl Model {
             .get_first_non_empty_in_row_after_column(sheet, row, column)
             .map_err(to_js_error)
     }
+
+    #[wasm_bindgen(js_name = "isValidDefinedName")]
+    pub fn is_valid_defined_name(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<(), JsError> {
+        match self.model.is_valid_defined_name(name, scope, formula) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(to_js_error(e.to_string())),
+        }
+    }
 }

docker-compose.yml

@@ -1,10 +1,12 @@
 services:
   server:
+    image: ghcr.io/ironcalc/ironcalc-server:0.6.0
     build:
       context: .
       target: server-runtime
 
   caddy:
+    image: ghcr.io/ironcalc/ironcalc-caddy:0.6.0
     build:
       context: .
       target: caddy-runtime

docs/package.json

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

docs/src/.vitepress/config.mts

@@ -2036,6 +2036,10 @@ export default defineConfig({
             text: "How to contribute",
             link: "/contributing/how-to-contribute",
           },
+          {
+            text: "Function documentation guide",
+            link: "/contributing/function-documentation-guide",
+          },
         ],
       },
     ],

docs/src/contributing/function-documentation-guide.md

@@ -0,0 +1,389 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Function Documentation Guide
+
+This guide explains how to document IronCalc functions following our established format and style conventions.
+
+## File Structure
+
+Function documentation files should be placed in the appropriate category directory under `src/functions/`. For example:
+
+- Financial functions: `src/functions/financial/function-name.md`
+- Text functions: `src/functions/text/function-name.md`
+- Logical functions: `src/functions/logical/function-name.md`
+
+## Required Frontmatter
+
+Every function documentation file must start with this frontmatter:
+
+```yaml
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+```
+
+## Document Structure
+
+A complete function documentation should include the following sections in order:
+
+### 1. Title
+
+The title should be the function name followed by the word "function":
+
+```markdown
+# FV function
+```
+
+The function name should be written in uppercase when mentioned in the documentation.
+
+### 2. Draft Warning (Optional)
+
+If the function hasn't been implemented, include this warning box:
+
+```markdown
+::: warning
+**Note:** This draft page is under construction 🚧
+:::
+```
+
+If the function has been implemented but not documented, include this warning box:
+
+```markdown
+::: warning
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
+:::
+```
+
+### 3. Overview
+
+Provide a brief, clear description of what the function does. If the function name is an acronym, expand it using underlined text:
+
+```markdown
+## Overview
+
+FV (<u>F</u>uture <u>V</u>alue) is a function of the Financial category that can be used to predict the future value of an investment or asset based on its present value.
+```
+
+Include:
+
+- Category (Financial, Text, Logical, etc.)
+- Primary purpose
+- Key use cases (if helpful)
+
+### 4. Usage
+
+This section contains multiple subsections:
+
+#### 4.1 Syntax
+
+Format the function syntax with color-coded argument types. Use the following color scheme:
+
+- **Numbers**: `#2F80ED` (blue)
+- **Booleans**: `#27AE60` (green)
+- **Text/Strings**: `#2F80ED` (orange)
+- **Arrays/Ranges**: `#EB5757` (red)
+
+**Format:**
+
+```markdown
+### Syntax
+
+**FUNCTION_NAME(<span title="Type" style="color:#HEXCODE">arg1</span>, <span title="Type" style="color:#HEXCODE">arg2</span>=default, ...) => <span title="ReturnType" style="color:#HEXCODE">return_value</span>**
+```
+
+**Example:**
+
+**FV(<span title="Number" style="color:#2F80ED">rate</span>, <span title="Number" style="color:#2F80ED">nper</span>, <span title="Number" style="color:#2F80ED">pmt</span>, [<span title="Number" style="color:#2F80ED">pv</span>], [<span title="Boolean" style="color:#27AE60">type</span>]  => <span title="Number" style="color:#2F80ED">fv</span>**
+
+```markdown
+### Syntax
+
+**FV(<span title="Number" style="color:#2F80ED">rate</span>, <span title="Number" style="color:#2F80ED">nper</span>, <span title="Number" style="color:#2F80ED">pmt</span>, <span title="Number" style="color:#2F80ED">pv</span>=0, <span title="Boolean" style="color:#27AE60">type</span>=FALSE) => <span title="Number" style="color:#2F80ED">fv</span>**
+```
+
+**Guidelines:**
+
+- Use `title` attribute to specify the data type
+- Use `style="color:#HEXCODE"` for syntax highlighting
+- Use square brackets for optional arguments
+- Show the return type after `=>`
+- Make the entire syntax **bold**
+
+#### 4.2 Argument Descriptions
+
+List each argument with:
+
+- Argument name in _italics_
+- Data type link (e.g., `[number](/features/value-types#numbers)`)
+- Required or optional indicator
+- Description
+
+**Format:**
+
+```markdown
+### Argument descriptions
+
+- _argname_ ([datatype](/features/value-types#datatype), [required|optional](/features/optional-arguments.md)). Description of the argument.
+```
+
+**Example:**
+
+```markdown
+### Argument descriptions
+
+- _rate_ ([number](/features/value-types#numbers), required). The fixed percentage interest rate or yield per period.
+- _pv_ ([number](/features/value-types#numbers), [optional](/features/optional-arguments.md)). "pv" is the <u>p</u>resent <u>v</u>alue or starting amount of the asset (default 0).
+- _type_ ([Boolean](/features/value-types#booleans), [optional](/features/optional-arguments.md)). A logical value indicating whether the payment due dates are at the end (FALSE or 0) of the compounding periods or at the beginning (TRUE or any non-zero value). The default is FALSE when omitted.
+```
+
+**Guidelines:**
+
+- Use bullet points (`*`)
+- Italicize argument names with `*argname*`
+- Link to value types documentation
+- Link to optional arguments page when applicable
+- Expand acronyms in descriptions using `<u>` tags if helpful
+- Mention default values for optional arguments
+
+#### 4.3 Additional Guidance
+
+Provide tips, best practices and important notes about using the function:
+
+```markdown
+### Additional guidance
+
+- Make sure that the _rate_ argument specifies the interest rate or yield applicable to the compounding period.
+- The _pmt_ and _pv_ arguments should be expressed in the same currency unit.
+- To ensure a worthwhile result, one of the _pmt_ and _pv_ arguments should be non-zero.
+```
+
+#### 4.4 Returned Value
+
+Describe what the function returns:
+
+```markdown
+### Returned value
+
+FV returns a [number](/features/value-types#numbers) representing the future value expressed in the same [currency unit](/features/units) that was used for the _pmt_ and _pv_ arguments.
+```
+
+Include:
+
+- Return type (with link to value types if applicable)
+- Units or format if relevant
+- Any important characteristics
+
+#### 4.5 Error Conditions
+
+List all error scenarios the function may encounter:
+
+```markdown
+### Error conditions
+
+- In common with many other IronCalc functions, FV propagates errors that are found in any of its arguments.
+- If too few or too many arguments are supplied, FV returns the [`#ERROR!`](/features/error-types.md#error) error.
+- If the value of any of the _rate_, _nper_, _pmt_ or _pv_ arguments is not (or cannot be converted to) a [number](/features/value-types#numbers), then FV returns the [`#VALUE!`](/features/error-types.md#value) error.
+- If the value of the _type_ argument is not (or cannot be converted to) a [Boolean](/features/value-types#booleans), then FV again returns the [`#VALUE!`](/features/error-types.md#value) error.
+- For some combinations of valid argument values, FV may return a [`#NUM!`](/features/error-types.md#num) error or a [`#DIV/0!`](/features/error-types.md#div-0) error.
+```
+
+**Guidelines:**
+
+- Use bullet points
+- Format error types using backticks and link to the error types page: `` [`#ERROR!`](/features/error-types.md#error) ``
+- Reference argument names in italics when discussing specific arguments
+- Add the include directive at the end if using the error details snippet:
+
+```markdown
+<!--@include: ../markdown-snippets/error-type-details.txt-->
+```
+
+### 5. Details (Optional but Recommended)
+
+For functions with mathematical formulas or complex behavior, include a Details section. This section can also include plots, graphs or charts to help clarify the function's behavior. 
+
+```markdown
+## Details
+
+- If $\text{type} \neq 0$, $\text{fv}$ is given by the equation:
+  $$ \text{fv} = -\text{pv} \times (1 + \text{rate})^\text{nper} - \dfrac{\text{pmt}\times\big({(1+\text{rate})^\text{nper}-1}\big) \times(1+\text{rate})}{\text{rate}}$$
+
+- If $\text{type} = 0$, $\text{fv}$ is given by the equation:
+  $$ \text{fv} = -\text{pv} \times (1 + \text{rate})^{\text{nper}} - \dfrac{\text{pmt}\times\big({(1+\text{rate})^\text{nper}-1}\big)}{\text{rate}}$$
+```
+
+**Guidelines:**
+
+- Use LaTeX math notation with `$` for inline and `$$` for block equations
+- Use `\text{}` for variable names in equations
+- Explain special cases or edge conditions
+
+### 6. Examples
+
+Link to interactive examples in IronCalc:
+
+```markdown
+## Examples
+
+[See some examples in IronCalc](https://app.ironcalc.com/?example=functionname).
+```
+
+Replace `functionname` with the actual function name (lowercase).
+
+### 7. Links
+
+Provide external references and related functions:
+
+```markdown
+## Links
+
+- For more information about the concept of "future value" in finance, visit Wikipedia's [Future value](https://en.wikipedia.org/wiki/Future_value) page.
+- See also IronCalc's [NPER](/functions/financial/nper), [PMT](/functions/financial/pmt), [PV](/functions/financial/pv) and [RATE](/functions/financial/rate) functions.
+- Visit Microsoft Excel's [FV function](https://support.microsoft.com/en-gb/office/fv-function-2eef9f44-a084-4c61-bdd8-4fe4bb1b71b3) page.
+- Both [Google Sheets](https://support.google.com/docs/answer/3093224) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/FV) provide versions of the FV function.
+```
+
+**Guidelines:**
+
+- Include Wikipedia links for concepts when available
+- Link to related IronCalc functions in the same category
+- Include links to equivalent functions in Excel, Google Sheets, and LibreOffice Calc
+- Use bullet points
+
+## Syntax Coloring Reference
+
+### Color Codes
+
+| Data Type   | Hex Color | Usage                                   |
+| ----------- | --------- | --------------------------------------- |
+| Number      | `#2F80ED` | All numeric arguments and return values |
+| Boolean     | `#27AE60` | TRUE/FALSE arguments                    |
+| Text/String | `#F2994A` | Text arguments                          |
+| Array/Range | `#EB5757` | Array or range arguments                |
+
+### Syntax Highlighting Template
+
+```html
+<span title="Type" style="color:#HEXCODE">argument_name</span>
+```
+
+**Examples:**
+
+- Number: `<span title="Number" style="color:#2F80ED">rate</span>`
+- Boolean: `<span title="Boolean" style="color:#27AE60">type</span>`
+- Text: `<span title="Text" style="color:#F2994A">text</span>`
+
+## Formatting Conventions
+
+### Text Formatting
+
+- **Function names**: Use exact case as in IronCalc
+- **Argument names**: Use _italics_ when referencing in prose
+- **Acronyms**: Expand using `<u>` tags: `<u>F</u>uture <u>V</u>alue`
+- **Code/values**: Use backticks for error codes: `` `#ERROR!` ``
+- **Links**: Use descriptive link text, not raw URLs
+
+### Section Headers
+
+- Use `#` for the page title with the function name (e.g., FV Function)
+- Use `##` for main sections (Overview, Usage, Details, Examples, Links)
+- Use `###` for subsections (Syntax, Argument descriptions, etc.)
+
+### Lists
+
+- Use bullet points (`*`) for argument descriptions and error conditions
+- Use numbered lists only when order matters
+
+## Checklist
+
+Before submitting a function documentation, ensure:
+
+- [ ] Frontmatter is correct
+- [ ] Title follows the format "FUNCTION_NAME function"
+- [ ] Overview clearly explains the function's purpose
+- [ ] Syntax is color-coded correctly
+- [ ] All arguments are documented with correct types
+- [ ] Required vs optional arguments are clearly marked
+- [ ] Return value is described
+- [ ] Error conditions are comprehensive
+- [ ] Examples link is included
+- [ ] Links section includes relevant references
+- [ ] Mathematical formulas (if any) use proper LaTeX syntax
+- [ ] All internal links use relative paths
+- [ ] Spelling and grammar are correct
+
+## Example Template
+
+```markdown
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# FUNCTION_NAME function
+
+::: warning
+**Note:** This draft page is under construction 🚧
+:::
+
+## Overview
+
+FUNCTION_NAME (<u>A</u>cronym <u>E</u>xplanation) is a function of the [Category] category that can be used to [primary purpose].
+
+[Additional context about when to use this function or related functions.]
+
+## Usage
+
+### Syntax
+
+**FUNCTION_NAME(<span title="Type" style="color:#2F80ED">arg1</span>, [<span title="Type" style="color:#2F80ED">arg2</span>], [<span title="Boolean" style="color:#27AE60">arg3</span>]) => <span title="Type" style="color:#2F80ED">return_value</span>**
+
+### Argument descriptions
+
+- _arg1_ ([type](/features/value-types#type), required). Description.
+- _arg2_ ([type](/features/value-types#type), [optional](/features/optional-arguments.md)). Description (default value).
+- _arg3_ ([Boolean](/features/value-types#booleans), [optional](/features/optional-arguments.md)). Description (default FALSE).
+
+### Additional guidance
+
+- Tip or best practice.
+- Another important note.
+
+### Returned value
+
+FUNCTION_NAME returns a [type](/features/value-types#type) representing [description].
+
+### Error conditions
+
+- General error propagation note.
+- Specific error condition with [`#ERROR!`](/features/error-types.md#error) link.
+- Another error condition.
+
+<!--@include: ../markdown-snippets/error-type-details.txt-->
+
+## Details
+
+[Mathematical formulas or detailed explanations if needed]
+
+## Examples
+
+[See some examples in IronCalc](https://app.ironcalc.com/?example=functionname).
+
+## Links
+
+- Wikipedia link if applicable.
+- Related IronCalc functions.
+- Microsoft Excel documentation.
+- Google Sheets and LibreOffice Calc links.
+```
+
+## Questions?
+
+If you have questions about documenting functions, reach out on our [Discord Channel](https://discord.com/invite/zZYWfh3RHJ) or check existing function documentation for examples.

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

@@ -6,4 +6,10 @@ lang: en-US
 
 # How to Contribute
 
-If you want to give us a hand, take a look at our [GitHub repository](https://github.com/ironcalc/IronCalc?tab=readme-ov-file#collaborators-needed-call-to-action), join our [Discord Channel](https://discord.com/invite/zZYWfh3RHJ) or send us an email to [hello@ironcalc.com](mailto:hello@ironcalc.com).
+If you want to give us a hand, take a look at our [GitHub repository](https://github.com/ironcalc/IronCalc?tab=readme-ov-file#collaborators-needed-call-to-action) – we've marked some issues there with the tag 'good first issue' that could serve you as a starting point.
+
+If you also want to discuss topics, share your thoughts or just say 'hi', you can join our [Discord Channel](https://discord.com/invite/zZYWfh3RHJ) or send us an email to [hello@ironcalc.com](mailto:hello@ironcalc.com).
+
+## Documentation
+
+If you're interested in contributing to our documentation, especially function documentation, please see our [Function Documentation Guide](/contributing/function-documentation-guide).

docs/src/features/value-types.md

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

docs/src/functions/date-and-time.md

@@ -6,28 +6,27 @@ lang: en-US
 
 # Date and Time functions
 
-At the moment IronCalc only supports a few function in this section.  
-You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/48).
+All Date and Time functions are already supported in IronCalc.
 
 | Function         | Status                                         | Documentation |
 | ---------------- | ---------------------------------------------- | ------------- |
 | DATE             | <Badge type="tip" text="Available" />          | –             |
-| DATEDIF          | <Badge type="tip" text="Available" />          | [DATEDIF](date_and_time/datedif) |
+| DATEDIF          | <Badge type="tip" text="Available" />          | –             |
 | DATEVALUE        | <Badge type="tip" text="Available" />          | [DATEVALUE](date_and_time/datevalue) |
 | DAY              | <Badge type="tip" text="Available" />          | [DAY](date_and_time/day) |
 | DAYS             | <Badge type="tip" text="Available" />          | –             |
 | DAYS360          | <Badge type="tip" text="Available" />          | –             |
 | EDATE            | <Badge type="tip" text="Available" />          | –             |
 | EOMONTH          | <Badge type="tip" text="Available" />          | –             |
-| HOUR             | <Badge type="tip" text="Available" />          | [HOUR](date_and_time/hour) |
+| HOUR             | <Badge type="tip" text="Available" />          | –             |
 | ISOWEEKNUM       | <Badge type="tip" text="Available" />          | –             |
-| MINUTE           | <Badge type="tip" text="Available" />          | [MINUTE](date_and_time/minute) |
+| MINUTE           | <Badge type="tip" text="Available" />          | –             |
 | MONTH            | <Badge type="tip" text="Available" />          | [MONTH](date_and_time/month) |
 | NETWORKDAYS      | <Badge type="tip" text="Available" />          | [NETWORKDAYS](date_and_time/networkdays) |
 | NETWORKDAYS.INTL | <Badge type="tip" text="Available" />          | [NETWORKDAYS.INTL](date_and_time/networkdays.intl) |
 | NOW              | <Badge type="tip" text="Available" />          | –             |
-| SECOND           | <Badge type="tip" text="Available" />          | [SECOND](date_and_time/second) |
-| TIME             | <Badge type="tip" text="Available" />          | [TIME](date_and_time/time) |
+| SECOND           | <Badge type="tip" text="Available" />          | –             |
+| TIME             | <Badge type="tip" text="Available" />          | –             |
 | TIMEVALUE        | <Badge type="tip" text="Available" />          | [TIMEVALUE](date_and_time/timevalue) |
 | TODAY            | <Badge type="tip" text="Available" />          | –             |
 | WEEKDAY          | <Badge type="tip" text="Available" />          | –             |

docs/src/functions/date_and_time/datevalue.md

@@ -4,8 +4,41 @@ outline: deep
 lang: en-US
 ---
 
-# DATEVALUE
+# DATEVALUE function
 
-::: warning
-🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-:::
+## Overview
+DATEVALUE is a function of the Date and Time category that converts a date stored as text to a [serial number](/features/serial-numbers.md) corresponding to a date value.
+
+## Usage
+### Syntax
+**DATEVALUE(<span title="Text" style="color:#1E88E5">date_text</span>) => <span title="Number" style="color:#1E88E5">datevalue</span>**
+
+### Argument descriptions
+* *date_text* ([text](/features/value-types#strings), required). A text string that represents a date in a known format. The text must represent a date between December 31, 1899 and December 31, 9999.
+
+### Additional guidance
+* If the year portion of the *date_text* argument is omitted, DATEVALUE uses the current year from the system clock.
+* Time information in the *date_text* argument is ignored. DATEVALUE processes only the date portion.
+
+### Returned value
+DATEVALUE returns a [number](/features/value-types#numbers) that represents the date as a [serial number](/features/serial-numbers.md). The serial number corresponds to the number of days since December 31, 1899.
+
+### Error conditions
+* In common with many other IronCalc functions, DATEVALUE propagates errors that are found in its argument.
+* If no argument, or more than one argument, is supplied, then DATEVALUE returns the [`#ERROR!`](/features/error-types.md#error) error.
+* If the value of the *date_text* argument is not (or cannot be converted to) a [text](/features/value-types#strings) value, then DATEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
+* If the *date_text* argument represents a date outside the valid range (before December 31, 1899 or after December 31, 9999), then DATEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
+* If the *date_text* argument cannot be recognized as a valid date format, then DATEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
+<!--@include: ../markdown-snippets/error-type-details.txt-->
+
+<!-- ## Details
+For more information on how IronCalc processes Date and Time functions and values, visit [Date and Time](/features/serial-numbers.md) 
+
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=datevalue).
+-->
+
+## Links
+* See also IronCalc's [TIMEVALUE](/functions/date_and_time/timevalue.md) function for converting time text to serial numbers.
+* Visit Microsoft Excel's [DATEVALUE function](https://support.microsoft.com/en-us/office/datevalue-function-df8b07d4-7761-4a93-bc33-b7471bbff252) page.
+* Both [Google Sheets](https://support.google.com/docs/answer/3093039) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/DATEVALUE) provide versions of the DATEVALUE function.

docs/src/functions/date_and_time/networkdays.intl.md

@@ -22,7 +22,7 @@ NETWORKDAYS.INTL is a function of the Date and Time category that calculates the
 * *start_date* ([number](/features/value-types#numbers), required). The start date expressed as a [serial number](/features/serial-numbers.md).
 * *end_date* ([number](/features/value-types#numbers), required). The end date expressed as a [serial number](/features/serial-numbers.md).
 * *weekend* ([number](/features/value-types#numbers) or [string](/features/value-types#strings), optional). Defines which days are considered weekends. Default is 1 (Saturday-Sunday).
-* *holidays* ([array](/features/value-types#arrays) or [range](/features/ranges), optional). A list of dates to exclude from the calculation, expressed as serial numbers.
+* *holidays* ([array](/features/value-types#arrays) or [range](/features/value-types#ranges), optional). A list of dates to exclude from the calculation, expressed as serial numbers.
 
 ### Weekend parameter options
 The _weekend_ parameter can be specified in two ways:

docs/src/functions/date_and_time/networkdays.md

@@ -21,7 +21,7 @@ NETWORKDAYS is a function of the Date and Time category that calculates the numb
 ### Argument descriptions
 * *start_date* ([number](/features/value-types#numbers), required). The start date expressed as a [serial number](/features/serial-numbers.md).
 * *end_date* ([number](/features/value-types#numbers), required). The end date expressed as a [serial number](/features/serial-numbers.md).
-* *holidays* ([array](/features/value-types#arrays) or [range](/features/ranges), optional). A list of dates to exclude from the calculation, expressed as serial numbers.
+* *holidays* ([array](/features/value-types#arrays) or [range](/features/value-types#ranges), optional). A list of dates to exclude from the calculation, expressed as serial numbers.
 
 ### Additional guidance
 - If the supplied _start_date_ and _end_date_ arguments have fractional parts, NETWORKDAYS uses their [floor values](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions).

docs/src/functions/date_and_time/timevalue.md

@@ -4,9 +4,42 @@ outline: deep
 lang: en-US
 ---
 
-# TIMEVALUE
+# TIMEVALUE function
 
-::: warning
-**Note:** This draft page is under construction 🚧
-The TIMEVALUE function is implemented and available in IronCalc.
-:::
+## Overview
+TIMEVALUE is a function of the Date and Time category that converts a time stored as text to a [serial number](/features/serial-numbers.md) corresponding to a time value. The serial number represents time as a decimal fraction of a 24-hour day (e.g., 0.5 represents 12:00:00 noon).
+
+## Usage
+### Syntax
+**TIMEVALUE(<span title="Text" style="color:#1E88E5">time_text</span>) => <span title="Number" style="color:#1E88E5">timevalue</span>**
+
+### Argument descriptions
+* *time_text* ([text](/features/value-types#strings), required). A text string that represents a time in a known format. The text must represent a time between 00:00:00 and 23:59:59.
+
+### Additional guidance
+* Date information in the *time_text* argument is ignored. TIMEVALUE processes only the time portion.
+* The function can handle various time formats, including both 12-hour and 24-hour formats, as well as text that includes both date and time information.
+
+### Returned value
+TIMEVALUE returns a [number](/features/value-types#numbers) that represents the time as a [serial number](/features/serial-numbers.md). The serial number is a decimal fraction of a 24-hour day, where:
+* 0.0 represents 00:00:00 (midnight)
+* 0.5 represents 12:00:00 (midday)
+* 0.99999... represents 23:59:59 (just before midnight)
+
+### Error conditions
+* In common with many other IronCalc functions, TIMEVALUE propagates errors that are found in its argument.
+* If no argument, or more than one argument, is supplied, then TIMEVALUE returns the [`#ERROR!`](/features/error-types.md#error) error.
+* If the value of the *time_text* argument is not (or cannot be converted to) a [text](/features/value-types#strings) value, then TIMEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
+* If the *time_text* argument represents a time outside the valid range, then TIMEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
+* If the *time_text* argument cannot be recognized as a valid time format, then TIMEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
+<!--@include: ../markdown-snippets/error-type-details.txt-->
+
+<!--
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=timevalue).
+-->
+
+## Links
+* See also IronCalc's [DATEVALUE](/functions/date_and_time/datevalue.md) function for converting date text to serial numbers.
+* Visit Microsoft Excel's [TIMEVALUE function](https://support.microsoft.com/en-us/office/timevalue-function-0b615c12-33d8-4431-bf3d-f3eb6d186645) page.
+* Both [Google Sheets](https://support.google.com/docs/answer/3267350) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/TIMEVALUE) provide versions of the TIMEVALUE function.

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

@@ -14,10 +14,10 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | ABS             | <Badge type="tip" text="Available" />          | –             |
 | ACOS            | <Badge type="tip" text="Available" />          | [ACOS](math_and_trigonometry/acos) |
 | ACOSH           | <Badge type="tip" text="Available" />          | [ACOSH](math_and_trigonometry/acosh) |
-| ACOT            | <Badge type="info" text="Not implemented yet" /> | –             |
-| ACOTH           | <Badge type="info" text="Not implemented yet" /> | –             |
+| ACOT            | <Badge type="tip" text="Available" />          | –             |
+| ACOTH           | <Badge type="tip" text="Available" />          | –             |
 | AGGREGATE       | <Badge type="info" text="Not implemented yet" /> | –             |
-| ARABIC          | <Badge type="info" text="Not implemented yet" /> | –             |
+| ARABIC          | <Badge type="tip" text="Available" />          | –             |
 | ASIN            | <Badge type="tip" text="Available" />          | [ASIN](math_and_trigonometry/asin) |
 | ASINH           | <Badge type="tip" text="Available" />          | [ASINH](math_and_trigonometry/asinh) |
 | ATAN            | <Badge type="tip" text="Available" />          | [ATAN](math_and_trigonometry/atan) |
@@ -27,64 +27,64 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | CEILING         | <Badge type="info" text="Not implemented yet" /> | –             |
 | CEILING.MATH    | <Badge type="info" text="Not implemented yet" /> | –             |
 | CEILING.PRECISE | <Badge type="info" text="Not implemented yet" /> | –             |
-| COMBIN          | <Badge type="info" text="Not implemented yet" /> | –             |
-| COMBINA         | <Badge type="info" text="Not implemented yet" /> | –             |
+| COMBIN          | <Badge type="tip" text="Available" />          | –             |
+| COMBINA         | <Badge type="tip" text="Available" />          | –             |
 | COS             | <Badge type="tip" text="Available" />          | [COS](math_and_trigonometry/cos) |
 | COSH            | <Badge type="tip" text="Available" />          | [COSH](math_and_trigonometry/cosh) |
-| COT             | <Badge type="info" text="Not implemented yet" /> | –             |
-| COTH            | <Badge type="info" text="Not implemented yet" /> | –             |
-| CSC             | <Badge type="info" text="Not implemented yet" /> | –             |
-| CSCH            | <Badge type="info" text="Not implemented yet" /> | –             |
+| COT             | <Badge type="tip" text="Available" />          | –             |
+| COTH            | <Badge type="tip" text="Available" />          | –             |
+| CSC             | <Badge type="tip" text="Available" />          | –             |
+| CSCH            | <Badge type="tip" text="Available" />          | –             |
 | DECIMAL         | <Badge type="info" text="Not implemented yet" /> | –             |
-| DEGREES         | <Badge type="info" text="Not implemented yet" /> | –             |
-| EVEN            | <Badge type="info" text="Not implemented yet" /> | –             |
-| EXP             | <Badge type="info" text="Not implemented yet" /> | –             |
+| DEGREES         | <Badge type="tip" text="Available" /> | [DEGREES](math_and_trigonometry/degrees) |
+| EVEN            | <Badge type="tip" text="Available" /> | [EVEN](math_and_trigonometry/even) |
+| EXP             | <Badge type="tip" text="Available" /> | –             |
 | FACT            | <Badge type="info" text="Not implemented yet" /> | –             |
 | FACTDOUBLE      | <Badge type="info" text="Not implemented yet" /> | –             |
 | FLOOR           | <Badge type="info" text="Not implemented yet" /> | –             |
 | FLOOR.MATH      | <Badge type="info" text="Not implemented yet" /> | –             |
 | FLOOR.PRECISE   | <Badge type="info" text="Not implemented yet" /> | –             |
 | GCD             | <Badge type="info" text="Not implemented yet" /> | –             |
-| INT             | <Badge type="info" text="Not implemented yet" /> | –             |
+| INT             | <Badge type="tip" text="Available" />          | –             |
 | ISO.CEILING     | <Badge type="info" text="Not implemented yet" /> | –             |
 | LCM             | <Badge type="info" text="Not implemented yet" /> | –             |
 | LET             | <Badge type="info" text="Not implemented yet" /> | –             |
-| LN              | <Badge type="info" text="Available" />           | –             |
-| LOG             | <Badge type="info" text="Available" />           | –             |
-| LOG10           | <Badge type="info" text="Available" />           | –             |
+| LN              | <Badge type="tip" text="Available" />           | –             |
+| LOG             | <Badge type="tip" text="Available" />           | –             |
+| LOG10           | <Badge type="tip" text="Available" />           | –             |
 | MDETERM         | <Badge type="info" text="Not implemented yet" /> | –             |
 | MINVERSE        | <Badge type="info" text="Not implemented yet" /> | –             |
 | MMULT           | <Badge type="info" text="Not implemented yet" /> | –             |
-| MOD             | <Badge type="info" text="Not implemented yet" /> | –             |
-| MROUND          | <Badge type="info" text="Not implemented yet" /> | –             |
+| MOD             | <Badge type="tip" text="Available" />          | [MOD](math_and_trigonometry/mod) |
+| MROUND          | <Badge type="tip" text="Available" />          | –             |
 | MULTINOMIAL     | <Badge type="info" text="Not implemented yet" /> | –             |
 | MUNIT           | <Badge type="info" text="Not implemented yet" /> | –             |
-| ODD             | <Badge type="info" text="Not implemented yet" /> | –             |
+| ODD             | <Badge type="tip" text="Available" /> | [ODD](math_and_trigonometry/odd) |
 | PI              | <Badge type="info" text="Not implemented yet" /> | –             |
 | POWER           | <Badge type="tip" text="Available" />          | –             |
 | PRODUCT         | <Badge type="tip" text="Available" />          | –             |
-| QUOTIENT        | <Badge type="info" text="Not implemented yet" /> | –             |
-| RADIANS         | <Badge type="info" text="Not implemented yet" /> | –             |
+| QUOTIENT        | <Badge type="tip" text="Available" /> | [QUOTIENT](math_and_trigonometry/quotient) |
+| RADIANS         | <Badge type="tip" text="Available" /> | [RADIANS](math_and_trigonometry/radians) |
 | RAND            | <Badge type="tip" text="Available" />          | –             |
 | RANDARRAY       | <Badge type="info" text="Not implemented yet" /> | –             |
 | RANDBETWEEN     | <Badge type="tip" text="Available" />          | –             |
-| ROMAN           | <Badge type="info" text="Not implemented yet" /> | –             |
+| ROMAN           | <Badge type="tip" text="Available" />          | –             |
 | ROUND           | <Badge type="tip" text="Available" />          | –             |
 | ROUNDDOWN       | <Badge type="tip" text="Available" />          | –             |
 | ROUNDUP         | <Badge type="tip" text="Available" />          | –             |
-| SEC             | <Badge type="info" text="Not implemented yet" /> | –             |
-| SECH            | <Badge type="info" text="Not implemented yet" /> | –             |
+| SEC             | <Badge type="tip" text="Available" />          | –             |
+| SECH            | <Badge type="tip" text="Available" />          | –             |
 | SERIESSUM       | <Badge type="info" text="Not implemented yet" /> | –             |
 | SEQUENCE        | <Badge type="info" text="Not implemented yet" /> | –             |
-| SIGN            | <Badge type="info" text="Not implemented yet" /> | –             |
+| SIGN            | <Badge type="tip" text="Available" /> | –             |
 | SIN             | <Badge type="tip" text="Available" />          | [SIN](math_and_trigonometry/sin) |
 | SINH            | <Badge type="tip" text="Available" />          | [SINH](math_and_trigonometry/sinh) |
 | SQRT            | <Badge type="tip" text="Available" />          | –             |
-| SQRTPI          | <Badge type="info" text="Available" />         | –             |
+| SQRTPI          | <Badge type="tip" text="Available" />         | –             |
 | SUBTOTAL        | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUM             | <Badge type="tip" text="Available" />          | –             |
 | SUMIF           | <Badge type="tip" text="Available" />          | –             |
-| SUMIFS          | <Badge type="info" text="Available" />         | –             |
+| SUMIFS          | <Badge type="tip" text="Available" />         | –             |
 | SUMPRODUCT      | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMSQ           | <Badge type="info" text="Not implemented yet" /> | –             |
 | SUMX2MY2        | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -92,4 +92,4 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | SUMXMY2         | <Badge type="info" text="Not implemented yet" /> | –             |
 | TAN             | <Badge type="tip" text="Available" />          | [TAN](math_and_trigonometry/tan) |
 | TANH            | <Badge type="tip" text="Available" />          | [TANH](math_and_trigonometry/tanh) |
-| TRUNC           | <Badge type="info" text="Not implemented yet" /> | –             |
+| TRUNC           | <Badge type="tip" text="Available" />          | –             |

docs/src/functions/math_and_trigonometry/acot.md

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

docs/src/functions/math_and_trigonometry/acoth.md

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

docs/src/functions/math_and_trigonometry/arabic.md

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

docs/src/functions/math_and_trigonometry/combin.md

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

docs/src/functions/math_and_trigonometry/combina.md

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