# API Reference Overview 

## Type aliases

### CellDependency 

Ƭ **CellDependency**: *[SimpleCellAddress](interfaces/simplecelladdress.md) | [AbsoluteCellRange](classes/absolutecellrange.md) | NamedExpressionDependency*

*Defined in [src/CellDependency.ts:10](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellDependency.ts#L10)*

___

### CellValue 

Ƭ **CellValue**: *[NoErrorCellValue](globals.md#noerrorcellvalue) | [DetailedCellError](classes/detailedcellerror.md)*

*Defined in [src/CellValue.ts:9](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellValue.ts#L9)*

___

### CellValueDetailedType 

Ƭ **CellValueDetailedType**: *[CellValueNoNumber](enums/cellvaluenonumber.md) | NumberType*

*Defined in [src/Cell.ts:94](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L94)*

___

### CellValueType 

Ƭ **CellValueType**: *[CellValueNoNumber](enums/cellvaluenonumber.md) | [CellValueJustNumber](enums/cellvaluejustnumber.md)*

*Defined in [src/Cell.ts:91](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L91)*

___

### ChangeList 

Ƭ **ChangeList**: *[CellValueChange](interfaces/cellvaluechange.md)[]*

*Defined in [src/ContentChanges.ts:20](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ContentChanges.ts#L20)*

___

### ClipboardCell 

Ƭ **ClipboardCell**: *[ClipboardCellValue](interfaces/clipboardcellvalue.md) | [ClipboardCellFormula](interfaces/clipboardcellformula.md) | [ClipboardCellEmpty](interfaces/clipboardcellempty.md) | [ClipboardCellParsingError](interfaces/clipboardcellparsingerror.md)*

*Defined in [src/ClipboardOperations.ts:16](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ClipboardOperations.ts#L16)*

___

### ColumnMap 

Ƭ **ColumnMap**: *Map‹RawInterpreterValue, [ValueIndex](interfaces/valueindex.md)›*

*Defined in [src/Lookup/ColumnIndex.ts:30](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Lookup/ColumnIndex.ts#L30)*

___

### ColumnRowIndex 

Ƭ **ColumnRowIndex**: *[number, number]*

*Defined in [src/CrudOperations.ts:65](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CrudOperations.ts#L65)*

___

### ConfigParamsList 

Ƭ **ConfigParamsList**: *keyof ConfigParams*

*Defined in [src/ConfigParams.ts:450](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ConfigParams.ts#L450)*

___

### ConsoleMessages 

Ƭ **ConsoleMessages**: *object*

*Defined in [src/helpers/licenseKeyValidator.ts:25](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L25)*

#### Type declaration:

___

### DateTime 

Ƭ **DateTime**: *[SimpleTime](interfaces/simpletime.md) | [SimpleDate](interfaces/simpledate.md) | [SimpleDateTime](globals.md#simpledatetime)*

*Defined in [src/DateTimeHelper.ts:31](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L31)*

___

### Dependencies 

Ƭ **Dependencies**: *Map‹Vertex, [CellDependency](globals.md#celldependency)[]›*

*Defined in [src/GraphBuilder.ts:25](https://github.com/handsontable/hyperformula/blob/dcf9354/src/GraphBuilder.ts#L25)*

___

### EngineState 

Ƭ **EngineState**: *object*

*Defined in [src/BuildEngineFactory.ts:35](https://github.com/handsontable/hyperformula/blob/dcf9354/src/BuildEngineFactory.ts#L35)*

#### Type declaration:

* **cellContentParser**: *[CellContentParser](classes/cellcontentparser.md)*

* **columnSearch**: *[ColumnSearchStrategy](interfaces/columnsearchstrategy.md)*

* **config**: *[Config](classes/config.md)*

* **crudOperations**: *[CrudOperations](classes/crudoperations.md)*

* **dependencyGraph**: *DependencyGraph*

* **evaluator**: *[Evaluator](classes/evaluator.md)*

* **exporter**: *[Exporter](classes/exporter.md)*

* **functionRegistry**: *FunctionRegistry*

* **lazilyTransformingAstService**: *[LazilyTransformingAstService](classes/lazilytransformingastservice.md)*

* **namedExpressions**: *[NamedExpressions](classes/namedexpressions.md)*

* **parser**: *ParserWithCaching*

* **serialization**: *[Serialization](classes/serialization.md)*

* **stats**: *[Statistics](classes/statistics.md)*

* **unparser**: *Unparser*

___

### ExportedChange 

Ƭ **ExportedChange**: *[ExportedCellChange](classes/exportedcellchange.md) | [ExportedNamedExpressionChange](classes/exportednamedexpressionchange.md)*

*Defined in [src/Exporter.ts:18](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Exporter.ts#L18)*

___

### LicenseKeyFormat 

Ƭ **LicenseKeyFormat**: *"entitlement" | "legacy" | "non-commercial-and-evaluation" | "gpl-v3" | "unknown"*

*Defined in [src/license/vendor/detectFormat.ts:14](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/detectFormat.ts#L14)*

The name of each license key format [detectLicenseKeyFormat](globals.md#detectlicensekeyformat) can answer with.

___

### LicenseKeyInvalidState 

Ƭ **LicenseKeyInvalidState**: *Exclude‹[LicenseKeyValidityState](enums/licensekeyvaliditystate.md), [VALID](enums/licensekeyvaliditystate.md#valid)›*

*Defined in [src/helpers/licenseKeyValidator.ts:19](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L19)*

___

### Maybe 

Ƭ **Maybe**: *T | undefined*

*Defined in [src/Maybe.ts:6](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Maybe.ts#L6)*

**`license`** 
Copyright (c) 2025 Handsoncode. All rights reserved.

___

### MessageDescriptor 

Ƭ **MessageDescriptor**: *object*

*Defined in [src/helpers/licenseKeyValidator.ts:29](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L29)*

#### Type declaration:

* **expiryDate**? : *Date*

* **template**: *[LicenseKeyValidityState](enums/licensekeyvaliditystate.md)*

___

### NamedExpressionOptions 

Ƭ **NamedExpressionOptions**: *Record‹string, string | number | boolean›*

*Defined in [src/NamedExpressions.ts:22](https://github.com/handsontable/hyperformula/blob/dcf9354/src/NamedExpressions.ts#L22)*

___

### NoErrorCellValue 

Ƭ **NoErrorCellValue**: *number | string | boolean | null*

*Defined in [src/CellValue.ts:8](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellValue.ts#L8)*

___

### RawCellContent 

Ƭ **RawCellContent**: *Date | string | number | boolean | null | undefined*

*Defined in [src/CellContentParser.ts:25](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellContentParser.ts#L25)*

___

### Sheet 

Ƭ **Sheet**: *[RawCellContent](globals.md#rawcellcontent)[][]*

*Defined in [src/Sheet.ts:12](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Sheet.ts#L12)*

Two-dimenstional array representation of sheet

___

### SheetDimensions 

Ƭ **SheetDimensions**: *object*

*Defined in [src/Sheet.ts:19](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Sheet.ts#L19)*

Represents size of a sheet

#### Type declaration:

* **height**: *number*

* **width**: *number*

___

### SheetIndex 

Ƭ **SheetIndex**: *[ColumnMap](globals.md#columnmap)[]*

*Defined in [src/Lookup/ColumnIndex.ts:37](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Lookup/ColumnIndex.ts#L37)*

___

### Sheets 

Ƭ **Sheets**: *Record‹string, [Sheet](globals.md#sheet)›*

*Defined in [src/Sheet.ts:14](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Sheet.ts#L14)*

___

### SimpleDateTime 

Ƭ **SimpleDateTime**: *[SimpleDate](interfaces/simpledate.md) & [SimpleTime](interfaces/simpletime.md)*

*Defined in [src/DateTimeHelper.ts:29](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L29)*

___

### Span 

Ƭ **Span**: *[RowsSpan](classes/rowsspan.md) | [ColumnsSpan](classes/columnsspan.md)*

*Defined in [src/Span.ts:6](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Span.ts#L6)*

**`license`** 
Copyright (c) 2025 Handsoncode. All rights reserved.

___

### TranslatableErrorType 

Ƭ **TranslatableErrorType**: *Exclude‹[ErrorType](classes/hyperformulans.md#static-errortype), [LIC](enums/errortype.md#lic)›*

*Defined in [src/Cell.ts:51](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L51)*

## Variables

### ALL_FEATURE_TOKENS

• **ALL_FEATURE_TOKENS**: *string[]* = [
  CRUD_FEATURE_TOKEN, UNDO_REDO_FEATURE_TOKEN, CLIPBOARD_FEATURE_TOKEN,
  NAMED_EXPRESSIONS_FEATURE_TOKEN, BATCHING_FEATURE_TOKEN,
]

*Defined in [src/license/capabilities.ts:34](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L34)*

Every feature token, in one list, for the opt-in rule in `licenseTermsOf`: a key naming no
`feat:*` token at all is granted all of these, because no key vocabulary in circulation can
express "no features" — see that function for the reasoning.

___

### BASE64_ALPHABET

• **BASE64_ALPHABET**: *"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"* = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

*Defined in [src/license/vendor/utils.ts:17](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L17)*

The base64 alphabet.

___

### BATCHING_FEATURE_TOKEN

• **BATCHING_FEATURE_TOKEN**: *"feat:batching"* = "feat:batching"

*Defined in [src/license/capabilities.ts:27](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L27)*

Grants [FeatureId.Batching](enums/featureid.md#batching).

___

### CALCULATED_FIELDS_FUNCTIONS

• **CALCULATED_FIELDS_FUNCTIONS**: *string[]* = gatableMembersOfGroups(CALCULATED_FIELDS_GROUPS)

*Defined in [src/license/capabilities.ts:216](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L216)*

Added by the calculated-fields package, on top of [MATH_ENGINE_FUNCTIONS](globals.md#const-math_engine_functions).

___

### CALCULATED_FIELDS_GROUPS

• **CALCULATED_FIELDS_GROUPS**: *string[]* = ['fun:time.b', 'fun:text.b', 'fun:logic.b', 'fun:math.b', 'fun:stat.b']

*Defined in [src/license/capabilities.ts:181](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L181)*

___

### CAPABILITY_TABLE

• **CAPABILITY_TABLE**: *ReadonlyMap‹string, [CapabilityGrant](interfaces/capabilitygrant.md)›* = new Map([
  [CORE_TOKEN, coreGrant],
  [FUNCTIONS_1_TOKEN, functions1Grant],
  [FUNCTIONS_2_TOKEN, functions2Grant],
  [FUNCTIONS_3_TOKEN, functions3Grant],
  [FUNCTIONS_4_TOKEN, functions4Grant],
  [CRUD_FEATURE_TOKEN, {functions: [], features: [FeatureId.Crud]}],
  [UNDO_REDO_FEATURE_TOKEN, {functions: [], features: [FeatureId.UndoRedo]}],
  [CLIPBOARD_FEATURE_TOKEN, {functions: [], features: [FeatureId.Clipboard]}],
  [NAMED_EXPRESSIONS_FEATURE_TOKEN, {functions: [], features: [FeatureId.NamedExpressions]}],
  [BATCHING_FEATURE_TOKEN, {functions: [], features: [FeatureId.Batching]}],
  [SPREADSHEET_ADDON_TOKEN, {
    functions: [],
    features: [FeatureId.Crud, FeatureId.UndoRedo, FeatureId.Clipboard, FeatureId.Batching],
  }],
  [IMPORT_EXPORT_ADDON_TOKEN, {functions: [], features: [FeatureId.ImportExport]}],
  [FUN_ALL_TOKEN, {functions: [...functions4Grant.functions], features: []}],
  ...groupEntries,
  ...singleFunctionEntries,
])

*Defined in [src/license/capabilities.ts:351](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L351)*

The production capability table, keyed by NORMALIZED token spelling — look up through
[normalizeCapabilityToken](globals.md#normalizecapabilitytoken), never with a raw key string.

The engine understands BOTH token dialects in circulation, resolved from the one group registry
above so they cannot drift apart:

- the key spec's package slices (`functions_1..4`) plus the two add-on tokens — the vocabulary
  the upstream generator's own schema mints today;
- the packaging doc's group vocabulary (`fun:all`, `fun:<family>.<A|B|C>`,
  `fun:<CANONICAL_FUNCTION_NAME>`) — §6 of the 12.08 packaging doc.

Accepting the superset is deliberate and spec-clean: an unrecognized token is defined as "a
grant this version does not implement" (strict-shape/lenient-vocabulary, T7), so implementing
more tokens than the generator currently mints breaks nothing — and it makes the engine robust
to the still-open business decision about which dialect keys will finally be worded in
(owner's call, 20.08). A key's function set is the UNION of everything recognized.

The grants are stored FULLY EXPANDED rather than chained through `implies`: the packaging
design states the enforcement layer must not assume a hierarchy between tokens, and that the
commercial nesting is expressed by a bigger licence simply listing more functions. The
cumulative spreads above keep the source DRY without putting that hierarchy into the runtime.

Every grant is STATIC. Nothing here is derived from the function registry at run time, so a
function registered by a user through `HyperFormula.registerFunctionPlugin` can never appear in
a package and can never be gated — see [EXCEL_SIMULATOR_FUNCTIONS](globals.md#const-excel_simulator_functions). The cost is that a
newly implemented built-in is ungated until it is added here, which the completeness invariant
in `unit/license/capability-registry.spec.ts` fails on.

The five `feat:*` tokens carry the gated API areas, one feature each, spelled after the draft
vocabulary in the task. A key may state them explicitly; a key naming none is granted all five
(the opt-in rule in `licenseTermsOf`); legacy keys resolve to the unrestricted entitlement and
never consult this table.

The two add-on tokens, wired per the 2026-08-12 packages meeting: `spreadsheet` backs the
'Spreadsheet Bundle' add-on and grants [FeatureId.Crud](enums/featureid.md#crud), [FeatureId.UndoRedo](enums/featureid.md#undoredo),
[FeatureId.Clipboard](enums/featureid.md#clipboard) and [FeatureId.Batching](enums/featureid.md#batching) (Kuba: batching too, 12.08).
`import_export` backs the import-export add-on and grants [FeatureId.ImportExport](enums/featureid.md#importexport) — a
RESERVED grant, since nothing in the public API is gated on it yet: HF-107 hasn't shipped the
feature it would gate. Both tokens stay recognized either way, so an issued key carrying one is
never reported as unrecognized.

Entry ORDER is load-bearing at one spot: `CapabilityRegistry`'s reverse index maps each
function id to the FIRST token that lists it, so the package slices stay ahead of the group and
single-function tokens, keeping `capabilityOf`'s answers what they were before the second
dialect existed.

___

### CHECKSUM

• **CHECKSUM**: *RegExp‹›* = /^[0-9a-f]+$/

*Defined in [src/license/vendor/extractKeyData.ts:25](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L25)*

___

### CLIPBOARD_FEATURE_TOKEN

• **CLIPBOARD_FEATURE_TOKEN**: *"feat:clipboard"* = "feat:clipboard"

*Defined in [src/license/capabilities.ts:23](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L23)*

Grants [FeatureId.Clipboard](enums/featureid.md#clipboard).

___

### CORE_TOKEN

• **CORE_TOKEN**: *"core"* = "core"

*Defined in [src/license/capabilities.ts:16](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L16)*

The always-granted token. Every entitlement built from a license key includes it.

It grants the calculation operators — and nothing else. In particular it grants NO features:
per Kuba's decision (task comment, 12.08) feature gating is real, and the gated API areas come
from the `feat:*` tokens below. The always-on functionality the packaging design assigns to
core (reads, serialization, teardown) is not behind `ensureCapability` at all.

___

### CRUD_FEATURE_TOKEN

• **CRUD_FEATURE_TOKEN**: *"feat:crud"* = "feat:crud"

*Defined in [src/license/capabilities.ts:19](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L19)*

Grants [FeatureId.Crud](enums/featureid.md#crud) — the mutating CRUD surface of the public API.

___

### DATE_FIELDS

• **DATE_FIELDS**: *readonly string[]* = ['usage_until', 'release_until']

*Defined in [src/license/vendor/constants.ts:28](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/constants.ts#L28)*

The two mutually exclusive date fields of a product entry. Exactly one of them has to be
present:

- `usage_until` — the last licensed day (inclusive, compared in UTC),
- `release_until` — builds released on or before that day may be used forever (compared
  against the build release date as text, no clock involved).

The pair replaces the contract type — nothing in the payload says "subscription" or
"perpetual".

___

### DATE_SEPARATOR_REGEXP

• **DATE_SEPARATOR_REGEXP**: *RegExp‹›* = new RegExp('[ /.-]')

*Defined in [src/DateTimeDefault.ts:13](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L13)*

___

### ENCODED_PAYLOAD

• **ENCODED_PAYLOAD**: *RegExp‹›* = /^[A-Za-z0-9\-_]+$/

*Defined in [src/license/vendor/extractKeyData.ts:24](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L24)*

The alphabet of the encoded payload — URL-safe base64 without padding. The checksum (lowercase
hex) is a subset of it, which is what lets the two be split by a fixed length from the right.

___

### ENTITLEMENT_KEY_CHECKSUM_LENGTH

• **ENTITLEMENT_KEY_CHECKSUM_LENGTH**: *128* = 128

*Defined in [src/license/vendor/constants.ts:15](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/constants.ts#L15)*

The length of the checksum (SHA-512 as hex) which postfixes the payload inside the
machine-readable block of every entitlement license key.

___

### EXCEL_SIMULATOR_FUNCTIONS

• **EXCEL_SIMULATOR_FUNCTIONS**: *string[]* = [
  'ACOSH', 'ACOT', 'ACOTH', 'ARABIC', 'ASINH', 'ATANH', 'AVEDEV', 'BASE', 'BESSELI', 'BESSELJ', 'BESSELK',
  'BESSELY', 'BETA.DIST', 'BETA.INV', 'BIN2DEC', 'BIN2HEX', 'BIN2OCT', 'BINOM.DIST', 'BINOM.INV', 'BITAND',
  'BITLSHIFT', 'BITOR', 'BITRSHIFT', 'BITXOR', 'CEILING.MATH', 'CEILING.PRECISE', 'CHISQ.DIST',
  'CHISQ.DIST.RT', 'CHISQ.INV', 'CHISQ.INV.RT', 'CHISQ.TEST', 'COMBIN', 'COMBINA', 'COMPLEX',
  'CONFIDENCE.NORM', 'CONFIDENCE.T', 'CORREL', 'COSH', 'COT', 'COTH', 'COUNTUNIQUE', 'COVARIANCE.P',
  'COVARIANCE.S', 'CSC', 'CSCH', 'CUMIPMT', 'CUMPRINC', 'DAVERAGE', 'DB', 'DCOUNT', 'DCOUNTA', 'DDB',
  'DEC2BIN', 'DEC2OCT', 'DECIMAL', 'DEGREES', 'DELTA', 'DEVSQ', 'DGET', 'DMAX', 'DMIN', 'DOLLARDE',
  'DOLLARFR', 'DPRODUCT', 'DSTDEV', 'DSTDEVP', 'DSUM', 'DVAR', 'DVARP', 'EFFECT', 'ERF', 'ERFC',
  'EXPON.DIST', 'F.DIST', 'F.DIST.RT', 'F.INV', 'F.INV.RT', 'F.TEST', 'FACT', 'FACTDOUBLE', 'FISHER',
  'FISHERINV', 'FLOOR.MATH', 'FLOOR.PRECISE', 'FORMULATEXT', 'FVSCHEDULE', 'GAMMA', 'GAMMA.DIST',
  'GAMMA.INV', 'GAMMALN', 'GAUSS', 'GCD', 'GEOMEAN', 'HARMEAN', 'HEX2BIN', 'HEX2OCT', 'HYPGEOM.DIST',
  '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', 'INTERVAL', 'ISBINARY', 'ISFORMULA', 'ISNONTEXT', 'ISPMT',
  'ISREF', 'LCM', 'LOG10', 'LOGNORM.DIST', 'LOGNORM.INV', 'MAXA', 'MAXPOOL', 'MEDIANPOOL', 'MINA', 'MIRR',
  'MMULT', 'MULTINOMIAL', 'NEGBINOM.DIST', 'NETWORKDAYS.INTL', 'NOMINAL', 'NORM.DIST', 'NORM.INV',
  'NORM.S.DIST', 'NORM.S.INV', 'NPER', 'OCT2BIN', 'OCT2DEC', 'OCT2HEX', 'PDURATION', 'PERCENTILE.EXC',
  'PHI', 'POISSON.DIST', 'QUARTILE.EXC', 'QUARTILE.INC', 'RADIANS', 'ROMAN', 'RRI', 'RSQ', 'SEC', 'SECH',
  'SERIESSUM', 'SHEET', 'SHEETS', 'SINH', 'SKEW', 'SKEW.P', 'SLOPE', 'SPLIT', 'SQRTPI', 'STANDARDIZE',
  'STEYX', 'SUMX2MY2', 'SUMX2PY2', 'SYD', 'T.DIST', 'T.DIST.2T', 'T.DIST.RT', 'T.INV', 'T.INV.2T', 'T.TEST',
  'TANH', 'TBILLEQ', 'TBILLPRICE', 'TBILLYIELD', 'TDIST', 'TIMEVALUE', 'UNICODE', 'VARA', 'VARPA',
  'WEIBULL.DIST', 'WORKDAY.INTL', 'Z.TEST',
]

*Defined in [src/license/capabilities.ts:235](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L235)*

Added by the excel-simulator package, on top of [SPREADSHEET_FUNCTIONS](globals.md#const-spreadsheet_functions) — the rest of the
implemented catalog.

Kuba's doc does not itemize this remainder into groups the way it does for the first three
packages: the excel-simulator package is stated as `fun:all` — the whole catalog, granted as a
single token rather than assembled from named groups. This list is that remainder, enumerated
rather than taken from the function registry at run time, even though "all functions" would be
the shorter way to say it. Reading the registry would sweep in functions registered through
`HyperFormula.registerFunctionPlugin`, putting a user's OWN custom function into a paid package
and returning `#LIC!` for it on a smaller licence — the opposite of HF-307 decision D1, which
drops custom-function gating entirely. A function this table does not list is not gated at all,
which is exactly the treatment a custom function should get.

___

### FEATURE_TOKEN_PREFIX

• **FEATURE_TOKEN_PREFIX**: *"feat:"* = "feat:"

*Defined in [src/license/licenseResolution.ts:35](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L35)*

The prefix marking a capability token as granting a public-API feature area.

Used to tell "this key names its feature grants" from "this key's vocabulary cannot express
one" — see the opt-in rule in [licenseTermsOf](globals.md#licensetermsof).

___

### FUNCTIONS_1_TOKEN

• **FUNCTIONS_1_TOKEN**: *"functions_1"* = "functions_1"

*Defined in [src/license/capabilities.ts:40](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L40)*

Math engine package — the free tier's function set.

___

### FUNCTIONS_2_TOKEN

• **FUNCTIONS_2_TOKEN**: *"functions_2"* = "functions_2"

*Defined in [src/license/capabilities.ts:42](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L42)*

Calculated fields package. Cumulative: includes [FUNCTIONS_1_TOKEN](globals.md#const-functions_1_token)'s functions.

___

### FUNCTIONS_3_TOKEN

• **FUNCTIONS_3_TOKEN**: *"functions_3"* = "functions_3"

*Defined in [src/license/capabilities.ts:44](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L44)*

Spreadsheet package. Cumulative: includes [FUNCTIONS_2_TOKEN](globals.md#const-functions_2_token)'s functions.

___

### FUNCTIONS_4_TOKEN

• **FUNCTIONS_4_TOKEN**: *"functions_4"* = "functions_4"

*Defined in [src/license/capabilities.ts:46](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L46)*

Excel simulator package — the entire implemented catalog.

___

### FUNCTION_GROUPS

• **FUNCTION_GROUPS**: *ReadonlyMap‹string, readonly string[]›* = new Map([
  ['fun:math.a', ['ABS', 'LOG', 'MOD', 'POWER', 'PRODUCT', 'ROUND', 'ROUNDDOWN', 'ROUNDUP', 'SQRT', 'SUM']],
  ['fun:stat.a', ['AVERAGE', 'COUNT', 'MAX', 'MIN']],
  ['fun:logic.a', ['IF']],
  ['fun:operator.a', [...OPERATOR_FUNCTIONS]],
  ['fun:info.a', ['VERSION']],
  ['fun:lookup.a', ['OFFSET']],
  ['fun:time.b', [
    'DATE', 'DATEDIF', 'DATEVALUE', 'DAY', 'DAYS', 'EOMONTH', 'HOUR', 'ISOWEEKNUM', 'MINUTE', 'MONTH',
    'NETWORKDAYS', 'SECOND', 'TODAY', 'WEEKDAY', 'WEEKNUM', 'WORKDAY', 'YEAR',
  ]],
  ['fun:text.b', [
    'CONCATENATE', 'EXACT', 'LEFT', 'LEN', 'LOWER', 'MID', 'REPLACE', 'REPT', 'RIGHT', 'SEARCH',
    'SUBSTITUTE', 'TEXT', 'TRIM', 'UPPER', 'VALUE',
  ]],
  ['fun:logic.b', ['AND', 'FALSE', 'IFS', 'NOT', 'OR', 'SWITCH', 'TRUE', 'XOR']],
  ['fun:math.b', ['RAND', 'RANDBETWEEN', 'SUMIF', 'SUMIFS']],
  ['fun:stat.b', ['AVERAGEIF', 'COUNTIF', 'STDEV.S']],
  ['fun:lookup.c', [
    'ADDRESS', 'CHOOSE', 'COLUMN', 'COLUMNS', 'FILTER', 'HLOOKUP', 'HSTACK', 'HYPERLINK', 'INDEX', 'MATCH',
    'ROW', 'ROWS', 'SORT', 'TRANSPOSE', 'UNIQUE', 'VLOOKUP', 'VSTACK', 'XLOOKUP',
  ]],
  ['fun:math.c', [
    'ACOS', 'ASIN', 'ATAN', 'ATAN2', 'CEILING', 'COS', 'EVEN', 'EXP', 'FLOOR', 'INT', 'LN', 'MROUND', 'ODD',
    'PI', 'QUOTIENT', 'SEQUENCE', 'SIGN', 'SIN', 'SUBTOTAL', 'SUMPRODUCT', 'SUMSQ', 'SUMXMY2', 'TAN',
  ]],
  ['fun:stat.c', [
    'AVERAGEA', 'COUNTA', 'COUNTBLANK', 'COUNTIFS', 'LARGE', 'MAXIFS', 'MEDIAN', 'MINIFS', 'PERCENTILE.INC',
    'SMALL', 'STDEV.P', 'STDEVA', 'STDEVPA', 'VAR.P', 'VAR.S',
  ]],
  ['fun:time.c', ['DAYS360', 'EDATE', 'NOW', 'TIME', 'YEARFRAC']],
  ['fun:text.c', ['CHAR', 'CLEAN', 'CODE', 'FIND', 'PROPER', 'T', 'TEXTJOIN', 'UNICHAR']],
  ['fun:info.c', [
    'ISBLANK', 'ISERR', 'ISERROR', 'ISEVEN', 'ISLOGICAL', 'ISNA', 'ISNUMBER', 'ISODD', 'ISTEXT', 'N', 'NA',
  ]],
  ['fun:logic.c', ['IFERROR', 'IFNA']],
  ['fun:finance.c', ['FV', 'IPMT', 'IRR', 'NPV', 'PMT', 'PPMT', 'PV', 'RATE', 'SLN', 'XIRR', 'XNPV']],
  ['fun:engineer.c', ['DEC2HEX', 'HEX2DEC']],
  ['fun:array.c', ['ARRAYFORMULA', 'ARRAY_CONSTRAIN']],
])

*Defined in [src/license/capabilities.ts:138](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L138)*

The 21 function groups of the packaging doc, keyed by their group tokens in normalized
(lowercase) spelling — the doc writes them `fun:<family>.<A|B|C>` and declares all token names
case-insensitive.

Transcribed 1:1 from §6 of Kuba's 12.08 packaging doc (CU doc `8cnjcyf-33175`, page
`8cnjcyf-47835`, "HF function groups and packages"), INCLUDING the members that resolve to no
grant here: the operators (granted by [CORE_TOKEN](globals.md#const-core_token) instead) and the protected built-ins
(outside the token system, see [PROTECTED_BUILT_INS](globals.md#const-protected_built_ins)). Keeping the doc's own membership
verbatim is what makes this map the SINGLE SOURCE OF TRUTH both token dialects read from — the
package slices below are DERIVED from these groups, so moving a function between groups moves
it in both dialects at once, and `capability-table.spec.ts` pins each group's size against the
doc's published counts so a re-transcription is a reviewable diff.

The doc freezes group names as API surface: once shipped inside license keys, a rename is a
breaking change.

___

### FUN_ALL_TOKEN

• **FUN_ALL_TOKEN**: *"fun:all"* = "fun:all"

*Defined in [src/license/capabilities.ts:51](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L51)*

The packaging doc's whole-catalog token — the excel-simulator package as that doc's own
vocabulary spells it. Grants exactly what [FUNCTIONS_4_TOKEN](globals.md#const-functions_4_token) grants.

___

### HOURS_PER_DAY

• **HOURS_PER_DAY**: *24* = 24

*Defined in [src/DateTimeHelper.ts:15](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L15)*

___

### HYPERFORMULA_PRODUCT_NAME

• **HYPERFORMULA_PRODUCT_NAME**: *"hyperformula"* = "hyperformula"

*Defined in [src/license/licenseResolution.ts:27](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L27)*

The name of HyperFormula's own product entry in an entitlement key payload. Every product
entry carries its own capabilities, dates and windows, so this is the only entry this library
reads — a key granting other products alongside (or instead of) HyperFormula is a valid key
whose other entries are simply not for us.

___

### IMPORT_EXPORT_ADDON_TOKEN

• **IMPORT_EXPORT_ADDON_TOKEN**: *"import_export"* = "import_export"

*Defined in [src/license/capabilities.ts:63](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L63)*

Import/export add-on (2026-08-12 packages meeting). Grants [FeatureId.ImportExport](enums/featureid.md#importexport), a
RESERVED grant: nothing in the public API is gated on it yet, because HF-107 hasn't shipped the
import/export feature it would gate.

___

### K

• **K**: *number[]* = [
  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817,
]

*Defined in [src/license/vendor/sha512.ts:15](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/sha512.ts#L15)*

The SHA-512 round constants. Each 64-bit constant is stored as a pair of 32-bit integers
(high word first, low word second).

___

### LCID_CURRENCY_TAG

• **LCID_CURRENCY_TAG**: *RegExp‹›* = /\[\$[^\-\]]+-/

*Defined in [src/format/format.ts:26](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L26)*

Detects Excel LCID-tagged currency tags (`[$SYMBOL-LCID]` with a non-empty
SYMBOL portion). Shared by `defaultStringifyDateTime` and
`defaultStringifyDuration` so a format string carrying such a tag short-
circuits both date and duration dispatch and falls through to the
number formatter (or the user-supplied `stringifyCurrency` callback).

The pattern is intentionally unanchored: any occurrence of `[$SYMBOL-`
in the format string triggers the guard. Excel does not mix date/time
tokens with a currency tag in the same format string, so a mid-string
match cannot misclassify a legitimate composite — every observed
format string with a currency tag is currency-only.

___

### LEGACY_KEY

• **LEGACY_KEY**: *RegExp‹›* = /^[0-9a-fA-F]{25}$/

*Defined in [src/license/vendor/detectFormat.ts:32](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/detectFormat.ts#L32)*

The classic 25-character key, once its dashes are stripped.

___

### LITERAL_KEYS

• **LITERAL_KEYS**: *ReadonlyMap‹string, [LicenseKeyFormat](globals.md#licensekeyformat)›* = new Map([
  ['non-commercial-and-evaluation', 'non-commercial-and-evaluation'],
  ['gpl-v3', 'gpl-v3'],
])

*Defined in [src/license/vendor/detectFormat.ts:24](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/detectFormat.ts#L24)*

The literal keys that stand for a licence rather than encode one.

___

### MATH_ENGINE_FUNCTIONS

• **MATH_ENGINE_FUNCTIONS**: *string[]* = gatableMembersOfGroups(MATH_ENGINE_GROUPS)

*Defined in [src/license/capabilities.ts:213](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L213)*

Package membership, DERIVED from [FUNCTION_GROUPS](globals.md#const-function_groups) as the cumulative group unions the
packaging doc's §4 table states: Math engine = the `.A` groups, Calculated fields = `.A` + `.B`,
Spreadsheet = `.A` + `.B` + `.C`. Reproducing that union gives 17 / 64 / 161 cumulative
functions before the two protected built-ins are removed; `capability-table.spec.ts` pins the
resulting full memberships by name so a re-derivation is a reviewable diff.

___

### MATH_ENGINE_GROUPS

• **MATH_ENGINE_GROUPS**: *string[]* = ['fun:math.a', 'fun:stat.a', 'fun:logic.a', 'fun:operator.a', 'fun:info.a', 'fun:lookup.a']

*Defined in [src/license/capabilities.ts:180](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L180)*

The group tokens each package adds, exactly as the packaging doc's §4 table states them.

___

### MILLISECONDS_PER_DAY

• **MILLISECONDS_PER_DAY**: *86400000* = 86400000

*Defined in [src/license/licenseResolution.ts:19](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L19)*

Milliseconds in a day, used to turn a grace period in days into a deadline.

___

### MINUTES_PER_HOUR

• **MINUTES_PER_HOUR**: *60* = 60

*Defined in [src/DateTimeHelper.ts:14](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L14)*

___

### NAMED_EXPRESSIONS_FEATURE_TOKEN

• **NAMED_EXPRESSIONS_FEATURE_TOKEN**: *"feat:named_expressions"* = "feat:named_expressions"

*Defined in [src/license/capabilities.ts:25](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L25)*

Grants [FeatureId.NamedExpressions](enums/featureid.md#namedexpressions).

___

### NOT_FOUND

• **NOT_FOUND**: *-1* = -1

*Defined in [src/Lookup/AdvancedFind.ts:19](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Lookup/AdvancedFind.ts#L19)*

___

### OPERATOR_FUNCTIONS

• **OPERATOR_FUNCTIONS**: *string[]* = [
  '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',
]

*Defined in [src/license/capabilities.ts:101](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L101)*

The calculation operators and their `HF.*` callable forms. Always available in every package —
the packaging design counts them as engine baseline and advertises them separately from the
function totals, so they are granted by [CORE_TOKEN](globals.md#const-core_token) rather than by any package.

___

### PROTECTED_BUILT_INS

• **PROTECTED_BUILT_INS**: *string[]* = ['OFFSET', 'VERSION']

*Defined in [src/license/capabilities.ts:113](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L113)*

The two protected built-ins. Both are named by the packaging doc (`fun:lookup.A`, `fun:info.A`)
but sit OUTSIDE the token system today — the interpreter never gate-checks a protected
function, so granting them would be dead weight that implies a restriction that does not exist.
The doc calls this a "technical limitation" on both; their tokens below are recognized but
grant nothing.

___

### QUICK_CHECK_REGEXP

• **QUICK_CHECK_REGEXP**: *RegExp‹›* = new RegExp('^[0-9/.\\-: ]+[ap]?m?$')

*Defined in [src/DateTimeDefault.ts:11](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L11)*

___

### SECONDS_PER_MINUTE

• **SECONDS_PER_MINUTE**: *60* = 60

*Defined in [src/DateTimeHelper.ts:13](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L13)*

___

### SECONDS_PRECISION

• **SECONDS_PRECISION**: *1000* = 1000

*Defined in [src/DateTimeDefault.ts:15](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L15)*

___

### SILENT_CONSOLE_FLAGS

• **SILENT_CONSOLE_FLAGS**: *string[]* = ['silent', 'silent-console', 'no-console-warns']

*Defined in [src/license/licenseResolution.ts:46](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L46)*

Flag spellings that suppress console output.

Three, because the key spec is not self-consistent: its normative flags table and its example
payload (rev 6 §2.3 and §2) say `no-console-warns`, while the runtime-behaviour sections of the
same revision (§4.3, §5.2) say `silent-console`, and earlier revisions said plain `silent`. A key
minted against any of those readings must be honoured — a SaaS deployment that asked for silence
and got console warnings is the failure this list exists to prevent.

___

### SPREADSHEET_ADDON_TOKEN

• **SPREADSHEET_ADDON_TOKEN**: *"spreadsheet"* = "spreadsheet"

*Defined in [src/license/capabilities.ts:57](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L57)*

Spreadsheet Bundle add-on (2026-08-12 packages meeting). Grants [FeatureId.Crud](enums/featureid.md#crud),
[FeatureId.UndoRedo](enums/featureid.md#undoredo), [FeatureId.Clipboard](enums/featureid.md#clipboard) and [FeatureId.Batching](enums/featureid.md#batching) — see
[CAPABILITY_TABLE](globals.md#const-capability_table).

___

### SPREADSHEET_FUNCTIONS

• **SPREADSHEET_FUNCTIONS**: *string[]* = gatableMembersOfGroups(SPREADSHEET_GROUPS)

*Defined in [src/license/capabilities.ts:219](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L219)*

Added by the spreadsheet package, on top of [CALCULATED_FIELDS_FUNCTIONS](globals.md#const-calculated_fields_functions).

___

### SPREADSHEET_GROUPS

• **SPREADSHEET_GROUPS**: *string[]* = [
  'fun:lookup.c', 'fun:math.c', 'fun:stat.c', 'fun:time.c', 'fun:text.c', 'fun:info.c', 'fun:logic.c',
  'fun:finance.c', 'fun:engineer.c', 'fun:array.c',
]

*Defined in [src/license/capabilities.ts:182](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L182)*

___

### TIME_FORMAT_SECONDS_ITEM_REGEXP

• **TIME_FORMAT_SECONDS_ITEM_REGEXP**: *RegExp‹›* = new RegExp('^ss(\\.(s+|0+))?$')

*Defined in [src/DateTimeDefault.ts:9](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L9)*

___

### TIME_SEPARATOR

• **TIME_SEPARATOR**: *":"* = ":"

*Defined in [src/DateTimeDefault.ts:14](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L14)*

___

### UNDO_REDO_FEATURE_TOKEN

• **UNDO_REDO_FEATURE_TOKEN**: *"feat:undo_redo"* = "feat:undo_redo"

*Defined in [src/license/capabilities.ts:21](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L21)*

Grants [FeatureId.UndoRedo](enums/featureid.md#undoredo).

___

### WHITESPACE_REGEXP

• **WHITESPACE_REGEXP**: *RegExp‹›* = new RegExp('\\s+')

*Defined in [src/DateTimeDefault.ts:12](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L12)*

___

### WRONG_RANGE_SIZE

• **WRONG_RANGE_SIZE**: *"AbsoluteCellRange: Wrong range size"* = "AbsoluteCellRange: Wrong range size"

*Defined in [src/AbsoluteCellRange.ts:22](https://github.com/handsontable/hyperformula/blob/dcf9354/src/AbsoluteCellRange.ts#L22)*

___

### _noticedKeys

• **_noticedKeys**: *Set‹string›* = new Set<string>()

*Defined in [src/helpers/licenseKeyValidator.ts:57](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L57)*

Identities (see [noticeIdentityOf](globals.md#noticeidentityof)) of license keys that have already printed their
expiry-approaching notice.

Deliberately keyed per key rather than a single boolean like [_notified](globals.md#let-_notified)
above: that flag reports one of a handful of states that mean the same thing regardless of
which key triggered them ("a key is invalid", "a key is missing"), so once-per-page-load is the
right behaviour for it. Two different keys approaching their OWN expiry are two different
events, and a page that swaps keys (or a test suite that builds one engine per key) must still
warn for the second one even though the first already consumed a shared flag.

___

### _notified

• **_notified**: *boolean* = false

*Defined in [src/helpers/licenseKeyValidator.ts:44](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L44)*

___

### _rl

• **_rl**: *"length"* = "length"

*Defined in [src/helpers/licenseKeyHelper.ts:9](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L9)*

**`license`** 
Copyright (c) 2025 Handsoncode. All rights reserved.

___

### dateFormatRegex

• **dateFormatRegex**: *RegExp‹›* = /(\\.|dd|DD|d|D|mm|MM|m|M|YYYY|YY|yyyy|yy|HH|hh|H|h|ss(\.(0+|s+))?|s|AM\/PM|am\/pm|A\/P|a\/p|\[mm]|\[MM]|\[hh]|\[HH])/g

*Defined in [src/format/parser.ts:8](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L8)*

___

### defaultLanguage

• **defaultLanguage**: *string* = Config.defaultConfig.language

*Defined in [src/index.ts:110](https://github.com/handsontable/hyperformula/blob/dcf9354/src/index.ts#L110)*

___

### groupEntries

• **groupEntries**: *[string, [CapabilityGrant](interfaces/capabilitygrant.md)][]* = Array.from(FUNCTION_GROUPS.keys()).map((groupToken) => [
  groupToken,
  {functions: gatableMembersOfGroups([groupToken]), features: []},
])

*Defined in [src/license/capabilities.ts:284](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L284)*

One table entry per group token: the group's gatable members, so a key may assemble a package
from groups instead of naming a `functions_N` slice. `fun:info.a` and `fun:lookup.a` resolve to
EMPTY grants on purpose — their members are the protected built-ins, which are always available
and must never become table-covered (a covered function is gated for every key not granting
it). The tokens stay recognized either way, so a key carrying them is never reported as
unrecognized: they are the doc's bookkeeping identifiers for functionality every key gets.

___

### memoizedParseDateFormat

• **memoizedParseDateFormat**: *(Anonymous function)* = memoize(parseDateFormat)

*Defined in [src/DateTimeDefault.ts:17](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L17)*

___

### memoizedParseTimeFormat

• **memoizedParseTimeFormat**: *(Anonymous function)* = memoize(parseTimeFormat)

*Defined in [src/DateTimeDefault.ts:16](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L16)*

___

### numDays

• **numDays**: *number[]* = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

*Defined in [src/DateTimeHelper.ts:10](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L10)*

___

### numberFormatRegex

• **numberFormatRegex**: *RegExp‹›* = /(\\.|[#0]+(\.[#0]*)?)/g

*Defined in [src/format/parser.ts:9](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L9)*

___

### prefSumDays

• **prefSumDays**: *number[]* = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]

*Defined in [src/DateTimeHelper.ts:11](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L11)*

___

### privatePool

• **privatePool**: *WeakMap‹[Config](classes/config.md), [LicensePrivateState](interfaces/licenseprivatestate.md)›* = new WeakMap()

*Defined in [src/Config.ts:40](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Config.ts#L40)*

___

### singleFunctionEntries

• **singleFunctionEntries**: *[string, [CapabilityGrant](interfaces/capabilitygrant.md)][]* = functions4Grant.functions
  .concat(OPERATOR_FUNCTIONS, PROTECTED_BUILT_INS)
  .map((name) => [
    `fun:${normalizeCapabilityToken(name)}`,
    {functions: PROTECTED_BUILT_INS.indexOf(name) === -1 ? [name] : [], features: []},
  ])

*Defined in [src/license/capabilities.ts:297](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L297)*

One table entry per canonical function name: the packaging doc's single-function tokens
(`fun:<CANONICAL_FUNCTION_NAME>`), "for surgical grants: custom deals, previews, per-function
exceptions". One exists for EVERY canonical name — including the operators (harmless: core
grants them anyway) and the protected built-ins (empty grants, as above). Alias names get no
token of their own: tokens reference canonical names, and an alias travels with its canonical
function because the gates canonicalize before consulting the table.

## Functions

### CellValueTypeOrd

▸ **CellValueTypeOrd**(`arg`: [CellValueType](classes/hyperformulans.md#static-cellvaluetype)): *number*

*Defined in [src/Cell.ts:97](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L97)*

**Parameters:**

Name | Type |
------ | ------ |
`arg` | [CellValueType](classes/hyperformulans.md#static-cellvaluetype) |

**Returns:** *number*

___

### _cp

▸ **_cp**(`v`: any): *number*

*Defined in [src/helpers/licenseKeyHelper.ts:14](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L14)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |

**Returns:** *number*

___

### _hd

▸ **_hd**(`v`: any): *number*

*Defined in [src/helpers/licenseKeyHelper.ts:10](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L10)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |

**Returns:** *number*

___

### _nm

▸ **_nm**(`v`: any): *string*

*Defined in [src/helpers/licenseKeyHelper.ts:12](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L12)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |

**Returns:** *string*

___

### _pi

▸ **_pi**(`v`: any): *number*

*Defined in [src/helpers/licenseKeyHelper.ts:11](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L11)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |

**Returns:** *number*

___

### _ss

▸ **_ss**(`v`: any, `s`: any, `l`: any): *any*

*Defined in [src/helpers/licenseKeyHelper.ts:13](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L13)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |
`s` | any |
`l` | any |

**Returns:** *any*

___

### absoluteSheetReference

▸ **absoluteSheetReference**(`address`: AddressWithSheet, `baseAddress`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *number*

*Defined in [src/Cell.ts:222](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L222)*

**Parameters:**

Name | Type |
------ | ------ |
`address` | AddressWithSheet |
`baseAddress` | [SimpleCellAddress](interfaces/simplecelladdress.md) |

**Returns:** *number*

___

### absolutizeDependencies

▸ **absolutizeDependencies**(`deps`: RelativeDependency[], `baseAddress`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *[CellDependency](globals.md#celldependency)[]*

*Defined in [src/absolutizeDependencies.ts:17](https://github.com/handsontable/hyperformula/blob/dcf9354/src/absolutizeDependencies.ts#L17)*

Converts dependencies from maybe relative addressing to absolute addressing.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`deps` | RelativeDependency[] | list of addresses in R0C0 format |
`baseAddress` | [SimpleCellAddress](interfaces/simplecelladdress.md) | base address with regard to which make a convertion  |

**Returns:** *[CellDependency](globals.md#celldependency)[]*

___

### addressKey

▸ **addressKey**(`address`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *string*

*Defined in [src/Cell.ts:209](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L209)*

**Parameters:**

Name | Type |
------ | ------ |
`address` | [SimpleCellAddress](interfaces/simplecelladdress.md) |

**Returns:** *string*

___

### allowsFeature 

▸ **allowsFeature**(`resolved`: [ResolvedCapabilities](interfaces/resolvedcapabilities.md), `feature`: [FeatureId](enums/featureid.md)): *boolean*

*Defined in [src/license/CapabilityRegistry.ts:129](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/CapabilityRegistry.ts#L129)*

Whether a resolved entitlement allows using the given feature area of the public API.

**Parameters:**

Name | Type |
------ | ------ |
`resolved` | [ResolvedCapabilities](interfaces/resolvedcapabilities.md) |
`feature` | [FeatureId](enums/featureid.md) |

**Returns:** *boolean*

___

### allowsFunction 

▸ **allowsFunction**(`resolved`: [ResolvedCapabilities](interfaces/resolvedcapabilities.md), `functionId`: string): *boolean*

*Defined in [src/license/CapabilityRegistry.ts:122](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/CapabilityRegistry.ts#L122)*

Whether a resolved entitlement allows calling the given function.

**Parameters:**

Name | Type |
------ | ------ |
`resolved` | [ResolvedCapabilities](interfaces/resolvedcapabilities.md) |
`functionId` | string |

**Returns:** *boolean*

___

### arraySizeForBinaryOp 

▸ **arraySizeForBinaryOp**(`leftArraySize`: [ArraySize](classes/arraysize.md), `rightArraySize`: [ArraySize](classes/arraysize.md)): *[ArraySize](classes/arraysize.md)*

*Defined in [src/ArraySize.ts:34](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArraySize.ts#L34)*

**Parameters:**

Name | Type |
------ | ------ |
`leftArraySize` | [ArraySize](classes/arraysize.md) |
`rightArraySize` | [ArraySize](classes/arraysize.md) |

**Returns:** *[ArraySize](classes/arraysize.md)*

___

### arraySizeForUnaryOp 

▸ **arraySizeForUnaryOp**(`arraySize`: [ArraySize](classes/arraysize.md)): *[ArraySize](classes/arraysize.md)*

*Defined in [src/ArraySize.ts:38](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArraySize.ts#L38)*

**Parameters:**

Name | Type |
------ | ------ |
`arraySize` | [ArraySize](classes/arraysize.md) |

**Returns:** *[ArraySize](classes/arraysize.md)*

___

### base64ToBytes 

▸ **base64ToBytes**(`base64`: string): *number[] | null*

*Defined in [src/license/vendor/utils.ts:177](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L177)*

Decodes a base64 string (standard or URL-safe alphabet, padding optional) back into bytes.
Returns `null` when the string is not valid base64.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`base64` | string | the base64 string to decode  |

**Returns:** *number[] | null*

___

### base64ToString 

▸ **base64ToString**(`base64`: string): *string | null*

*Defined in [src/license/vendor/utils.ts:214](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L214)*

Decodes a base64 (standard or URL-safe) string back into a string. Returns `null` when the
input is not valid base64.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`base64` | string | the base64 string to decode  |

**Returns:** *string | null*

___

### buildColumnSearchStrategy 

▸ **buildColumnSearchStrategy**(`dependencyGraph`: DependencyGraph, `config`: [Config](classes/config.md), `statistics`: [Statistics](classes/statistics.md)): *[ColumnSearchStrategy](interfaces/columnsearchstrategy.md)*

*Defined in [src/Lookup/SearchStrategy.ts:63](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Lookup/SearchStrategy.ts#L63)*

**Parameters:**

Name | Type |
------ | ------ |
`dependencyGraph` | DependencyGraph |
`config` | [Config](classes/config.md) |
`statistics` | [Statistics](classes/statistics.md) |

**Returns:** *[ColumnSearchStrategy](interfaces/columnsearchstrategy.md)*

___

### checkKeySchema 

▸ **checkKeySchema**(`v`: any): *boolean*

*Defined in [src/helpers/licenseKeyHelper.ts:20](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L20)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |

**Returns:** *boolean*

___

### checkLicenseKeyValidity 

▸ **checkLicenseKeyValidity**(`licenseKey`: string): *[LicenseKeyValidityState](enums/licensekeyvaliditystate.md)*

*Defined in [src/helpers/licenseKeyValidator.ts:152](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L152)*

Checks if the provided license key is grammatically valid or not expired.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`licenseKey` | string | The license key to check. |

**Returns:** *[LicenseKeyValidityState](enums/licensekeyvaliditystate.md)*

Returns the checking state.

___

### collatorFromConfig 

▸ **collatorFromConfig**(`config`: [Config](classes/config.md)): *Collator*

*Defined in [src/StringHelper.ts:8](https://github.com/handsontable/hyperformula/blob/dcf9354/src/StringHelper.ts#L8)*

**Parameters:**

Name | Type |
------ | ------ |
`config` | [Config](classes/config.md) |

**Returns:** *Collator*

___

### configCheckIfParametersNotInConflict 

▸ **configCheckIfParametersNotInConflict**(...`params`: object[]): *void*

*Defined in [src/ArgumentSanitization.ts:57](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArgumentSanitization.ts#L57)*

**Parameters:**

Name | Type |
------ | ------ |
`...params` | object[] |

**Returns:** *void*

___

### configValueFromParam 

▸ **configValueFromParam**(`inputValue`: any, `expectedType`: string | string[], `paramName`: [ConfigParamsList](globals.md#configparamslist)): *any*

*Defined in [src/ArgumentSanitization.ts:16](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArgumentSanitization.ts#L16)*

**Parameters:**

Name | Type |
------ | ------ |
`inputValue` | any |
`expectedType` | string &#124; string[] |
`paramName` | [ConfigParamsList](globals.md#configparamslist) |

**Returns:** *any*

___

### configValueFromParamCheck 

▸ **configValueFromParamCheck**(`inputValue`: any, `typeCheck`: function, `expectedType`: string, `paramName`: [ConfigParamsList](globals.md#configparamslist)): *any*

*Defined in [src/ArgumentSanitization.ts:47](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArgumentSanitization.ts#L47)*

**Parameters:**

▪ **inputValue**: *any*

▪ **typeCheck**: *function*

▸ (`object`: any): *boolean*

**Parameters:**

Name | Type |
------ | ------ |
`object` | any |

▪ **expectedType**: *string*

▪ **paramName**: *[ConfigParamsList](globals.md#configparamslist)*

**Returns:** *any*

___

### countChars 

▸ **countChars**(`text`: string, `char`: string): *number*

*Defined in [src/format/format.ts:74](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L74)*

**Parameters:**

Name | Type |
------ | ------ |
`text` | string |
`char` | string |

**Returns:** *number*

___

### createTokens 

▸ **createTokens**(`regexTokens`: RegExpExecArray[], `str`: string): *[FormatToken](interfaces/formattoken.md)[]*

*Defined in [src/format/parser.ts:66](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L66)*

**Parameters:**

Name | Type |
------ | ------ |
`regexTokens` | RegExpExecArray[] |
`str` | string |

**Returns:** *[FormatToken](interfaces/formattoken.md)[]*

___

### dayToMonth 

▸ **dayToMonth**(`dayOfYear`: number): *number*

*Defined in [src/DateTimeHelper.ts:270](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L270)*

**Parameters:**

Name | Type |
------ | ------ |
`dayOfYear` | number |

**Returns:** *number*

___

### deepFreeze 

▸ **deepFreeze**‹**T**›(`value`: T): *T*

*Defined in [src/license/vendor/utils.ts:25](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L25)*

Recursively freezes the value (and every nested object). Used to make a verified schema
immutable so it cannot drift from what was validated.

**Type parameters:**

▪ **T**

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`value` | T | the value to freeze  |

**Returns:** *T*

___

### defaultParseToDate 

▸ **defaultParseToDate**(`dateItems`: string[], `dateFormat`: [Maybe](globals.md#maybe)‹string›): *[Maybe](globals.md#maybe)‹[SimpleDate](interfaces/simpledate.md)›*

*Defined in [src/DateTimeDefault.ts:137](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L137)*

Parses a date value from a string if the string matches the given date format.

**Parameters:**

Name | Type |
------ | ------ |
`dateItems` | string[] |
`dateFormat` | [Maybe](globals.md#maybe)‹string› |

**Returns:** *[Maybe](globals.md#maybe)‹[SimpleDate](interfaces/simpledate.md)›*

___

### defaultParseToDateTime 

▸ **defaultParseToDateTime**(`text`: string, `dateFormat`: [Maybe](globals.md#maybe)‹string›, `timeFormat`: [Maybe](globals.md#maybe)‹string›): *[Maybe](globals.md#maybe)‹[DateTime](globals.md#datetime)›*

*Defined in [src/DateTimeDefault.ts:30](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L30)*

Parses a DateTime value from a string if the string matches the given date format and time format.

Idea for more readable implementation:
  - divide string into parts by a regexp [date_regexp]? [time_regexp]? [ampm_regexp]?
  - start by finding the time part, because it is unambiguous '([0-9]+:[0-9:.]+ ?[ap]?m?)$', before it is the date part
  - OR split by spaces - last segment is ampm token, second to last is time (with or without ampm), rest is date
If applied:
  - date parsing might work differently after these changes but still according to the docs
  - make sure to test edge cases like timeFormats: ['hh', 'ss.ss'] etc, string: '01-01-2019 AM', 'PM'

**Parameters:**

Name | Type |
------ | ------ |
`text` | string |
`dateFormat` | [Maybe](globals.md#maybe)‹string› |
`timeFormat` | [Maybe](globals.md#maybe)‹string› |

**Returns:** *[Maybe](globals.md#maybe)‹[DateTime](globals.md#datetime)›*

___

### defaultParseToTime 

▸ **defaultParseToTime**(`timeItems`: string[], `timeFormat`: [Maybe](globals.md#maybe)‹string›): *[Maybe](globals.md#maybe)‹[SimpleTime](interfaces/simpletime.md)›*

*Defined in [src/DateTimeDefault.ts:82](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L82)*

Parses a time value from a string if the string matches the given time format.

**Parameters:**

Name | Type |
------ | ------ |
`timeItems` | string[] |
`timeFormat` | [Maybe](globals.md#maybe)‹string› |

**Returns:** *[Maybe](globals.md#maybe)‹[SimpleTime](interfaces/simpletime.md)›*

___

### defaultStringifyCurrency 

▸ **defaultStringifyCurrency**(`_value`: number, `_formatArg`: string): *[Maybe](globals.md#maybe)‹string›*

*Defined in [src/format/format.ts:328](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L328)*

Default implementation of the `stringifyCurrency` config option.

Returning `undefined` instructs the formatter to fall through to the
built-in number formatter, preserving HyperFormula's zero-dependency
default behavior. Replace this default by setting the
[`stringifyCurrency`](../../api/interfaces/configparams.md#stringifycurrency)
config option.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`_value` | number | the numeric value to format (unused in default). |
`_formatArg` | string | the format string passed to `TEXT` (unused in default). |

**Returns:** *[Maybe](globals.md#maybe)‹string›*

`undefined` — caller should fall through to the built-in formatter.

___

### defaultStringifyDateTime 

▸ **defaultStringifyDateTime**(`dateTime`: [SimpleDateTime](globals.md#simpledatetime), `formatArg`: string): *[Maybe](globals.md#maybe)‹string›*

*Defined in [src/format/format.ts:224](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L224)*

Default `stringifyDateTime` callback — formats a date/time value against an
Excel-style format string (e.g. `YYYY-MM-DD HH:mm:ss`).

Returns `undefined` for format strings that are not date/time formats so the
dispatcher in `format()` can fall through to `parseForNumberFormat` (or to a
user-supplied `stringifyCurrency` callback for currency-tagged formats).

**LCID currency-tag guard** — explicitly returns `undefined` for Excel
currency tags `[$SYMBOL-LCID]` (non-empty SYMBOL portion). Without the
guard, `parseForDateTimeFormat` greedily consumes letters like `D`/`M`/`S`/`Y`/`H`
inside the currency code (e.g. `D` in USD, `H` in CHF, `M`+`D` in AMD),
mangling the output of an `[$USD-409] #,##0.00` format into
`[$US9-409] #,##0.00` because `D` is read as a day token. The pre-HF-24
behaviour was to mis-format; the guarded return is the deliberate
correction, not a regression. Bit-for-bit compatibility is preserved for
every non-currency format (dates, durations, `$#,##0.00`, etc.).

The guard pattern (`/\[\$[^\-\]]+-/`) requires ≥1 character between `[$`
and `-` so it distinguishes currency tags (`[$USD-409]`, `[$€-2]`) from
Excel's locale-only modifier (`[$-409]`, `[$-F800]`), which is valid on
date/time formats and must continue to flow through this function.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`dateTime` | [SimpleDateTime](globals.md#simpledatetime) | parsed date/time value to render |
`formatArg` | string | Excel-style format string |

**Returns:** *[Maybe](globals.md#maybe)‹string›*

formatted string, or `undefined` to defer to the next dispatch step

___

### defaultStringifyDuration 

▸ **defaultStringifyDuration**(`time`: [SimpleTime](interfaces/simpletime.md), `formatArg`: string): *[Maybe](globals.md#maybe)‹string›*

*Defined in [src/format/format.ts:132](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L132)*

Default `stringifyDuration` callback — formats a duration value against an
Excel-style time format string (e.g. `[hh]:mm:ss`).

Returns `undefined` for format strings that are not duration formats so the
dispatcher in `format()` can fall through to other handlers.

**LCID currency-tag guard** — sibling to the same guard in
`defaultStringifyDateTime`; explicitly returns `undefined` for Excel
currency tags `[$SYMBOL-LCID]` because the SYMBOL portion contains
duration-token letters (`H` in CHF/HUF, `m` in AMD/HMD) that
`parseForDateTimeFormat` would otherwise interpret as time tokens and
mangle the output. See `defaultStringifyDateTime` for the full
symbol-vs-locale-modifier rationale and the historical pre-HF-24
behaviour the guard corrects.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`time` | [SimpleTime](interfaces/simpletime.md) | parsed duration value to render |
`formatArg` | string | Excel-style format string |

**Returns:** *[Maybe](globals.md#maybe)‹string›*

formatted string, or `undefined` to defer to the next dispatch step

___

### defineOwn 

▸ **defineOwn**(`target`: object, `key`: string, `value`: unknown): *void*

*Defined in [src/license/vendor/extractKeyData.ts:116](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L116)*

Adds an own, ordinary property.

Both the product names and the field names of a product entry come from JSON, so `__proto__`
is a name an attacker can put in a key. A plain assignment would go through the
`Object.prototype` setter: the value would vanish from `Object.keys` while still resolving
through the chain.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`target` | object | the object to add the property to |
`key` | string | the property name |
`value` | unknown | the property value  |

**Returns:** *void*

___

### detectLicenseKeyFormat 

▸ **detectLicenseKeyFormat**(`licenseKey`: unknown): *[LicenseKeyFormat](globals.md#licensekeyformat)*

*Defined in [src/license/vendor/detectFormat.ts:46](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/detectFormat.ts#L46)*

Tells which license key format a string is in, without validating it.

The entitlement key format removed the leading type tag, so a key no longer announces itself
in its first characters — it now ends with the bracketed machine-readable block instead.
Products that accept several formats need one place that makes the distinction, and this is it.

The answer is about SHAPE only. A returned `'entitlement'` means "route this to the
entitlement validator", not "this key is valid".

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`licenseKey` | unknown | the license key to inspect  |

**Returns:** *[LicenseKeyFormat](globals.md#licensekeyformat)*

___

### doesContainRelativeReferences

▸ **doesContainRelativeReferences**(`ast`: Ast): *boolean*

*Defined in [src/NamedExpressions.ts:299](https://github.com/handsontable/hyperformula/blob/dcf9354/src/NamedExpressions.ts#L299)*

**Parameters:**

Name | Type |
------ | ------ |
`ast` | Ast |

**Returns:** *boolean*

___

### doesItLookLikeADateTimeQuickCheck 

▸ **doesItLookLikeADateTimeQuickCheck**(`text`: string): *boolean*

*Defined in [src/DateTimeDefault.ts:222](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L222)*

If this function returns false, the string is not parsable as a date time. Otherwise, it might be.
This is a quick check that is used to avoid running the more expensive parsing operations.

**Parameters:**

Name | Type |
------ | ------ |
`text` | string |

**Returns:** *boolean*

___

### empty 

▸ **empty**‹**T**›(): *IterableIterator‹T›*

*Defined in [src/generatorUtils.ts:8](https://github.com/handsontable/hyperformula/blob/dcf9354/src/generatorUtils.ts#L8)*

**Type parameters:**

▪ **T**

**Returns:** *IterableIterator‹T›*

___

### entitlementOf 

▸ **entitlementOf**(`terms`: [LicenseTerms](interfaces/licenseterms.md)): *[LicenseEntitlement](interfaces/licenseentitlement.md)*

*Defined in [src/license/licenseResolution.ts:303](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L303)*

Turns the terms of an intact, unexpired entitlement key into the entitlement it grants.

Per HF-307 decision D3 this is fail-closed and silent: a token this version does not recognize
is recorded in `unrecognizedCapabilities` and grants nothing, without a warning, a message, or
anything public to read it back from. "Silent" there means the *grant* is silent — whether the
key's console messages are suppressed is decided solely by its `flags` (`terms.silent`), never
by the presence of an unrecognized token; coupling the two suppressed expiry notices as a side
effect of a vocabulary mismatch, and was confirmed an implementation error (Kuba, 12.08).

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`terms` | [LicenseTerms](interfaces/licenseterms.md) | the terms of the key  |

**Returns:** *[LicenseEntitlement](interfaces/licenseentitlement.md)*

___

### equalSimpleCellAddress

▸ **equalSimpleCellAddress**(`left`: [SimpleCellAddress](interfaces/simplecelladdress.md), `right`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *boolean*

*Defined in [src/Cell.ts:226](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L226)*

**Parameters:**

Name | Type |
------ | ------ |
`left` | [SimpleCellAddress](interfaces/simplecelladdress.md) |
`right` | [SimpleCellAddress](interfaces/simplecelladdress.md) |

**Returns:** *boolean*

___

### expiryWithinNoticeWindow 

▸ **expiryWithinNoticeWindow**(`terms`: [LicenseTerms](interfaces/licenseterms.md)): *Date | null*

*Defined in [src/license/licenseResolution.ts:277](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L277)*

The day a VALID key's usage-until expiry falls on, if the current UTC instant is within its
notice window — `null` otherwise, which covers "no notice window configured" (`noticeDays` is
`0`, which is also what a key with no HyperFormula entry resolves to) just as much as "not close
enough yet" or "already past its usage-until day".

Deliberately blind to `graceDays`: notice is about the usage_until axis itself, not about the
grace extension past it. Key spec rev 6 §4.1 sequences notice, then a soft-stop window, then the
hard-stop this build already enforces; only the hard stop and this notice are built for 3.5.0
(Kuba's decision D5-A), so the window checked here ends exactly where the soft-stop phase would
begin, rather than reaching into grace and printing a notice for a key already past its expiry.

`release_until`-axis keys never reach here with a non-`null` result — `kind` is `'usage'` only
when the date came from `usage_until` (see [licenseTermsOf](globals.md#licensetermsof)) — matching the spec's rule
that notice and grace have no effect on that axis. The converse holds too now: the tagged
format let an entry with no date of its own fall through to the key envelope's `exp`, so
`'usage'` did not imply `usage_until`; an entitlement key has no envelope date to fall back to.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`terms` | [LicenseTerms](interfaces/licenseterms.md) | the terms of the key  |

**Returns:** *Date | null*

___

### extractEntitlementKeyData 

▸ **extractEntitlementKeyData**(`licenseKey`: string): *[EntitlementKeyData](interfaces/entitlementkeydata.md) | null*

*Defined in [src/license/vendor/extractKeyData.ts:199](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L199)*

Extracts the machine-readable data from an entitlement license key.

The checksum is verified first, so the returned data is guaranteed to belong to an intact
block. For a malformed or tampered key `null` is returned — reporting an invalid key is the
caller's job, not this function's.

Only the bracketed block matters. The prose in front of it is neither parsed nor covered by
the checksum, so the caller may pass the whole artifact or just the `[...]` block, and
rewrapped or re-pasted text still validates.

No schema is needed. Unknown products, capabilities and flags are all tolerated, so nothing
about reading a key depends on the vocabulary — which is what lets a product vendor this
parser on its own.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`licenseKey` | string | the license key to extract the data from  |

**Returns:** *[EntitlementKeyData](interfaces/entitlementkeydata.md) | null*

___

### extractTime 

▸ **extractTime**(`v`: any): *number*

*Defined in [src/helpers/licenseKeyHelper.ts:16](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyHelper.ts#L16)*

**Parameters:**

Name | Type |
------ | ------ |
`v` | any |

**Returns:** *number*

___

### filterDependenciesOutOfScope

▸ **filterDependenciesOutOfScope**(`deps`: [CellDependency](globals.md#celldependency)[]): *[CellDependency](globals.md#celldependency)[]*

*Defined in [src/absolutizeDependencies.ts:21](https://github.com/handsontable/hyperformula/blob/dcf9354/src/absolutizeDependencies.ts#L21)*

**Parameters:**

Name | Type |
------ | ------ |
`deps` | [CellDependency](globals.md#celldependency)[] |

**Returns:** *[CellDependency](globals.md#celldependency)[]*

___

### findBoundaries 

▸ **findBoundaries**(`sheet`: [Sheet](globals.md#sheet)): *[SheetBoundaries](interfaces/sheetboundaries.md)*

*Defined in [src/Sheet.ts:49](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Sheet.ts#L49)*

Returns actual width, height and fill ratio of a sheet

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`sheet` | [Sheet](globals.md#sheet) | two-dimmensional array sheet representation  |

**Returns:** *[SheetBoundaries](interfaces/sheetboundaries.md)*

___

### findInOrderedArray 

▸ **findInOrderedArray**(`key`: number, `values`: number[], `handlingMisses`: "lowerBound" | "upperBound"): *number*

*Defined in [src/Lookup/ColumnIndex.ts:339](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Lookup/ColumnIndex.ts#L339)*

**Parameters:**

Name | Type | Default |
------ | ------ | ------ |
`key` | number | - |
`values` | number[] | - |
`handlingMisses` | "lowerBound" &#124; "upperBound" | "upperBound" |

**Returns:** *number*

___

### first 

▸ **first**‹**T**›(`iterable`: IterableIterator‹T›): *[Maybe](globals.md#maybe)‹T›*

*Defined in [src/generatorUtils.ts:22](https://github.com/handsontable/hyperformula/blob/dcf9354/src/generatorUtils.ts#L22)*

**Type parameters:**

▪ **T**

**Parameters:**

Name | Type |
------ | ------ |
`iterable` | IterableIterator‹T› |

**Returns:** *[Maybe](globals.md#maybe)‹T›*

___

### format 

▸ **format**(`value`: number, `formatArg`: string, `config`: [Config](classes/config.md), `dateHelper`: [DateTimeHelper](classes/datetimehelper.md)): *RawScalarValue*

*Defined in [src/format/format.ts:28](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L28)*

**Parameters:**

Name | Type |
------ | ------ |
`value` | number |
`formatArg` | string |
`config` | [Config](classes/config.md) |
`dateHelper` | [DateTimeHelper](classes/datetimehelper.md) |

**Returns:** *RawScalarValue*

___

### formatDate 

▸ **formatDate**(`date`: Date): *string*

*Defined in [src/helpers/licenseKeyValidator.ts:193](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L193)*

Formats a Date instance to hard-coded format MMMM DD, YYYY.

Read in UTC, not local time. Every date reaching this function is built at UTC midnight — the
legacy path from a whole number of days since the epoch, the entitlement-key path from a calendar
date in the payload — so local getters shifted the day backwards for anyone west of UTC and
printed an expiry one day earlier than the one the key actually carries.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`date` | Date | The date to format, at UTC midnight. |

**Returns:** *string*

The date as `MMMM DD, YYYY`.

___

### formatToken 

▸ **formatToken**(`type`: [TokenType](enums/tokentype.md), `value`: string): *[FormatToken](interfaces/formattoken.md)*

*Defined in [src/format/parser.ts:21](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L21)*

**Parameters:**

Name | Type |
------ | ------ |
`type` | [TokenType](enums/tokentype.md) |
`value` | string |

**Returns:** *[FormatToken](interfaces/formattoken.md)*

___

### gatableMembersOfGroups 

▸ **gatableMembersOfGroups**(`groupTokens`: string[]): *string[]*

*Defined in [src/license/capabilities.ts:200](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L200)*

The members a group contributes to a package GRANT: the group verbatim, minus the operators
(granted by [CORE_TOKEN](globals.md#const-core_token) in every package) and the protected built-ins (outside the token
system entirely).

**Parameters:**

Name | Type |
------ | ------ |
`groupTokens` | string[] |

**Returns:** *string[]*

___

### getCellType

▸ **getCellType**(`vertex`: [Maybe](globals.md#maybe)‹CellVertex›, `address`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *[CellType](classes/hyperformulans.md#static-celltype)*

*Defined in [src/Cell.ts:61](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L61)*

**Parameters:**

Name | Type |
------ | ------ |
`vertex` | [Maybe](globals.md#maybe)‹CellVertex› |
`address` | [SimpleCellAddress](interfaces/simplecelladdress.md) |

**Returns:** *[CellType](classes/hyperformulans.md#static-celltype)*

___

### getCellValueDetailedType

▸ **getCellValueDetailedType**(`cellValue`: InterpreterValue): *[CellValueDetailedType](classes/hyperformulans.md#static-cellvaluedetailedtype)*

*Defined in [src/Cell.ts:133](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L133)*

**Parameters:**

Name | Type |
------ | ------ |
`cellValue` | InterpreterValue |

**Returns:** *[CellValueDetailedType](classes/hyperformulans.md#static-cellvaluedetailedtype)*

___

### getCellValueFormat

▸ **getCellValueFormat**(`cellValue`: InterpreterValue): *string | undefined*

*Defined in [src/Cell.ts:141](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L141)*

**Parameters:**

Name | Type |
------ | ------ |
`cellValue` | InterpreterValue |

**Returns:** *string | undefined*

___

### getCellValueType

▸ **getCellValueType**(`cellValue`: InterpreterValue): *[CellValueType](classes/hyperformulans.md#static-cellvaluetype)*

*Defined in [src/Cell.ts:113](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L113)*

**Parameters:**

Name | Type |
------ | ------ |
`cellValue` | InterpreterValue |

**Returns:** *[CellValueType](classes/hyperformulans.md#static-cellvaluetype)*

___

### getDefaultConfig 

▸ **getDefaultConfig**(): *[ConfigParams](interfaces/configparams.md)*

*Defined in [src/Config.ts:407](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Config.ts#L407)*

**Returns:** *[ConfigParams](interfaces/configparams.md)*

___

### getFullConfigFromPartial 

▸ **getFullConfigFromPartial**(`partialConfig`: Partial‹[ConfigParams](interfaces/configparams.md)›): *[ConfigParams](interfaces/configparams.md)*

*Defined in [src/Config.ts:393](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Config.ts#L393)*

**Parameters:**

Name | Type |
------ | ------ |
`partialConfig` | Partial‹[ConfigParams](interfaces/configparams.md)› |

**Returns:** *[ConfigParams](interfaces/configparams.md)*

___

### instanceOfSimpleDate 

▸ **instanceOfSimpleDate**(`obj`: any): *obj is SimpleDate*

*Defined in [src/DateTimeHelper.ts:34](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L34)*

**Parameters:**

Name | Type |
------ | ------ |
`obj` | any |

**Returns:** *obj is SimpleDate*

___

### instanceOfSimpleTime 

▸ **instanceOfSimpleTime**(`obj`: any): *obj is SimpleTime*

*Defined in [src/DateTimeHelper.ts:43](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L43)*

**Parameters:**

Name | Type |
------ | ------ |
`obj` | any |

**Returns:** *obj is SimpleTime*

___

### invalidSimpleColumnAddress

▸ **invalidSimpleColumnAddress**(`address`: [SimpleColumnAddress](interfaces/simplecolumnaddress.md)): *boolean*

*Defined in [src/Cell.ts:190](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L190)*

**Parameters:**

Name | Type |
------ | ------ |
`address` | [SimpleColumnAddress](interfaces/simplecolumnaddress.md) |

**Returns:** *boolean*

___

### invalidSimpleRowAddress

▸ **invalidSimpleRowAddress**(`address`: [SimpleRowAddress](interfaces/simplerowaddress.md)): *boolean*

*Defined in [src/Cell.ts:181](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L181)*

**Parameters:**

Name | Type |
------ | ------ |
`address` | [SimpleRowAddress](interfaces/simplerowaddress.md) |

**Returns:** *boolean*

___

### isBoolean 

▸ **isBoolean**(`text`: string): *boolean*

*Defined in [src/CellContentParser.ts:81](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellContentParser.ts#L81)*

**Parameters:**

Name | Type |
------ | ------ |
`text` | string |

**Returns:** *boolean*

___

### isColOrRowInvalid

▸ **isColOrRowInvalid**(`address`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *boolean*

*Defined in [src/Cell.ts:203](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L203)*

Checks if the column or row id is negative.

**Parameters:**

Name | Type |
------ | ------ |
`address` | [SimpleCellAddress](interfaces/simplecelladdress.md) |

**Returns:** *boolean*

___

### isError 

▸ **isError**(`text`: string, `errorMapping`: Record‹string, [ErrorType](classes/hyperformulans.md#static-errortype)›): *boolean*

*Defined in [src/CellContentParser.ts:86](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellContentParser.ts#L86)*

**Parameters:**

Name | Type |
------ | ------ |
`text` | string |
`errorMapping` | Record‹string, [ErrorType](classes/hyperformulans.md#static-errortype)› |

**Returns:** *boolean*

___

### isEscapeToken 

▸ **isEscapeToken**(`token`: RegExpExecArray): *boolean*

*Defined in [src/format/parser.ts:131](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L131)*

**Parameters:**

Name | Type |
------ | ------ |
`token` | RegExpExecArray |

**Returns:** *boolean*

___

### isFormula 

▸ **isFormula**(`text`: string): *boolean*

*Defined in [src/CellContentParser.ts:77](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CellContentParser.ts#L77)*

Checks whether string looks like formula or not.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`text` | string | formula  |

**Returns:** *boolean*

___

### isIsoDate 

▸ **isIsoDate**(`value`: unknown): *boolean*

*Defined in [src/license/vendor/extractKeyData.ts:91](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L91)*

Returns `true` when the value is a real calendar date in the `YYYY-MM-DD` format. A time
component, an offset, a numeric timestamp and a date that does not exist are all rejected —
the format is the whole contract, and a validator that accepted two spellings would hide a
timezone bug at generation instead of surfacing it.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`value` | unknown | the value to check  |

**Returns:** *boolean*

___

### isNonNegativeInteger 

▸ **isNonNegativeInteger**(`value`: unknown): *value is number*

*Defined in [src/license/vendor/extractKeyData.ts:70](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L70)*

Returns `true` when the value is a non-negative integer.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`value` | unknown | the value to check  |

**Returns:** *value is number*

___

### isNonnegativeInteger 

▸ **isNonnegativeInteger**(`x`: number): *boolean*

*Defined in [src/CrudOperations.ts:668](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CrudOperations.ts#L668)*

**Parameters:**

Name | Type |
------ | ------ |
`x` | number |

**Returns:** *boolean*

___

### isPlainObject 

▸ **isPlainObject**(`value`: unknown): *value is Record‹string, unknown›*

*Defined in [src/license/vendor/extractKeyData.ts:61](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L61)*

Returns `true` when the value is a plain object.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`value` | unknown | the value to check  |

**Returns:** *value is Record‹string, unknown›*

___

### isPositiveInteger 

▸ **isPositiveInteger**(`x`: number): *boolean*

*Defined in [src/CrudOperations.ts:664](https://github.com/handsontable/hyperformula/blob/dcf9354/src/CrudOperations.ts#L664)*

**Parameters:**

Name | Type |
------ | ------ |
`x` | number |

**Returns:** *boolean*

___

### isRowOrColumnRange 

▸ **isRowOrColumnRange**(`leftCorner`: [SimpleCellAddress](interfaces/simplecelladdress.md), `width`: number, `height`: number): *boolean*

*Defined in [src/Operations.ts:1100](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Operations.ts#L1100)*

**Parameters:**

Name | Type |
------ | ------ |
`leftCorner` | [SimpleCellAddress](interfaces/simplecelladdress.md) |
`width` | number |
`height` | number |

**Returns:** *boolean*

___

### isSimpleCellAddress 

▸ **isSimpleCellAddress**(`obj`: unknown): *obj is SimpleCellAddress*

*Defined in [src/Cell.ts:214](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L214)*

Checks if the object is a simple cell address.

**Parameters:**

Name | Type |
------ | ------ |
`obj` | unknown |

**Returns:** *obj is SimpleCellAddress*

___

### isSimpleCellRange 

▸ **isSimpleCellRange**(`val`: unknown): *val is SimpleCellRange*

*Defined in [src/AbsoluteCellRange.ts:34](https://github.com/handsontable/hyperformula/blob/dcf9354/src/AbsoluteCellRange.ts#L34)*

Type guard that checks if an object is a valid SimpleCellRange.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`val` | unknown | Value to check |

**Returns:** *val is SimpleCellRange*

True if and only if the object is a valid SimpleCellRange

___

### isStringArray 

▸ **isStringArray**(`value`: unknown): *value is string[]*

*Defined in [src/license/vendor/extractKeyData.ts:79](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L79)*

Returns `true` when the value is an array of strings.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`value` | unknown | the value to check  |

**Returns:** *value is string[]*

___

### licenseAllowsFunction 

▸ **licenseAllowsFunction**(`registry`: [CapabilityRegistry](classes/capabilityregistry.md), `resolved`: [ResolvedCapabilities](interfaces/resolvedcapabilities.md), `canonicalFunctionId`: string): *boolean*

*Defined in [src/license/CapabilityRegistry.ts:155](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/CapabilityRegistry.ts#L155)*

Whether the license lets an instance evaluate — and therefore describe — the given function.

The rule both gate-B function call sites share: a function the capability table does not cover
at all is allowed. [CapabilityRegistry.capabilityOf](classes/capabilityregistry.md#capabilityof) returns `undefined` only for an id no
token lists, which the completeness invariant in `unit/license/capability-registry.spec.ts`
guarantees is not an unlisted built-in but a custom, instance-registered function — exempt from
gate B by decision D1. Everything the table does cover has to be granted by the entitlement.

Extracted so the interpreter and the function metadata API cannot drift apart. The metadata API
exists to describe the functions an instance can actually evaluate, so a second spelling of this
rule would eventually let it advertise a function that then returns `#LIC!` — the exact failure
removing the static metadata methods (HF-349) was meant to prevent.

Note this is gate B only: it says nothing about [LicenseKeyValidityState](enums/licensekeyvaliditystate.md). Callers that
also need gate A check it separately, because the two gates have different answers for the same
key — see the comment on `resolveLicense`.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`registry` | [CapabilityRegistry](classes/capabilityregistry.md) | the registry the capabilities were resolved against |
`resolved` | [ResolvedCapabilities](interfaces/resolvedcapabilities.md) | the instance's resolved capabilities |
`canonicalFunctionId` | string | the function id, already resolved through the alias map  |

**Returns:** *boolean*

___

### licenseTermsOf 

▸ **licenseTermsOf**(`data`: [EntitlementKeyData](interfaces/entitlementkeydata.md)): *[LicenseTerms](interfaces/licenseterms.md)*

*Defined in [src/license/licenseResolution.ts:132](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L132)*

Reads HyperFormula's terms out of an intact entitlement key payload.

Total on purpose: the vendored reader has already rejected every malformed shape, so every
field read here is exactly what [EntitlementProductGrant](interfaces/entitlementproductgrant.md) promises. A payload without a
`hyperformula` entry — including `products: {}` — is a VALID key that grants this library
nothing and never expires for it; per HF-307 decision D6-A that cliff is silent. Note this
differs from the typed-key format this replaces, where a key licensed to another product
carried the expiry HyperFormula was checked against: an entitlement key's product entries each
carry their own terms, so another product's dates are not ours to read.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`data` | [EntitlementKeyData](interfaces/entitlementkeydata.md) | the extracted key data  |

**Returns:** *[LicenseTerms](interfaces/licenseterms.md)*

___

### matchDateFormat 

▸ **matchDateFormat**(`str`: string): *RegExpExecArray[]*

*Defined in [src/format/parser.ts:39](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L39)*

**Parameters:**

Name | Type |
------ | ------ |
`str` | string |

**Returns:** *RegExpExecArray[]*

___

### matchNumberFormat 

▸ **matchNumberFormat**(`str`: string): *RegExpExecArray[]*

*Defined in [src/format/parser.ts:55](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L55)*

**Parameters:**

Name | Type |
------ | ------ |
`str` | string |

**Returns:** *RegExpExecArray[]*

___

### membersOfGroups 

▸ **membersOfGroups**(`groupTokens`: string[]): *string[]*

*Defined in [src/license/capabilities.ts:188](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L188)*

The members of the given groups, concatenated. The groups are disjoint, so this is a union.

**Parameters:**

Name | Type |
------ | ------ |
`groupTokens` | string[] |

**Returns:** *string[]*

___

### memoize 

▸ **memoize**‹**T**›(`fn`: function): *(Anonymous function)*

*Defined in [src/DateTimeDefault.ts:229](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L229)*

Function memoization for improved performance.

**Type parameters:**

▪ **T**

**Parameters:**

▪ **fn**: *function*

▸ (`arg`: string): *T*

**Parameters:**

Name | Type |
------ | ------ |
`arg` | string |

**Returns:** *(Anonymous function)*

___

### movedSimpleCellAddress

▸ **movedSimpleCellAddress**(`address`: [SimpleCellAddress](interfaces/simplecelladdress.md), `toSheet`: number, `toRight`: number, `toBottom`: number): *[SimpleCellAddress](interfaces/simplecelladdress.md)*

*Defined in [src/Cell.ts:205](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L205)*

**Parameters:**

Name | Type |
------ | ------ |
`address` | [SimpleCellAddress](interfaces/simplecelladdress.md) |
`toSheet` | number |
`toRight` | number |
`toBottom` | number |

**Returns:** *[SimpleCellAddress](interfaces/simplecelladdress.md)*

___

### normalizeAddedIndexes 

▸ **normalizeAddedIndexes**(`indexes`: [ColumnRowIndex](globals.md#columnrowindex)[]): *[ColumnRowIndex](globals.md#columnrowindex)[]*

*Defined in [src/Operations.ts:1068](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Operations.ts#L1068)*

**Parameters:**

Name | Type |
------ | ------ |
`indexes` | [ColumnRowIndex](globals.md#columnrowindex)[] |

**Returns:** *[ColumnRowIndex](globals.md#columnrowindex)[]*

___

### normalizeCapabilityToken 

▸ **normalizeCapabilityToken**(`token`: string): *string*

*Defined in [src/license/capabilities.ts:81](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L81)*

The canonical spelling of a capability token for table lookups.

Token names are case-insensitive — the packaging doc states it outright for its `fun:*`
vocabulary, and tolerating case on the other tokens costs nothing since none of them collide
under lowercasing. Surrounding whitespace is trimmed for a sharper reason than tidiness: every
rule that reads a token has to read the SAME token, and a padded one used to be read two
different ways at once — `' feat:crud'` failed the `feat:` prefix test that decides whether a key
speaks the feature vocabulary, so the key was granted all five feature areas instead of the one
it named, while `'feat:crud '` passed that test and then missed the table, granting none.

Normalization happens at LOOKUP, never at storage: an entitlement carries the key's own
spellings (they are diagnostics), and [CAPABILITY_TABLE](globals.md#const-capability_table) is keyed by the normalized form.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`token` | string | a capability token as the key spells it  |

**Returns:** *string*

___

### normalizeProductEntry 

▸ **normalizeProductEntry**(`entry`: unknown): *[EntitlementProductGrant](interfaces/entitlementproductgrant.md) | null*

*Defined in [src/license/vendor/extractKeyData.ts:137](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/extractKeyData.ts#L137)*

Verifies and normalizes one product entry.

Strict about SHAPE: exactly one of the two dates, a real date, and the two window sizes. A key
that gets this wrong is malformed, not merely unknown, and reading it would mean guessing what
was licensed.

Lenient about VOCABULARY: an unrecognised capability token, an unrecognised flag and an
unrecognised extra field are all kept and ignored. Without that leniency every token added on
the issuing side would break every library version already deployed in the field.

Returns `null` when the entry is malformed.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`entry` | unknown | the product entry of the payload  |

**Returns:** *[EntitlementProductGrant](interfaces/entitlementproductgrant.md) | null*

___

### normalizeRemovedIndexes 

▸ **normalizeRemovedIndexes**(`indexes`: [ColumnRowIndex](globals.md#columnrowindex)[]): *[ColumnRowIndex](globals.md#columnrowindex)[]*

*Defined in [src/Operations.ts:1037](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Operations.ts#L1037)*

**Parameters:**

Name | Type |
------ | ------ |
`indexes` | [ColumnRowIndex](globals.md#columnrowindex)[] |

**Returns:** *[ColumnRowIndex](globals.md#columnrowindex)[]*

___

### noticeIdentityOf 

▸ **noticeIdentityOf**(`licenseKey`: string): *string*

*Defined in [src/helpers/licenseKeyValidator.ts:142](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L142)*

The warn-once identity of a key: its trailing 129 characters, after trimming — for an intact
entitlement key, the sha512 checksum plus the closing bracket that ends the machine-readable
block, unique per distinct key content.

Trimmed because the reader ignores trailing whitespace (it looks for the block, not for the end
of the string), so `'KEY'` and `'KEY\n'` are one license and must be one identity here too.
Reading from the END rather than the start also makes the whole artifact and its bare `[...]`
block — which the format says are equally valid spellings of the same license — one identity.

Truncated because the set retains its entries for the life of the process: a multi-tenant server
building one engine per customer-supplied key would otherwise accumulate every full key string
it has ever warned about; 129 characters per entry bounds that to the checksum alone.

**Parameters:**

Name | Type |
------ | ------ |
`licenseKey` | string |

**Returns:** *string*

___

### notifyLicenseKeyNotice 

▸ **notifyLicenseKeyNotice**(`licenseKey`: string, `expiryDate`: Date): *void*

*Defined in [src/helpers/licenseKeyValidator.ts:117](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L117)*

Prints a one-time notice that a VALID entitlement key's usage-until expiry is approaching, at
most once per distinct license key.

Called from `src/license/licenseResolution.ts`'s `resolveLicense`, alongside
[notifyLicenseKeyState](globals.md#notifylicensekeystate) — see that function's doc for why the two share this module
instead of each keeping a message table and a flag of their own.

The wording is rev 5 §3.2's own subscription clause ("valid until {date} (UTC)"), naming the
key's LAST covered day. It deliberately does not say "expires on": the pre-existing expired
message reports the first day NOT covered (`validityOf`'s convention, +1 day), and two messages
for the same key must not name two different days for the same boundary. "Valid until Aug 25"
followed later by "expired on Aug 26" is consistent; "expires on Aug 25" followed by
"expired on Aug 26" is a support ticket.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`licenseKey` | string | the raw key string; only its identity is retained, see below |
`expiryDate` | Date | the last covered day of the key's usage-until axis, at UTC midnight  |

**Returns:** *void*

___

### notifyLicenseKeyState 

▸ **notifyLicenseKeyState**(`state`: [LicenseKeyValidityState](enums/licensekeyvaliditystate.md), `keyValidityDate?`: Date): *void*

*Defined in [src/helpers/licenseKeyValidator.ts:88](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L88)*

Prints the console message for a non-valid license key state, at most once per page load.

Extracted so the entitlement-key path in `src/license/licenseResolution.ts` reports the same states
with the same wording and the same once-only behaviour, without duplicating the message table
or getting a second `_notified` flag of its own — two flags would let a page print two
warnings for one key.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`state` | [LicenseKeyValidityState](enums/licensekeyvaliditystate.md) | the state to report; `VALID` prints nothing |
`keyValidityDate?` | Date | - |

**Returns:** *void*

___

### numberFormat 

▸ **numberFormat**(`tokens`: [FormatToken](interfaces/formattoken.md)[], `value`: number): *RawScalarValue*

*Defined in [src/format/format.ts:78](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L78)*

**Parameters:**

Name | Type |
------ | ------ |
`tokens` | [FormatToken](interfaces/formattoken.md)[] |
`value` | number |

**Returns:** *RawScalarValue*

___

### numberToSimpleTime 

▸ **numberToSimpleTime**(`arg`: number): *[SimpleTime](interfaces/simpletime.md)*

*Defined in [src/DateTimeHelper.ts:304](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L304)*

**Parameters:**

Name | Type |
------ | ------ |
`arg` | number |

**Returns:** *[SimpleTime](interfaces/simpletime.md)*

___

### objectDestroy 

▸ **objectDestroy**(`object`: any): *void*

*Defined in [src/Destroy.ts:6](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Destroy.ts#L6)*

**`license`** 
Copyright (c) 2025 Handsoncode. All rights reserved.

**Parameters:**

Name | Type |
------ | ------ |
`object` | any |

**Returns:** *void*

___

### offsetMonth 

▸ **offsetMonth**(`date`: [SimpleDate](interfaces/simpledate.md), `offset`: number): *[SimpleDate](interfaces/simpledate.md)*

*Defined in [src/DateTimeHelper.ts:286](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L286)*

**Parameters:**

Name | Type |
------ | ------ |
`date` | [SimpleDate](interfaces/simpledate.md) |
`offset` | number |

**Returns:** *[SimpleDate](interfaces/simpledate.md)*

___

### padLeft 

▸ **padLeft**(`number`: number | string, `size`: number): *string*

*Defined in [src/format/format.ts:58](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L58)*

**Parameters:**

Name | Type |
------ | ------ |
`number` | number &#124; string |
`size` | number |

**Returns:** *string*

___

### padRight 

▸ **padRight**(`number`: number | string, `size`: number): *string*

*Defined in [src/format/format.ts:66](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/format.ts#L66)*

**Parameters:**

Name | Type |
------ | ------ |
`number` | number &#124; string |
`size` | number |

**Returns:** *string*

___

### parse 

▸ **parse**(`str`: string): *[FormatExpression](interfaces/formatexpression.md)*

*Defined in [src/format/parser.ts:121](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L121)*

**Parameters:**

Name | Type |
------ | ------ |
`str` | string |

**Returns:** *[FormatExpression](interfaces/formatexpression.md)*

___

### parseDateFormat 

▸ **parseDateFormat**(`dateFormat`: string): *object*

*Defined in [src/DateTimeDefault.ts:206](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L206)*

Parses a date format string into a format object.

**Parameters:**

Name | Type |
------ | ------ |
`dateFormat` | string |

**Returns:** *object*

* **dayItem**: *number*

* **itemsCount**: *number*

* **longYearItem**: *number*

* **monthItem**: *number*

* **shortYearItem**: *number*

___

### parseForDateTimeFormat 

▸ **parseForDateTimeFormat**(`str`: string): *[Maybe](globals.md#maybe)‹[FormatExpression](interfaces/formatexpression.md)›*

*Defined in [src/format/parser.ts:96](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L96)*

**Parameters:**

Name | Type |
------ | ------ |
`str` | string |

**Returns:** *[Maybe](globals.md#maybe)‹[FormatExpression](interfaces/formatexpression.md)›*

___

### parseForNumberFormat 

▸ **parseForNumberFormat**(`str`: string): *[Maybe](globals.md#maybe)‹[FormatExpression](interfaces/formatexpression.md)›*

*Defined in [src/format/parser.ts:109](https://github.com/handsontable/hyperformula/blob/dcf9354/src/format/parser.ts#L109)*

**Parameters:**

Name | Type |
------ | ------ |
`str` | string |

**Returns:** *[Maybe](globals.md#maybe)‹[FormatExpression](interfaces/formatexpression.md)›*

___

### parseIsoDate 

▸ **parseIsoDate**(`isoDate`: string, `dateLabel`: string): *[ParsedIsoDate](interfaces/parsedisodate.md)*

*Defined in [src/license/vendor/utils.ts:54](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L54)*

Parses the date in the `YYYY-MM-DD` format into its numeric parts and the epoch milliseconds
of its UTC midnight. Throws when the date is malformed or does not exist in the calendar.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`isoDate` | string | the date to parse |
`dateLabel` | string | the date name used in the error message  |

**Returns:** *[ParsedIsoDate](interfaces/parsedisodate.md)*

___

### parseTimeFormat 

▸ **parseTimeFormat**(`timeFormat`: string): *object*

*Defined in [src/DateTimeDefault.ts:186](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeDefault.ts#L186)*

Parses a time format string into a format object.

**Parameters:**

Name | Type |
------ | ------ |
`timeFormat` | string |

**Returns:** *object*

* **hourItem**: *number*

* **itemsCount**: *number*

* **minuteItem**: *number*

* **secondItem**: *number*

___

### postMortem 

▸ **postMortem**(`method`: any): *(Anonymous function)*

*Defined in [src/Destroy.ts:16](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Destroy.ts#L16)*

**Parameters:**

Name | Type |
------ | ------ |
`method` | any |

**Returns:** *(Anonymous function)*

___

### releaseDateTimestamp 

▸ **releaseDateTimestamp**(): *number | null*

*Defined in [src/license/licenseResolution.ts:112](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L112)*

The build's release date as epoch milliseconds (UTC midnight), or `null` when it is unknown or
malformed.

Read from the same `HT_RELEASE_DATE` (`DD/MM/YYYY`) the legacy validator uses, but **parsed
differently on purpose**, and the difference is observable — so do not "simplify" either one to
match the other without reading this.

This function uses `Date.UTC`. The legacy validator builds the same value with
`new Date(month/day/year)`, which is parsed in the host's LOCAL zone. East of UTC the two land on
different day numbers for one and the same release date:

```text
HT_RELEASE_DATE=10/08/2026        legacy (local)   this function (UTC)
  TZ=UTC, TZ=America/Los_Angeles      20675              20675     agree
  TZ=Asia/Tokyo                       20674              20675     differ by a day
  TZ=Pacific/Kiritimati               20674              20675     differ by a day
```

UTC is the required reading for an entitlement key: key spec rev 6 §1.2 makes offline/online
parity a hard rule — the offline check and a future online check must return the same verdict
for the same key at the same instant — and any rule reading a local clock breaks it. The legacy
path keeps its local parse because legacy behaviour is frozen for this release; switching it
would move the expiry verdict of already-issued legacy keys by a day for every customer east
of UTC.

The consequence, flagged rather than hidden: two customers east of UTC, one on a legacy key and
one on an equivalent entitlement key, can disagree by a day about whether this build is covered.
Reconciling them is a product decision, not a refactor.

**Returns:** *number | null*

___

### replacer 

▸ **replacer**(`key`: string, `val`: any): *any*

*Defined in [src/errors.ts:135](https://github.com/handsontable/hyperformula/blob/dcf9354/src/errors.ts#L135)*

**Parameters:**

Name | Type |
------ | ------ |
`key` | string |
`val` | any |

**Returns:** *any*

___

### resolveLicense 

▸ **resolveLicense**(`licenseKey`: string, `notifyConsole`: boolean): *[ResolvedLicense](interfaces/resolvedlicense.md)*

*Defined in [src/license/licenseResolution.ts:351](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L351)*

Resolves a license key into both gates' inputs.

Routing follows the vendored [detectLicenseKeyFormat](globals.md#detectlicensekeyformat), whose test order is normative
(key spec addendum, T12): the literals, then the trailing bracketed block that marks an
entitlement key, then the legacy 25-character shape. Everything that is not an entitlement key
— `gpl-v3`, a legacy key, an empty string — falls through to [checkLicenseKeyValidity](globals.md#checklicensekeyvalidity)
completely unchanged, which is what keeps this from touching existing behaviour. A string that
carries a bracketed block routes here even when the block is garbage: such a key is INVALID,
not a legacy key that happens to contain brackets.

**The invariant this function exists to protect.** Only a VALID entitlement key resolves to a
restricted entitlement. Every other outcome — missing, invalid, or expired, for an entitlement
key as much as for a legacy one — resolves to [unrestrictedEntitlement](globals.md#unrestrictedentitlement). That asymmetry is
deliberate and load-bearing: gate A already stops formula evaluation on its own (a bad key
yields `#LIC!` in cells), while gate B additionally makes PR 2's `ensureCapability` throw from
the CRUD API. Letting a bad key restrict the entitlement would turn today's "formulas fail,
the API still works" into "the API throws", which is a silent breaking change for every
existing user whose key lapsed. D3's fail-closed rule governs unrecognized tokens INSIDE an
otherwise valid key; it is not a rule about invalid keys, and conflating the two is exactly
the mistake this comment is here to prevent.

A checksum-valid key whose payload shape cannot be read is INVALID, not a crash and not a free
pass: every payload field is untrusted, so nothing here may assume a shape the vendored reader
has not verified.

**Parameters:**

Name | Type | Default | Description |
------ | ------ | ------ | ------ |
`licenseKey` | string | - | the raw `licenseKey` config value |
`notifyConsole` | boolean | true | pass `false` for a resolution whose result exists only to be thrown away (e.g. the transient serialization-only `Config` that `rebuildWithConfig` builds from the OUTGOING config) — such a resolution must not print notices for a key the caller is in the middle of replacing. Legacy keys notify inside [checkLicenseKeyValidity](globals.md#checklicensekeyvalidity) behind a once-per-page-load flag, so they cannot double-print regardless of this parameter.  |

**Returns:** *[ResolvedLicense](interfaces/resolvedlicense.md)*

___

### roundToEpsilon 

▸ **roundToEpsilon**(`arg`: number, `epsilon`: number): *number*

*Defined in [src/DateTimeHelper.ts:299](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L299)*

**Parameters:**

Name | Type | Default |
------ | ------ | ------ |
`arg` | number | - |
`epsilon` | number | 1 |

**Returns:** *number*

___

### roundToNearestSecond 

▸ **roundToNearestSecond**(`arg`: number): *number*

*Defined in [src/DateTimeHelper.ts:295](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L295)*

**Parameters:**

Name | Type |
------ | ------ |
`arg` | number |

**Returns:** *number*

___

### sha512 

▸ **sha512**(`bytes`: number[] | Uint8Array): *string*

*Defined in [src/license/vendor/sha512.ts:78](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/sha512.ts#L78)*

Calculates the SHA-512 checksum of the passed bytes. The implementation is a plain (pure JS)
one on purpose. It does not depend on the Web Crypto API (`crypto.subtle`), which browsers
expose only on secure origins (https). Thanks to that, the checksum can be verified on plain
http:// pages, for example, intranets of big companies.

A second reason applies on HyperFormula's side: `crypto.subtle.digest` is asynchronous, and
the license key is read from `Config`'s constructor, which is not.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`bytes` | number[] &#124; Uint8Array | the bytes to calculate the checksum from  |

**Returns:** *string*

___

### simpleCellAddress

▸ **simpleCellAddress**(`sheet`: number, `col`: number, `row`: number): *[SimpleCellAddress](interfaces/simplecelladdress.md)*

*Defined in [src/Cell.ts:198](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L198)*

**Parameters:**

Name | Type |
------ | ------ |
`sheet` | number |
`col` | number |
`row` | number |

**Returns:** *[SimpleCellAddress](interfaces/simplecelladdress.md)*

___

### simpleCellRange

▸ **simpleCellRange**(`start`: [SimpleCellAddress](interfaces/simplecelladdress.md), `end`: [SimpleCellAddress](interfaces/simplecelladdress.md)): *object*

*Defined in [src/AbsoluteCellRange.ts:43](https://github.com/handsontable/hyperformula/blob/dcf9354/src/AbsoluteCellRange.ts#L43)*

**Parameters:**

Name | Type |
------ | ------ |
`start` | [SimpleCellAddress](interfaces/simplecelladdress.md) |
`end` | [SimpleCellAddress](interfaces/simplecelladdress.md) |

**Returns:** *object*

* **end**: *[SimpleCellAddress](interfaces/simplecelladdress.md)*

* **start**: *[SimpleCellAddress](interfaces/simplecelladdress.md)*

___

### simpleColumnAddress

▸ **simpleColumnAddress**(`sheet`: number, `col`: number): *[SimpleColumnAddress](interfaces/simplecolumnaddress.md)*

*Defined in [src/Cell.ts:188](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L188)*

**Parameters:**

Name | Type |
------ | ------ |
`sheet` | number |
`col` | number |

**Returns:** *[SimpleColumnAddress](interfaces/simplecolumnaddress.md)*

___

### simpleRowAddress

▸ **simpleRowAddress**(`sheet`: number, `row`: number): *[SimpleRowAddress](interfaces/simplerowaddress.md)*

*Defined in [src/Cell.ts:179](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L179)*

**Parameters:**

Name | Type |
------ | ------ |
`sheet` | number |
`row` | number |

**Returns:** *[SimpleRowAddress](interfaces/simplerowaddress.md)*

___

### split 

▸ **split**‹**T**›(`iterable`: IterableIterator‹T›): *object*

*Defined in [src/generatorUtils.ts:11](https://github.com/handsontable/hyperformula/blob/dcf9354/src/generatorUtils.ts#L11)*

**Type parameters:**

▪ **T**

**Parameters:**

Name | Type |
------ | ------ |
`iterable` | IterableIterator‹T› |

**Returns:** *object*

* **rest**: *IterableIterator‹T›*

* **value**? : *T*

___

### stringToUtf8Bytes 

▸ **stringToUtf8Bytes**(`text`: string): *number[]*

*Defined in [src/license/vendor/utils.ts:92](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L92)*

Encodes the string as UTF-8 bytes. The plain implementation is used on purpose. It does not
depend on `TextEncoder` or `Buffer`, so the same code works in Node.js and in every browser,
including plain http:// pages.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`text` | string | the string to encode  |

**Returns:** *number[]*

___

### timeToNumber 

▸ **timeToNumber**(`time`: [SimpleTime](interfaces/simpletime.md)): *number*

*Defined in [src/DateTimeHelper.ts:315](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L315)*

**Parameters:**

Name | Type |
------ | ------ |
`time` | [SimpleTime](interfaces/simpletime.md) |

**Returns:** *number*

___

### toBasisEU 

▸ **toBasisEU**(`date`: [SimpleDate](interfaces/simpledate.md)): *[SimpleDate](interfaces/simpledate.md)*

*Defined in [src/DateTimeHelper.ts:319](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L319)*

**Parameters:**

Name | Type |
------ | ------ |
`date` | [SimpleDate](interfaces/simpledate.md) |

**Returns:** *[SimpleDate](interfaces/simpledate.md)*

___

### toHex32 

▸ **toHex32**(`value`: number): *string*

*Defined in [src/license/vendor/sha512.ts:63](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/sha512.ts#L63)*

Converts a 32-bit integer to a zero-padded 8-character hex string.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`value` | number | the 32-bit integer value  |

**Returns:** *string*

___

### truncateDayInMonth 

▸ **truncateDayInMonth**(`date`: [SimpleDate](interfaces/simpledate.md)): *[SimpleDate](interfaces/simpledate.md)*

*Defined in [src/DateTimeHelper.ts:291](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L291)*

**Parameters:**

Name | Type |
------ | ------ |
`date` | [SimpleDate](interfaces/simpledate.md) |

**Returns:** *[SimpleDate](interfaces/simpledate.md)*

___

### unrestrictedEntitlement 

▸ **unrestrictedEntitlement**(): *[LicenseEntitlement](interfaces/licenseentitlement.md)*

*Defined in [src/license/LicenseEntitlement.ts:92](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/LicenseEntitlement.ts#L92)*

The unrestricted entitlement: legacy keys and `gpl-v3` resolve to this today.

HF-307 decision D3 (fail-closed, silent) means an entitlement key whose tokens this library version
does not recognize at all no longer maps here — it resolves to an entitlement with an empty,
silent capability set instead of falling back to unrestricted access. Do not reuse this
function for that case.

**Returns:** *[LicenseEntitlement](interfaces/licenseentitlement.md)*

___

### utf8BytesToString 

▸ **utf8BytesToString**(`bytes`: number[]): *string*

*Defined in [src/license/vendor/utils.ts:136](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/vendor/utils.ts#L136)*

Decodes UTF-8 bytes back into a string.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`bytes` | number[] | the bytes to decode  |

**Returns:** *string*

___

### validateArgToType 

▸ **validateArgToType**(`inputValue`: any, `expectedType`: string, `paramName`: string): *void*

*Defined in [src/ArgumentSanitization.ts:81](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArgumentSanitization.ts#L81)*

**Parameters:**

Name | Type |
------ | ------ |
`inputValue` | any |
`expectedType` | string |
`paramName` | string |

**Returns:** *void*

___

### validateAsSheet 

▸ **validateAsSheet**(`sheet`: [Sheet](globals.md#sheet)): *void*

*Defined in [src/Sheet.ts:33](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Sheet.ts#L33)*

**Parameters:**

Name | Type |
------ | ------ |
`sheet` | [Sheet](globals.md#sheet) |

**Returns:** *void*

___

### validateNumberToBeAtLeast 

▸ **validateNumberToBeAtLeast**(`value`: number, `paramName`: string, `minimum`: number): *void*

*Defined in [src/ArgumentSanitization.ts:34](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArgumentSanitization.ts#L34)*

**Parameters:**

Name | Type |
------ | ------ |
`value` | number |
`paramName` | string |
`minimum` | number |

**Returns:** *void*

___

### validateNumberToBeAtMost 

▸ **validateNumberToBeAtMost**(`value`: number, `paramName`: string, `maximum`: number): *void*

*Defined in [src/ArgumentSanitization.ts:40](https://github.com/handsontable/hyperformula/blob/dcf9354/src/ArgumentSanitization.ts#L40)*

**Parameters:**

Name | Type |
------ | ------ |
`value` | number |
`paramName` | string |
`maximum` | number |

**Returns:** *void*

___

### validityOf 

▸ **validityOf**(`terms`: [LicenseTerms](interfaces/licenseterms.md)): *object*

*Defined in [src/license/licenseResolution.ts:237](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/licenseResolution.ts#L237)*

Whether an intact entitlement key is still valid, and if not, the day it stopped being valid.

A key with no expiry never expires. Otherwise the expiration date is INCLUSIVE of its last
valid day, and a grace period extends it further. A date compared against the build's release
date involves no clock at all, which is what keeps an air-gapped install with a wrong system
clock working.

An unknown release date resolves to "not expired", matching what the legacy validator already
does when `HT_RELEASE_DATE` is missing: a build that cannot tell its own age must not start
rejecting keys that customers paid for.

**Parameters:**

Name | Type | Description |
------ | ------ | ------ |
`terms` | [LicenseTerms](interfaces/licenseterms.md) | the terms of the key  |

**Returns:** *object*

* **expiredOn**? : *Date*

* **state**: *[LicenseKeyValidityState](enums/licensekeyvaliditystate.md)*

## Object literals

### CellValueDetailedType

### ▪ **CellValueDetailedType**: *object*

*Defined in [src/Cell.ts:95](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L95)*

___

### CellValueType

### ▪ **CellValueType**: *object*

*Defined in [src/Cell.ts:92](https://github.com/handsontable/hyperformula/blob/dcf9354/src/Cell.ts#L92)*

___

### consoleMessages

### ▪ **consoleMessages**: *object*

*Defined in [src/helpers/licenseKeyValidator.ts:37](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L37)*

List of all not valid messages which may occur.

### expired 

▸ **expired**(`__namedParameters`: object): *string*

*Defined in [src/helpers/licenseKeyValidator.ts:39](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L39)*

**Parameters:**

▪ **__namedParameters**: *object*

Name | Type |
------ | ------ |
`keyValidityDate` | string |

**Returns:** *string*

### invalid 

▸ **invalid**(): *string*

*Defined in [src/helpers/licenseKeyValidator.ts:38](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L38)*

**Returns:** *string*

### missing 

▸ **missing**(): *string*

*Defined in [src/helpers/licenseKeyValidator.ts:41](https://github.com/handsontable/hyperformula/blob/dcf9354/src/helpers/licenseKeyValidator.ts#L41)*

**Returns:** *string*

___

### coreGrant

### ▪ **coreGrant**: *object*

*Defined in [src/license/capabilities.ts:260](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L260)*

### features 

• **features**: *never[]* = []

*Defined in [src/license/capabilities.ts:260](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L260)*

### functions 

• **functions**: *string[]* = [...OPERATOR_FUNCTIONS]

*Defined in [src/license/capabilities.ts:260](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L260)*

___

### functions1Grant

### ▪ **functions1Grant**: *object*

*Defined in [src/license/capabilities.ts:261](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L261)*

### features 

• **features**: *never[]* = []

*Defined in [src/license/capabilities.ts:261](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L261)*

### functions 

• **functions**: *string[]* = [...MATH_ENGINE_FUNCTIONS]

*Defined in [src/license/capabilities.ts:261](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L261)*

___

### functions2Grant

### ▪ **functions2Grant**: *object*

*Defined in [src/license/capabilities.ts:262](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L262)*

### features 

• **features**: *never[]* = []

*Defined in [src/license/capabilities.ts:263](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L263)*

### functions 

• **functions**: *string[]* = [...MATH_ENGINE_FUNCTIONS, ...CALCULATED_FIELDS_FUNCTIONS]

*Defined in [src/license/capabilities.ts:263](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L263)*

___

### functions3Grant

### ▪ **functions3Grant**: *object*

*Defined in [src/license/capabilities.ts:265](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L265)*

### features 

• **features**: *never[]* = []

*Defined in [src/license/capabilities.ts:266](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L266)*

### functions 

• **functions**: *string[]* = [...MATH_ENGINE_FUNCTIONS, ...CALCULATED_FIELDS_FUNCTIONS, ...SPREADSHEET_FUNCTIONS]

*Defined in [src/license/capabilities.ts:266](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L266)*

___

### functions4Grant

### ▪ **functions4Grant**: *object*

*Defined in [src/license/capabilities.ts:268](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L268)*

### features 

• **features**: *never[]* = []

*Defined in [src/license/capabilities.ts:273](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L273)*

### functions 

• **functions**: *string[]* = [
    ...MATH_ENGINE_FUNCTIONS, ...CALCULATED_FIELDS_FUNCTIONS, ...SPREADSHEET_FUNCTIONS,
    ...EXCEL_SIMULATOR_FUNCTIONS,
  ]

*Defined in [src/license/capabilities.ts:269](https://github.com/handsontable/hyperformula/blob/dcf9354/src/license/capabilities.ts#L269)*

___

### maxDate

### ▪ **maxDate**: *object*

*Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L51)*

### day 

• **day**: *number* = 31

*Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L51)*

### month 

• **month**: *number* = 12

*Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L51)*

### year 

• **year**: *number* = 9999

*Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/dcf9354/src/DateTimeHelper.ts#L51)*