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

Defined in hyperformula/src/license/functionCapabilities.ts:108

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.

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 hyperformula/src/license/capabilities.ts:55

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

DATE_SEPARATOR_REGEXP

Const

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

Defined in hyperformula/src/DateTimeDefault.ts:13

FEATURE_CAPABILITY_TABLE

Const

• FEATURE_CAPABILITY_TABLE: ReadonlyMap‹string, readonly FeatureId[]› = new Map([ …singleFeatureEntries, [‘feat:all’, ALL_FEATURES] as [string, readonly FeatureId[]], ])

Defined in hyperformula/src/license/featureCapabilities.ts:35

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 hyperformula/src/license/functionCapabilities.ts:136

The fun:* half of the vocabulary, keyed by NORMALIZED token spelling, as the packaging design defines it: 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 hyperformula/src/license/functionCapabilities.ts:24

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. 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 hyperformula/src/DateTimeHelper.ts:15

HYPERFORMULA_PRODUCT_NAME

Const

• HYPERFORMULA_PRODUCT_NAME: “hyperformula” = “hyperformula”

Defined in hyperformula/src/license/licenseResolution.ts:23

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.

LCID_CURRENCY_TAG

Const

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

Defined in hyperformula/src/format/format.ts:26

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.

MINUTES_PER_HOUR

Const

• MINUTES_PER_HOUR: 60 = 60

Defined in hyperformula/src/DateTimeHelper.ts:14

NOT_FOUND

Const

• NOT_FOUND: -1 = -1

Defined in hyperformula/src/Lookup/AdvancedFind.ts:19

PURCHASE_LICENSE_TEXT

Const

• PURCHASE_LICENSE_TEXT: “To continue using HyperFormula, you need to purchase a license.” = “To continue using HyperFormula, you need to purchase a license.”

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:66

QUICK_CHECK_REGEXP

Const

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

Defined in hyperformula/src/DateTimeDefault.ts:11

SECONDS_PER_MINUTE

Const

• SECONDS_PER_MINUTE: 60 = 60

Defined in hyperformula/src/DateTimeHelper.ts:13

SECONDS_PRECISION

Const

• SECONDS_PRECISION: 1000 = 1000

Defined in hyperformula/src/DateTimeDefault.ts:15

TIME_FORMAT_SECONDS_ITEM_REGEXP

Const

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

Defined in hyperformula/src/DateTimeDefault.ts:9

TIME_SEPARATOR

Const

• TIME_SEPARATOR: “:” = “:”

Defined in hyperformula/src/DateTimeDefault.ts:14

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’, ‘RANK.EQ’, ‘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 hyperformula/src/license/functionCapabilities.ts:77

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 license token and returning #LIC! for it, while custom functions must never be gated. A function this table does not list is not gated at all, which is exactly the treatment a custom function should get.

WHITESPACE_REGEXP

Const

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

Defined in hyperformula/src/DateTimeDefault.ts:12

WRONG_RANGE_SIZE

Const

• WRONG_RANGE_SIZE: “AbsoluteCellRange: Wrong range size” = “AbsoluteCellRange: Wrong range size”

Defined in hyperformula/src/AbsoluteCellRange.ts:22

_notified

Let

• _notified: boolean = false

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:44

_rl

Const

• _rl: “length” = “length”

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:9

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 hyperformula/src/format/parser.ts:8

defaultLanguage

Const

• defaultLanguage: string = Config.defaultConfig.language

Defined in hyperformula/src/index.ts:112

memoizedParseDateFormat

Const

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

Defined in hyperformula/src/DateTimeDefault.ts:17

memoizedParseTimeFormat

Const

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

Defined in hyperformula/src/DateTimeDefault.ts:16

numDays

Const

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

Defined in hyperformula/src/DateTimeHelper.ts:10

numberFormatRegex

Const

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

Defined in hyperformula/src/format/parser.ts:9

prefSumDays

Const

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

