# API Reference Overview

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 | ExportedNamedExpressionChange

Defined in src/Exporter.ts:18 (opens new window)

# LicenseExpiryAxis

Ƭ LicenseExpiryAxis: "release" | "usage"

Defined in src/helpers/licenseKeyValidator.ts:25 (opens new window)

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 (opens new window)

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, VALID›

Defined in src/helpers/licenseKeyValidator.ts:19 (opens new window)

# LicenseState

Defined in src/license/handsontable-license-key-parser/types.ts:58 (opens new window)

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 (opens new window)

# MessageDescriptor

Ƭ MessageDescriptor: object

Defined in src/helpers/licenseKeyValidator.ts:35 (opens new window)

# Type declaration:

expiryDate? : Date
template: LicenseKeyValidityState

# NamedExpressionOptions

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

Defined in src/NamedExpressions.ts:22 (opens new window)

# NoErrorCellValue

Ƭ NoErrorCellValue: number | string | boolean | null

Defined in src/CellValue.ts:8 (opens new window)

# RawCellContent

Defined in src/CellContentParser.ts:25 (opens new window)

# Sheet

Ƭ Sheet: RawCellContent[][]

Defined in src/Sheet.ts:12 (opens new window)

Two-dimenstional array representation of sheet

# SheetDimensions

Ƭ SheetDimensions: object

Defined in src/Sheet.ts:19 (opens new window)

Represents size of a sheet

# Type declaration:

height: number
width: number

# SheetIndex

Ƭ SheetIndex: ColumnMap[]

Defined in src/Lookup/ColumnIndex.ts:37 (opens new window)

# Sheets

Ƭ Sheets: Record‹string, Sheet›

Defined in src/Sheet.ts:14 (opens new window)

# SimpleDateTime

Ƭ SimpleDateTime: SimpleDate & SimpleTime

Defined in src/DateTimeHelper.ts:29 (opens new window)

# Span

Ƭ Span: RowsSpan | ColumnsSpan

Defined in src/Span.ts:6 (opens new window)

# TranslatableErrorType

Ƭ TranslatableErrorType: Exclude‹ErrorType, LIC›

Defined in src/Cell.ts:51 (opens new window)

# UnlicensedReason

Ƭ UnlicensedReason: "unreadable" | "product_missing"

Defined in src/license/handsontable-license-key-parser/types.ts:133 (opens new window)

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 (opens new window)

The window a usage_until license is in, before the trial flag decides how it is worded.

# Variables

# ALL_FEATURES Const

• ALL_FEATURES: FeatureId[] = singleFeatureEntries.reduce<FeatureId[]>( (features, [, granted]) => features.concat(granted), [], )

Defined in src/license/featureCapabilities.ts:24 (opens new window)

Every gated API area: what feat:all grants.

# ALL_FUNCTIONS Const

• ALL_FUNCTIONS: string[] = Array.from(FUNCTION_GROUPS.values()) .reduce<string[]>((functions, members) => functions.concat(members), []) .concat(UNGROUPED_FUNCTIONS)

Defined in src/license/functionCapabilities.ts:115 (opens new window)

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 Const

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

Defined in src/license/handsontable-license-key-parser/encoding.ts:8 (opens new window)

The base64 alphabet.

# CAPABILITY_TABLE Const

