# API Reference Overview

• 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 (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.

# 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 (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 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.

# COLOR_TAG_REGEX Const

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

# DATE_SEPARATOR_REGEXP Const

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

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

# 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 (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 hyperformula/src/license/functionCapabilities.ts:136 (opens new window)

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

# HYPERFORMULA_PRODUCT_NAME Const

• HYPERFORMULA_PRODUCT_NAME: "hyperformula" = "hyperformula"

Defined in hyperformula/src/license/licenseResolution.ts:23 (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.

# LCID_CURRENCY_TAG Const

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

Defined in hyperformula/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.

# MINUTES_PER_HOUR Const

• MINUTES_PER_HOUR: 60 = 60

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

# NOT_FOUND Const

• NOT_FOUND: -1 = -1

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

# NUMBER_FORMAT_REGEX_SOURCE Const

• NUMBER_FORMAT_REGEX_SOURCE: string = numberFormatRegex.source

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

The source of numberFormatRegex, exported for the white-box ReDoS shape assertion. Not re-exported from src/index.ts — test-only internal.

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

# QUICK_CHECK_REGEXP Const

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

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

# SECONDS_PER_MINUTE Const

• SECONDS_PER_MINUTE: 60 = 60

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

# SECONDS_PRECISION Const

• SECONDS_PRECISION: 1000 = 1000

Defined in hyperformula/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 hyperformula/src/DateTimeDefault.ts:9 (opens new window)

# TIME_SEPARATOR Const

• TIME_SEPARATOR: ":" = ":"

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

# 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 hyperformula/src/license/functionCapabilities.ts:77 (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 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 (opens new window)

# WRONG_RANGE_SIZE Const

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

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

# _notified Let

• _notified: boolean = false

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

# _rl Const

• _rl: "length" = "length"

Defined in hyperformula/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 hyperformula/src/format/parser.ts:8 (opens new window)

# defaultLanguage Const

• defaultLanguage: string = Config.defaultConfig.language

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

# memoizedParseDateFormat Const

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

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

# memoizedParseTimeFormat Const

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

Defined in hyperformula/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 hyperformula/src/DateTimeHelper.ts:10 (opens new window)

# numberFormatRegex Const

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

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

Number-format tokenizer regex.

The class is intentionally FLAT — [#0,]+(\.[#0]*)? — admitting the grouping comma alongside the #/0 placeholders. Whether a comma means "group thousands", a "trailing scaler", or neither is decided later by string inspection in format.ts, never by regex structure.

Synchronous catastrophic backtracking is not catchable by jest/jasmine wall-clock timeouts, so this pattern MUST NOT be rewritten into a nested-quantifier form such as ([#0]+,)*[#0]+. Its shape is pinned by a white-box test via NUMBER_FORMAT_REGEX_SOURCE.

# prefSumDays Const

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

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

# privatePool Const

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

Defined in hyperformula/src/Config.ts:40 (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 hyperformula/src/license/featureCapabilities.ts:12 (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.

# singleFunctionEntries Const

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

Defined in hyperformula/src/license/functionCapabilities.ts:120 (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 hyperformula/src/Cell.ts:97 (opens new window)

Parameters:

Name	Type
`arg`	CellValueType

Returns: number

# _cp Const

▸ _cp(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# _hd Const

▸ _hd(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# _nm Const

▸ _nm(v: any): string

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

Parameters:

Name	Type
`v`	any

Returns: string

# _pi Const

▸ _pi(v: any): number

Defined in hyperformula/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 hyperformula/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 hyperformula/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 hyperformula/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 hyperformula/src/Cell.ts:209 (opens new window)

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: string

# allowsFeature

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

Defined in hyperformula/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 hyperformula/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 hyperformula/src/ArraySize.ts:35 (opens new window)

Parameters:

Name	Type
`leftArraySize`	ArraySize
`rightArraySize`	ArraySize

Returns: ArraySize

# arraySizeForUnaryOp

▸ arraySizeForUnaryOp(arraySize: ArraySize): ArraySize

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

Parameters:

Name	Type
`arraySize`	ArraySize

Returns: ArraySize

# buildColumnSearchStrategy

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

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

Parameters:

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

Returns: ColumnSearchStrategy

# checkKeySchema

▸ checkKeySchema(v: any): boolean

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

Parameters:

Name	Type
`v`	any

Returns: boolean

# checkLicenseKeyValidity

▸ checkLicenseKeyValidity(licenseKey: string): LicenseKeyValidityState

Defined in hyperformula/src/helpers/licenseKeyValidator.ts:225 (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.

# collatorFromConfig

▸ collatorFromConfig(config: Config): Collator

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

Parameters:

Name	Type
`config`	Config

Returns: Collator

# configCheckIfParametersNotInConflict

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

Defined in hyperformula/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 hyperformula/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 hyperformula/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 hyperformula/src/format/format.ts:256 (opens new window)

Parameters:

Name	Type
`text`	string
`char`	string

Returns: number

# createTokens

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

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

Parameters:

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

Returns: FormatToken[]

# dayToMonth

▸ dayToMonth(dayOfYear: number): number

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

Parameters:

Name	Type
`dayOfYear`	number

Returns: number

# defaultParseToDate

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

Defined in hyperformula/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 hyperformula/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 hyperformula/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 hyperformula/src/format/format.ts:588 (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 hyperformula/src/format/format.ts:484 (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 hyperformula/src/format/format.ts:392 (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

# doesContainRelativeReferences Const

▸ doesContainRelativeReferences(ast: Ast): boolean

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

Parameters:

Name	Type
`ast`	Ast

Returns: boolean

# doesItLookLikeADateTimeQuickCheck

▸ doesItLookLikeADateTimeQuickCheck(text: string): boolean

Defined in hyperformula/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 hyperformula/src/generatorUtils.ts:8 (opens new window)

Type parameters:

▪ T

Returns: IterableIterator‹T›

# ensureFeatureAllowed

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

Defined in hyperformula/src/license/ensureFeatureAllowed.ts:39 (opens new window)

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

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

Parameters:

Name	Type
`left`	SimpleCellAddress
`right`	SimpleCellAddress

Returns: boolean

# expiryClause

▸ expiryClause(days: number): string

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

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

# extractTime

▸ extractTime(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# filterDependenciesOutOfScope Const

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

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

Parameters:

Name	Type
`deps`	CellDependency[]

Returns: CellDependency[]

# findBoundaries

▸ findBoundaries(sheet: Sheet): SheetBoundaries

Defined in hyperformula/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 hyperformula/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 hyperformula/src/generatorUtils.ts:22 (opens new window)

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

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

# formatNumberWithSections

▸ formatNumberWithSections(formatArg: string, value: number, config: Config): RawScalarValue

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

Number path of the dispatcher: split the format into sign-selected sections, pick the section for the value, tokenize it and render.

When the SELECTED section carries no #/0 placeholder it is pure literal text (e.g. "neg", an empty section, or a bare Foo): render THAT section's literal characters — never the whole format string — so 0.00;"neg" on a negative renders neg (not 0.00;"neg") and an empty section renders ''. A single literal section preserves format(2, 'Foo') → 'Foo'. Never throws.

Parameters:

Name	Type	Description
`formatArg`	string	the color-stripped format string
`value`	number	the numeric value being formatted
`config`	Config	the live HyperFormula config (separators)

Returns: RawScalarValue

the formatted string

# formatToken

▸ formatToken(type: TokenType, value: string): FormatToken

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

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

Parameters:

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

Returns: CellType

# getCellValueDetailedType Const

▸ getCellValueDetailedType(cellValue: InterpreterValue): CellValueDetailedType

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

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueDetailedType

# getCellValueFormat Const

▸ getCellValueFormat(cellValue: InterpreterValue): string | undefined

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

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: string | undefined

# getCellValueType Const

▸ getCellValueType(cellValue: InterpreterValue): CellValueType

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

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueType

# getDefaultConfig

▸ getDefaultConfig(): ConfigParams

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

Returns: ConfigParams

# getFullConfigFromPartial

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

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

Parameters:

Name	Type
`partialConfig`	Partial‹ConfigParams›

Returns: ConfigParams

# insertGrouping

▸ insertGrouping(digits: string, separator: string): string

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

Inserts a grouping separator every three digits from the right of a run of digits (e.g. 1234567 → 1,234,567). The caller guarantees digits is a pure-digit string and separator is non-empty.

Parameters:

Name	Type	Description
`digits`	string	a pure-digit integer string
`separator`	string	the grouping glyph (from `config.thousandSeparator`)

Returns: string

the grouped digit string

# instanceOfSimpleDate

▸ instanceOfSimpleDate(obj: any): obj is SimpleDate

Defined in hyperformula/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 hyperformula/src/DateTimeHelper.ts:43 (opens new window)

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleTime

# invalidSimpleColumnAddress Const

▸ invalidSimpleColumnAddress(address: SimpleColumnAddress): boolean

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

Parameters:

Name	Type
`address`	SimpleColumnAddress

Returns: boolean

# invalidSimpleRowAddress Const

▸ invalidSimpleRowAddress(address: SimpleRowAddress): boolean

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

Parameters:

Name	Type
`address`	SimpleRowAddress

Returns: boolean

# isBoolean

▸ isBoolean(text: string): boolean

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

Parameters:

Name	Type
`text`	string

Returns: boolean

# isColOrRowInvalid Const

▸ isColOrRowInvalid(address: SimpleCellAddress): boolean

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

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

Parameters:

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

Returns: boolean

# isEscapeToken

▸ isEscapeToken(token: RegExpExecArray): boolean

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

Parameters:

Name	Type
`token`	RegExpExecArray

Returns: boolean

# isFeatureAllowed

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

Defined in hyperformula/src/license/ensureFeatureAllowed.ts:25 (opens new window)

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

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

Parameters:

Name	Type
`x`	number

Returns: boolean

# isPositiveInteger

▸ isPositiveInteger(x: number): boolean

Defined in hyperformula/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 hyperformula/src/Operations.ts:1107 (opens new window)

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 (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 hyperformula/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

# licenseAllowsFunction

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

Defined in hyperformula/src/license/CapabilityRegistry.ts:160 (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, 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:59 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

# matchNumberFormat

▸ matchNumberFormat(str: string): RegExpExecArray[]

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

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

# memoize

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

Defined in hyperformula/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 hyperformula/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 hyperformula/src/Operations.ts:1075 (opens new window)

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

# normalizeCapabilityToken

▸ normalizeCapabilityToken(token: string): string

Defined in hyperformula/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 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 (opens new window)

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

# notifyEntitlementKey

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

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

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

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

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, config: Config): RawScalarValue

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

Renders a single sign-selected section's tokens against a value.

The sign is extracted up front: the value is formatted on its magnitude (Math.abs) and a leading - is prepended to the whole result iff the value is negative AND some rendered digit is non-zero — Excel displays a magnitude that rounds to zero unsigned (TEXT(-0.4,"0") → 0, not -0). Only this implicit sign is suppressed: an explicit - literal in the mask (0;-0) flows through the FREE_TEXT path and still prints. Callers pass abs for an explicit negative section (whose own literals carry the sign) and the signed value for a single-section mask (so the - is re-added here) — see pickSection.

Per integer-format token:

a trailing comma run (Excel's scaler) is peeled off and re-emitted as a literal so the output is recognizably un-scaled rather than silently mis-scaled;
grouping is requested when an interior comma exists (#,##0), and the grouping glyph is config.thousandSeparator (empty on default config → no visible glyph);
the decimal glyph is config.decimalSeparator.

Parameters:

Name	Type	Description
`tokens`	FormatToken[]	the tokenized number-format section
`value`	number	the sign-adjusted numeric value to render
`config`	Config	the live config (grouping / decimal separators)

Returns: RawScalarValue

the rendered section string

# numberToSimpleTime

▸ numberToSimpleTime(arg: number): SimpleTime

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

Parameters:

Name	Type
`arg`	number

Returns: SimpleTime

# objectDestroy

▸ objectDestroy(object: any): void

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

Parameters:

Name	Type
`object`	any

Returns: void

# offsetMonth

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

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

Parameters:

Name	Type
`date`	SimpleDate
`offset`	number

Returns: SimpleDate

# padLeft

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

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

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

Parameters:

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

Returns: string

# parse

▸ parse(str: string): FormatExpression

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

Parameters:

Name	Type
`str`	string

Returns: FormatExpression

# parseDateFormat

▸ parseDateFormat(dateFormat: string): object

Defined in hyperformula/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 hyperformula/src/format/parser.ts:125 (opens new window)

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

# parseForNumberFormat

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

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

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

# parseTimeFormat

▸ parseTimeFormat(timeFormat: string): object

Defined in hyperformula/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

# pickSection

▸ pickSection(sections: string[], value: number): object

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

Selects the format section for a value by its RAW sign (before rounding) and returns the value to feed the formatter:

> 0 → positive section (section 0), formatted signed (non-negative).
< 0 → negative section (section 1) when present, formatted on abs (the section's own literals, e.g. (0.00), carry the sign); when only one section exists the signed value is passed so the formatter re-adds - (unless every rendered digit is zero — see numberFormat).
= 0 → zero section (section 2) when present, else the positive section.

Excel-canonical fallbacks: 1 section → all values; 2 sections → [pos+zero ; neg]; 3 sections → [pos ; neg ; zero]; a missing zero section falls back to positive.

Parameters:

Name	Type	Description
`sections`	string[]	the split format sections
`value`	number	the numeric value being formatted

Returns: object

the chosen section string and the (sign-adjusted) value to format

sectionStr: string
valueForFormat: number

# postMortem

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

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

Parameters:

Name	Type
`method`	any

Returns: (Anonymous function)

# printNotification

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

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

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

# renderLiteralSection

▸ renderLiteralSection(section: string): string

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

Renders a placeholder-less format section as literal text: double-quote delimiters are removed ("z" → z) and backslash escapes are resolved (\- → -). Used when the section selected for a value's sign carries no #/0 placeholder, so the value is never spliced in — only the section's own literal characters are emitted (an empty section renders ''). Mirrors Excel, where a literal-only section shows just its text.

Parameters:

Name	Type	Description
`section`	string	the raw (unstripped) format section

Returns: string

the section's literal text

# replacer

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

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

Parameters:

Name	Type
`key`	string
`val`	any

Returns: any

# resolveLicense

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

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

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

Parameters:

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

Returns: number

# roundToNearestSecond

▸ roundToNearestSecond(arg: number): number

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

Parameters:

Name	Type
`arg`	number

Returns: number

# simpleCellAddress Const

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

Defined in hyperformula/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 hyperformula/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 hyperformula/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 hyperformula/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 hyperformula/src/generatorUtils.ts:11 (opens new window)

Type parameters:

▪ T

Parameters:

Name	Type
`iterable`	IterableIterator‹T›

Returns: object

rest: IterableIterator‹T›
value? : T

# splitIntoSections

▸ splitIntoSections(formatStr: string): string[]

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

Splits an Excel number-format string into its sign-selected sections on unescaped ;, honoring \; escapes and "…" quoted literals so a semicolon inside a quoted literal does not split. Excel uses up to four sections (positive;negative;zero;text); only the first three are ever selected for a numeric value, so no cap is enforced here — surplus sections are simply never read.

Parameters:

Name	Type	Description
`formatStr`	string	the (color-stripped) format string

Returns: string[]

the list of raw section strings, in order

# stringifyMagnitude

▸ stringifyMagnitude(absValue: number, decimalPlaces: number): object

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

Stringifies the integer and fractional digits of a magnitude for rendering: the value is rounded to decimalPlaces and split on the dot, with the trailing zeros of the fraction dropped (the placeholder padding re-adds them).

Doubles >= 1e21 stringify in scientific notation (1e+21), which would defeat placeholder padding and grouping, so they are expanded to their exact decimal digits via BigInt instead — every such double is integer-valued. NOTE: beyond 15 significant digits Excel displays zeros while the double's exact expansion may carry non-zero tail digits; HyperFormula renders the double's exact value (measured equal to Excel for the round 1e21 case).

Parameters:

Name	Type	Description
`absValue`	number	the non-negative magnitude to stringify
`decimalPlaces`	number	the number of decimal places requested by the format

Returns: object

the integer digits and the trailing-zero-free fractional digits

decimalPart: string
integerPart: string

# stripColorTags

▸ stripColorTags(formatArg: string): string

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

Removes Excel color tags ([Red], [Blue], …, [Color56]) from a format string. HyperFormula's TEXT output is a plain string with no color channel, so presentational color tags are semantically meaningless and are simply dropped.

The whitelist is deliberately color-NAME-specific (flat alternation, no nested quantifier) so it cannot clobber other bracketed tokens: duration tags [hh]/[mm], currency/locale tags [$USD-409]/[$-409], and condition tags [>=100] are all left untouched.

Parameters:

Name	Type	Description
`formatArg`	string	the raw format string

Returns: string

the format string with recognized color tags removed

# stripQuotes

▸ stripQuotes(section: string): string

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

Strips the delimiting double-quotes from quoted literals so "zł" renders as zł. Quotes are removed from the whole section, so digit and placeholder characters inside quotes still reach the number tokenizer.

Parameters:

Name	Type	Description
`section`	string	a single format section

Returns: string

the section with double-quote delimiters removed

# subscriptionExpiredMessage

▸ subscriptionExpiredMessage(__namedParameters: object): string

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

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

Parameters:

Name	Type
`time`	SimpleTime

Returns: number

# toBasisEU

▸ toBasisEU(date: SimpleDate): SimpleDate

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

Parameters:

Name	Type
`date`	SimpleDate

Returns: SimpleDate

# unrestrictedEntitlement

▸ unrestrictedEntitlement(): LicenseEntitlement

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

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

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

Parameters:

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

Returns: void

# validateAsSheet

▸ validateAsSheet(sheet: Sheet): void

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

Parameters:

Name	Type
`sheet`	Sheet

Returns: void

# validateNumberToBeAtLeast

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

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

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

Parameters:

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

Returns: void

# Object literals

# CellValueDetailedType Const

# ▪ CellValueDetailedType: object

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

# CellValueType Const

# ▪ CellValueType: object

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

# ENTITLEMENT_CONSOLE_NOTIFICATIONS Const

# ▪ ENTITLEMENT_CONSOLE_NOTIFICATIONS: object

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

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

severity: "error" = "error"
message(__namedParameters: object): string

▪ trial_hard_stop: object

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

severity: "error" = "error"
message(__namedParameters: object): string

▪ trial_notice: object

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

severity: "warn" = "warn"
message(__namedParameters: object): string

▪ trial_soft_stop: object

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

severity: "error" = "error"
message(__namedParameters: object): string

▪ usage_hard_stop: object

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

message: subscriptionExpiredMessage = subscriptionExpiredMessage
severity: "error" = "error"

▪ usage_notice: object

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

severity: "warn" = "warn"
message(__namedParameters: object): string

▪ usage_soft_stop: object

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

message: subscriptionExpiredMessage = subscriptionExpiredMessage
severity: "error" = "error"

# LIFECYCLE_VERDICTS Const

# ▪ LIFECYCLE_VERDICTS: object

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

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