Defined in hyperformula/src/DateTimeHelper.ts:11

privatePool

Const

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

Defined in hyperformula/src/Config.ts:40

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 hyperformula/src/license/featureCapabilities.ts:12

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.

singleFunctionEntries

Const

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

Defined in hyperformula/src/license/functionCapabilities.ts:120

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 hyperformula/src/Cell.ts:97

Parameters:

Name	Type
`arg`	CellValueType

Returns: number

_cp

Const

▸ _cp(v: any): number

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:14

Parameters:

Name	Type
`v`	any

Returns: number

_hd

Const

▸ _hd(v: any): number

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:10

Parameters:

Name	Type
`v`	any

Returns: number

_nm

Const

▸ _nm(v: any): string

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:12

Parameters:

Name	Type
`v`	any

Returns: string

_pi

Const

▸ _pi(v: any): number

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:11

Parameters:

Name	Type
`v`	any

Returns: number

_ss

Const

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

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:13

Parameters:

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

Returns: any

absoluteSheetReference

Const

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

Defined in hyperformula/src/Cell.ts:222

Parameters:

Name	Type
`address`	AddressWithSheet
`baseAddress`	SimpleCellAddress

Returns: number

absolutizeDependencies

Const

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

Defined in hyperformula/src/absolutizeDependencies.ts:17

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 hyperformula/src/Cell.ts:209

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: string

allowsFeature

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

Defined in hyperformula/src/license/CapabilityRegistry.ts:135

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 hyperformula/src/license/CapabilityRegistry.ts:128

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 hyperformula/src/ArraySize.ts:35

Parameters:

Name	Type
`leftArraySize`	ArraySize
`rightArraySize`	ArraySize

Returns: ArraySize

arraySizeForUnaryOp

▸ arraySizeForUnaryOp(arraySize: ArraySize): ArraySize

Defined in hyperformula/src/ArraySize.ts:39

Parameters:

Name	Type
`arraySize`	ArraySize

Returns: ArraySize

buildColumnSearchStrategy

▸ buildColumnSearchStrategy(dependencyGraph: DependencyGraph, config: Config, statistics: Statistics): ColumnSearchStrategy

Defined in hyperformula/src/Lookup/SearchStrategy.ts:63

Parameters:

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

Returns: ColumnSearchStrategy

checkKeySchema

▸ checkKeySchema(v: any): boolean

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:20

Parameters:

Name	Type
`v`	any

Returns: boolean

checkLicenseKeyValidity

▸ checkLicenseKeyValidity(licenseKey: string): LicenseKeyValidityState

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:225

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.

collatorFromConfig

▸ collatorFromConfig(config: Config): Collator

Defined in hyperformula/src/StringHelper.ts:8

Parameters:

Name	Type
`config`	Config

Returns: Collator

configCheckIfParametersNotInConflict

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

Defined in hyperformula/src/ArgumentSanitization.ts:57

Parameters:

Name	Type
`...params`	object[]

Returns: void

configValueFromParam

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

Defined in hyperformula/src/ArgumentSanitization.ts:16

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 hyperformula/src/ArgumentSanitization.ts:47

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 hyperformula/src/format/format.ts:74

Parameters:

Name	Type
`text`	string
`char`	string

Returns: number

createTokens

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

Defined in hyperformula/src/format/parser.ts:66

Parameters:

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

Returns: FormatToken[]

dayToMonth

▸ dayToMonth(dayOfYear: number): number

Defined in hyperformula/src/DateTimeHelper.ts:278

Parameters:

Name	Type
`dayOfYear`	number

Returns: number

defaultParseToDate

▸ defaultParseToDate(dateItems: string[], dateFormat: Maybe‹string›): Maybe‹SimpleDate›

Defined in hyperformula/src/DateTimeDefault.ts:137

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 hyperformula/src/DateTimeDefault.ts:30

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 hyperformula/src/DateTimeDefault.ts:82

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 hyperformula/src/format/format.ts:328

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 hyperformula/src/format/format.ts:224

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 hyperformula/src/format/format.ts:132

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