• CAPABILITY_TABLE: ReadonlyMap‹string, CapabilityGrant› = new Map<string, CapabilityGrant>([ ...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 (opens new window)

The production capability table the engine reads: FEATURE_CAPABILITY_TABLE and FUNCTION_CAPABILITY_TABLE under one key space, keyed by NORMALIZED token spelling — look up through 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 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 Const

• CHECKSUM: RegExp‹› = /^[1]+$/

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:14 (opens new window)

# CHECKSUM_LENGTH Const

• CHECKSUM_LENGTH: 128 = 128

Defined in src/license/handsontable-license-key-parser/constants.ts:7 (opens new window)

The length of the checksum (SHA-512 as hex) that closes the machine-readable block of every entitlement license key.

# CUSTOM_FLAG Const

• CUSTOM_FLAG: "custom" = "custom"

Defined in src/license/handsontable-license-key-parser/constants.ts:63 (opens new window)

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 Const

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

Defined in src/license/handsontable-license-key-parser/constants.ts:23 (opens new window)

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 Const

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

Defined in src/DateTimeDefault.ts:13 (opens new window)

# ENCODED_PAYLOAD Const

• ENCODED_PAYLOAD: RegExp‹› = /^[2]+$/

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:13 (opens new window)

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 Const

• 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 (opens new window)

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 Const

• 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 (opens new window)

The fun:* half of the vocabulary, keyed by NORMALIZED token spelling, per §6 of the packaging design: fun:all, the group tokens fun:<family>.<a|b|c>, and one fun:<CANONICAL_FUNCTION_NAME> 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 Const

• 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 (opens new window)

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

Transcribed 1:1 from 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 Const

• HOURS_PER_DAY: 24 = 24

Defined in src/DateTimeHelper.ts:15 (opens new window)

# HYPERFORMULA_PRODUCT_NAME Const

• HYPERFORMULA_PRODUCT_NAME: "hyperformula" = "hyperformula"

Defined in src/license/licenseResolution.ts:28 (opens new window)

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 Const

• 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 (opens new window)

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 Const

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

Defined in src/format/format.ts:26 (opens new window)

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 Const

• LEGACY_KEY: RegExp‹› = /^[3]{25}$/

Defined in src/license/handsontable-license-key-parser/detectFormat.ts:8 (opens new window)

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

# MILLISECONDS_PER_DAY Const

• MILLISECONDS_PER_DAY: 86400000 = 86400000

Defined in src/license/handsontable-license-key-parser/constants.ts:71 (opens new window)

Defined in src/license/licenseResolution.ts:21 (opens new window)

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 Const

• MINUTES_PER_HOUR: 60 = 60

Defined in src/DateTimeHelper.ts:14 (opens new window)

# NOTICE_STATES Const

• NOTICE_STATES: LicenseState[] = ['usage_notice', 'trial_notice']

Defined in src/license/licenseResolution.ts:44 (opens new window)

Lifecycle states in which a key that is still valid prints its expiry notice.

# NOT_FOUND Const

• NOT_FOUND: -1 = -1

Defined in src/Lookup/AdvancedFind.ts:19 (opens new window)

# NO_CONSOLE_WARNS_FLAG Const

• NO_CONSOLE_WARNS_FLAG: "no-console-warns" = "no-console-warns"

Defined in src/license/handsontable-license-key-parser/constants.ts:41 (opens new window)

Closes the console channel: nothing the license has to say reaches it.

# NO_UI_WARNS_FLAG Const

• NO_UI_WARNS_FLAG: "no-ui-warns" = "no-ui-warns"

Defined in src/license/handsontable-license-key-parser/constants.ts:55 (opens new window)

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 Const

• OPEN_CHANNELS: LicenseChannels = Object.freeze({ console: true, ui: true })

Defined in src/license/handsontable-license-key-parser/readLicense.ts:18 (opens new window)

Both notification channels open - what a key gets when its flags could not be read.

# QUICK_CHECK_REGEXP Const

• QUICK_CHECK_REGEXP: RegExp‹› = new RegExp('^[4]+[ap]?m?$')

Defined in src/DateTimeDefault.ts:11 (opens new window)

# SECONDS_PER_MINUTE Const

• SECONDS_PER_MINUTE: 60 = 60

Defined in src/DateTimeHelper.ts:13 (opens new window)

# SECONDS_PRECISION Const

• SECONDS_PRECISION: 1000 = 1000

Defined in src/DateTimeDefault.ts:15 (opens new window)

# TIME_FORMAT_SECONDS_ITEM_REGEXP Const

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

Defined in src/DateTimeDefault.ts:9 (opens new window)

# TIME_SEPARATOR Const

• TIME_SEPARATOR: ":" = ":"

Defined in src/DateTimeDefault.ts:14 (opens new window)

# TRIAL_FLAG Const

• TRIAL_FLAG: "trial" = "trial"

Defined in src/license/handsontable-license-key-parser/constants.ts:34 (opens new window)

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 Const

• 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 (opens new window)

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 Const

• UNRESTRICTED_GRANTS: LicenseGrants = Object.freeze({ unrestricted: true, products: Object.freeze({}), })

Defined in src/license/handsontable-license-key-parser/grants.ts:14 (opens new window)

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 Const

• VALID_STATES: LicenseState[] = [ 'usage_valid', 'usage_notice', 'usage_soft_stop', 'trial_valid', 'trial_notice', 'trial_soft_stop', 'release_valid', ]

Defined in src/license/licenseResolution.ts:37 (opens new window)

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 Const

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

Defined in src/DateTimeDefault.ts:12 (opens new window)

# WRONG_RANGE_SIZE Const

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

Defined in src/AbsoluteCellRange.ts:22 (opens new window)

# _noticedKeys Const

• _noticedKeys: Set‹string› = new Set()

Defined in src/helpers/licenseKeyValidator.ts:69 (opens new window)

Identities (see noticeIdentityOf) of license keys that have already printed their expiry-approaching notice.

Deliberately keyed per key rather than a single boolean like _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 Let

• _notified: boolean = false

Defined in src/helpers/licenseKeyValidator.ts:56 (opens new window)

# _rl Const

• _rl: "length" = "length"

Defined in src/helpers/licenseKeyHelper.ts:9 (opens new window)

# dateFormatRegex Const

• 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 (opens new window)

# defaultLanguage Const

• defaultLanguage: string = Config.defaultConfig.language

Defined in src/index.ts:110 (opens new window)

# memoizedData Let

• memoizedData: EntitlementKeyData | null = null

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:256 (opens new window)

# memoizedKey Let

• memoizedKey: string | null = null

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:255 (opens new window)

# memoizedParseDateFormat Const

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

Defined in src/DateTimeDefault.ts:17 (opens new window)

# memoizedParseTimeFormat Const

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

Defined in src/DateTimeDefault.ts:16 (opens new window)

# numDays Const

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

Defined in src/DateTimeHelper.ts:10 (opens new window)

# numberFormatRegex Const

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

Defined in src/format/parser.ts:9 (opens new window)

# prefSumDays Const

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

Defined in src/DateTimeHelper.ts:11 (opens new window)

# privatePool Const

• privatePool: WeakMap‹Config, LicensePrivateState› = new WeakMap()

Defined in src/Config.ts:39 (opens new window)

# singleFeatureEntries Const

• 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 (opens new window)

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 deliberately has no token: HF-307 decision D1 drops function-registration gating, so nothing may grant it.

# singleFunctionEntries Const

• singleFunctionEntries: [string, readonly string[]][] = ALL_FUNCTIONS.map((name) => [ fun:${name.trim().toLowerCase()}, [name], ])

Defined in src/license/functionCapabilities.ts:127 (opens new window)

One table entry per canonical function name: the packaging doc's single-function tokens (fun:<CANONICAL_FUNCTION_NAME>), "for surgical grants: custom deals, previews, per-function exceptions". One exists for EVERY canonical name — 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 Const

▸ CellValueTypeOrd(arg: CellValueType): number

Defined in src/Cell.ts:97 (opens new window)

Parameters:

Name	Type
`arg`	CellValueType

Returns: number

# _cp Const

▸ _cp(v: any): number

Defined in src/helpers/licenseKeyHelper.ts:14 (opens new window)

Parameters:

Name	Type
`v`	any

Returns: number

# _hd Const

▸ _hd(v: any): number

Defined in src/helpers/licenseKeyHelper.ts:10 (opens new window)

Parameters:

Name	Type
`v`	any

Returns: number

# _nm Const

▸ _nm(v: any): string

Defined in src/helpers/licenseKeyHelper.ts:12 (opens new window)

Parameters:

Name	Type
`v`	any

Returns: string

# _pi Const

▸ _pi(v: any): number

Defined in src/helpers/licenseKeyHelper.ts:11 (opens new window)

Parameters:

Name	Type
`v`	any

Returns: number

# _ss Const

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

Defined in src/helpers/licenseKeyHelper.ts:13 (opens new window)

Parameters:

Name	Type
`v`	any
`s`	any
`l`	any

Returns: any

# absoluteSheetReference Const

▸ absoluteSheetReference(address: AddressWithSheet, baseAddress: SimpleCellAddress): number

Defined in src/Cell.ts:222 (opens new window)

Parameters:

Name	Type
`address`	AddressWithSheet
`baseAddress`	SimpleCellAddress

Returns: number

# absolutizeDependencies Const

▸ absolutizeDependencies(deps: RelativeDependency[], baseAddress: SimpleCellAddress): CellDependency[]

Defined in src/absolutizeDependencies.ts:17 (opens new window)

Converts dependencies from maybe relative addressing to absolute addressing.

Parameters:

Name	Type	Description
`deps`	RelativeDependency[]	list of addresses in R0C0 format
`baseAddress`	SimpleCellAddress	base address with regard to which make a convertion

Returns: CellDependency[]

# addressKey Const

▸ addressKey(address: SimpleCellAddress): string

Defined in src/Cell.ts:209 (opens new window)

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: string

# allowsFeature

▸ allowsFeature(resolved: ResolvedCapabilities, feature: FeatureId): boolean

Defined in src/license/CapabilityRegistry.ts:135 (opens new window)

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

Parameters:

Name	Type
`resolved`	ResolvedCapabilities
`feature`	FeatureId

Returns: boolean

# allowsFunction

▸ allowsFunction(resolved: ResolvedCapabilities, functionId: string): boolean

Defined in src/license/CapabilityRegistry.ts:128 (opens new window)

Whether a resolved entitlement allows calling the given function.

Parameters:

Name	Type
`resolved`	ResolvedCapabilities
`functionId`	string

Returns: boolean

# arraySizeForBinaryOp

▸ arraySizeForBinaryOp(leftArraySize: ArraySize, rightArraySize: ArraySize): ArraySize

Defined in src/ArraySize.ts:34 (opens new window)

Parameters:

Name	Type
`leftArraySize`	ArraySize
`rightArraySize`	ArraySize

Returns: ArraySize

# arraySizeForUnaryOp

▸ arraySizeForUnaryOp(arraySize: ArraySize): ArraySize

Defined in src/ArraySize.ts:38 (opens new window)

Parameters:

Name	Type
`arraySize`	ArraySize

Returns: ArraySize

# base64ToBytes

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

Defined in src/license/handsontable-license-key-parser/encoding.ts:129 (opens new window)

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 (opens new window)

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, statistics: Statistics): ColumnSearchStrategy

Defined in src/Lookup/SearchStrategy.ts:63 (opens new window)

Parameters:

Name	Type
`dependencyGraph`	DependencyGraph
`config`	Config
`statistics`	Statistics

Returns: ColumnSearchStrategy

# bytesToBase64

▸ bytesToBase64(bytes: number[]): string

Defined in src/license/handsontable-license-key-parser/encoding.ts:104 (opens new window)

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 (opens new window)

Parameters:

Name	Type
`v`	any

Returns: boolean

# checkLicenseKeyValidity

▸ checkLicenseKeyValidity(licenseKey: string): LicenseKeyValidityState

Defined in src/helpers/licenseKeyValidator.ts:173 (opens new window)

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

Returns the checking state.

# classifyEntitlement

▸ classifyEntitlement(entitlement: ProductEntitlement, time: LicenseTimeReference): LicenseLifecycle

Defined in src/license/handsontable-license-key-parser/classify.ts:99 (opens new window)

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	The verified product entry.
`time`	LicenseTimeReference	The time references to measure against.

Returns: LicenseLifecycle

# collatorFromConfig

▸ collatorFromConfig(config: Config): Collator

Defined in src/StringHelper.ts:8 (opens new window)

Parameters:

Name	Type
`config`	Config

Returns: Collator

# configCheckIfParametersNotInConflict

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

Defined in src/ArgumentSanitization.ts:57 (opens new window)

Parameters:

Name	Type
`...params`	object[]

Returns: void

# configValueFromParam

▸ configValueFromParam(inputValue: any, expectedType: string | string[], paramName: ConfigParamsList): any

Defined in src/ArgumentSanitization.ts:16 (opens new window)

Parameters:

Name	Type
`inputValue`	any
`expectedType`	string \| string[]
`paramName`	ConfigParamsList

Returns: any

# configValueFromParamCheck

▸ configValueFromParamCheck(inputValue: any, typeCheck: function, expectedType: string, paramName: ConfigParamsList): any

Defined in src/ArgumentSanitization.ts:47 (opens new window)

Parameters:

▪ inputValue: any

▪ typeCheck: function

▸ (object: any): boolean

Parameters:

Name	Type
`object`	any

▪ expectedType: string

▪ paramName: ConfigParamsList

Returns: any

# countChars

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

Defined in src/format/format.ts:74 (opens new window)

Parameters:

Name	Type
`text`	string
`char`	string

Returns: number

# createTokens

▸ createTokens(regexTokens: RegExpExecArray[], str: string): FormatToken[]

Defined in src/format/parser.ts:66 (opens new window)

Parameters:

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

Returns: FormatToken[]

# dayToMonth

▸ dayToMonth(dayOfYear: number): number

Defined in src/DateTimeHelper.ts:270 (opens new window)

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 (opens new window)

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 (opens new window)

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‹string›): Maybe‹SimpleDate›

