An open-source headless spreadsheet for business web apps
AllCellPrecedents={start}
let Q be an empty queue
Q.enqueue(start)
while Q is not empty do
cell := Q.dequeue()
S := getCellPrecedents(cell)
for all cells c in S do:
if c is not in AllCellPrecedents then:
insert w to AllCellPrecedents
Q.enqueue(c)
AllCellDependents={start}
let Q be an empty queue
Q.enqueue(start)
while Q is not empty do
cell := Q.dequeue()
S := getCellDependents(cell)
for all cells c in S do:
if c is not in AllCellDependents then:
insert w to AllCellDependents
Q.enqueue(c)
| {{ cell }} | }
| {{ cell }} |
| {String(cell ?? '')} | ))}
| {{ cell }} |
Result: {result}
{/if}| {#if hf.doesCellHaveFormula({ sheet: sheetId, row: r, col: c })} {hf.getCellFormula({ sheet: sheetId, row: r, col: c })} {:else} {hf.getCellValue({ sheet: sheetId, row: r, col: c })} {/if} | {/each}
Result: {result}
{/if} ``` ## Next steps - [Configuration options](https://hyperformula.handsontable.com/docs/guide/configuration-options.md) — full list of `buildFromArray` / `buildEmpty` options - [Basic operations](https://hyperformula.handsontable.com/docs/guide/basic-operations.md) — CRUD on cells, rows, columns, sheets - [Advanced usage](https://hyperformula.handsontable.com/docs/guide/advanced-usage.md) — multi-sheet workbooks, named expressions - [Custom functions](https://hyperformula.handsontable.com/docs/guide/custom-functions.md) — register your own formulas ## Demo For a more advanced example, check out the [Svelte demo on Stackblitz](https://stackblitz.com/github/handsontable/hyperformula-demos/tree/3.4.x/svelte-demo?v=). --- ## Named expressions URL: https://hyperformula.handsontable.com/docs/guide/named-expressions # Named expressions An expression can be assigned a human-friendly name. Thanks to this you can refer to that name anywhere across the workbook. Names are especially useful when you use some references repeatedly. In this case, names simplify the formulas and reduce the risk of making a mistake. Such a worksheet is also easier to maintain. You can name a formula, string, number, or any other type of data. By default, references in named expressions are absolute. Most people use absolute references in spreadsheet software like Excel without even knowing about it. Very few know that references can be relative too. Unfortunately, HyperFormula doesn't support relative references inside named expressions at the moment. Dynamic ranges are supported through functions such as INDEX and OFFSET. Named ranges can overlap each other, e.g., it is possible to define the names as follows: - rangeOne: Sheet1!$A$1:$D$10 - rangeTwo: Sheet1!$A$1:$E$1 ## Examples | Type | Custom name | Example expression | |:------------------------|:------------|:--------------------------| | Named cell | myCell | =Sheet1!$A$1 | | Named range of cells | myRange | =Sheet1!$A$1:$D$10 | | Named constant (number) | myNumber | =10 | | Named constant (string) | myText | ="One Small Step for Man" | | Named formula | myFormula | =SUM(Sheet1!$A$1:$D$10) | ## Naming rules Expression names are case-insensitive, and they: - Must start with a Unicode letter or with an underscore (`_`). - Can contain only Unicode letters, numbers, underscores, and periods (`.`). - Can't be the same as any possible reference in the A1 notation (for example, `Q4` or `YEAR2023`). - Can't be the same as any possible reference in the R1C1 notation (for example, `R4C5`, `RC` or `R0C`). - Must be unique within a given scope. > Expression names must be unique within a given scope, but you can override a > global named-expression with a local one. For example: > > ```javascript > // `MyRevenue` has to be unique within the global scope > hfInstance.addNamedExpression('MyRevenue', '=SUM(100+10)'); > > // but you can still use `MyRevenue` within the local scope of Sheet2 (sheetId = 1) > hfInstance.addNamedExpression('MyRevenue', '=Sheet2!$A$1+100', 1); > ``` For examples of valid and invalid expression names, see the following table: | Name | Validity | |:------------|:---------| | my Revenue | Invalid | | myRevenue | Valid | | quarter1 | Invalid | | quarter_1 | Valid | | 1stQuarter | Invalid | | _1stQuarter | Valid | | .NET | Invalid | | ASP.NET | Valid | | A1 | Invalid | | $A$1 | Invalid | | RC | Invalid | ## Using named expressions in formulas Named expressions can be used in any formula by referencing their names. Use them anywhere you would normally use a cell reference, range, or constant value. ```javascript // Define named expressions hfInstance.addNamedExpression('TaxRate', '=0.08'); hfInstance.addNamedExpression('SalesData', '=Sheet1!$A$1:$A$10'); // Use them in formulas hfInstance.setCellContents({sheet: 0, col: 2, row: 0}, [['=SUM(SalesData)']]); hfInstance.setCellContents({sheet: 0, col: 2, row: 1}, [['=SUM(SalesData) * TaxRate']]); ``` ## Using named ranges in formulas A named expression that resolves to a range of cells behaves differently depending on where it is used: - **As a function argument** — it works as expected. `=SUM(myRange)`, `=COUNT(myRange)`, and `=INDEX(myRange, 1, 1)` all operate on the full range. - **As an operand of an operator** — the range is reduced to a single cell before the operation. In `=myRange + 1`, only the cell of the range that shares the formula's row (for a vertical range) or column (for a horizontal range) is used. If the formula's row or column falls outside the range, or the range is two-dimensional, the result is a `#VALUE!` error. - **As a bare reference** — `=myRange` on its own returns a `#VALUE!` error; a range cannot be placed directly into a single cell. In the default mode the range is reduced before the operator runs, so `=SUM(myRange + 1)` adds 1 to that single reduced value rather than to every element (for a formula in row 1 of a vertical range, the result is `SUM(A1 + 1)`). When array arithmetic is enabled (`useArrayArithmetic: true`), named ranges still work as function arguments and aggregate correctly, but as an operand they behave differently from the default mode: - A bare `=myRange + 1` does not spill — it returns a `#VALUE!` error rather than producing one result per element. - Inside an aggregate the operator becomes element-wise. `=SUM(myRange + 1)` adds 1 to every element and then sums, so for `myRange` covering values `1..5` it returns `20` (`SUM(2, 3, 4, 5, 6)`), not the single reduced value of the default mode. ## Available methods These are the basic methods that can be used to add and manipulate named expressions, including the creation and handling of named ranges. The full list of methods is available in the [API reference](https://hyperformula.handsontable.com/docs/api). ### Adding a named expression You can add a named expression in two ways: **During engine initialization**: You can provide named expressions as a parameter when creating a HyperFormula instance using the factory methods `buildEmpty`, `buildFromArray`, or `buildFromSheets`. This is the most efficient way to add multiple named expressions at once. ```javascript // Define named expressions during initialization const namedExpressions = [ { name: 'prettyName', expression: '=Sheet1!$A$1+100', scope: 0 // optional: local scope for 'Sheet1' }, { name: 'globalConstant', expression: '=42' // no scope specified = global scope } ]; // Create engine with named expressions const hfInstance = HyperFormula.buildEmpty({}, namedExpressions); // or const hfInstance = HyperFormula.buildFromArray(sheetData, {}, namedExpressions); // or const hfInstance = HyperFormula.buildFromSheets(sheetsData, {}, namedExpressions); ``` **After engine creation**: You can add a named expression by using the `addNamedExpression` method. It accepts name for the expression, the expression as a raw cell content, and optionally the scope. If you do not define the scope it will be set to global, meaning the expression name will be valid for the whole workbook. If you want to add many of them, it is advised to do so in a [batch](https://hyperformula.handsontable.com/docs/guide/batch-operations.md). This method returns [an array of changed cells](https://hyperformula.handsontable.com/docs/guide/basic-operations.md#changes-array). ```javascript // add 'prettyName' expression to the local scope of 'Sheet1' (sheetId = 0) const changes = hfInstance.addNamedExpression( 'prettyName', '=Sheet1!$A$1+100', 0 ); ``` ### Changing a named expression You can change a named expression by using the `changeNamedExpression` method. Select the name of an expression to change and pass it as the first parameter, then define the new expression as raw cell content and optionally add the scope. If you do not define the scope it will be set to global, meaning the expression will be valid for the whole workbook. If you want to change many of them, it is advised to do so in a [batch](https://hyperformula.handsontable.com/docs/guide/batch-operations.md). This method returns [an array of changed cells](https://hyperformula.handsontable.com/docs/guide/basic-operations.md#changes-array). ```javascript // change the named expression const changes = hfInstance.changeNamedExpression( 'prettyName', '=Sheet1!$A$1+200' ); ``` ### Removing a named expression You can remove a named expression by using the `removeNamedExpression` method. Select the name of an expression to remove and pass it as the first parameter and optionally define the scope. If you do not define the scope it will be understood as global, meaning, the whole workbook. This method returns [an array of changed cells](https://hyperformula.handsontable.com/docs/guide/basic-operations.md#changes-array). ```javascript // remove 'prettyName' expression from 'Sheet1' (sheetId=0) const changes = hfInstance.removeNamedExpression('prettyName', 0); ``` ### Listing all named expressions You can retrieve a whole list of named expressions by using the `listNamedExpressions` method. It requires no parameters and returns all named expressions as an array of strings. ```javascript // get all named-expression names const listOfExpressions = hfInstance.listNamedExpressions(); ``` ## Handling errors Operations on named expressions throw errors when something goes wrong. These errors can be [handled](https://hyperformula.handsontable.com/docs/guide/basic-operations.md#handling-an-error) to provide a good user experience in the application. It is also possible to check the availability of operations using `isItPossibleTo*` methods, which are also described in [that section](https://hyperformula.handsontable.com/docs/guide/basic-operations.md#isitpossibleto-methods). --- ## Performance URL: https://hyperformula.handsontable.com/docs/guide/performance # Performance We implemented various techniques to boost the performance of HyperFormula. In some cases, turning them on or off might increase the performance of your app. Below we provide a number of tips on how to speed it up. ## VLOOKUP/MATCH If you are planning to use VLOOKUP or MATCH heavily in your app, you may consider enabling the `useColumnIndex` flag in the HyperFormula configuration. It will increase memory usage but can significantly improve the performance of these two functions, especially when running on unsorted or very large data sets. The column index will not be used despite the option `useColumnIndex` enabled when using **wildcards** or **regular expressions**. Leaving this option disabled will cause the engine to use binary search when dealing with sorted data, and the naive approach otherwise. ## Address mapping strategies HyperFormula uses two approaches to store the mapping of cell addresses in order to optimize memory usage. The choice of the strategy is made independently for each sheet. The `chooseAddressMappingPolicy` option allows for changing the way the strategy will be chosen. You may use one of three built-in policies: * `AlwaysDense` – uses dense mapping for each sheet. This policy is particularly useful when the spreadsheet is a densely filled rectangle. * `AlwaysSparse` – uses sparse mapping for each sheet. This approach is useful when in your spreadsheet/dataset there are relatively few cells filled, but located very far from each other. * `DenseSparseChooseBasedOnThreshold` – the choice is made based on the fill ratio of the sheet. Let the engine choose the best strategy for you. ## Lazy transformation cleanup Structural operations (adding/removing rows/columns, moving cells) create transformations that are applied lazily to formulas. Over time, these transformations accumulate in memory. HyperFormula automatically flushes them when their count reaches the `maxPendingLazyTransformations` threshold (default: 50). You can tune this setting to balance memory usage and CPU overhead: * **Lower values** (e.g., 10) reduce peak memory usage but trigger cleanup more frequently, adding slight CPU overhead per flush. * **Higher values** (e.g., 200) reduce the frequency of cleanup but allow more memory to accumulate between flushes. * The default of **50** works well for most use cases. ```javascript const hf = HyperFormula.buildEmpty({ licenseKey: 'gpl-v3', maxPendingLazyTransformations: 100, }) ``` ## Suspending automatic recalculations By default, HyperFormula recalculates formulas after every change. However, due to the fact that we store the graph of dependencies between cells in the sheet, we recalculate only the cells affected by the update. Sometimes, a simple change can cause recalculation of a large part of the sheet, e.g., when the modified cell is at the very beginning of the dependency chain or when there are many [volatile functions](https://hyperformula.handsontable.com/docs/guide/volatile-functions.md) in the worksheet. In such a case you may want to postpone the recalculation. The first option is to call `suspendEvaluation` before making changes and `resumeEvaluation` at a convenient moment. The second option is to pass the callback function with multiple operations to a [batch function](https://hyperformula.handsontable.com/docs/guide/batch-operations.md). Recalculation will be suspended before performing operations and resumed after them. In cases where you perform operations which may not cause a recalculation but only change the shape of the worksheet, like `addRows`, `removeRows`, or `moveColumns` , we do not recommend suspending recalculation, as this may have a slightly negative impact on performance. --- ## Events URL: https://hyperformula.handsontable.com/docs/api/enums/events # Events ## Enumeration members ### EvaluationResumed • **EvaluationResumed**: = "evaluationResumed" *Defined in [src/Emitter.ts:17](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L17)* ___ ### EvaluationSuspended • **EvaluationSuspended**: = "evaluationSuspended" *Defined in [src/Emitter.ts:16](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L16)* ___ ### NamedExpressionAdded • **NamedExpressionAdded**: = "namedExpressionAdded" *Defined in [src/Emitter.ts:13](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L13)* ___ ### NamedExpressionRemoved • **NamedExpressionRemoved**: = "namedExpressionRemoved" *Defined in [src/Emitter.ts:14](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L14)* ___ ### SheetAdded • **SheetAdded**: = "sheetAdded" *Defined in [src/Emitter.ts:10](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L10)* ___ ### SheetRemoved • **SheetRemoved**: = "sheetRemoved" *Defined in [src/Emitter.ts:11](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L11)* ___ ### SheetRenamed • **SheetRenamed**: = "sheetRenamed" *Defined in [src/Emitter.ts:12](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L12)* ___ ### ValuesUpdated • **ValuesUpdated**: = "valuesUpdated" *Defined in [src/Emitter.ts:15](https://github.com/handsontable/hyperformula/blob/9c22416/src/Emitter.ts#L15)* --- ## Quality & Security URL: https://hyperformula.handsontable.com/docs/guide/quality # Quality & Security HyperFormula is built with the highest standards of software quality, backed by rigorous research, comprehensive testing, and transparent development practices. ## Research Foundation HyperFormula originated as a research and development project **funded by the European Union**. The project was **successfully executed and positively evaluated** by The National Centre for Research and Development in Poland, validating both the technical approach and implementation quality. This EU funding provided the foundation for developing a calculation engine that meets the highest academic and industry standards. ## Expert Development Team HyperFormula is developed by a team of highly qualified experts: - **Computer Science specialists** with Master's and PhD degrees - **Mathematics experts** with deep knowledge in numerical computation - **Software engineering professionals** with years of enterprise-grade experience ## Comprehensive Testing Quality assurance is at the heart of our development process: - **Over 5,000 unit tests** covering all aspects of the calculation engine - **97% test coverage** ensuring virtually every line of code is verified - Continuous integration across multiple environments - Regular performance comparisons between versions > Our high test coverage means you can be confident that HyperFormula will behave predictably in your application, even in complex scenarios. ## Open Source Transparency HyperFormula's **entire source code is available on GitHub**, providing complete transparency that allows you to: - **Inspect the implementation** to understand exactly how calculations are performed - **Verify the quality** of the code and development practices - **Contribute improvements** or report issues directly to the development team - **Build confidence** through code reviews and community oversight [View the source code on GitHub →](https://github.com/handsontable/hyperformula) ## Real-World Validation HyperFormula powers **Handsontable**, one of the most popular data grid solutions in JavaScript, trusted by thousands of developers worldwide. Additionally, HyperFormula is used by many other projects and organizations, providing continuous validation of its stability and performance across diverse applications. ## Security HyperFormula maintains the highest security standards to protect your applications: - **Regular external security audits** conducted by independent security experts - **Dependency vulnerability scanning** using industry-leading tools including Fossa, Dependabot, and Snyk - **Security risk assessments** to identify and mitigate potential threats - **Proactive monitoring** of security advisories and immediate response to emerging threats ### Independent security certificate In July 2026, HyperFormula was awarded a security certificate by **TestArmy Group S.A.** (signed by Wojciech Humiński, CEO), confirming an independent security assessment of the library. The assessment covered HyperFormula [v3.3.0](https://www.npmjs.com/package/hyperformula/v/3.3.0) and included: - **Code review and white-box penetration testing** of the source code - **Static, dynamic, and manual code analysis** carried out against the OWASP Application Security Verification Standard (ASVS), with a focus on the OWASP Top 10 - **Dependency and dev-dependency analysis** to identify vulnerabilities in third-party packages [Download the security certificate (PDF) →](https://hyperformula.handsontable.com/docs/hyperformula_security_certificate.pdf) ## Quality Assurance Process Our development includes multiple quality layers: 1. **Code Reviews** - All changes are peer-reviewed by experienced developers 2. **Automated Testing** - Comprehensive test suite runs on every commit 3. **Performance Testing** - Regular benchmarking ensures optimal performance 4. **Cross-Platform Testing** - Verification across different browsers and Node.js versions 5. **Documentation Reviews** - All features are thoroughly documented and reviewed ## Professional Support HyperFormula offers comprehensive support options to ensure your success: - **Direct contact with the dev team** through GitHub platform - **Premium support** for companies using HyperFormula in mission-critical applications - **Consulting services** for turn-key solutions, including proof of concepts, deployment strategies, and custom feature development Our expert team has been supporting enterprises since 2012 and understands how to respond to individual business needs. [Learn more about support options →](https://hyperformula.handsontable.com/#pricing) --- ## Server-side installation URL: https://hyperformula.handsontable.com/docs/guide/server-side-installation # Server-side installation > For full compatibility, the minimum required version of **Node is 13**. > It is related to the support for ICU. There is a possibility to use > lower versions of Node but you need to install an additional package > as the dependency: [`full-icu`](https://github.com/unicode-org/full-icu-npm) The basic steps are very similar to the ones in the [client-side installation](https://hyperformula.handsontable.com/docs/guide/client-side-installation.md) process. ## Install with npm or Yarn You can install the latest version of HyperFormula with popular packaging managers. Navigate to your project folder and run the following command: **npm:** ```bash $ npm install hyperformula ``` **Yarn:** ```bash $ yarn add hyperformula ``` The package will be added to your `package.json` file and installed in the `./node_modules` directory. Then you can just `require` it: ```javascript const { HyperFormula } = require('hyperformula'); // your code ``` --- ## Release notes URL: https://hyperformula.handsontable.com/docs/guide/release-notes # Release notes This page lists HyperFormula release notes. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). HyperFormula adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## 3.4.0 **Release date: August 10, 2026** ### Added - Added the `getAvailableFunctions()` and `getFunctionDetails()` instance methods for retrieving function metadata. [#1692](https://github.com/handsontable/hyperformula/pull/1692) - Added new functions: VSTACK, HSTACK. [#1698](https://github.com/handsontable/hyperformula/pull/1698) - Added a new function: `XIRR`. [#1701](https://github.com/handsontable/hyperformula/pull/1701) - Added the UNIQUE function. [#1708](https://github.com/handsontable/hyperformula/pull/1708) - Added the SORT function. [#1707](https://github.com/handsontable/hyperformula/pull/1707) - Added an Indonesian (Bahasa Indonesia) language pack. [#1674](https://github.com/handsontable/hyperformula/pull/1674) - Added a `stringifyCurrency` config option that lets you plug in a custom currency formatter for the `TEXT` function. [#1145](https://github.com/handsontable/hyperformula/issues/1145) ### Fixed - Fixed the behavior of `MATCH`, `VLOOKUP`, `HLOOKUP`, and `XLOOKUP` functions when the search range contained empty cells. [#1697](https://github.com/handsontable/hyperformula/pull/1697) - Fixed the `VLOOKUP`, `HLOOKUP`, and `XLOOKUP` functions to return `0` instead of an empty value when the matched cell in the result range is empty. [#1697](https://github.com/handsontable/hyperformula/pull/1697) - Fixed the page freezing when entering a long string of digits containing a non-digit character near the end (e.g. `012...789a` or `012...789 123`) into a cell. [#1520](https://github.com/handsontable/hyperformula/issues/1520) ## 3.3.0 **Release date: May 20, 2026** ### Added - Added 12 database functions: DCOUNT, DSUM, DAVERAGE, DMAX, DMIN, DGET, DPRODUCT, DCOUNTA, DSTDEV, DSTDEVP, DVAR, DVARP. [#1652](https://github.com/handsontable/hyperformula/pull/1652) - Added new functions: PERCENTILE, PERCENTILE.INC, PERCENTILE.EXC, QUARTILE, QUARTILE.INC, QUARTILE.EXC. [#1650](https://github.com/handsontable/hyperformula/pull/1650) - Added `maxPendingLazyTransformations` configuration option to control memory usage by limiting accumulated transformations before cleanup. [#1629](https://github.com/handsontable/hyperformula/issues/1629) - Added a new function: TEXTJOIN. [#1640](https://github.com/handsontable/hyperformula/pull/1640) - Added a new function: SEQUENCE. [#1645](https://github.com/handsontable/hyperformula/pull/1645) ### Fixed - Fixed a memory leak in `LazilyTransformingAstService` where the transformations array grew unboundedly, causing increasing memory usage over time. [#1629](https://github.com/handsontable/hyperformula/issues/1629) - Fixed a memory leak in `UndoRedo` where `oldData` entries for evicted undo stack entries were never cleaned up, causing increasing memory usage over time. [#1629](https://github.com/handsontable/hyperformula/issues/1629) - Fixed the IRR function returning `#NUM!` error when the initial investment significantly exceeds the sum of returns. [#1628](https://github.com/handsontable/hyperformula/issues/1628) - Fixed the ADDRESS function ignoring `defaultValue` when arguments are syntactically empty (e.g., `=ADDRESS(2,3,,FALSE())`). [#1632](https://github.com/handsontable/hyperformula/issues/1632) ## 3.2.0 **Release date: February 19, 2026** ### Added - Added a new function: IRR. [#1591](https://github.com/handsontable/hyperformula/issues/1591) - Added a new function: N. [#1585](https://github.com/handsontable/hyperformula/issues/1585) - Added a new function: VALUE. [#1592](https://github.com/handsontable/hyperformula/issues/1592) ### Fixed - Fixed `Error Map maximum size exceeded` error when loading big spreadsheets. [#1602](https://github.com/handsontable/hyperformula/issues/1602) ## 3.1.1 **Release date: December 18, 2025** ### Fixed - Fixed an issue where cells were not recalculated after adding, removing and renaming sheets. [#1116](https://github.com/handsontable/hyperformula/issues/1116) - Fixed an issue where overwriting a non-computed cell caused the `Value of the formula cell is not computed` error. [#1194](https://github.com/handsontable/hyperformula/issues/1194) ## 3.1.0 **Release date: October 14, 2025** ### Changed - Renamed the `arraySizeMethod` parameter in the `FunctionMetadata` interface to `sizeOfResultArrayMethod`. The `arraySizeMethod` is deprecated and will be removed in one of the next major releases. [#1401](https://github.com/handsontable/hyperformula/issues/1401) - Renamed the `arrayFunction` parameter in the `FunctionMetadata` interface to `enableArrayArithmeticForArguments`. The `arrayFunction` is deprecated and will be removed in one of the next major releases. [#1401](https://github.com/handsontable/hyperformula/issues/1401) ### Fixed - Fixed an issue where the `OFFSET` function was ignoring the sheet reference in the provided address. [#1477](https://github.com/handsontable/hyperformula/issues/1477) ## 3.0.1 **Release date: August 11, 2025** ### Fixed - Fixed `Edge does not exist` error when a named expression is used twice in the same formula. [#1102](https://github.com/handsontable/hyperformula/issues/1102) - Fixed typos in the built-in functions guide. [#1517](https://github.com/handsontable/hyperformula/issues/1517) - Fixed an issue where named expressions added on engine initialization were not updated on changes. [#1501](https://github.com/handsontable/hyperformula/issues/1501) ## 3.0.0 **Release date: January 14, 2025** ### Added - Added a new function: XLOOKUP. [#1458](https://github.com/handsontable/hyperformula/issues/1458) ### Changed - **Breaking change**: Changed ES module build to use `mjs` files and `exports` property in `package.json` to make importing language files possible in Node environment. [#1344](https://github.com/handsontable/hyperformula/issues/1344) - **Breaking change**: Changed the default value of the `precisionRounding` configuration option to `10`. [#1300](https://github.com/handsontable/hyperformula/issues/1300) - Make methods `simpleCellAddressToString` and `simpleCellRangeToString` more logical and easier to use. [#1151](https://github.com/handsontable/hyperformula/issues/1151) ### Removed - **Breaking change**: Removed the `binarySearchThreshold` configuration option. [#1439](https://github.com/handsontable/hyperformula/issues/1439) ## 2.7.1 **Release date: July 18, 2024** ### Fixed - Fixed an issue where adding or removing columns with `DenseStrategy` for address mapping resulted in the `Cannot read properties of undefined (reading 'splice')` error. [#1406](https://github.com/handsontable/hyperformula/issues/1406) ## 2.7.0 **Release date: Apr 10, 2024** ### Added - Added method `getNamedExpressionsFromFormula` to extract named expressions from formulas. [#1365](https://github.com/handsontable/hyperformula/issues/1365) - Added `context` config option for passing data to custom functions. [#1396](https://github.com/handsontable/hyperformula/issues/1396) ## 2.6.2 **Release date: Feb 15, 2024** ### Changed - Removed `unorm` dependency. [#1370](https://github.com/handsontable/hyperformula/issues/1370) ## 2.6.1 **Release date: Dec 27, 2023** ### Fixed - Fixed an issue where operating on ranges of incompatible sizes resulted in a runtime exception. [#1267](https://github.com/handsontable/hyperformula/issues/1267) - Fixed an issue where the [`simpleCellAddressFromString()`](https://hyperformula.handsontable.com/docs/api/classes/hyperformula.md#simplecelladdressfromstring) method was crashing when called with a non-ASCII character in an unquoted sheet name. [#1312](https://github.com/handsontable/hyperformula/issues/1312) - Fixed an issue where adding a row to a very large spreadsheet resulted in the `Maximum call stack size exceeded` error. [#1332](https://github.com/handsontable/hyperformula/issues/1332) - Fixed an issue where using a column-range reference to an empty sheet as a function argument resulted in the `Incorrect array size` error. [#1147](https://github.com/handsontable/hyperformula/issues/1147) - Fixed an issue where the SUBSTITUTE function wasn't working correctly with regex special characters. [#1289](https://github.com/handsontable/hyperformula/issues/1289) - Fixed a typo in the JSDoc comment of the `HyperFormula` class. [#1323](https://github.com/handsontable/hyperformula/issues/1323) ## 2.6.0 **Release date: Sep 19, 2023** ### Added - Exported the `EmptyValue` symbol as a public API. This allows custom functions to handle empty cell values. [#1232](https://github.com/handsontable/hyperformula/issues/1265) ### Changed - Improved the efficiency of the default date/time parsing methods. [#876](https://github.com/handsontable/hyperformula/issues/876) - Improved the efficiency of the operations on the dependency graph. [#876](https://github.com/handsontable/hyperformula/issues/876) ### Fixed - Fixed a bug where neighboring exported changes of an array formula were missing. [#1291](https://github.com/handsontable/hyperformula/issues/1291) - Fixed a typo in the source code of the `MatrixPlugin`. [#1306](https://github.com/handsontable/hyperformula/issues/1306) ## 2.5.0 **Release date: May 29, 2023** ### Added - Added a new function: ADDRESS. [#1221](https://github.com/handsontable/hyperformula/issues/1221) - Added a new function: HYPERLINK. [#1215](https://github.com/handsontable/hyperformula/issues/1215) - Added a new function: IFS. [#1157](https://github.com/handsontable/hyperformula/issues/1157) ### Changed - Optimized the [`updateConfig()`](https://hyperformula.handsontable.com/docs/api/classes/hyperformula.md#updateconfig) method to rebuild HyperFormula only when the new configuration is different from the old one. [#1251](https://github.com/handsontable/hyperformula/issues/1251) ### Fixed - Fixed the SEARCH function to be case-insensitive regardless of HyperFormula's configuration. [#1225](https://github.com/handsontable/hyperformula/issues/1225) ## 2.4.0 **Release date: April 24, 2023** ### Added - Exported the [`CellError`](https://hyperformula.handsontable.com/docs/api/classes/cellerror.md) class as a public API. [#1232](https://github.com/handsontable/hyperformula/issues/1232) - Exported the [`SimpleRangeValue`](https://hyperformula.handsontable.com/docs/api/classes/simplerangevalue.md) class as a public API. [#1178](https://github.com/handsontable/hyperformula/issues/1178) ### Fixed - Fixed an `EmptyCellVertex` data integrity issue between the `AddressMapping` and `DependencyGraph` objects. [#1188](https://github.com/handsontable/hyperformula/issues/1188) - Fixed a build issue with M1- and M2-chip MacBooks. [#1166](https://github.com/handsontable/hyperformula/issues/1166) - Fixed an issue where the order of items returned by [`removeColumns()`](https://hyperformula.handsontable.com/docs/api/classes/hyperformula.md#removecolumns) depended on the address mapping policy. [#1205](https://github.com/handsontable/hyperformula/issues/1205) ## 2.3.1 **Release date: March 3, 2023** ### Fixed - Fixed an issue where named-expression names were not allowed to start with a cell reference. [#1058](https://github.com/handsontable/hyperformula/issues/1058) - Fixed an issue where named-expression names were allowed to start with "R1C1" cell references. For better compatibility with other spreadsheet software, strings such as `R4C5`, `RC1000`, `R1C` or `RC` can't be used in named-expression names anymore. [#1058](https://github.com/handsontable/hyperformula/issues/1058) - Fixed an issue where using reversed ranges with absolute addressing could cause the `Incorrect array size` error. [#1106](https://github.com/handsontable/hyperformula/issues/1106) - Fixed an issue where removing a sheet (`removeSheet()`) without clearing it (`clearSheet()`) could cause an error. [#1121](https://github.com/handsontable/hyperformula/issues/1121) ## 2.3.0 **Release date: December 22, 2022** ### Added - Exported the [`ArraySize`](https://hyperformula.handsontable.com/docs/api/classes/arraysize.md) class as a public API. [#843](https://github.com/handsontable/hyperformula/issues/843) - Renamed an internal interface from `ArgumentTypes` to [`FunctionArgumentType`](https://hyperformula.handsontable.com/docs/api/classes/hyperformulans.md#functionargumenttype), and exported it as a public API. [#1108](https://github.com/handsontable/hyperformula/pull/1108) - Exported `ImplementedFunctions` and `FunctionMetadata` as public APIs. [#1108](https://github.com/handsontable/hyperformula/pull/1108) ## 2.2.0 **Release date: November 17, 2022** ### Added - Added an American English (`enUS`) language pack. It's a convenience alias: it contains the same translations as the existing British English (`enGB`) language pack. [#1025](https://github.com/handsontable/hyperformula/issues/1025) ### Fixed - Fixed functions VLOOKUP and HLOOKUP to handle duplicates in the way specified by the [OpenDocument](https://docs.oasis-open.org/office/OpenDocument/v1.3/os/part4-formula/OpenDocument-v1.3-os-part4-formula.html#HLOOKUP) standard. [#1072](https://github.com/handsontable/hyperformula/issues/1072) - Fixed the MATCH function to handle descending ranges in the way specified by the [OpenDocument](https://docs.oasis-open.org/office/OpenDocument/v1.3/os/part4-formula/OpenDocument-v1.3-os-part4-formula.html#MATCH) standard. [#1063](https://github.com/handsontable/hyperformula/issues/1063) ## 2.1.0 **Release date: September 8, 2022** ### Added - Added two new functions: MAXIFS and MINIFS. [#1049](https://github.com/handsontable/hyperformula/issues/1049) ### Changed - Changed the rounding strategy of the default time-parsing function to be independent of the [`timeFormats`](https://hyperformula.handsontable.com/docs/api/interfaces/configparams.md#timeformats) configuration option. Now, time values are always rounded to the nearest millisecond (0.001 s). [#953](https://github.com/handsontable/hyperformula/issues/953) ### Fixed - Fixed a rounding issue that caused the TEXT function to convert dates and times to strings incorrectly. [#1043](https://github.com/handsontable/hyperformula/issues/1043) - Fixed an issue where functions SUMIF, SUMIFS, COUNTIF, COUNTIFS, and AVERAGEIF incorrectly handled complex numeric values. [#951](https://github.com/handsontable/hyperformula/issues/951) ### Removed - Removed all polyfills from the CommonJS build and the ES modules build. In the UMD build, kept only the polyfills required by the [supported browsers](https://hyperformula.handsontable.com/guide/supported-browsers.html). [#1011](https://github.com/handsontable/hyperformula/issues/1011) ## 2.0.1 **Release date: June 14, 2022** ### Changed - Changed the following npm scripts (used internally): `docs`, `docs:api`, `docs:dev`, `docs:build`, `coverage`, `typings:check`. [#977](https://github.com/handsontable/hyperformula/issues/977) ### Fixed - Fixed an issue where it was impossible to add a custom function with no `parameters`. [#968](https://github.com/handsontable/hyperformula/issues/968) ## 2.0.0 **Release date: April 14, 2022** ### Added - Added support for reversed ranges. [#834](https://github.com/handsontable/hyperformula/issues/834) - Added a new configuration option, [`ignoreWhiteSpace`](https://hyperformula.handsontable.com/docs/api/interfaces/configparams.md#ignorewhitespace), which allows for parsing formulas that contain whitespace characters of any kind. [#898](https://github.com/handsontable/hyperformula/issues/898) ### Changed - **Breaking change**: Removed the `gpu.js` dependency and its use, to speed up the installation time. [#812](https://github.com/handsontable/hyperformula/issues/812) - **Breaking change**: Removed the deprecated `gpujs` and `gpuMode` configuration options. [#812](https://github.com/handsontable/hyperformula/issues/812) ### Fixed - Fixed an issue where the RATE function didn't converge for some inputs. [#905](https://github.com/handsontable/hyperformula/issues/905) ## 1.3.1 **Release date: January 11, 2022** ### Fixed - Fixed an issue where warnings about deprecated configuration options were getting duplicated. [#882](https://github.com/handsontable/hyperformula/pull/882) ## 1.3.0 **Release date: October 20, 2021** ### Added - Added a new static property: [`HyperFormula.defaultConfig`](https://hyperformula.handsontable.com/docs/api/classes/hyperformula.md#defaultconfig). [#822](https://github.com/handsontable/hyperformula/issues/822) - The [`getFillRangeData()`](https://hyperformula.handsontable.com/docs/api/classes/hyperformula.md#getfillrangedata) method can now use one sheet for its source and another sheet for its target. [#836](https://github.com/handsontable/hyperformula/issues/836) ### Fixed - Fixed the handling of Unicode characters and non-letter characters in the [PROPER](https://hyperformula.handsontable.com/docs/guide/built-in-functions.md#text) function. [#811](https://github.com/handsontable/hyperformula/issues/811) - Fixed unnecessary warnings caused by deprecated configuration options. [#830](https://github.com/handsontable/hyperformula/issues/830) - Fixed the [SUMPRODUCT](https://hyperformula.handsontable.com/docs/guide/built-in-functions.md#math-and-trigonometry) function. [#810](https://github.com/handsontable/hyperformula/issues/810) ## 1.2.0 **Release date: September 23, 2021** ### Changed - Removed `gpu.js` from optional dependencies and marked config options `gpujs` and `gpuMode` as deprecated. ## 1.1.0 **Release date: August 12, 2021** ### Added - Added support for the array arithmetic mode in the `calculateFormula()` method. [#782](https://github.com/handsontable/hyperformula/issues/782) - Added a new `CellType` returned by `getCellType`: `CellType.ARRAYFORMULA`. It's assigned to the top-left corner of an array, and is recognized by the `isCellPartOfArray()` and `doesCellHaveFormula()` methods. [#781](https://github.com/handsontable/hyperformula/issues/781) ### Changed - Deprecated the `binarySearchThreshold` configuration option, as every search of sorted data always uses binary search. [#791](https://github.com/handsontable/hyperformula/pull/791) ### Fixed - Fixed an issue with searching sorted data. [#787](https://github.com/handsontable/hyperformula/issues/787) - Fixed the `destroy` method to properly destroy HyperFormula instances. [#788](https://github.com/handsontable/hyperformula/pull/788) ## 1.0.0 **Release date: July 15, 2021** ### Added - Added support for array arithmetic. [#628](https://github.com/handsontable/hyperformula/issues/628) - Added performance improvements for array handling. [#629](https://github.com/handsontable/hyperformula/issues/629) - Added ARRAYFORMULA function. [#630](https://github.com/handsontable/hyperformula/issues/630) - Added FILTER function. [#668](https://github.com/handsontable/hyperformula/issues/668) - Added ARRAY_CONSTRAIN function. [#661](https://github.com/handsontable/hyperformula/issues/661) - Added casting to scalars from non-range arrays. [#663](https://github.com/handsontable/hyperformula/issues/663) - Added support for range interpolation. [#665](https://github.com/handsontable/hyperformula/issues/665) - Added parsing of arrays in formulas (together with respective config options for separators). [#671](https://github.com/handsontable/hyperformula/issues/671) - Added support for vectorization of scalar functions. [#673](https://github.com/handsontable/hyperformula/issues/673) - Added support for time in JS `Date()` objects on the input. [#648](https://github.com/handsontable/hyperformula/issues/648) - Added validation of API argument types for simple types. [#654](https://github.com/handsontable/hyperformula/issues/654) - Added named expression handling to engine factories. [#680](https://github.com/handsontable/hyperformula/issues/680) - Added `getAllNamedExpressionsSerialized` method. [#680](https://github.com/handsontable/hyperformula/issues/680) - Added parsing of arrays in formulas (together with respective config options for separators). [#671](https://github.com/handsontable/hyperformula/issues/671) - Added utility function for filling ranges with source from other range. [#678](https://github.com/handsontable/hyperformula/issues/678) - Added pretty print for detailedCellError. [#712](https://github.com/handsontable/hyperformula/issues/712) - Added `simpleCellRangeFromString` and `simpleCellRangeToString` helpers. [#720](https://github.com/handsontable/hyperformula/issues/720) - Added `CellError` to exports. [#736](https://github.com/handsontable/hyperformula/issues/736) - Added mapping policies to the exports: `AlwaysDense`, `AlwaysSparse`, `DenseSparseChooseBasedOnThreshold`. [#747](https://github.com/handsontable/hyperformula/issues/747) - Added `#SPILL!` error type. [#708](https://github.com/handsontable/hyperformula/issues/708) - Added large tests for CRUD interactions. [#755](https://github.com/handsontable/hyperformula/issues/755) - Added a flag to `getFillRangeData` to support different types of offsetting. [#767](https://github.com/handsontable/hyperformula/issues/767) ### Changed - **Breaking change**: Changed API of many sheet-related methods to take sheetId instead of sheetName as an argument. [#645](https://github.com/handsontable/hyperformula/issues/645) - **Breaking change**: Removed support for matrix formulas (`{=FORMULA}`) notation. Engine now supports formulas returning array of values (instead of only scalars). [#652](https://github.com/handsontable/hyperformula/issues/652) - **Breaking change**: Removed numeric matrix detection along with matrixDetection and matrixDetectionThreshold config options. [#669](https://github.com/handsontable/hyperformula/issues/669) - **Breaking change**: Changed API of the following methods to take `SimpleCellRange` type argument: `copy`, `cut`, `getCellDependents`, `getCellPrecedents`, `getFillRangeData`, `getRangeFormulas`, `getRangeSerialized`, `getRangeValues`, `isItPossibleToMoveCells`, `isItPossibleToSetCellContents`, `moveCells`. [#687](https://github.com/handsontable/hyperformula/issues/687) - **Breaking change**: Changed the AGPLv3 license to GPLv3. - **Breaking change**: Removed the free non-commercial license. - **Breaking change**: Changed behaviour of `setCellContents` so that it is possible to override space occupied by spilled array. [#708](https://github.com/handsontable/hyperformula/issues/708) - **Breaking change**: Changed behaviour of `addRows/removeRows` so that it is possible to add/remove rows across spilled array without changing array size. [#708](https://github.com/handsontable/hyperformula/issues/708) - **Breaking change**: Changed behaviour of `addColumns/removeColumns` so that it is possible to add/remove columns across spilled array without changing array size. [#732](https://github.com/handsontable/hyperformula/issues/732) - **Breaking change**: Changed config options [#747](https://github.com/handsontable/hyperformula/issues/747): | before | after | | --------------------- | -------------------- | | matrixColumnSeparator | arrayColumnSeparator | | matrixRowSeparator | arrayRowSeparator | - **Breaking change**: Changed CellType.MATRIX to CellType.ARRAY [#747](https://github.com/handsontable/hyperformula/issues/747) - **Breaking change**: Changed API methods [#747](https://github.com/handsontable/hyperformula/issues/747): | before | after | | ------------------ | ----------------- | | matrixMapping | arrrayMapping | | isCellPartOfMatrix | isCellPartOfArray | - **Breaking change**: Changed Exceptions [#747](https://github.com/handsontable/hyperformula/issues/747): | before | after | | ---------------------------- | --------------------------- | | SourceLocationHasMatrixError | SourceLocationHasArrayError | | TargetLocationHasMatrixError | TargetLocationHasArrayError | - Changed SWITCH function, so it takes array as its first argument. - Changed TRANSPOSE function, so it works with data of any type. [#708](https://github.com/handsontable/hyperformula/issues/708) - Changed the way how we include `gpu.js` making it even more optional [#753](https://github.com/handsontable/hyperformula/issues/753) ### Fixed - Fixed an issue with arrays and cruds. [#651](https://github.com/handsontable/hyperformula/issues/651) - Fixed handling of arrays for ROWS/COLUMNS functions. [#677](https://github.com/handsontable/hyperformula/issues/677) - Fixed an issue with nested namedexpressions. [#679](https://github.com/handsontable/hyperformula/issues/679) - Fixed an issue with matrixDetection + number parsing. [#686](https://github.com/handsontable/hyperformula/issues/686) - Fixed an issue with NOW and TODAY functions. [#709](https://github.com/handsontable/hyperformula/issues/709) - Fixed an issue with MIN/MAX function caches. [#711](https://github.com/handsontable/hyperformula/issues/711) - Fixed an issue with caching and order of evaluation. [#735](https://github.com/handsontable/hyperformula/issues/735) ## 0.6.2 **Release date: May 26, 2021** ### Changed - Modified a private field in one of the classes to ensure broader compatibility with older TypeScript versions. [#681](https://github.com/handsontable/hyperformula/issues/681) ## 0.6.1 **Release date: May 24, 2021** ### Changed - Remove redundant `'assert'` dependency from the code. [#672](https://github.com/handsontable/hyperformula/issues/672) ### Fixed - Fixed library support for IE11. The `unorm` package is added to the dependencies. [#675](https://github.com/handsontable/hyperformula/issues/675) ## 0.6.0 **Release date: April 27, 2021** ### Added - Added two new fired events, for suspending and resuming execution. [#637](https://github.com/handsontable/hyperformula/issues/637) - Added listing in scopes to `listNamedExpressions` method. [#638](https://github.com/handsontable/hyperformula/issues/638) ### Changed - **Breaking change**: Moved `GPU.js` from `dependencies` to `devDependencies` and `optionalDependencies`. [#642](https://github.com/handsontable/hyperformula/issues/642) ### Fixed - Fixed issues with scoped named expression. [#646](https://github.com/handsontable/hyperformula/issues/646) , [#641](https://github.com/handsontable/hyperformula/issues/641) - Fixed an issue with losing formating info about DateTime numbers. [#626](https://github.com/handsontable/hyperformula/issues/626) ## 0.5.0 **Release date: April 15, 2021** ### Added - Added support for row and column reordering. [#343](https://github.com/handsontable/hyperformula/issues/343) - Added type inferrence for subtypes for number. [#313](https://github.com/handsontable/hyperformula/issues/313) - Added parsing of number literals containing '%' or currency symbol (default '$'). [#590](https://github.com/handsontable/hyperformula/issues/590) - Added ability to fallback to plain CPU implementation for functions that uses GPU.js [#355](https://github.com/handsontable/hyperformula/issues/355) ### Changed - **Breaking change**: A change to the type of value returned via serialization methods. [#617](https://github.com/handsontable/hyperformula/issues/617) - An input value should be preserved through serialization more precisely. [#617](https://github.com/handsontable/hyperformula/issues/617) - GPU.js constructor needs to be provided directly to engine configuration. [#355](https://github.com/handsontable/hyperformula/issues/355) - A deprecated config option vlookupThreshold has been removed. [#620](https://github.com/handsontable/hyperformula/issues/620) ### Fixed - Fixed minor issue. [#631](https://github.com/handsontable/hyperformula/issues/631) - Fixed a bug with serialization of some addresses after CRUDs. [#587](https://github.com/handsontable/hyperformula/issues/587) - Fixed a bug with MEDIAN function implementation. [#601](https://github.com/handsontable/hyperformula/issues/601) - Fixed a bug with copy-paste operation that could cause out of scope references [#591](https://github.com/handsontable/hyperformula/issues/591) - Fixed a bug with date parsing. [#614](https://github.com/handsontable/hyperformula/issues/614) - Fixed a bug where accent/case sensitivity was ignored for LOOKUPs. [#621](https://github.com/handsontable/hyperformula/issues/621) - Fixed a bug with handling of no time format/no date format scenarios. [#616](https://github.com/handsontable/hyperformula/issues/616) ## 0.4.0 **Release date: December 17, 2020** ### Added - Added 50 mathematical functions: ROMAN, ARABIC, FACT, FACTDOUBLE, COMBIN, COMBINA, GCD, LCM, MROUND, MULTINOMIAL, QUOTIENT, RANDBETWEEN, SERIESSUM, SIGN, SQRTPI, SUMX2MY2, SUMX2PY2, SUMXMY2, CEILING.MATH, FLOOR.MATH, FLOOR, CEILING.PRECISE, FLOOR.PRECISE, ISO.CEILING, COMPLEX, IMABS, IMAGINARY, IMARGUMENT, IMCONJUGATE, IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMDIV, IMEXP, IMLN, IMLOG10, IMLOG2, IMPOWER, IMPRODUCT, IMREAL, IMSEC, IMSECH, IMSIN, IMSINH, IMSQRT, IMSUB, IMSUM, IMTAN. [#537](https://github.com/handsontable/hyperformula/issues/537) , [#582](https://github.com/handsontable/hyperformula/issues/582) , [#281](https://github.com/handsontable/hyperformula/issues/281) , [#581](https://github.com/handsontable/hyperformula/issues/581) - Added 106 statistical functions: EXPON.DIST, EXPONDIST, FISHER, FISHERINV, GAMMA, GAMMA.DIST, GAMMADIST, GAMMALN, GAMMALN.PRECISE, GAMMA.INV, GAMMAINV, GAUSS, BETA.DIST, BETADIST, BETA.INV, BETAINV, BINOM.DIST, BINOMDIST, BINOM.INV, BESSELI, BESSELJ, BESSELK, BESSELY, CHISQ.DIST, CHISQ.DIST.RT, CHISQ.INV, CHISQ.INV.RT, CHIDIST, CHIINV, F.DIST, F.DIST.RT, F.INV, F.INV.RT, FDIST, FINV, WEIBULL, WEIBULL.DIST, HYPGEOMDIST, HYPGEOM.DIST, T.DIST, T.DIST.2T, T.DIST.RT, T.INV, T.INV.2T, TDIST, TINV, LOGNORM.DIST, LOGNORMDIST, LOGNORM.INV, LOGINV, NORM.DIST, NORMDIST, NORM.S.DIST, NORMSDIST, NORM.INV, NORMINV, NORM.S.INV, NORMSINV, PHI, NEGBINOM.DIST, NEGBINOMDIST, POISSON, POISSON.DIST, LARGE, SMALL, AVEDEV, CONFIDENCE, CONFIDENCE.NORM, CONFIDENCE.T, DEVSQ, GEOMEAN, HARMEAN, CRITBINOM, COVAR, COVARIANCE.P, COVARIANCE.S, PEARSON, RSQ, STANDARDIZE, Z.TEST, ZTEST, F.TEST, FTEST, STEYX, SLOPE, CHITEST, CHISQ.TEST, T.TEST, TTEST, SKEW.P, SKEW, WEIBULLDIST, VARS, TINV2T, TDISTRT, TDIST2T, STDEVS, FINVRT, FDISTRT, CHIDISTRT, CHIINVRT, COVARIANCEP, COVARIANCES, LOGNORMINV, POISSONDIST, SKEWP. [#152](https://github.com/handsontable/hyperformula/issues/152) , [#154](https://github.com/handsontable/hyperformula/issues/154) , [#160](https://github.com/handsontable/hyperformula/issues/160) - Added function aliases mechanism. [#569](https://github.com/handsontable/hyperformula/pull/569) - Added support for scientific notation. [#579](https://github.com/handsontable/hyperformula/issues/579) - Added support for complex numbers. [#281](https://github.com/handsontable/hyperformula/issues/281) ### Changed - A **breaking change**: CEILING function implementation to be consistent with existing implementations. [#582](https://github.com/handsontable/hyperformula/issues/582) ### Fixed - Fixed a problem with dependencies not collected for specific functions. [#550](https://github.com/handsontable/hyperformula/issues/550) , [#549](https://github.com/handsontable/hyperformula/issues/549) - Fixed a minor problem with dependencies under nested parenthesis. [#549](https://github.com/handsontable/hyperformula/issues/549) , [#558](https://github.com/handsontable/hyperformula/issues/558) - Fixed a problem with HLOOKUP/VLOOKUP getting stuck in binary search. [#559](https://github.com/handsontable/hyperformula/issues/559) , [#562](https://github.com/handsontable/hyperformula/issues/562) - Fixed a problem with the logic of dependency resolving. [#561](https://github.com/handsontable/hyperformula/issues/561) , [#563](https://github.com/handsontable/hyperformula/pull/563) - Fixed a minor bug with ATAN2 function. [#581](https://github.com/handsontable/hyperformula/issues/581) ## 0.3.0 **Release date: October 22, 2020** ### Added - Added 9 text functions EXACT, LOWER, UPPER, MID, T, SUBSTITUTE, REPLACE, UNICODE, UNICHAR. [#159](https://github.com/handsontable/hyperformula/issues/159) - Added 5 datetime functions: INTERVAL, NETWORKDAYS, NETWORKDAYS.INTL, WORKDAY, WORKDAY.INTL. [#153](https://github.com/handsontable/hyperformula/issues/153) - Added 3 information functions HLOOKUP, ROW, COLUMN. [#520](https://github.com/handsontable/hyperformula/pull/520) - Added 5 financial functions FVSCHEDULE, NPV, MIRR, PDURATION, XNPV. [#542](https://github.com/handsontable/hyperformula/pull/542) - Added 12 statistical functions VAR.P, VAR.S, VARA, VARPA, STDEV.P, STDEV.S, STDEVA, STDEVPA, VARP, VAR, STDEVP, STDEV. [#536](https://github.com/handsontable/hyperformula/pull/536) - Added 2 mathematical functions SUBTOTAL, PRODUCT. [#536](https://github.com/handsontable/hyperformula/pull/536) - Added 15 operator functions HF.ADD, HF.CONCAT, HF.DIVIDE, HF.EQ, HF.GT, HF.GTE, HF.LT, HF.LTE, HF.MINUS, HF.MULTIPLY, HF.NE, HF.POW, HF.UMINUS, HF.UNARY_PERCENT, HF.UPLUS. [#543](https://github.com/handsontable/hyperformula/pull/543) ### Fixed - Fixed multiple issues with VLOOKUP function. [#526](https://github.com/handsontable/hyperformula/issues/526) and [#528](https://github.com/handsontable/hyperformula/issues/528) - Fixed MATCH and INDEX functions compatiblity. [#520](https://github.com/handsontable/hyperformula/pull/520) - Fixed issue with config update that does not preserve named expressions. [#527](https://github.com/handsontable/hyperformula/issues/527) - Fixed minor issue with arithmetic operations error messages. [#532](https://github.com/handsontable/hyperformula/issues/532) ## 0.2.0 **Release date: September 22, 2020** ### Added - Added 9 text functions LEN, TRIM, PROPER, CLEAN, REPT, RIGHT, LEFT, SEARCH, FIND. [#221](https://github.com/handsontable/hyperformula/issues/221) - Added helper methods for keeping track of cell/range dependencies: `getCellPrecedents` and `getCellDependents`. [#441](https://github.com/handsontable/hyperformula/issues/441) - Added 22 financial functions FV, PMT, PPMT, IPMT, CUMIPMT, CUMPRINC, DB, DDB, DOLLARDE, DOLLARFR, EFFECT, ISPMT, NOMINAL, NPER, RATE, PV, RRI, SLN, SYD, TBILLEQ, TBILLPRICE, TBILLYIELD. [#494](https://github.com/handsontable/hyperformula/issues/494) - Added FORMULATEXT function. [#422](https://github.com/handsontable/hyperformula/pull/422) - Added 8 information functions ISERR, ISNA, ISREF, NA, SHEET, SHEETS, ISBINARY, ISFORMULA. [#481](https://github.com/handsontable/hyperformula/issues/481) - Added 15 date functions: WEEKDAY, DATEVALUE, HOUR, MINUTE, SECOND, TIME, TIMEVALUE, NOW, TODAY, EDATE, WEEKNUM, ISOWEEKNUM, DATEDIF, DAYS360, YEARFRAC. [#483](https://github.com/handsontable/hyperformula/issues/483) - Added 13 trigonometry functions: SEC, CSC, SINH, COSH, TANH, COTH, SECH, CSCH, ACOT, ASINH, ACOSH, ATANH, ACOTH. [#485](https://github.com/handsontable/hyperformula/issues/485) - Added 6 engineering functions: OCT2BIN, OCT2DEC, OCT2HEX, HEX2BIN, HEX2OCT, HEX2DEC. [#497](https://github.com/handsontable/hyperformula/issues/497) - Added a configuration option to evaluate reference to an empty cells as a zero. [#476](https://github.com/handsontable/hyperformula/issues/476) - Added new error type: missing licence. [#306](https://github.com/handsontable/hyperformula/issues/306) - Added detailed error messages for error values. [#506](https://github.com/handsontable/hyperformula/issues/506) - Added ability to handle more characters in quoted sheet names. [#509](https://github.com/handsontable/hyperformula/issues/509) - Added support for escaping apostrophe character in quoted sheet names. [#64](https://github.com/handsontable/hyperformula/issues/64) ### Changed - Operation `moveCells` creating cyclic dependencies does not cause losing original formula. [#479](https://github.com/handsontable/hyperformula/issues/479) - Simplified adding new function modules, reworked (simplified) implementations of existing modules. [#480](https://github.com/handsontable/hyperformula/issues/480) ### Fixed - Fixed hardcoding of languages in i18n tests. [#471](https://github.com/handsontable/hyperformula/issues/471) - Fixed many compilation warnings based on LGTM analysis. [#473](https://github.com/handsontable/hyperformula/issues/473) - Fixed `moveCells` behaviour when moving part of a range. [#479](https://github.com/handsontable/hyperformula/issues/479) - Fixed `moveColumns`/`moveRows` inconsistent behaviour. [#479](https://github.com/handsontable/hyperformula/issues/479) - Fixed undo of `moveColumns`/`moveRows` operations. [#479](https://github.com/handsontable/hyperformula/issues/479) - Fixed name-collision issue in translations. [#486](https://github.com/handsontable/hyperformula/issues/486) - Fixed bug in concatenation + `nullValue`. [#495](https://github.com/handsontable/hyperformula/issues/495) - Fixed bug when undoing irreversible operation. [#502](https://github.com/handsontable/hyperformula/issues/502) - Fixed minor issue with CHAR function logic. [#510](https://github.com/handsontable/hyperformula/issues/510) - Fixed `simpleCellAddressToString` behaviour when converting quoted sheet names. [#514](https://github.com/handsontable/hyperformula/issues/514) - Fixed issues with numeric aggregation functions. [#515](https://github.com/handsontable/hyperformula/issues/515) ## 0.1.3 **Release date: July 21, 2020** ### Fixed - Fixed a bug in coercion of empty string to boolean value. [#453](https://github.com/handsontable/hyperformula/issues/453) ## 0.1.2 **Release date: July 13, 2020** ### Fixed - Fixed a bug in topological ordering module. [#442](https://github.com/handsontable/hyperformula/issues/442) ## 0.1.1 **Release date: July 1, 2020** ### Fixed - Fixed a typo in a config option from `useRegularExpresssions` to `useRegularExpressions`. [#437](https://github.com/handsontable/hyperformula/issues/437) ## 0.1.0 **Alpha release date: June 25, 2020 🎉** - Core functionality of the engine - Support for data types: String, Error, Number, Date, Time, DateTime, Duration, Distinct Logical - Support for logical operators: =, <>, >, <, >=, <= - Support for arithmetic operators: +, -, \*, /, % - Support for text operator: & - CRUD operations: - modifying the value of a single cell - adding/deleting row/column - reading the value or formula from the selected cell - moving a cell or a block of cells - deleting a subset of rows or columns - recalculating and refreshing of a worksheet - batching CRUD operations - support for wildcards and regex inside criterion functions like SUMIF, COUNTIF - named expressions support - support for cut, copy, paste - undo/redo support - The following functions: ABS(), ACOS(), AND(), ASIN(), ATAN(), ATAN2(), AVERAGE(), AVERAGEA(), AVERAGEIF(), BASE(), BIN2DEC(), BIN2HEX()BIN2OCT(), BITAND(), BITLSHIFT(), BITOR(), BITRSHIFT(), BITXOR(), CEILING(), CHAR(), CHOOSE(), CODE(), COLUMNS(), CONCATENATE(), CORREL(), COS(), COT(), COUNT(), COUNTA(), COUNTBLANK(), COUNTIF(), COUNTIFS(), COUNTUNIQUE(), DATE(), DAY(), DAYS(), DEC2BIN(), DEC2HEX(), DEC2OCT(), DECIMAL(), DEGREES(), DELTA(), E(), EOMONTH(), ERF(), ERFC(), EVEN(), EXP(), FALSE(), IF(), IFERROR(), IFNA(), INDEX(), INT(), ISBLANK(), ISERROR(), ISEVEN(), ISLOGICAL(), ISNONTEXT(), ISNUMBER(), ISODD(), ISTEXT(), LN(), LOG(), LOG10(), MATCH(), MAX(), MAXA(), MAXPOOL(), MEDIAN(), MEDIANPOOL(), MIN(), MINA(), MMULT(), MOD(), MONTH(), NOT(), ODD(), OFFSET(), OR(), PI(), POWER(), RADIANS() , RAND(), ROUND(), ROUNDDOWN(), ROUNDUP(), ROWS(), SIN(), SPLIT(), SQRT(), SUM(), SUMIF(), SUMIFS(), SUMPRODUCT(), SUMSQ(), SWITCH(), TAN(), TEXT(), TRANSPOSE(), TRUE(), TRUNC(), VLOOKUP(), XOR(), YEAR() - Support for volatile functions - Cultures supports - can be configured according to the application need - Custom functions support - Set [OpenDocument v1.2](http://docs.oasis-open.org/office/v1.2/OpenDocument-v1.2-part2.html) as a standard to follow - Error handling: - Division by zero: #DIV/0! - Unknown function name: #NAME? - Wrong type of argument in a function or wrong type of operator: #VALUE! - Invalid numeric values: #NUM! - No value available: #N/A - Cyclic dependency: #CYCLE! - Wrong address reference: #REF - Built-in function translation support for 16 languages: English, Czech, Danish, Dutch, Finnish, French, German, Hungarian, Italian, Norwegian, Polish, Portuguese, Russian, Spanish, Swedish, Turkish. --- ## Specifications and limits URL: https://hyperformula.handsontable.com/docs/guide/specifications-and-limits # Specifications and limits The following table presents the limits of features. Many of them are bounded only by system resources. This means the actual limit depends on several factors, for example, the resources (such as available memory) of the device HyperFormula is running on. ## Sheet and cell limits| Feature | Maximum limit |
|---|---|
| Number of cells |
Limited by system resources (JavaScript) Can be set in the configuration:
|
| Number of nested levels of functions | 120 |
| Earliest date allowed for the calculation | December 30, 1899 |
| Latest date allowed for the calculation | December 31, 9999 |
| Number of named expressions | Limited by system resources (JavaScript) |
| Characters in a cell | Limited by system resources (JavaScript) |
| Characters in a named expression | Limited by system resources (JavaScript) |
| Characters in a sheet name | Limited by system resources (JavaScript) |
| Characters in a column name | Depends on the configuration of MaxColumns |
| Number of sheets in a workbook | Limited by system resources (JavaScript) |
| Number of custom functions | Limited by system resources (JavaScript) |
| Undo levels | Limited by the configuration - undoLimit (default: 20) |
| Number of elements in a batch operation | Limited by system resources (JavaScript) |
| Precedence | Operator | Description |
|---|---|---|
| 1 |
: (colon) , (comma) (space) |
Reference operators: range (colon), union (comma), intersection (space). Currently supported by HyperFormula only at the grammar level of a function. |
| 2 | – | Negation |
| 3 | % | Percent |
| 4 | ^ | Exponentiation |
| 5 | * and / | Multiplication and division |
| 6 | + and – | Addition and subtraction |
| 7 | & (ampersand) | Concatenation of two or more text strings |
| 8 |
< (less than) = (equal to) > (greater than) <= (less than or equal to) >= (greater than or equal to) <> (not equal to) |
Comparison |