doesContainRelativeReferences

Const

▸ doesContainRelativeReferences(ast: Ast): boolean

Defined in hyperformula/src/NamedExpressions.ts:299

Parameters:

Name	Type
`ast`	Ast

Returns: boolean

doesItLookLikeADateTimeQuickCheck

▸ doesItLookLikeADateTimeQuickCheck(text: string): boolean

Defined in hyperformula/src/DateTimeDefault.ts:222

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 hyperformula/src/generatorUtils.ts:8

Type parameters:

▪ T

Returns: IterableIterator‹T›

ensureFeatureAllowed

▸ ensureFeatureAllowed(config: Config, feature: FeatureId): void

Defined in hyperformula/src/license/ensureFeatureAllowed.ts:39

Throws LicenseCapabilityMissingError unless isFeatureAllowed. When the key itself blocks evaluation, the error names the key’s state.

Shared by the build-time named-expressions check and HyperFormula.ensureCapability, so the two cannot disagree about the same key.

Parameters:

Name	Type	Description
`config`	Config	the config whose resolved license is checked
`feature`	FeatureId	the gated feature being called

Returns: void

entitlementOf

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

Defined in hyperformula/src/license/licenseResolution.ts:113

Turns HyperFormula’s entry of a valid entitlement key into the entitlement it grants.

This is fail-closed and silent: a token this version does not recognize 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 would suppress expiry notices as a side effect of a vocabulary mismatch.

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 hyperformula/src/Cell.ts:226

Parameters:

Name	Type
`left`	SimpleCellAddress
`right`	SimpleCellAddress

Returns: boolean

expiryClause

▸ expiryClause(days: number): string

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:83

The countdown of a trial notice: expires today, expires in 1 day or expires in N days.

Parameters:

Name	Type	Description
`days`	number	the whole UTC days left until the last licensed day

Returns: string

expiryOf

▸ expiryOf(entry: ProductEntitlement): LicenseExpiry

Defined in hyperformula/src/license/licenseResolution.ts:89

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

extractTime

▸ extractTime(v: any): number

Defined in hyperformula/src/helpers/licenseKeyHelper.ts:16

Parameters:

Name	Type
`v`	any

Returns: number

filterDependenciesOutOfScope

Const

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

Defined in hyperformula/src/absolutizeDependencies.ts:21

Parameters:

Name	Type
`deps`	CellDependency[]

Returns: CellDependency[]

findBoundaries

▸ findBoundaries(sheet: Sheet): SheetBoundaries

Defined in hyperformula/src/Sheet.ts:49

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 hyperformula/src/Lookup/ColumnIndex.ts:339

Parameters:

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

Returns: number

first

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

Defined in hyperformula/src/generatorUtils.ts:22

Type parameters:

▪ T

Parameters:

Name	Type
`iterable`	IterableIterator‹T›

Returns: Maybe‹T›

format

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

Defined in hyperformula/src/format/format.ts:28

Parameters:

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

Returns: RawScalarValue

formatDate

▸ formatDate(date: Date): string

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:267

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 hyperformula/src/format/parser.ts:21

Parameters:

Name	Type
`type`	TokenType
`value`	string

Returns: FormatToken

getCellType

Const

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

Defined in hyperformula/src/Cell.ts:61

Parameters:

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

Returns: CellType

getCellValueDetailedType

Const

▸ getCellValueDetailedType(cellValue: InterpreterValue): CellValueDetailedType

Defined in hyperformula/src/Cell.ts:133

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueDetailedType

getCellValueFormat

Const

▸ getCellValueFormat(cellValue: InterpreterValue): string | undefined

Defined in hyperformula/src/Cell.ts:141

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: string | undefined

getCellValueType

Const

▸ getCellValueType(cellValue: InterpreterValue): CellValueType