Defined in src/DateTimeDefault.ts:137 (opens new window)

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

Parameters:

Name	Type
`dateItems`	string[]
`dateFormat`	Maybe‹string›

Returns: Maybe‹SimpleDate›

# defaultParseToDateTime

▸ defaultParseToDateTime(text: string, dateFormat: Maybe‹string›, timeFormat: Maybe‹string›): Maybe‹DateTime›

Defined in src/DateTimeDefault.ts:30 (opens new window)

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‹string›
`timeFormat`	Maybe‹string›

Returns: Maybe‹DateTime›

# defaultParseToTime

▸ defaultParseToTime(timeItems: string[], timeFormat: Maybe‹string›): Maybe‹SimpleTime›

Defined in src/DateTimeDefault.ts:82 (opens new window)

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

Parameters:

Name	Type
`timeItems`	string[]
`timeFormat`	Maybe‹string›

Returns: Maybe‹SimpleTime›

# defaultStringifyCurrency

▸ defaultStringifyCurrency(_value: number, _formatArg: string): Maybe‹string›

Defined in src/format/format.ts:328 (opens new window)

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 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‹string›

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

# defaultStringifyDateTime

▸ defaultStringifyDateTime(dateTime: SimpleDateTime, formatArg: string): Maybe‹string›

Defined in src/format/format.ts:224 (opens new window)

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	parsed date/time value to render
`formatArg`	string	Excel-style format string

