# 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/8e47e2b/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/8e47e2b/src/CellValue.ts#L9)* ___ ### CellValueDetailedType Ƭ **CellValueDetailedType**: *[CellValueNoNumber](enums/cellvaluenonumber.md) | NumberType* *Defined in [src/Cell.ts:94](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/Cell.ts#L91)* ___ ### ChangeList Ƭ **ChangeList**: *[CellValueChange](interfaces/cellvaluechange.md)[]* *Defined in [src/ContentChanges.ts:20](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/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/8e47e2b/src/Lookup/ColumnIndex.ts#L30)* ___ ### ColumnRowIndex Ƭ **ColumnRowIndex**: *[number, number]* *Defined in [src/CrudOperations.ts:65](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/CrudOperations.ts#L65)* ___ ### ConfigParamsList Ƭ **ConfigParamsList**: *keyof ConfigParams* *Defined in [src/ConfigParams.ts:450](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/ConfigParams.ts#L450)* ___ ### ConsoleMessages Ƭ **ConsoleMessages**: *object* *Defined in [src/helpers/licenseKeyValidator.ts:31](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L31)* #### 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/8e47e2b/src/DateTimeHelper.ts#L31)* ___ ### Dependencies Ƭ **Dependencies**: *Map‹Vertex, [CellDependency](globals.md#celldependency)[]›* *Defined in [src/GraphBuilder.ts:25](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/GraphBuilder.ts#L25)* ___ ### EngineState Ƭ **EngineState**: *object* *Defined in [src/BuildEngineFactory.ts:35](https://github.com/handsontable/hyperformula/blob/8e47e2b/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* ___ ### EntitlementLicense Ƭ **EntitlementLicense**: *object | object* *Defined in [src/license/handsontable-license-key-parser/types.ts:148](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/types.ts#L148)* The result of reading an entitlement key for one product. When `licensed` is `true`, `entitlement`, `lifecycle` and `channels` describe that product and `grants` lists exactly what the key unlocks. When `licensed` is `false`, the product must report an invalid key. `entitlement` and `lifecycle` are `null`, both channels are open (the flags that close them could not be read), and `grants` is unrestricted - an invalid key nags, it never takes features away. The whole result is frozen, in both cases. ___ ### ExportedChange Ƭ **ExportedChange**: *[ExportedCellChange](classes/exportedcellchange.md) | [ExportedNamedExpressionChange](classes/exportednamedexpressionchange.md)* *Defined in [src/Exporter.ts:18](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Exporter.ts#L18)* ___ ### LicenseExpiryAxis Ƭ **LicenseExpiryAxis**: *"release" | "usage"* *Defined in [src/helpers/licenseKeyValidator.ts:25](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L25)* Which deadline a key ran out against: the date of the build in use (`release`) or the wall clock (`usage`). ___ ### LicenseKeyFormat Ƭ **LicenseKeyFormat**: *"entitlement" | "legacy" | "literal" | "unknown"* *Defined in [src/license/handsontable-license-key-parser/types.ts:9](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/types.ts#L9)* The shapes a license key string can have. `literal` is one of the plain words the calling product accepts as a key (for example "non-commercial-and-evaluation" or "gpl-v3") - which words those are is the product's decision, so the reader only recognizes the ones it is handed. Only "entitlement" is read by this module; every other format is the product's own path. ___ ### 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/8e47e2b/src/helpers/licenseKeyValidator.ts#L19)* ___ ### LicenseState Ƭ **LicenseState**: *"usage_valid" | "usage_notice" | "usage_soft_stop" | "usage_hard_stop" | "trial_valid" | "trial_notice" | "trial_soft_stop" | "trial_hard_stop" | "release_valid" | "release_expired"* *Defined in [src/license/handsontable-license-key-parser/types.ts:58](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/types.ts#L58)* The lifecycle state of a license, derived from the governing date of the product entry: - `usage_until` runs the notice -> soft stop -> hard stop windows against the current UTC instant. The `trial_*` states are the same windows on a key carrying the `trial` flag - they differ in what the user is told and shown, not in how they are measured. - `release_until` compares the build release date against the maintenance date as text. No clock takes part, so the verdict never changes. ___ ### Maybe Ƭ **Maybe**: *T | undefined* *Defined in [src/Maybe.ts:6](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Maybe.ts#L6)* **`license`** Copyright (c) 2025 Handsoncode. All rights reserved. ___ ### MessageDescriptor Ƭ **MessageDescriptor**: *object* *Defined in [src/helpers/licenseKeyValidator.ts:35](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L35)* #### 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/8e47e2b/src/NamedExpressions.ts#L22)* ___ ### NoErrorCellValue Ƭ **NoErrorCellValue**: *number | string | boolean | null* *Defined in [src/CellValue.ts:8](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/CellValue.ts#L8)* ___ ### RawCellContent Ƭ **RawCellContent**: *Date | string | number | boolean | null | undefined* *Defined in [src/CellContentParser.ts:25](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/CellContentParser.ts#L25)* ___ ### Sheet Ƭ **Sheet**: *[RawCellContent](globals.md#rawcellcontent)[][]* *Defined in [src/Sheet.ts:12](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/Cell.ts#L51)* ___ ### UnlicensedReason Ƭ **UnlicensedReason**: *"unreadable" | "product_missing"* *Defined in [src/license/handsontable-license-key-parser/types.ts:133](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/types.ts#L133)* Why an entitlement key does not license the product that reads it: - `unreadable` the block is missing, tampered with or malformed, - `product_missing` the key is intact but grants other products only. Both are reported to the user as an invalid key; the split exists so a product can log which one it was. ___ ### UsageWindow Ƭ **UsageWindow**: *"valid" | "notice" | "soft_stop" | "hard_stop"* *Defined in [src/license/handsontable-license-key-parser/classify.ts:21](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/classify.ts#L21)* The window a `usage_until` license is in, before the trial flag decides how it is worded. ## Variables ### ALL_FEATURES • **ALL_FEATURES**: *[FeatureId](enums/featureid.md)[]* = singleFeatureEntries.reduce( (features, [, granted]) => features.concat(granted), [], ) *Defined in [src/license/featureCapabilities.ts:24](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/featureCapabilities.ts#L24)* Every gated API area: what `feat:all` grants. ___ ### ALL_FUNCTIONS • **ALL_FUNCTIONS**: *string[]* = Array.from(FUNCTION_GROUPS.values()) .reduce((functions, members) => functions.concat(members), []) .concat(UNGROUPED_FUNCTIONS) *Defined in [src/license/functionCapabilities.ts:115](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/functionCapabilities.ts#L115)* The whole catalog: what `fun:all` grants. Flattened by `reduce` rather than `Array.prototype.flat`, which is ES2019 and so sits above the `lib` ceiling this package compiles against. ___ ### BASE64_ALPHABET • **BASE64_ALPHABET**: *"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"* = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" *Defined in [src/license/handsontable-license-key-parser/encoding.ts:8](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L8)* The base64 alphabet. ___ ### CAPABILITY_TABLE • **CAPABILITY_TABLE**: *ReadonlyMap‹string, [CapabilityGrant](interfaces/capabilitygrant.md)›* = new Map([ ...Array.from(FEATURE_CAPABILITY_TABLE, ([token, features]): [string, CapabilityGrant] => [ token, {functions: [], features: [...features]}, ]), ...Array.from(FUNCTION_CAPABILITY_TABLE, ([token, functions]): [string, CapabilityGrant] => [ token, {functions: [...functions], features: []}, ]), ]) *Defined in [src/license/capabilities.ts:55](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/capabilities.ts#L55)* The production capability table the engine reads: [FEATURE_CAPABILITY_TABLE](globals.md#const-feature_capability_table) and [FUNCTION_CAPABILITY_TABLE](globals.md#const-function_capability_table) under one key space, keyed by NORMALIZED token spelling — look up through [normalizeCapabilityToken](globals.md#normalizecapabilitytoken), never with a raw key string. The two halves share no token (one vocabulary is prefixed `feat:`, the other `fun:`), so the merge cannot lose an entry to a collision. Features come first so that the function half keeps its own iteration order, which is what decides the winner in `CapabilityRegistry`'s reverse index: `fun:all` covers every gatable function and therefore names every one of them there. Both halves are copied into fresh [CapabilityGrant](interfaces/capabilitygrant.md) objects rather than referenced, so that a consumer holding a grant cannot reach back into a sub-table's arrays. No token here names a package, and no grant refers to another token. Which tokens a commercial package consists of is the generator's knowledge, expressed by the bigger licence simply listing more tokens — so a key's function set is the union of everything it names that this table recognizes, and an unrecognized token is inert (strict-shape/lenient-vocabulary, T7). Legacy keys resolve to the unrestricted entitlement and never consult this table at all. There is no entry for any add-on. An add-on is a commercial wrapper, and which capabilities it bundles is decided where keys are minted; the engine only ever reads the capabilities the key actually names. That is what lets pricing rename or re-bundle an add-on without a release here. ___ ### CHECKSUM • **CHECKSUM**: *RegExp‹›* = /^[0-9a-f]+$/ *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:14](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L14)* ___ ### CHECKSUM_LENGTH • **CHECKSUM_LENGTH**: *128* = 128 *Defined in [src/license/handsontable-license-key-parser/constants.ts:7](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L7)* The length of the checksum (SHA-512 as hex) that closes the machine-readable block of every entitlement license key. ___ ### CUSTOM_FLAG • **CUSTOM_FLAG**: *"custom"* = "custom" *Defined in [src/license/handsontable-license-key-parser/constants.ts:63](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L63)* Marks an individually negotiated key. Reserved - it changes nothing a reader does today, and is listed only so a reader knows the name is taken. ___ ### DATE_FIELDS • **DATE_FIELDS**: *string[]* = ['usage_until', 'release_until'] *Defined in [src/license/handsontable-license-key-parser/constants.ts:23](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L23)* The two mutually exclusive date fields of a product entry. Exactly one of them is 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/8e47e2b/src/DateTimeDefault.ts#L13)* ___ ### ENCODED_PAYLOAD • **ENCODED_PAYLOAD**: *RegExp‹›* = /^[A-Za-z0-9\-_]+$/ *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:13](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L13)* 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. ___ ### FEATURE_CAPABILITY_TABLE • **FEATURE_CAPABILITY_TABLE**: *ReadonlyMap‹string, readonly FeatureId[]›* = new Map([ ...singleFeatureEntries, ['feat:all', ALL_FEATURES] as [string, readonly FeatureId[]], ]) *Defined in [src/license/featureCapabilities.ts:38](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/featureCapabilities.ts#L38)* The `feat:*` half of the vocabulary, keyed by NORMALIZED token spelling: one token per gated area of the public API, plus `feat:all` for all of them at once. Kept apart from `FUNCTION_CAPABILITY_TABLE` because the two halves are maintained by different forces. This one grows when a public API area becomes gated — an engine decision, one entry hand-written per area — while the function half is a transcription of the packaging document's group membership. `CAPABILITY_TABLE` in `./capabilities` merges them for the consumers. ___ ### FUNCTION_CAPABILITY_TABLE • **FUNCTION_CAPABILITY_TABLE**: *ReadonlyMap‹string, readonly string[]›* = new Map([ ['fun:all', ALL_FUNCTIONS] as [string, readonly string[]], ...FUNCTION_GROUPS, ...singleFunctionEntries, ]) *Defined in [src/license/functionCapabilities.ts:143](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/functionCapabilities.ts#L143)* The `fun:*` half of the vocabulary, keyed by NORMALIZED token spelling, per §6 of the packaging design: `fun:all`, the group tokens `fun:.`, and one `fun:` per canonical function. 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 be gated — see the note on `UNGROUPED_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. ___ ### 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', ['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']], ['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/functionCapabilities.ts:31](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/functionCapabilities.ts#L31)* The 21 function groups of the packaging doc, keyed by their group tokens in normalized (lowercase) spelling — the doc writes them `fun:.` and declares all token names case-insensitive. Transcribed 1:1 from section 6 of the internal packaging design document ("HF function groups and packages"), so that a re-transcription is a reviewable diff against the doc's published counts. Exported so the paired suite can compare it group by group; the table below is the only thing production code reads it through. `fun:info.a` and `fun:lookup.a` name nothing but the two protected built-ins, `VERSION` and `OFFSET` (see `FunctionRegistry._protectedPlugins`). The doc calls that a "technical limitation" on both: the interpreter never gate-checks a protected function, so those two evaluate under every key no matter which tokens name them, and the groups that carry them are bookkeeping identifiers for functionality every key already has. The doc freezes group names as API surface: once shipped inside license keys, a rename is a breaking change. ___ ### HOURS_PER_DAY • **HOURS_PER_DAY**: *24* = 24 *Defined in [src/DateTimeHelper.ts:15](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L15)* ___ ### HYPERFORMULA_PRODUCT_NAME • **HYPERFORMULA_PRODUCT_NAME**: *"hyperformula"* = "hyperformula" *Defined in [src/license/licenseResolution.ts:28](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L28)* The name of HyperFormula's own product entry in an entitlement key payload. A key that grants other products but not this one is not a license for HyperFormula (the reader returns `product_missing`), however many other products it grants. ___ ### 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/handsontable-license-key-parser/sha512.ts:9](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/sha512.ts#L9)* 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/8e47e2b/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/handsontable-license-key-parser/detectFormat.ts:8](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/detectFormat.ts#L8)* The classic 25-character key, once its dashes are stripped. ___ ### MILLISECONDS_PER_DAY • **MILLISECONDS_PER_DAY**: *86400000* = 86400000 *Defined in [src/license/handsontable-license-key-parser/constants.ts:71](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L71)* *Defined in [src/license/licenseResolution.ts:21](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L21)* The number of milliseconds in a day, used to walk from one UTC midnight to the next. 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/8e47e2b/src/DateTimeHelper.ts#L14)* ___ ### NOTICE_STATES • **NOTICE_STATES**: *[LicenseState](globals.md#licensestate)[]* = ['usage_notice', 'trial_notice'] *Defined in [src/license/licenseResolution.ts:44](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L44)* Lifecycle states in which a key that is still valid prints its expiry notice. ___ ### NOT_FOUND • **NOT_FOUND**: *-1* = -1 *Defined in [src/Lookup/AdvancedFind.ts:19](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Lookup/AdvancedFind.ts#L19)* ___ ### NO_CONSOLE_WARNS_FLAG • **NO_CONSOLE_WARNS_FLAG**: *"no-console-warns"* = "no-console-warns" *Defined in [src/license/handsontable-license-key-parser/constants.ts:41](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L41)* Closes the console channel: nothing the license has to say reaches it. ___ ### NO_UI_WARNS_FLAG • **NO_UI_WARNS_FLAG**: *"no-ui-warns"* = "no-ui-warns" *Defined in [src/license/handsontable-license-key-parser/constants.ts:55](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L55)* Closes the UI WARNING surfaces (a banner, a badge, a popover). Both this flag and the one above are the default for a key issued for external, end-user-facing use. It does NOT close the trial hard-stop block. The block is enforcement rather than a warning. This is a product decision (DEV-2709, Handsontable); the specification's S4.1 table header does not yet record the split, so do not "restore" the other reading from the spec alone. ___ ### OPEN_CHANNELS • **OPEN_CHANNELS**: *[LicenseChannels](interfaces/licensechannels.md)* = Object.freeze({ console: true, ui: true }) *Defined in [src/license/handsontable-license-key-parser/readLicense.ts:18](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/readLicense.ts#L18)* Both notification channels open - what a key gets when its flags could not be read. ___ ### 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/8e47e2b/src/DateTimeDefault.ts#L11)* ___ ### SECONDS_PER_MINUTE • **SECONDS_PER_MINUTE**: *60* = 60 *Defined in [src/DateTimeHelper.ts:13](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L13)* ___ ### SECONDS_PRECISION • **SECONDS_PRECISION**: *1000* = 1000 *Defined in [src/DateTimeDefault.ts:15](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeDefault.ts#L15)* ___ ### 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/8e47e2b/src/DateTimeDefault.ts#L9)* ___ ### TIME_SEPARATOR • **TIME_SEPARATOR**: *":"* = ":" *Defined in [src/DateTimeDefault.ts:14](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeDefault.ts#L14)* ___ ### TRIAL_FLAG • **TRIAL_FLAG**: *"trial"* = "trial" *Defined in [src/license/handsontable-license-key-parser/constants.ts:34](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/constants.ts#L34)* Marks a license as an evaluation one. It changes how a license is WORDED and whether the hard stop blocks the product - never how its dates are measured. A flag is present or absent - there is no `false` value - and an unrecognized flag is ignored, for the same reason an unrecognized capability token is. ___ ### UNGROUPED_FUNCTIONS • **UNGROUPED_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/functionCapabilities.ts:84](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/functionCapabilities.ts#L84)* The implemented functions no group names — the packaging design's niche tail, reachable only through `fun:all` or their own single-function token. Enumerated rather than taken from the function registry at run time, even though "everything not in a group" 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 under a licence token and returning `#LIC!` for it — 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. ___ ### UNRESTRICTED_GRANTS • **UNRESTRICTED_GRANTS**: *[LicenseGrants](interfaces/licensegrants.md)* = Object.freeze({ unrestricted: true, products: Object.freeze({}), }) *Defined in [src/license/handsontable-license-key-parser/grants.ts:14](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/grants.ts#L14)* The grants shared by every non-entitlement license state: a valid legacy commercial key, a legacy expired key, a literal key, a missing key, an invalid key, or an unreadable entitlement key. Every query short-circuits on `unrestricted`, so these keys unlock everything - introducing capability gating can never take a feature away from an existing customer. Frozen so it cannot be mutated by a consumer. ___ ### VALID_STATES • **VALID_STATES**: *[LicenseState](globals.md#licensestate)[]* = [ 'usage_valid', 'usage_notice', 'usage_soft_stop', 'trial_valid', 'trial_notice', 'trial_soft_stop', 'release_valid', ] *Defined in [src/license/licenseResolution.ts:37](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L37)* Lifecycle states in which an entitlement key still lets this build evaluate formulas. The soft-stop states are here on purpose: HF-307 decision D5-A builds the notice and the hard stop for 3.5.0, not the soft-stop message, so the grace period behaves as it did before the reader was adopted — valid and quiet. ___ ### WHITESPACE_REGEXP • **WHITESPACE_REGEXP**: *RegExp‹›* = new RegExp('\\s+') *Defined in [src/DateTimeDefault.ts:12](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/AbsoluteCellRange.ts#L22)* ___ ### _noticedKeys • **_noticedKeys**: *Set‹string›* = new Set() *Defined in [src/helpers/licenseKeyValidator.ts:69](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L69)* 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:56](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L56)* ___ ### _rl • **_rl**: *"length"* = "length" *Defined in [src/helpers/licenseKeyHelper.ts:9](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/format/parser.ts#L8)* ___ ### defaultLanguage • **defaultLanguage**: *string* = Config.defaultConfig.language *Defined in [src/index.ts:110](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/index.ts#L110)* ___ ### memoizedData • **memoizedData**: *[EntitlementKeyData](interfaces/entitlementkeydata.md) | null* = null *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:256](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L256)* ___ ### memoizedKey • **memoizedKey**: *string | null* = null *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:255](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L255)* ___ ### memoizedParseDateFormat • **memoizedParseDateFormat**: *(Anonymous function)* = memoize(parseDateFormat) *Defined in [src/DateTimeDefault.ts:17](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeDefault.ts#L17)* ___ ### memoizedParseTimeFormat • **memoizedParseTimeFormat**: *(Anonymous function)* = memoize(parseTimeFormat) *Defined in [src/DateTimeDefault.ts:16](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/DateTimeHelper.ts#L10)* ___ ### numberFormatRegex • **numberFormatRegex**: *RegExp‹›* = /(\\.|[#0]+(\.[#0]*)?)/g *Defined in [src/format/parser.ts:9](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/DateTimeHelper.ts#L11)* ___ ### privatePool • **privatePool**: *WeakMap‹[Config](classes/config.md), [LicensePrivateState](interfaces/licenseprivatestate.md)›* = new WeakMap() *Defined in [src/Config.ts:39](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Config.ts#L39)* ___ ### singleFeatureEntries • **singleFeatureEntries**: *[string, readonly FeatureId[]][]* = [ ['feat:crud', [FeatureId.Crud]], ['feat:undo_redo', [FeatureId.UndoRedo]], ['feat:clipboard', [FeatureId.Clipboard]], ['feat:named_expressions', [FeatureId.NamedExpressions]], ['feat:batching', [FeatureId.Batching]], ] *Defined in [src/license/featureCapabilities.ts:15](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/featureCapabilities.ts#L15)* One entry per single-area feature token. `feat:all` is derived from this list rather than spelled out beside it, so a new gated area reaches it by being added here and nowhere else. [FeatureId.CustomFunctions](enums/featureid.md#customfunctions) deliberately has no token: HF-307 decision D1 drops function-registration gating, so nothing may grant it. ___ ### singleFunctionEntries • **singleFunctionEntries**: *[string, readonly string[]][]* = ALL_FUNCTIONS.map((name) => [ `fun:${name.trim().toLowerCase()}`, [name], ]) *Defined in [src/license/functionCapabilities.ts:127](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/functionCapabilities.ts#L127)* One table entry per canonical function name: the packaging doc's single-function tokens (`fun:`), "for surgical grants: custom deals, previews, per-function exceptions". One exists for EVERY canonical name — the operator callable forms and the protected built-ins included. 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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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:135](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/CapabilityRegistry.ts#L135)* 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:128](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/CapabilityRegistry.ts#L128)* 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/8e47e2b/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/8e47e2b/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/handsontable-license-key-parser/encoding.ts:129](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L129)* 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/handsontable-license-key-parser/encoding.ts:181](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L181)* 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/8e47e2b/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)* ___ ### bytesToBase64 ▸ **bytesToBase64**(`bytes`: number[]): *string* *Defined in [src/license/handsontable-license-key-parser/encoding.ts:104](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L104)* Encodes the bytes as a base64 string (standard alphabet, with padding). **Parameters:** Name | Type | Description | ------ | ------ | ------ | `bytes` | number[] | The bytes to encode. | **Returns:** *string* ___ ### checkKeySchema ▸ **checkKeySchema**(`v`: any): *boolean* *Defined in [src/helpers/licenseKeyHelper.ts:20](https://github.com/handsontable/hyperformula/blob/8e47e2b/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:173](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L173)* 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. ___ ### classifyEntitlement ▸ **classifyEntitlement**(`entitlement`: [ProductEntitlement](interfaces/productentitlement.md), `time`: [LicenseTimeReference](interfaces/licensetimereference.md)): *[LicenseLifecycle](interfaces/licenselifecycle.md)* *Defined in [src/license/handsontable-license-key-parser/classify.ts:99](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/classify.ts#L99)* Classifies one product entitlement into its lifecycle facet. Which of the two dates the entry carries decides how it is measured; the `trial` flag decides only what the user is told. Nothing here branches on a contract type, because the payload does not carry one. A `release_until` entry never reads `time.now`, and a `usage_until` entry never compares against `time.buildDate`. The build date is checked either way, so a wrong one fails on the first key a product's tests read, whatever its kind - see `resolveBuildDate`. Pass an entry from `extractEntitlementKeyData` / `getProductEntitlement`. An entry that is not a verified one - no date, both dates, a date that is not a real "YYYY-MM-DD" string - throws rather than being guessed at. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `entitlement` | [ProductEntitlement](interfaces/productentitlement.md) | The verified product entry. | `time` | [LicenseTimeReference](interfaces/licensetimereference.md) | The time references to measure against. | **Returns:** *[LicenseLifecycle](interfaces/licenselifecycle.md)* ___ ### collatorFromConfig ▸ **collatorFromConfig**(`config`: [Config](classes/config.md)): *Collator* *Defined in [src/StringHelper.ts:8](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/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/8e47e2b/src/ArgumentSanitization.ts#L16)* **Parameters:** Name | Type | ------ | ------ | `inputValue` | any | `expectedType` | string | 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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/DateTimeHelper.ts#L270)* **Parameters:** Name | Type | ------ | ------ | `dayOfYear` | number | **Returns:** *number* ___ ### daysUntil ▸ **daysUntil**(`expiryTimestamp`: number, `now`: number): *number* *Defined in [src/license/handsontable-license-key-parser/classify.ts:46](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/classify.ts#L46)* Whole UTC days from today until the last licensed day. `0` on the last licensed day (which is still licensed in full) and negative once it has passed. Both sides are UTC midnights, so the count is a whole number of calendar days and never a rounded fraction. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `expiryTimestamp` | number | The UTC midnight of the last licensed day. | `now` | number | The current instant, in epoch milliseconds. | **Returns:** *number* ___ ### deepFreeze ▸ **deepFreeze**‹**T**›(`value`: T): *T* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:73](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L73)* Freezes the value and everything nested in it. The read result is shared between callers (see the memo below), so a caller that sorted or pushed into it would silently rewrite what the next caller reads. It walks with an explicit stack, not by recursion. An unknown extra field is kept as it is, and a key can nest one thousands of levels deep - recursion would then overflow the call stack and throw out of the reader, where a key is only ever allowed to read as data or as `null`. **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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/handsontable-license-key-parser/extractKeyData.ts:103](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L103)* 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. Exported because every payload-keyed write in this module must use it - `grants.ts` re-keys the same product names. **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, `literalKeys?`: readonly string[] | null): *[LicenseKeyFormat](globals.md#licensekeyformat)* *Defined in [src/license/handsontable-license-key-parser/detectFormat.ts:35](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/detectFormat.ts#L35)* Tells which license key format a string is in, without validating it. The entitlement key format has no leading type tag, so a key no longer announces itself in its first characters - it ends with the bracketed machine-readable block instead. A product that accepts several formats needs one place that makes the distinction, and this is it. The answer is about SHAPE only. A returned "entitlement" means "route this to `readEntitlementLicense`", not "this key is valid". A returned "legacy" means "route this to the product's own legacy validator" - this module does not read the legacy format. Surrounding whitespace is ignored: a key pasted out of an email or a chat window commonly carries a trailing space or newline. Whitespace INSIDE the brackets is not - see `extractEntitlementKeyData`. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `licenseKey` | unknown | The license key to inspect. | `literalKeys?` | readonly string[] | null | - | **Returns:** *[LicenseKeyFormat](globals.md#licensekeyformat)* ___ ### doesContainRelativeReferences ▸ **doesContainRelativeReferences**(`ast`: Ast): *boolean* *Defined in [src/NamedExpressions.ts:299](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/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/8e47e2b/src/generatorUtils.ts#L8)* **Type parameters:** ▪ **T** **Returns:** *IterableIterator‹T›* ___ ### entitlementOf ▸ **entitlementOf**(`entry`: [ProductEntitlement](interfaces/productentitlement.md), `isTrial`: boolean, `silent`: boolean): *[LicenseEntitlement](interfaces/licenseentitlement.md)* *Defined in [src/license/licenseResolution.ts:104](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L104)* Turns HyperFormula's entry of a valid 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 `no-console-warns` flag, 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. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `entry` | [ProductEntitlement](interfaces/productentitlement.md) | HyperFormula's entry of a valid key | `isTrial` | boolean | whether the key carries the `trial` flag | `silent` | boolean | whether the key closes the console channel | **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/8e47e2b/src/Cell.ts#L226)* **Parameters:** Name | Type | ------ | ------ | `left` | [SimpleCellAddress](interfaces/simplecelladdress.md) | `right` | [SimpleCellAddress](interfaces/simplecelladdress.md) | **Returns:** *boolean* ___ ### expiryOf ▸ **expiryOf**(`entry`: [ProductEntitlement](interfaces/productentitlement.md)): *[LicenseExpiry](interfaces/licenseexpiry.md)* *Defined in [src/license/licenseResolution.ts:67](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L67)* The expiry details an entitlement records, read off HyperFormula's own entry. A `release_until` date has no grace period: it is compared with the build date, which never moves, so there is no window to be inside of. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `entry` | [ProductEntitlement](interfaces/productentitlement.md) | HyperFormula's entry of an intact key | **Returns:** *[LicenseExpiry](interfaces/licenseexpiry.md)* ___ ### extractEntitlementKeyData ▸ **extractEntitlementKeyData**(`licenseKey`: string): *[EntitlementKeyData](interfaces/entitlementkeydata.md) | null* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:281](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L281)* 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. A malformed or tampered key reads as `null` - 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 key or just the `[...]` block, and rewrapped or re-pasted prose still validates. The block itself has to be intact: its alphabet has no whitespace, so a newline inside it makes the key unreadable, exactly as it does for the key generator. Do not "repair" such a key by stripping whitespace inside the brackets - that would accept keys the generator rejects. Unknown products, capability tokens and flags are all tolerated, so nothing about reading a key depends on the commercial vocabulary. The result is frozen. Copy an array before sorting or changing it. **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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/Lookup/ColumnIndex.ts#L339)* **Parameters:** Name | Type | Default | ------ | ------ | ------ | `key` | number | - | `values` | number[] | - | `handlingMisses` | "lowerBound" | "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/8e47e2b/src/generatorUtils.ts#L22)* **Type parameters:** ▪ **T** **Parameters:** Name | Type | ------ | ------ | `iterable` | IterableIterator‹T› | **Returns:** *[Maybe](globals.md#maybe)‹T›* ___ ### firstUncoveredDay ▸ **firstUncoveredDay**(`expiry`: [LicenseExpiry](interfaces/licenseexpiry.md)): *Date* *Defined in [src/license/licenseResolution.ts:84](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L84)* The first day an expired key no longer covers, which is the convention the legacy validator already uses for the same message (it reports `keyValidityDays + 1`). **Parameters:** Name | Type | Description | ------ | ------ | ------ | `expiry` | [LicenseExpiry](interfaces/licenseexpiry.md) | the expiry of the key | **Returns:** *Date* ___ ### 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/8e47e2b/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:214](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L214)* 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/8e47e2b/src/format/parser.ts#L21)* **Parameters:** Name | Type | ------ | ------ | `type` | [TokenType](enums/tokentype.md) | `value` | string | **Returns:** *[FormatToken](interfaces/formattoken.md)* ___ ### 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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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:395](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Config.ts#L395)* **Returns:** *[ConfigParams](interfaces/configparams.md)* ___ ### getFullConfigFromPartial ▸ **getFullConfigFromPartial**(`partialConfig`: Partial‹[ConfigParams](interfaces/configparams.md)›): *[ConfigParams](interfaces/configparams.md)* *Defined in [src/Config.ts:381](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Config.ts#L381)* **Parameters:** Name | Type | ------ | ------ | `partialConfig` | Partial‹[ConfigParams](interfaces/configparams.md)› | **Returns:** *[ConfigParams](interfaces/configparams.md)* ___ ### getLicenseGrants ▸ **getLicenseGrants**(`keyData`: [EntitlementKeyData](interfaces/entitlementkeydata.md)): *[LicenseGrants](interfaces/licensegrants.md)* *Defined in [src/license/handsontable-license-key-parser/grants.ts:28](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/grants.ts#L28)* Builds the grants facet from a verified entitlement key: exactly the capability tokens the payload lists, per product. Entitlement keys are never unrestricted - they unlock only what they name. Frozen, like every result of this module, so the grants a product resolved once cannot be rewritten later. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `keyData` | [EntitlementKeyData](interfaces/entitlementkeydata.md) | The verified key data. | **Returns:** *[LicenseGrants](interfaces/licensegrants.md)* ___ ### getProductCapabilities ▸ **getProductCapabilities**(`grants`: [LicenseGrants](interfaces/licensegrants.md), `productName`: string): *string[] | null* *Defined in [src/license/handsontable-license-key-parser/grants.ts:73](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/grants.ts#L73)* Returns the capability tokens a license grants for a product, or `null` when the product is not granted. An unrestricted license reports no token list - it answers "granted" to every capability query instead, so a caller that needs a yes/no answer asks `hasCapability`. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `grants` | [LicenseGrants](interfaces/licensegrants.md) | The resolved grants. | `productName` | string | The product to read. | **Returns:** *string[] | null* ___ ### getProductEntitlement ▸ **getProductEntitlement**(`keyData`: [EntitlementKeyData](interfaces/entitlementkeydata.md), `productName`: string): *[ProductEntitlement](interfaces/productentitlement.md) | null* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:321](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L321)* Returns the entitlement of one product, but only when it is present as an own property. Used by the lifecycle and grants layers to read one product without trusting the prototype chain. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `keyData` | [EntitlementKeyData](interfaces/entitlementkeydata.md) | The verified key data. | `productName` | string | The product to read. | **Returns:** *[ProductEntitlement](interfaces/productentitlement.md) | null* ___ ### hasCapability ▸ **hasCapability**(`grants`: [LicenseGrants](interfaces/licensegrants.md), `productName`: string, `capability`: string): *boolean* *Defined in [src/license/handsontable-license-key-parser/grants.ts:94](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/grants.ts#L94)* Tells whether the license unlocks a capability for a product. An unrestricted license unlocks every capability - even tokens that do not exist yet. An entitlement license unlocks a capability only when its payload lists the token for that product. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `grants` | [LicenseGrants](interfaces/licensegrants.md) | The resolved grants. | `productName` | string | The product the capability belongs to. | `capability` | string | The capability token to check. | **Returns:** *boolean* ___ ### hasOwn ▸ **hasOwn**(`object`: object, `key`: string): *boolean* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:24](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L24)* Reports own-property presence without trusting a payload's inherited or overridden `hasOwnProperty`. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `object` | object | The object to inspect. | `key` | string | The property name to look up. | **Returns:** *boolean* ___ ### hasProductGrant ▸ **hasProductGrant**(`grants`: [LicenseGrants](interfaces/licensegrants.md), `productName`: string): *boolean* *Defined in [src/license/handsontable-license-key-parser/grants.ts:59](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/grants.ts#L59)* Tells whether the license grants a product. An unrestricted license grants every product; an entitlement license grants a product only when its payload lists it. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `grants` | [LicenseGrants](interfaces/licensegrants.md) | The resolved grants. | `productName` | string | The product to check. | **Returns:** *boolean* ___ ### instanceOfSimpleDate ▸ **instanceOfSimpleDate**(`obj`: any): *obj is SimpleDate* *Defined in [src/DateTimeHelper.ts:34](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/Cell.ts#L203)* Checks if the column or row id is negative. **Parameters:** Name | Type | ------ | ------ | `address` | [SimpleCellAddress](interfaces/simplecelladdress.md) | **Returns:** *boolean* ___ ### isEntitlementKey ▸ **isEntitlementKey**(`licenseKey`: unknown): *boolean* *Defined in [src/license/handsontable-license-key-parser/detectFormat.ts:75](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/detectFormat.ts#L75)* Tells whether a license key has the shape of an entitlement key - the one check a product needs to route a key away from its legacy path. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `licenseKey` | unknown | The license key to inspect. | **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/8e47e2b/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/8e47e2b/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/8e47e2b/src/CellContentParser.ts#L77)* Checks whether string looks like formula or not. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `text` | string | formula | **Returns:** *boolean* ___ ### isNonNegativeInteger ▸ **isNonNegativeInteger**(`value`: unknown): *value is number* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:46](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L46)* Returns `true` when the value is a non-negative integer. `Number.isFinite` also rejects `Infinity` (JSON `1e999` parses to it), which would otherwise turn a window size into a non-finite date later on. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `value` | unknown | The value to check. | **Returns:** *value is number* ___ ### isNonnegativeInteger ▸ **isNonnegativeInteger**(`x`: number): *boolean* *Defined in [src/CrudOperations.ts:657](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/CrudOperations.ts#L657)* **Parameters:** Name | Type | ------ | ------ | `x` | number | **Returns:** *boolean* ___ ### isPlainObject ▸ **isPlainObject**(`value`: unknown): *value is Record‹string, unknown›* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:34](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L34)* Narrows an unknown value to a plain (non-null, non-array) 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:653](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/CrudOperations.ts#L653)* **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/8e47e2b/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/8e47e2b/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/8e47e2b/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/handsontable-license-key-parser/extractKeyData.ts:56](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L56)* 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:161](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/CapabilityRegistry.ts#L161)* 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* ___ ### matchDateFormat ▸ **matchDateFormat**(`str`: string): *RegExpExecArray[]* *Defined in [src/format/parser.ts:39](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/format/parser.ts#L55)* **Parameters:** Name | Type | ------ | ------ | `str` | string | **Returns:** *RegExpExecArray[]* ___ ### memoize ▸ **memoize**‹**T**›(`fn`: function): *(Anonymous function)* *Defined in [src/DateTimeDefault.ts:229](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/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/8e47e2b/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:80](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/capabilities.ts#L80)* 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 because a key's token list is text a human edited somewhere upstream: `'feat:crud '` is the token its author meant, and a padded spelling that silently grants nothing is a support ticket, not a licence restriction. 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): *[ProductEntitlement](interfaces/productentitlement.md) | null* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:126](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L126)* Verifies and normalizes one product entry. Strict about SHAPE: exactly one of the two dates, a real calendar 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 unrecognized capability token, an unrecognized flag and an unrecognized extra field are all kept and ignored. Without that leniency every token added on the issuing side would break every build 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:** *[ProductEntitlement](interfaces/productentitlement.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/8e47e2b/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:163](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L163)* 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:138](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L138)* 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, `expiryAxis`: [LicenseExpiryAxis](globals.md#licenseexpiryaxis)): *void* *Defined in [src/helpers/licenseKeyValidator.ts:103](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L103)* 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 | Default | Description | ------ | ------ | ------ | ------ | `state` | [LicenseKeyValidityState](enums/licensekeyvaliditystate.md) | - | the state to report; `VALID` prints nothing | `keyValidityDate?` | Date | - | - | `expiryAxis` | [LicenseExpiryAxis](globals.md#licenseexpiryaxis) | "release" | - | **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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/format/format.ts#L58)* **Parameters:** Name | Type | ------ | ------ | `number` | number | 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/8e47e2b/src/format/format.ts#L66)* **Parameters:** Name | Type | ------ | ------ | `number` | number | 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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/format/parser.ts#L109)* **Parameters:** Name | Type | ------ | ------ | `str` | string | **Returns:** *[Maybe](globals.md#maybe)‹[FormatExpression](interfaces/formatexpression.md)›* ___ ### parseIsoDateToTimestamp ▸ **parseIsoDateToTimestamp**(`isoDate`: unknown): *number | null* *Defined in [src/license/handsontable-license-key-parser/encoding.ts:197](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L197)* Parses a date in the "YYYY-MM-DD" format into the epoch milliseconds of its UTC midnight. Returns `null` when the date is malformed or does not exist in the calendar (for example "2027-02-30"). Unlike the generator side, the reader never throws on a bad date - a broken payload simply makes the key unreadable. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `isoDate` | unknown | The date to parse. Anything but a string is not a date. | **Returns:** *number | null* ___ ### parseTimeFormat ▸ **parseTimeFormat**(`timeFormat`: string): *object* *Defined in [src/DateTimeDefault.ts:186](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/Destroy.ts#L16)* **Parameters:** Name | Type | ------ | ------ | `method` | any | **Returns:** *(Anonymous function)* ___ ### readEntitlementKeyData ▸ **readEntitlementKeyData**(`licenseKey`: string): *[EntitlementKeyData](interfaces/entitlementkeydata.md) | null* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:179](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L179)* Reads and verifies one key. Split out from the memoized public entry point so the memo can wrap every exit path uniformly. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `licenseKey` | string | The license key to read. | **Returns:** *[EntitlementKeyData](interfaces/entitlementkeydata.md) | null* ___ ### readEntitlementLicense ▸ **readEntitlementLicense**(`licenseKey`: string, `options`: [ReadEntitlementLicenseOptions](interfaces/readentitlementlicenseoptions.md)): *[EntitlementLicense](globals.md#entitlementlicense)* *Defined in [src/license/handsontable-license-key-parser/readLicense.ts:72](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/readLicense.ts#L72)* Reads an entitlement license key for one product, in one call: verifies the block, picks the product's entry, places it in its lifecycle window, reads its silencing flags and resolves what it unlocks. This is the single entry point a product needs. Route a key here only when `detectLicenseKeyFormat` says "entitlement" - legacy and literal keys are the product's own path. A key that grants other products but not this one is NOT a license for this product, however many others it grants. It reads as `licensed: false` with the reason `product_missing`, and the product reports it as an invalid key. Another product's entry never invalidates the key on its own: one install can be licensed for one product and not for another. The grants of an unlicensed key stay UNRESTRICTED on purpose. An invalid key nags - it does not strip features - so introducing capability gating can never take a feature away from a customer whose key failed to read. The clock is read only for a `usage_until` entry, and only when `now` is not passed. A `release_until` entry never reads it. A missing build date fails OPEN; a build date that is present but not a bare "YYYY-MM-DD" throws - see `resolveBuildDate`. Both are checked before the key is read, so the error shows whatever key a product's tests use. The result is frozen, whichever way it goes. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `licenseKey` | string | The license key, as the user supplied it. | `options` | [ReadEntitlementLicenseOptions](interfaces/readentitlementlicenseoptions.md) | What the product tells the reader. | **Returns:** *[EntitlementLicense](globals.md#entitlementlicense)* ___ ### replacer ▸ **replacer**(`key`: string, `val`: any): *any* *Defined in [src/errors.ts:135](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/errors.ts#L135)* **Parameters:** Name | Type | ------ | ------ | `key` | string | `val` | any | **Returns:** *any* ___ ### resolveBuildDate ▸ **resolveBuildDate**(`buildDate`: unknown, `caller`: string): *string* *Defined in [src/license/handsontable-license-key-parser/buildDate.ts:54](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/buildDate.ts#L54)* Checks the build date a caller passed in, and returns it ready to compare. Two different failures, two different answers: - MISSING (`undefined`, `null`, an empty or blank string) fails OPEN and returns "". That is a broken build - a bundler that did not inline the release date constant - and a paying customer must never be told their license lapsed because of it. - PRESENT BUT WRONG (anything else that is not a bare, real "YYYY-MM-DD", such as the raw "DD/MM/YYYY" a build pipeline injects) throws. That is the product's bug, it is the same on every run, and failing open on it would silently turn off every `release_until` check. The product's own tests see the error on the first key they read. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `buildDate` | unknown | The build date the caller passed. | `caller` | string | The public function name, for the error message. | **Returns:** *string* The build date, or "" when it is missing. ___ ### resolveChannels ▸ **resolveChannels**(`entitlement`: [ProductEntitlement](interfaces/productentitlement.md)): *[LicenseChannels](interfaces/licensechannels.md)* *Defined in [src/license/handsontable-license-key-parser/classify.ts:152](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/classify.ts#L152)* Reads which notification channels a product entitlement leaves open. Both flags are per product and default to open; a key issued for external, end-user-facing use carries both. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `entitlement` | [ProductEntitlement](interfaces/productentitlement.md) | The verified product entry. | **Returns:** *[LicenseChannels](interfaces/licensechannels.md)* ___ ### resolveLicense ▸ **resolveLicense**(`licenseKey`: string, `notifyConsole`: boolean): *[ResolvedLicense](interfaces/resolvedlicense.md)* *Defined in [src/license/licenseResolution.ts:165](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/licenseResolution.ts#L165)* 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. An entitlement key is read by the vendored [readEntitlementLicense](globals.md#readentitlementlicense), the single entry point upstream prescribes for products: it verifies the block, picks HyperFormula's entry, places it in its lifecycle window and reads its flags. Only the meaning of the capability tokens and the console messages live here. **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)* ___ ### resolveUsageWindow ▸ **resolveUsageWindow**(`expiryTimestamp`: number, `entitlement`: [ProductEntitlement](interfaces/productentitlement.md), `now`: number): *[UsageWindow](globals.md#usagewindow)* *Defined in [src/license/handsontable-license-key-parser/classify.ts:63](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/classify.ts#L63)* Places a `usage_until` license in its window. The named day is licensed in full: the license runs until the UTC midnight that FOLLOWS it, and the grace period is measured from there. A `notice` of `0` means no advance warning at all, so the notice window is empty rather than one day long. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `expiryTimestamp` | number | The UTC midnight of the last licensed day. | `entitlement` | [ProductEntitlement](interfaces/productentitlement.md) | The product entry the windows come from. | `now` | number | The current instant, in epoch milliseconds. | **Returns:** *[UsageWindow](globals.md#usagewindow)* ___ ### roundToEpsilon ▸ **roundToEpsilon**(`arg`: number, `epsilon`: number): *number* *Defined in [src/DateTimeHelper.ts:299](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/DateTimeHelper.ts#L295)* **Parameters:** Name | Type | ------ | ------ | `arg` | number | **Returns:** *number* ___ ### sha512 ▸ **sha512**(`bytes`: number[] | Uint8Array): *string* *Defined in [src/license/handsontable-license-key-parser/sha512.ts:72](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/sha512.ts#L72)* 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. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `bytes` | number[] | Uint8Array | The bytes to calculate the checksum from. | **Returns:** *string* The checksum as a 128-character hex 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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/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/8e47e2b/src/generatorUtils.ts#L11)* **Type parameters:** ▪ **T** **Parameters:** Name | Type | ------ | ------ | `iterable` | IterableIterator‹T› | **Returns:** *object* * **rest**: *IterableIterator‹T›* * **value**? : *T* ___ ### stringToBase64Url ▸ **stringToBase64Url**(`string`: string): *string* *Defined in [src/license/handsontable-license-key-parser/encoding.ts:167](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L167)* Encodes the string as a URL-safe base64 string without padding (the same format as the JWT payload segment). **Parameters:** Name | Type | Description | ------ | ------ | ------ | `string` | string | The string to encode. | **Returns:** *string* ___ ### stringToUtf8Bytes ▸ **stringToUtf8Bytes**(`string`: string): *number[]* *Defined in [src/license/handsontable-license-key-parser/encoding.ts:18](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L18)* 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 | ------ | ------ | ------ | `string` | 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/8e47e2b/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/8e47e2b/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/handsontable-license-key-parser/sha512.ts:58](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/sha512.ts#L58)* 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* ___ ### toIsoBuildDate ▸ **toIsoBuildDate**(`releaseDate`: unknown): *string* *Defined in [src/license/handsontable-license-key-parser/buildDate.ts:21](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/buildDate.ts#L21)* Turns a build release date into the bare "YYYY-MM-DD" text that `release_until` is compared against. Accepts the "DD/MM/YYYY" form the Handsoncode build pipelines inject (for example `process.env.HOT_RELEASE_DATE` or `process.env.HT_RELEASE_DATE`) and an already-bare "YYYY-MM-DD". The parts are REORDERED as text and never routed through a `Date`: `new Date('07/14/2025')` parses in the machine's local timezone, which is exactly the kind of shift the date rules exist to prevent. Returns an empty string when the value is missing or not a real date. Passed on to `readEntitlementLicense`, an empty build date fails OPEN - a broken build must never tell a paying customer that their license lapsed. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `releaseDate` | unknown | The build release date, "DD/MM/YYYY" or "YYYY-MM-DD". | **Returns:** *string* The date as "YYYY-MM-DD", or "" when it cannot be read. ___ ### truncateDayInMonth ▸ **truncateDayInMonth**(`date`: [SimpleDate](interfaces/simpledate.md)): *[SimpleDate](interfaces/simpledate.md)* *Defined in [src/DateTimeHelper.ts:291](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L291)* **Parameters:** Name | Type | ------ | ------ | `date` | [SimpleDate](interfaces/simpledate.md) | **Returns:** *[SimpleDate](interfaces/simpledate.md)* ___ ### unlicensed ▸ **unlicensed**(`reason`: [UnlicensedReason](globals.md#unlicensedreason)): *[EntitlementLicense](globals.md#entitlementlicense)* *Defined in [src/license/handsontable-license-key-parser/readLicense.ts:26](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/readLicense.ts#L26)* Builds the result for a key that does not license the product. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `reason` | [UnlicensedReason](globals.md#unlicensedreason) | Why the key does not license the product. | **Returns:** *[EntitlementLicense](globals.md#entitlementlicense)* ___ ### unrestrictedEntitlement ▸ **unrestrictedEntitlement**(): *[LicenseEntitlement](interfaces/licenseentitlement.md)* *Defined in [src/license/LicenseEntitlement.ts:87](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/LicenseEntitlement.ts#L87)* 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)* ___ ### utcMidnightOf ▸ **utcMidnightOf**(`timestamp`: number): *number* *Defined in [src/license/handsontable-license-key-parser/classify.ts:32](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/classify.ts#L32)* The UTC midnight of the day an instant falls on. Every window boundary is a UTC midnight, so both sides of every comparison are snapped to one - the local calendar, the locale and DST are inputs the classification must not read at all. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `timestamp` | number | The instant, in epoch milliseconds. | **Returns:** *number* ___ ### utf8BytesToString ▸ **utf8BytesToString**(`bytes`: number[]): *string* *Defined in [src/license/handsontable-license-key-parser/encoding.ts:63](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/encoding.ts#L63)* 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/8e47e2b/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/8e47e2b/src/Sheet.ts#L33)* **Parameters:** Name | Type | ------ | ------ | `sheet` | [Sheet](globals.md#sheet) | **Returns:** *void* ___ ### validateEntitlementKey ▸ **validateEntitlementKey**(`licenseKey`: string): *boolean* *Defined in [src/license/handsontable-license-key-parser/extractKeyData.ts:308](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/license/handsontable-license-key-parser/extractKeyData.ts#L308)* Tells whether a license key is a well-formed, untampered entitlement key. The check is about integrity, not about entitlement: a key that is valid here may still be past its `usage_until` date, or may grant a product the caller does not care about. `readEntitlementLicense` answers those. **Parameters:** Name | Type | Description | ------ | ------ | ------ | `licenseKey` | string | The license key to check. | **Returns:** *boolean* ___ ### validateNumberToBeAtLeast ▸ **validateNumberToBeAtLeast**(`value`: number, `paramName`: string, `minimum`: number): *void* *Defined in [src/ArgumentSanitization.ts:34](https://github.com/handsontable/hyperformula/blob/8e47e2b/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/8e47e2b/src/ArgumentSanitization.ts#L40)* **Parameters:** Name | Type | ------ | ------ | `value` | number | `paramName` | string | `maximum` | number | **Returns:** *void* ## Object literals ### CellValueDetailedType ### ▪ **CellValueDetailedType**: *object* *Defined in [src/Cell.ts:95](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Cell.ts#L95)* ___ ### CellValueType ### ▪ **CellValueType**: *object* *Defined in [src/Cell.ts:92](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/Cell.ts#L92)* ___ ### consoleMessages ### ▪ **consoleMessages**: *object* *Defined in [src/helpers/licenseKeyValidator.ts:43](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L43)* List of all not valid messages which may occur. ### expired ▸ **expired**(`__namedParameters`: object): *string* *Defined in [src/helpers/licenseKeyValidator.ts:50](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L50)* **Parameters:** ▪ **__namedParameters**: *object* Name | Type | ------ | ------ | `axis` | string | `keyValidityDate` | string | **Returns:** *string* ### invalid ▸ **invalid**(): *string* *Defined in [src/helpers/licenseKeyValidator.ts:44](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L44)* **Returns:** *string* ### missing ▸ **missing**(): *string* *Defined in [src/helpers/licenseKeyValidator.ts:53](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/helpers/licenseKeyValidator.ts#L53)* **Returns:** *string* ___ ### maxDate ### ▪ **maxDate**: *object* *Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L51)* ### day • **day**: *number* = 31 *Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L51)* ### month • **month**: *number* = 12 *Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L51)* ### year • **year**: *number* = 9999 *Defined in [src/DateTimeHelper.ts:51](https://github.com/handsontable/hyperformula/blob/8e47e2b/src/DateTimeHelper.ts#L51)*