Defined in hyperformula/src/Cell.ts:113

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueType

getDefaultConfig

▸ getDefaultConfig(): ConfigParams

Defined in hyperformula/src/Config.ts:407

Returns: ConfigParams

getFullConfigFromPartial

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

Defined in hyperformula/src/Config.ts:393

Parameters:

Name	Type
`partialConfig`	Partial‹ConfigParams›

Returns: ConfigParams

instanceOfSimpleDate

▸ instanceOfSimpleDate(obj: any): obj is SimpleDate

Defined in hyperformula/src/DateTimeHelper.ts:34

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleDate

instanceOfSimpleTime

▸ instanceOfSimpleTime(obj: any): obj is SimpleTime

Defined in hyperformula/src/DateTimeHelper.ts:43

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleTime

invalidSimpleColumnAddress

Const

▸ invalidSimpleColumnAddress(address: SimpleColumnAddress): boolean

Defined in hyperformula/src/Cell.ts:190

Parameters:

Name	Type
`address`	SimpleColumnAddress

Returns: boolean

invalidSimpleRowAddress

Const

▸ invalidSimpleRowAddress(address: SimpleRowAddress): boolean

Defined in hyperformula/src/Cell.ts:181

Parameters:

Name	Type
`address`	SimpleRowAddress

Returns: boolean

isBoolean

▸ isBoolean(text: string): boolean

Defined in hyperformula/src/CellContentParser.ts:81

Parameters:

Name	Type
`text`	string

Returns: boolean

isColOrRowInvalid

Const

▸ isColOrRowInvalid(address: SimpleCellAddress): boolean

Defined in hyperformula/src/Cell.ts:203

Checks if the column or row id is negative.

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: boolean

isError

▸ isError(text: string, errorMapping: Record‹string, ErrorType›): boolean

Defined in hyperformula/src/CellContentParser.ts:86

Parameters:

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

Returns: boolean

isEscapeToken

▸ isEscapeToken(token: RegExpExecArray): boolean

Defined in hyperformula/src/format/parser.ts:131

Parameters:

Name	Type
`token`	RegExpExecArray

Returns: boolean

isFeatureAllowed

▸ isFeatureAllowed(config: Config, feature: FeatureId): boolean

Defined in hyperformula/src/license/ensureFeatureAllowed.ts:25

Whether the license lets the caller use feature. Checks both gates, in the same order the interpreter does for functions:

gate A first: a key whose state blocks evaluation (a missing or invalid key, an expired classic key, or a trial past its grace period) blocks every gated feature, whatever the entitlement says;
then gate B: a key that evaluates must grant feature.

The one rule behind ensureFeatureAllowed, the isItPossibleTo* predicates and isThereSomethingToUndo/isThereSomethingToRedo, so a predicate never answers true for a call that then throws a license error.

Parameters:

Name	Type	Description
`config`	Config	the config whose resolved license is checked
`feature`	FeatureId	the gated feature being asked about

Returns: boolean

isFormula

▸ isFormula(text: string): boolean

Defined in hyperformula/src/CellContentParser.ts:77

Checks whether string looks like formula or not.

Parameters:

Name	Type	Description
`text`	string	formula

Returns: boolean

isNonnegativeInteger

▸ isNonnegativeInteger(x: number): boolean

Defined in hyperformula/src/CrudOperations.ts:657

Parameters:

Name	Type
`x`	number

Returns: boolean

isPositiveInteger

▸ isPositiveInteger(x: number): boolean

Defined in hyperformula/src/CrudOperations.ts:653

Parameters:

Name	Type
`x`	number

Returns: boolean

isRowOrColumnRange

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

Defined in hyperformula/src/Operations.ts:1107

Parameters:

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

Returns: boolean

isSimpleCellAddress

▸ isSimpleCellAddress(obj: unknown): obj is SimpleCellAddress

Defined in hyperformula/src/Cell.ts:214

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 hyperformula/src/AbsoluteCellRange.ts:34

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