Returns: Maybe‹string›

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

# defaultStringifyDuration

▸ defaultStringifyDuration(time: SimpleTime, formatArg: string): Maybe‹string›

Defined in src/format/format.ts:132 (opens new window)

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	parsed duration value to render
`formatArg`	string	Excel-style format string

Returns: 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 (opens new window)

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

Defined in src/license/handsontable-license-key-parser/detectFormat.ts:35 (opens new window)

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

# doesContainRelativeReferences Const

▸ doesContainRelativeReferences(ast: Ast): boolean

Defined in src/NamedExpressions.ts:299 (opens new window)

Parameters:

Name	Type
`ast`	Ast

Returns: boolean

# doesItLookLikeADateTimeQuickCheck

▸ doesItLookLikeADateTimeQuickCheck(text: string): boolean

Defined in src/DateTimeDefault.ts:222 (opens new window)

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 (opens new window)

Type parameters:

▪ T

Returns: IterableIterator‹T›

# entitlementOf

▸ entitlementOf(entry: ProductEntitlement, isTrial: boolean, silent: boolean): LicenseEntitlement

Defined in src/license/licenseResolution.ts:104 (opens new window)

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	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

# equalSimpleCellAddress Const

▸ equalSimpleCellAddress(left: SimpleCellAddress, right: SimpleCellAddress): boolean