licenseAllowsFunction

▸ licenseAllowsFunction(registry: CapabilityRegistry, resolved: ResolvedCapabilities, canonicalFunctionId: string): boolean

Defined in hyperformula/src/license/CapabilityRegistry.ts:160

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, because custom functions are never gated. 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!.

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 hyperformula/src/format/parser.ts:39

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

matchNumberFormat

▸ matchNumberFormat(str: string): RegExpExecArray[]

Defined in hyperformula/src/format/parser.ts:55

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

memoize

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

Defined in hyperformula/src/DateTimeDefault.ts:229

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 hyperformula/src/Cell.ts:205

Parameters:

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

Returns: SimpleCellAddress

normalizeAddedIndexes

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

Defined in hyperformula/src/Operations.ts:1075

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

normalizeCapabilityToken

▸ normalizeCapabilityToken(token: string): string

Defined in hyperformula/src/license/capabilities.ts:80

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

normalizeRemovedIndexes

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

Defined in hyperformula/src/Operations.ts:1044

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

notifyEntitlementKey

▸ notifyEntitlementKey(state: LicenseState, params: EntitlementMessageParams): void

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:185

Prints the console message for an entitlement key’s lifecycle state, every time a key is resolved: unlike classic keys, entitlement keys keep no record of what they already printed. States inside the term print nothing.

Parameters:

Name	Type	Description
`state`	LicenseState	the reader’s lifecycle state
`params`	EntitlementMessageParams	the key’s own date and days remaining

Returns: void

notifyLicenseKeyState

▸ notifyLicenseKeyState(state: LicenseKeyValidityState, keyValidityDate?: Date): void

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:166

Prints the console message for a classic 25-character key’s non-valid state, at most once per page load. Entitlement keys do not go through this function.

Parameters:

Name	Type	Description
`state`	LicenseKeyValidityState	the state to report; `VALID` prints nothing
`keyValidityDate?`	Date	-

Returns: void

notifyUnlicensedEntitlementKey

▸ notifyUnlicensedEntitlementKey(reason: UnlicensedReason): void

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:199

Prints the console message for an entitlement key that does not license HyperFormula, every time such a key is resolved.

Parameters:

Name	Type	Description
`reason`	UnlicensedReason	why the reader does not license HyperFormula with the key

Returns: void

numberFormat

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

Defined in hyperformula/src/format/format.ts:78

Parameters:

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

Returns: RawScalarValue

numberToSimpleTime

▸ numberToSimpleTime(arg: number): SimpleTime

Defined in hyperformula/src/DateTimeHelper.ts:308

Parameters:

Name	Type
`arg`	number

Returns: SimpleTime

objectDestroy

▸ objectDestroy(object: any): void

Defined in hyperformula/src/Destroy.ts:6

Parameters:

Name	Type
`object`	any

Returns: void

offsetMonth

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

Defined in hyperformula/src/DateTimeHelper.ts:294

Parameters:

Name	Type
`date`	SimpleDate
`offset`	number

Returns: SimpleDate

padLeft

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

Defined in hyperformula/src/format/format.ts:58

Parameters:

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

Returns: string

padRight

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

Defined in hyperformula/src/format/format.ts:66

Parameters:

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

Returns: string

parse

▸ parse(str: string): FormatExpression

Defined in hyperformula/src/format/parser.ts:121

Parameters:

Name	Type
`str`	string

Returns: FormatExpression

parseDateFormat

▸ parseDateFormat(dateFormat: string): object

Defined in hyperformula/src/DateTimeDefault.ts:206

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 hyperformula/src/format/parser.ts:96

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

parseForNumberFormat

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

Defined in hyperformula/src/format/parser.ts:109

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

parseTimeFormat

▸ parseTimeFormat(timeFormat: string): object

Defined in hyperformula/src/DateTimeDefault.ts:186

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 hyperformula/src/Destroy.ts:16