Defined in src/Cell.ts:226 (opens new window)

Parameters:

Name	Type
`left`	SimpleCellAddress
`right`	SimpleCellAddress

Returns: boolean

# expiryOf

▸ expiryOf(entry: ProductEntitlement): LicenseExpiry

Defined in src/license/licenseResolution.ts:67 (opens new window)

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	HyperFormula's entry of an intact key

Returns: LicenseExpiry

# extractEntitlementKeyData

▸ extractEntitlementKeyData(licenseKey: string): EntitlementKeyData | null

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:281 (opens new window)

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 | null

# extractTime

▸ extractTime(v: any): number

Defined in src/helpers/licenseKeyHelper.ts:16 (opens new window)

Parameters:

Name	Type
`v`	any

Returns: number

# filterDependenciesOutOfScope Const

▸ filterDependenciesOutOfScope(deps: CellDependency[]): CellDependency[]

Defined in src/absolutizeDependencies.ts:21 (opens new window)

Parameters:

Name	Type
`deps`	CellDependency[]

Returns: CellDependency[]

# findBoundaries

▸ findBoundaries(sheet: Sheet): SheetBoundaries

Defined in src/Sheet.ts:49 (opens new window)

Returns actual width, height and fill ratio of a sheet

Parameters:

Name	Type	Description
`sheet`	Sheet	two-dimmensional array sheet representation

Returns: SheetBoundaries

# findInOrderedArray

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

Defined in src/Lookup/ColumnIndex.ts:339 (opens new window)

Parameters:

Name	Type	Default
`key`	number	-
`values`	number[]	-
`handlingMisses`	"lowerBound" \| "upperBound"	"upperBound"

Returns: number

# first

▸ first‹T›(iterable: IterableIterator‹T›): Maybe‹T›

Defined in src/generatorUtils.ts:22 (opens new window)

Type parameters:

▪ T

Parameters:

Name	Type
`iterable`	IterableIterator‹T›

Returns: Maybe‹T›

# firstUncoveredDay

▸ firstUncoveredDay(expiry: LicenseExpiry): Date

Defined in src/license/licenseResolution.ts:84 (opens new window)

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	the expiry of the key

Returns: Date

# format

▸ format(value: number, formatArg: string, config: Config, dateHelper: DateTimeHelper): RawScalarValue

Defined in src/format/format.ts:28 (opens new window)

Parameters:

Name	Type
`value`	number
`formatArg`	string
`config`	Config
`dateHelper`	DateTimeHelper

Returns: RawScalarValue

# formatDate

▸ formatDate(date: Date): string

Defined in src/helpers/licenseKeyValidator.ts:214 (opens new window)

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, value: string): FormatToken

Defined in src/format/parser.ts:21 (opens new window)

Parameters:

Name	Type
`type`	TokenType
`value`	string

Returns: FormatToken

# getCellType Const

▸ getCellType(vertex: Maybe‹CellVertex›, address: SimpleCellAddress): CellType

Defined in src/Cell.ts:61 (opens new window)

Parameters:

Name	Type
`vertex`	Maybe‹CellVertex›
`address`	SimpleCellAddress

Returns: CellType

# getCellValueDetailedType Const