Parameters:

Name	Type
`method`	any

Returns: (Anonymous function)

printNotification

▸ printNotification(severity: “warn” | “error”, text: string): void

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:211

Prints text on the console channel that matches severity.

Parameters:

Name	Type	Description
`severity`	“warn” \| “error”	`warn` while the license still works, `error` once it does not
`text`	string	the message

Returns: void

replacer

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

Defined in hyperformula/src/errors.ts:136

Parameters:

Name	Type
`key`	string
`val`	any

Returns: any

resolveLicense

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

Defined in hyperformula/src/license/licenseResolution.ts:165

Resolves a license key into both gates’ inputs.

Routing follows the vendored {@link detectLicenseKeyFormat}, whose test order is normative: 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 behavior. 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 {@link readEntitlementLicense}, the single entry point upstream prescribes for products: it verifies the key (the checksum and the prose digest), 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 an entitlement key that lets this build evaluate — a valid one, or an expired one whose LIFECYCLE_VERDICTS entry does not block — resolves to a restricted entitlement, and an expired one keeps exactly the grants it had while current. Every key that blocks evaluation (a missing or invalid key, an expired classic key, or a trial past its grace period) resolves to unrestrictedEntitlement, and so does every classic key. A key that blocks is stopped by gate A alone, through blocksEvaluation: formulas yield #LIC! and every gated API feature throws with the key’s state (see ensureFeatureAllowed). Gate B never reports such a key, so its “not included in your license” error is reserved for a key that evaluates but lacks the grant. The fail-closed rule governs unrecognized tokens INSIDE an otherwise valid key; it is not a rule about invalid keys.

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

roundToEpsilon

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

Defined in hyperformula/src/DateTimeHelper.ts:303

Parameters:

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

Returns: number

roundToNearestSecond

▸ roundToNearestSecond(arg: number): number

Defined in hyperformula/src/DateTimeHelper.ts:299

Parameters:

Name	Type
`arg`	number

Returns: number

simpleCellAddress

Const

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

Defined in hyperformula/src/Cell.ts:198

Parameters:

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

Returns: SimpleCellAddress

simpleCellRange

Const

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

Defined in hyperformula/src/AbsoluteCellRange.ts:43

Parameters:

Name	Type
`start`	SimpleCellAddress
`end`	SimpleCellAddress

Returns: object

end: SimpleCellAddress
start: SimpleCellAddress

simpleColumnAddress

Const

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

Defined in hyperformula/src/Cell.ts:188

Parameters:

Name	Type
`sheet`	number
`col`	number

Returns: SimpleColumnAddress

simpleRowAddress

Const

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

Defined in hyperformula/src/Cell.ts:179

Parameters:

Name	Type
`sheet`	number
`row`	number

Returns: SimpleRowAddress

split

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

Defined in hyperformula/src/generatorUtils.ts:11

Type parameters:

▪ T

Parameters:

Name	Type
`iterable`	IterableIterator‹T›

Returns: object

rest: IterableIterator‹T›
value? : T

subscriptionExpiredMessage

▸ subscriptionExpiredMessage(__namedParameters: object): string

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:92

The message of a subscription past its usage_until date, inside its grace period or after it.

Parameters:

▪ __namedParameters: object

Name	Type
`licensedUntil`	string

Returns: string

timeToNumber

▸ timeToNumber(time: SimpleTime): number

Defined in hyperformula/src/DateTimeHelper.ts:319

Parameters:

Name	Type
`time`	SimpleTime

Returns: number

toBasisEU

▸ toBasisEU(date: SimpleDate): SimpleDate

Defined in hyperformula/src/DateTimeHelper.ts:323

Parameters:

Name	Type
`date`	SimpleDate

Returns: SimpleDate

unrestrictedEntitlement

▸ unrestrictedEntitlement(): LicenseEntitlement

Defined in hyperformula/src/license/LicenseEntitlement.ts:86