▸ getCellValueDetailedType(cellValue: InterpreterValue): CellValueDetailedType

Defined in src/Cell.ts:133 (opens new window)

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueDetailedType

# getCellValueFormat Const

▸ getCellValueFormat(cellValue: InterpreterValue): string | undefined

Defined in src/Cell.ts:141 (opens new window)

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: string | undefined

# getCellValueType Const

▸ getCellValueType(cellValue: InterpreterValue): CellValueType

Defined in src/Cell.ts:113 (opens new window)

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueType

# getDefaultConfig

▸ getDefaultConfig(): ConfigParams

Defined in src/Config.ts:395 (opens new window)

Returns: ConfigParams

# getFullConfigFromPartial

▸ getFullConfigFromPartial(partialConfig: Partial‹ConfigParams›): ConfigParams

Defined in src/Config.ts:381 (opens new window)

Parameters:

Name	Type
`partialConfig`	Partial‹ConfigParams›

Returns: ConfigParams

# getLicenseGrants

▸ getLicenseGrants(keyData: EntitlementKeyData): LicenseGrants

Defined in src/license/handsontable-license-key-parser/grants.ts:28 (opens new window)

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	The verified key data.

Returns: LicenseGrants

# getProductCapabilities

▸ getProductCapabilities(grants: LicenseGrants, productName: string): string[] | null

Defined in src/license/handsontable-license-key-parser/grants.ts:73 (opens new window)

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	The resolved grants.
`productName`	string	The product to read.

Returns: string[] | null

# getProductEntitlement

▸ getProductEntitlement(keyData: EntitlementKeyData, productName: string): ProductEntitlement | null

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:321 (opens new window)

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	The verified key data.
`productName`	string	The product to read.

Returns: ProductEntitlement | null

# hasCapability

▸ hasCapability(grants: LicenseGrants, productName: string, capability: string): boolean

Defined in src/license/handsontable-license-key-parser/grants.ts:94 (opens new window)

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	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 (opens new window)

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, productName: string): boolean

Defined in src/license/handsontable-license-key-parser/grants.ts:59 (opens new window)

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	The resolved grants.
`productName`	string	The product to check.

Returns: boolean

# instanceOfSimpleDate

▸ instanceOfSimpleDate(obj: any): obj is SimpleDate

Defined in src/DateTimeHelper.ts:34 (opens new window)

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleDate

# instanceOfSimpleTime

▸ instanceOfSimpleTime(obj: any): obj is SimpleTime

Defined in src/DateTimeHelper.ts:43 (opens new window)

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleTime

# invalidSimpleColumnAddress Const

▸ invalidSimpleColumnAddress(address: SimpleColumnAddress): boolean

Defined in src/Cell.ts:190 (opens new window)

Parameters:

Name	Type
`address`	SimpleColumnAddress

Returns: boolean

# invalidSimpleRowAddress Const

▸ invalidSimpleRowAddress(address: SimpleRowAddress): boolean

Defined in src/Cell.ts:181 (opens new window)

Parameters:

Name	Type
`address`	SimpleRowAddress

Returns: boolean

# isBoolean

▸ isBoolean(text: string): boolean

Defined in src/CellContentParser.ts:81 (opens new window)

Parameters:

Name	Type
`text`	string

Returns: boolean

# isColOrRowInvalid Const

▸ isColOrRowInvalid(address: SimpleCellAddress): boolean

Defined in src/Cell.ts:203 (opens new window)

Checks if the column or row id is negative.

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: boolean

# isEntitlementKey

▸ isEntitlementKey(licenseKey: unknown): boolean

Defined in src/license/handsontable-license-key-parser/detectFormat.ts:75 (opens new window)

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›): boolean

Defined in src/CellContentParser.ts:86 (opens new window)

Parameters:

Name	Type
`text`	string
`errorMapping`	Record‹string, ErrorType›

Returns: boolean

# isEscapeToken

▸ isEscapeToken(token: RegExpExecArray): boolean

Defined in src/format/parser.ts:131 (opens new window)

Parameters:

Name	Type
`token`	RegExpExecArray

Returns: boolean

# isFormula

▸ isFormula(text: string): boolean

Defined in src/CellContentParser.ts:77 (opens new window)

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 (opens new window)

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 (opens new window)

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 (opens new window)

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 (opens new window)

Parameters:

Name	Type
`x`	number

Returns: boolean

# isRowOrColumnRange

▸ isRowOrColumnRange(leftCorner: SimpleCellAddress, width: number, height: number): boolean

Defined in src/Operations.ts:1100 (opens new window)

Parameters:

Name	Type
`leftCorner`	SimpleCellAddress
`width`	number
`height`	number

Returns: boolean

# isSimpleCellAddress

▸ isSimpleCellAddress(obj: unknown): obj is SimpleCellAddress

Defined in src/Cell.ts:214 (opens new window)

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 (opens new window)

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 (opens new window)

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, resolved: ResolvedCapabilities, canonicalFunctionId: string): boolean

Defined in src/license/CapabilityRegistry.ts:161 (opens new window)

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 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. 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	the registry the capabilities were resolved against
`resolved`	ResolvedCapabilities	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 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

# matchNumberFormat

▸ matchNumberFormat(str: string): RegExpExecArray[]

Defined in src/format/parser.ts:55 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

# memoize

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

Defined in src/DateTimeDefault.ts:229 (opens new window)

Function memoization for improved performance.

Type parameters:

▪ T

Parameters:

▪ fn: function

▸ (arg: string): T

Parameters:

Name	Type
`arg`	string

Returns: (Anonymous function)

# movedSimpleCellAddress Const

▸ movedSimpleCellAddress(address: SimpleCellAddress, toSheet: number, toRight: number, toBottom: number): SimpleCellAddress

Defined in src/Cell.ts:205 (opens new window)

Parameters:

Name	Type
`address`	SimpleCellAddress
`toSheet`	number
`toRight`	number
`toBottom`	number

Returns: SimpleCellAddress

# normalizeAddedIndexes

▸ normalizeAddedIndexes(indexes: ColumnRowIndex[]): ColumnRowIndex[]

Defined in src/Operations.ts:1068 (opens new window)

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

# normalizeCapabilityToken

▸ normalizeCapabilityToken(token: string): string

Defined in src/license/capabilities.ts:80 (opens new window)

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 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 | null

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:126 (opens new window)

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 | null

# normalizeRemovedIndexes

▸ normalizeRemovedIndexes(indexes: ColumnRowIndex[]): ColumnRowIndex[]

Defined in src/Operations.ts:1037 (opens new window)

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

# noticeIdentityOf

▸ noticeIdentityOf(licenseKey: string): string

Defined in src/helpers/licenseKeyValidator.ts:163 (opens new window)

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 (opens new window)

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 — 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, keyValidityDate?: Date, expiryAxis: LicenseExpiryAxis): void

Defined in src/helpers/licenseKeyValidator.ts:103 (opens new window)

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	-	the state to report; `VALID` prints nothing
`keyValidityDate?`	Date	-	-
`expiryAxis`	LicenseExpiryAxis	"release"	-

Returns: void

# numberFormat

▸ numberFormat(tokens: FormatToken[], value: number): RawScalarValue

Defined in src/format/format.ts:78 (opens new window)

Parameters:

Name	Type
`tokens`	FormatToken[]
`value`	number

Returns: RawScalarValue

# numberToSimpleTime

▸ numberToSimpleTime(arg: number): SimpleTime

Defined in src/DateTimeHelper.ts:304 (opens new window)

Parameters:

Name	Type
`arg`	number

Returns: SimpleTime

# objectDestroy

▸ objectDestroy(object: any): void

Defined in src/Destroy.ts:6 (opens new window)

Parameters:

Name	Type
`object`	any

Returns: void

# offsetMonth

▸ offsetMonth(date: SimpleDate, offset: number): SimpleDate

Defined in src/DateTimeHelper.ts:286 (opens new window)

Parameters:

Name	Type
`date`	SimpleDate
`offset`	number

Returns: SimpleDate

# padLeft

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

Defined in src/format/format.ts:58 (opens new window)

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 (opens new window)

Parameters:

Name	Type
`number`	number \| string
`size`	number

Returns: string

# parse

▸ parse(str: string): FormatExpression

Defined in src/format/parser.ts:121 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: FormatExpression

# parseDateFormat

▸ parseDateFormat(dateFormat: string): object

Defined in src/DateTimeDefault.ts:206 (opens new window)

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‹FormatExpression›

Defined in src/format/parser.ts:96 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

# parseForNumberFormat

▸ parseForNumberFormat(str: string): Maybe‹FormatExpression›

Defined in src/format/parser.ts:109 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

# parseIsoDateToTimestamp

▸ parseIsoDateToTimestamp(isoDate: unknown): number | null

Defined in src/license/handsontable-license-key-parser/encoding.ts:197 (opens new window)

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 (opens new window)

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 (opens new window)

Parameters:

Name	Type
`method`	any

Returns: (Anonymous function)

# readEntitlementKeyData

▸ readEntitlementKeyData(licenseKey: string): EntitlementKeyData | null

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:179 (opens new window)

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 | null

# readEntitlementLicense

▸ readEntitlementLicense(licenseKey: string, options: ReadEntitlementLicenseOptions): EntitlementLicense

Defined in src/license/handsontable-license-key-parser/readLicense.ts:72 (opens new window)

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	What the product tells the reader.