The unrestricted entitlement: classic keys, gpl-v3, and every key that blocks evaluation (a missing or invalid key, an expired classic key, or a trial past its grace period) resolve to this. An entitlement key that has expired but keeps evaluating does not: it keeps its own grants.

Unrecognized tokens fail closed and silently, so an entitlement key whose tokens this library version does not recognize at all does not map 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

utcDay

▸ utcDay(isoDate: string): string

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:74

Formats a usage_until date for a message. It is compared against the clock in UTC, so it is printed with the marker; a release_until date involves no clock and is printed without one.

Parameters:

Name	Type	Description
`isoDate`	string	the date as the key carries it, `YYYY-MM-DD`

Returns: string

validateArgToType

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

Defined in hyperformula/src/ArgumentSanitization.ts:81

Parameters:

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

Returns: void

validateAsSheet

▸ validateAsSheet(sheet: Sheet): void

Defined in hyperformula/src/Sheet.ts:33

Parameters:

Name	Type
`sheet`	Sheet

Returns: void

validateNumberToBeAtLeast

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

Defined in hyperformula/src/ArgumentSanitization.ts:34

Parameters:

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

Returns: void

validateNumberToBeAtMost

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

Defined in hyperformula/src/ArgumentSanitization.ts:40

Parameters:

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

Returns: void

Object literals

CellValueDetailedType

Const

▪ CellValueDetailedType: object

Defined in hyperformula/src/Cell.ts:95

CellValueType

Const

▪ CellValueType: object

Defined in hyperformula/src/Cell.ts:92

ENTITLEMENT_CONSOLE_NOTIFICATIONS

Const

▪ ENTITLEMENT_CONSOLE_NOTIFICATIONS: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:104

The console message for each entitlement-key lifecycle state that talks to the developer: the specification’s text (as the vendored reader’s README carries it), the same table Handsontable prints (handsontable/src/helpers/mixed.ts, entitlementConsoleNotifications), so one key reads the same in both products. Silent states (inside the term, a build covered by its maintenance date) have no entry. A non-trial key past its grace keeps the soft-stop message: it never blocks a paying customer.

▪ release_expired: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:124

severity: “error” = “error”
message(__namedParameters: object): string

▪ trial_hard_stop: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:114

severity: “error” = “error”
message(__namedParameters: object): string

▪ trial_notice: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:105

severity: “warn” = “warn”
message(__namedParameters: object): string

▪ trial_soft_stop: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:110

severity: “error” = “error”
message(__namedParameters: object): string

▪ usage_hard_stop: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:123

message: subscriptionExpiredMessage = subscriptionExpiredMessage
severity: “error” = “error”

▪ usage_notice: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:118

severity: “warn” = “warn”
message(__namedParameters: object): string

▪ usage_soft_stop: object

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:122

message: subscriptionExpiredMessage = subscriptionExpiredMessage
severity: “error” = “error”

LIFECYCLE_VERDICTS

Const

▪ LIFECYCLE_VERDICTS: object

Defined in hyperformula/src/license/licenseResolution.ts:49

The verdict for every lifecycle state the vendored reader reports. A Record over {@link LicenseState}, so a state added upstream fails compilation here until it is classified, instead of falling into a default.

The valid and notice states, and release_valid, report VALID and evaluate.
The soft-stop states report VALID and evaluate on purpose: the grace period keeps working and prints the specification’s error (see notifyEntitlementKey).
A subscription past its grace period (usage_hard_stop) and a key whose release_until is before the build (release_expired) report EXPIRED but keep evaluating, printing an error to the console instead. An expired license never blocks a paying customer, as the reader’s guide and the key specification both say. Such a key keeps its own grants: the reader reports it as licensed, so it is never granted more than the same key was granted while it was current.
A trial past its grace period (trial_hard_stop) reports EXPIRED and blocks.

▪ release_expired: object

Defined in hyperformula/src/license/licenseResolution.ts:59