Returns: EntitlementLicense

# replacer

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

Defined in src/errors.ts:135 (opens new window)

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 (opens new window)

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): LicenseChannels

Defined in src/license/handsontable-license-key-parser/classify.ts:152 (opens new window)

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	The verified product entry.

Returns: LicenseChannels

# resolveLicense

▸ resolveLicense(licenseKey: string, notifyConsole: boolean): ResolvedLicense

Defined in src/license/licenseResolution.ts:165 (opens new window)

Resolves a license key into both gates' inputs.

Routing follows the vendored 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 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, 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. 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 behind a once-per-page-load flag, so they cannot double-print regardless of this parameter.

Returns: ResolvedLicense

# resolveUsageWindow

▸ resolveUsageWindow(expiryTimestamp: number, entitlement: ProductEntitlement, now: number): UsageWindow

Defined in src/license/handsontable-license-key-parser/classify.ts:63 (opens new window)

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	The product entry the windows come from.
`now`	number	The current instant, in epoch milliseconds.

Returns: UsageWindow

# roundToEpsilon

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

Defined in src/DateTimeHelper.ts:299 (opens new window)

Parameters:

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

Returns: number

# roundToNearestSecond

▸ roundToNearestSecond(arg: number): number

Defined in src/DateTimeHelper.ts:295 (opens new window)

Parameters:

Name	Type
`arg`	number

Returns: number

# sha512

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

Defined in src/license/handsontable-license-key-parser/sha512.ts:72 (opens new window)

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 Const

▸ simpleCellAddress(sheet: number, col: number, row: number): SimpleCellAddress

Defined in src/Cell.ts:198 (opens new window)

Parameters:

Name	Type
`sheet`	number
`col`	number
`row`	number

Returns: SimpleCellAddress

# simpleCellRange Const

▸ simpleCellRange(start: SimpleCellAddress, end: SimpleCellAddress): object

Defined in src/AbsoluteCellRange.ts:43 (opens new window)

Parameters:

Name	Type
`start`	SimpleCellAddress
`end`	SimpleCellAddress

Returns: object

end: SimpleCellAddress
start: SimpleCellAddress

# simpleColumnAddress Const

▸ simpleColumnAddress(sheet: number, col: number): SimpleColumnAddress

Defined in src/Cell.ts:188 (opens new window)

Parameters:

Name	Type
`sheet`	number
`col`	number

Returns: SimpleColumnAddress

# simpleRowAddress Const

▸ simpleRowAddress(sheet: number, row: number): SimpleRowAddress

Defined in src/Cell.ts:179 (opens new window)

Parameters:

Name	Type
`sheet`	number
`row`	number

Returns: SimpleRowAddress

# split

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

Defined in src/generatorUtils.ts:11 (opens new window)

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 (opens new window)

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 (opens new window)

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): number

Defined in src/DateTimeHelper.ts:315 (opens new window)

Parameters:

Name	Type
`time`	SimpleTime

Returns: number

# toBasisEU

▸ toBasisEU(date: SimpleDate): SimpleDate

Defined in src/DateTimeHelper.ts:319 (opens new window)

Parameters:

Name	Type
`date`	SimpleDate

Returns: SimpleDate

# toHex32

▸ toHex32(value: number): string

Defined in src/license/handsontable-license-key-parser/sha512.ts:58 (opens new window)

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 (opens new window)

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): SimpleDate

Defined in src/DateTimeHelper.ts:291 (opens new window)

Parameters:

Name	Type
`date`	SimpleDate

Returns: SimpleDate

# unlicensed

▸ unlicensed(reason: UnlicensedReason): EntitlementLicense

Defined in src/license/handsontable-license-key-parser/readLicense.ts:26 (opens new window)

Builds the result for a key that does not license the product.

Parameters:

Name	Type	Description
`reason`	UnlicensedReason	Why the key does not license the product.

Returns: EntitlementLicense

# unrestrictedEntitlement

▸ unrestrictedEntitlement(): LicenseEntitlement

Defined in src/license/LicenseEntitlement.ts:87 (opens new window)

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

# utcMidnightOf

▸ utcMidnightOf(timestamp: number): number

Defined in src/license/handsontable-license-key-parser/classify.ts:32 (opens new window)

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 (opens new window)

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 (opens new window)

Parameters:

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

Returns: void

# validateAsSheet

▸ validateAsSheet(sheet: Sheet): void

Defined in src/Sheet.ts:33 (opens new window)

Parameters:

Name	Type
`sheet`	Sheet

Returns: void

# validateEntitlementKey

▸ validateEntitlementKey(licenseKey: string): boolean

Defined in src/license/handsontable-license-key-parser/extractKeyData.ts:308 (opens new window)

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: