# API Reference Overview

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

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

Every feature token, in one list, for the shipped-shape adapter: the shipped key vocabulary predates feature tokens entirely, so a commercial tier is translated into its functions token PLUS all of these — see licenseTermsOf for the reasoning.

# BASE64_ALPHABET Const

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

Defined in src/license/vendor/utils.ts:17 (opens new window)

The base64 alphabet.

# BATCHING_FEATURE_TOKEN Const

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

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

Grants FeatureId.Batching.

# CALCULATED_FIELDS_FUNCTIONS Const

• CALCULATED_FIELDS_FUNCTIONS: string[] = [ 'AND', 'AVERAGEIF', 'CONCATENATE', 'COUNTIF', 'DATE', 'DATEDIF', 'DATEVALUE', 'DAY', 'DAYS', 'EOMONTH', 'EXACT', 'FALSE', 'HOUR', 'IFS', 'ISOWEEKNUM', 'LEFT', 'LEN', 'LOWER', 'MID', 'MINUTE', 'MONTH', 'NETWORKDAYS', 'NOT', 'OR', 'RAND', 'RANDBETWEEN', 'REPLACE', 'REPT', 'RIGHT', 'SEARCH', 'SECOND', 'STDEV.S', 'SUBSTITUTE', 'SUMIF', 'SUMIFS', 'SWITCH', 'TEXT', 'TODAY', 'TRIM', 'TRUE', 'UPPER', 'VALUE', 'WEEKDAY', 'WEEKNUM', 'WORKDAY', 'XOR', 'YEAR', ]

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

Added by the calculated-fields package, on top of MATH_ENGINE_FUNCTIONS.

# CAPABILITY_TABLE Const

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

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

The production capability table.

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

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

The five feat:* tokens carry the gated API areas, one feature each, spelled after the draft vocabulary in the task. A rev-5 key states them explicitly; the shipped-shape adapter grants all five alongside the tier (that vocabulary predates feature tokens); legacy keys resolve to the unrestricted entitlement and never consult this table.

The two add-on tokens are RESERVED: recognized, so an issued key carrying one is not reported as unrecognized, but granting nothing. spreadsheet has no agreed content yet — the packaging proposal names a package "Spreadsheet" and the pricing task names a "Spreadsheet Bundle" add-on, and it is not settled whether those are the same set; guessing would silently sell an empty add-on or duplicate a whole tier. import_export has nothing to grant until HF-107.

# CLIPBOARD_FEATURE_TOKEN Const

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

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

Grants FeatureId.Clipboard.

# CORE_TOKEN Const

• CORE_TOKEN: "core" = "core"

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

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

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

# CRUD_FEATURE_TOKEN Const

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

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

Grants FeatureId.Crud — the mutating CRUD surface of the public API.

# DATE_SEPARATOR_REGEXP Const

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

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

# DEFAULT_TYPED_KEY_SCHEMA Const

• DEFAULT_TYPED_KEY_SCHEMA: TypedKeySchema = deepFreeze({ // Every key type defines its tag, its legal wording (the "{PRODUCT}" placeholder is replaced // with the licensed product display name), the beginning of the expiration clause, and two // flags: "expires" (does the key carry an expiration date) and "hasHardStop" (does it stop // working "grace" days after the expiration - such keys require the grace period in the // payload). keyTypes: { trial: { tag: '[TRIAL]', legalClauses: [ 'is_granted_for_evaluation_only', 'Use_in_production_is_not_permitted', 'Please_report_misuse_to_legal@handsontable.com', 'For_purchasing_contact_sales@handsontable.com', ], expiryWording: 'This_key_will_deactivate_on', expires: true, hasHardStop: true, }, freemium: { tag: '[FREE]', legalClauses: [ 'is_granted_under_the_Free_plan', 'Use_is_subject_to_the_{PRODUCT}_Free_License_Terms', 'Features_beyond_the_Free_plan_require_a_commercial_license', 'To_upgrade_contact_sales@handsontable.com', ], expiryWording: 'This_key_does_not_expire', expires: false, hasHardStop: false, }, subscription: { tag: '[SUB]', legalClauses: [ 'is_granted_under_a_subscription_license', 'Use_after_expiry_is_not_permitted_per_the_subscription_agreement', 'To_renew_contact_sales@handsontable.com', ], expiryWording: 'This_key_will_deactivate_on', expires: true, hasHardStop: true, }, perpetual: { tag: '[PERP]', legalClauses: [ 'is_granted_under_a_perpetual_license', 'Access_to_new_versions_ends_when_maintenance_expires', 'Versions_released_before_that_date_may_be_used_indefinitely', 'To_renew_maintenance_contact_sales@handsontable.com', ], expiryWording: 'Maintenance_ends_on', expires: true, hasHardStop: false, }, }, // The products, in priority order: the FIRST product of this list found in the payload is the // "licensed product" - it carries the expiration date and the grace period, and its display // name is spelled in the key header. // // Every product defines its scope wordings (tier, or "tier:mode" when the product supports // deployment modes) and optionally its add-on wordings. products: [ { name: 'handsontable', displayName: 'Handsontable', modes: ['internal', 'saas'], defaultMode: 'internal', scopeWordings: { freemium: 'Free', 'enterprise:internal': 'Enterprise', 'enterprise:saas': 'Enterprise_SaaS', }, }, { name: 'hyperformula', displayName: 'HyperFormula', scopeWordings: { freemium: 'HyperFormula_Free', crm: 'HyperFormula_CRM', data_grid: 'HyperFormula_Data_Grid', excel_simulator: 'HyperFormula_Excel_Simulator', }, addonWordings: { spreadsheet: 'Spreadsheet_addon', import_export: 'Import_Export_addon', }, }, ], })

Defined in src/license/vendor/defaultSchema.ts:72 (opens new window)

The default typed-key schema: the marketing-owned vocabulary of the license keys. The schema describes WHAT can be licensed (products, tiers, modes, add-ons) and HOW it is worded in the human-readable part of the key (legal clauses, scope wordings, expiry wordings).

The engine (generate/validate/extract) only defines the key FORMAT — the type tag, the prose/payload structure, the checksum, the version stamping, and the strict validation rules.

Compatibility rules that matter to a reader such as HyperFormula:

key type names and tags are append-only — renaming or removing one makes already-issued keys of that type unreadable;
product names are append-only for the same reason (the expiration time is derived from the first schema product found in the payload);
wordings and legal clauses may change freely — they only affect newly generated keys, already-issued keys stay valid (the checksum covers whatever prose they were born with).

It is deeply frozen so it cannot be mutated in place.

# EXCEL_SIMULATOR_FUNCTIONS Const

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

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

Added by the excel-simulator package, on top of SPREADSHEET_FUNCTIONS — the rest of the implemented catalog.

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

# FEATURE_TOKEN_PREFIX Const

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

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

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

Used to tell "this key names its feature grants" from "this key's vocabulary cannot express one" — see the opt-in rule in licenseTermsOf.

# FUNCTIONS_1_TOKEN Const

• FUNCTIONS_1_TOKEN: "functions_1" = "functions_1"

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

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

# FUNCTIONS_2_TOKEN Const

• FUNCTIONS_2_TOKEN: "functions_2" = "functions_2"

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

Calculated fields package. Cumulative: includes FUNCTIONS_1_TOKEN's functions.

# FUNCTIONS_3_TOKEN Const

• FUNCTIONS_3_TOKEN: "functions_3" = "functions_3"

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

Spreadsheet package. Cumulative: includes FUNCTIONS_2_TOKEN's functions.

# FUNCTIONS_4_TOKEN Const

• FUNCTIONS_4_TOKEN: "functions_4" = "functions_4"

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

Excel simulator package — the entire implemented catalog.

# HOURS_PER_DAY Const

• HOURS_PER_DAY: 24 = 24

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

# HYPERFORMULA_PRODUCT_NAME Const

• HYPERFORMULA_PRODUCT_NAME: "hyperformula" = "hyperformula"

Defined in src/license/vendor/defaultSchema.ts:168 (opens new window)

The name of HyperFormula's own product entry in the typed-key payload. Note this is NOT necessarily the licensed product of a key: a key that grants both Handsontable and HyperFormula carries its expiration date on the Handsontable entry, because that product comes first in DEFAULT_TYPED_KEY_SCHEMA's priority order.

# IMPORT_EXPORT_ADDON_TOKEN Const

• IMPORT_EXPORT_ADDON_TOKEN: "import_export" = "import_export"

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

Import/export add-on. Reserved until HF-107 ships the feature it would gate.

# K Const

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

Defined in src/license/vendor/sha512.ts:15 (opens new window)

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

# LCID_CURRENCY_TAG Const

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

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

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

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

# MATH_ENGINE_FUNCTIONS Const

• MATH_ENGINE_FUNCTIONS: string[] = [ 'ABS', 'AVERAGE', 'COUNT', 'IF', 'LOG', 'MAX', 'MIN', 'MOD', 'POWER', 'PRODUCT', 'ROUND', 'ROUNDDOWN', 'ROUNDUP', 'SQRT', 'SUM', ]

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

Package membership, as the LOWEST package that includes each function.

Transcribed from section 6 of the internal packaging design document ("HF function groups and packages"), which supersedes the earlier evidence file this table was first built from. The doc organizes the catalog into 21 group tokens (fun:<family>.<A|B|C>) and states each package as the cumulative union of specific groups: Math engine = the .A groups, Calculated fields = .A + .B, Spreadsheet = .A + .B + .C. Reproducing that union gives 17 / 64 / 161 cumulative functions before the two protected built-ins below are removed; capability-table.spec.ts pins the resulting counts so a later edit cannot drift from them silently.

OFFSET and VERSION are named by the doc (as fun:lookup.A and fun:info.A) but are deliberately absent from every list below: both are protected built-ins that sit OUTSIDE the token system today — the interpreter never gate-checks a protected function, so listing them would be dead weight that implies a restriction that does not exist. The doc calls this a "technical limitation" on both; see hf-306-token-vocabulary-final for the root cause of each (registry protection for VERSION, parse-time resolution for OFFSET) and what closing it would take.

# MAX_TIMESTAMP Const

• MAX_TIMESTAMP: 8640000000000000 = 8640000000000000

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

The largest value Date can represent; beyond it toISOString() throws.

# MILLISECONDS_PER_DAY Const

• MILLISECONDS_PER_DAY: 86400000 = 86400000

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

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

# MINUTES_PER_HOUR Const

• MINUTES_PER_HOUR: 60 = 60

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

# NAMED_EXPRESSIONS_FEATURE_TOKEN Const

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

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

Grants FeatureId.NamedExpressions.

# NOT_FOUND Const

• NOT_FOUND: -1 = -1

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

# OPERATOR_FUNCTIONS Const

• OPERATOR_FUNCTIONS: string[] = [ 'HF.ADD', 'HF.CONCAT', 'HF.DIVIDE', 'HF.EQ', 'HF.GT', 'HF.GTE', 'HF.LT', 'HF.LTE', 'HF.MINUS', 'HF.MULTIPLY', 'HF.NE', 'HF.POW', 'HF.UMINUS', 'HF.UNARY_PERCENT', 'HF.UPLUS', ]

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

The calculation operators and their HF.* callable forms. Always available in every package — the packaging design counts them as engine baseline and advertises them separately from the function totals, so they are granted by CORE_TOKEN rather than by any package.

# QUICK_CHECK_REGEXP Const

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

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

# SECONDS_MILLISECONDS_THRESHOLD Const

• SECONDS_MILLISECONDS_THRESHOLD: 100000000000 = 100000000000

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

Below this value a numeric timestamp is read as epoch SECONDS, above it as milliseconds. 1e11 seconds is year 5138, and 1e11 milliseconds is 1973 — no real license date is near either, so the split is unambiguous for anything a key can plausibly carry.

# SECONDS_PER_MINUTE Const

• SECONDS_PER_MINUTE: 60 = 60

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

# SECONDS_PRECISION Const

• SECONDS_PRECISION: 1000 = 1000

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

# SILENT_CONSOLE_FLAGS Const

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

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

Flag spellings that suppress console output.

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

# SPREADSHEET_ADDON_TOKEN Const

• SPREADSHEET_ADDON_TOKEN: "spreadsheet" = "spreadsheet"

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

Spreadsheet add-on. Reserved: recognized, grants nothing yet — see CAPABILITY_TABLE.

# SPREADSHEET_FUNCTIONS Const

• SPREADSHEET_FUNCTIONS: string[] = [ 'ACOS', 'ADDRESS', 'ARRAYFORMULA', 'ARRAY_CONSTRAIN', 'ASIN', 'ATAN', 'ATAN2', 'AVERAGEA', 'CEILING', 'CHAR', 'CHOOSE', 'CLEAN', 'CODE', 'COLUMN', 'COLUMNS', 'COS', 'COUNTA', 'COUNTBLANK', 'COUNTIFS', 'DAYS360', 'DEC2HEX', 'EDATE', 'EVEN', 'EXP', 'FILTER', 'FIND', 'FLOOR', 'FV', 'HEX2DEC', 'HLOOKUP', 'HSTACK', 'HYPERLINK', 'IFERROR', 'IFNA', 'INDEX', 'INT', 'IPMT', 'IRR', 'ISBLANK', 'ISERR', 'ISERROR', 'ISEVEN', 'ISLOGICAL', 'ISNA', 'ISNUMBER', 'ISODD', 'ISTEXT', 'LARGE', 'LN', 'MATCH', 'MAXIFS', 'MEDIAN', 'MINIFS', 'MROUND', 'N', 'NA', 'NOW', 'NPV', 'ODD', 'PERCENTILE.INC', 'PI', 'PMT', 'PPMT', 'PROPER', 'PV', 'QUOTIENT', 'RATE', 'ROW', 'ROWS', 'SEQUENCE', 'SIGN', 'SIN', 'SLN', 'SMALL', 'SORT', 'STDEV.P', 'STDEVA', 'STDEVPA', 'SUBTOTAL', 'SUMPRODUCT', 'SUMSQ', 'SUMXMY2', 'T', 'TAN', 'TEXTJOIN', 'TIME', 'TRANSPOSE', 'UNICHAR', 'UNIQUE', 'VAR.P', 'VAR.S', 'VLOOKUP', 'VSTACK', 'XIRR', 'XLOOKUP', 'XNPV', 'YEARFRAC', ]

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

Added by the spreadsheet package, on top of CALCULATED_FIELDS_FUNCTIONS.

# TIER_TO_CAPABILITY_TOKEN Const

• TIER_TO_CAPABILITY_TOKEN: ReadonlyMap‹string, string› = new Map([ ['freemium', FUNCTIONS_1_TOKEN], ['crm', FUNCTIONS_2_TOKEN], ['data_grid', FUNCTIONS_3_TOKEN], ['excel_simulator', FUNCTIONS_4_TOKEN], ])

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

Commercial tier names (the shipped key format) mapped to the capability tokens the library actually resolves. A tier this map does not know is passed through unchanged, so it surfaces as an unrecognized capability rather than being silently swallowed.

A Map, not an object literal, and that matters for safety rather than style: the tier is an attacker-influenced string, and an object lookup also answers for every Object.prototype member, so tier: "constructor" would resolve to a FUNCTION and tier: "__proto__" to an object. Either put a non-string into the token list, which then crashed the scan that reads tokens as strings — a thrown TypeError escaping the HyperFormula constructor instead of an invalid verdict. A Map answers only for keys actually put in it, matching CAPABILITY_TABLE.

# TIME_FORMAT_SECONDS_ITEM_REGEXP Const

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

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

# TIME_SEPARATOR Const

• TIME_SEPARATOR: ":" = ":"

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

# TYPED_KEY_CHECKSUM_LENGTH Const

• TYPED_KEY_CHECKSUM_LENGTH: 128 = 128

Defined in src/license/vendor/constants.ts:23 (opens new window)

The length of the checksum (SHA-512 as hex) which postfixes every typed license key.

# TYPED_KEY_SUPPORTED_VERSIONS Const

• TYPED_KEY_SUPPORTED_VERSIONS: number[] = [1]

Defined in src/license/vendor/constants.ts:18 (opens new window)

The typed license key format versions this library can read. The version is stamped into the key payload (the v field) at generation and checked automatically at extraction — the format version describes HOW the key is parsed (envelope, encoding, checksum), unlike the schema, which describes WHAT the key grants. When a new format version ships, it is ADDED here (with per-version handling where needed) so one build keeps reading all the already-issued keys.

# UNDO_REDO_FEATURE_TOKEN Const

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

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

Grants FeatureId.UndoRedo.

# WHITESPACE_REGEXP Const

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

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

# WRONG_RANGE_SIZE Const

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

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

# _noticedKeys Const

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

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

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

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

# _notified Let

• _notified: boolean = false

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

# _rl Const

• _rl: "length" = "length"

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

# dateFormatRegex Const

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

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

# defaultLanguage Const

• defaultLanguage: string = Config.defaultConfig.language

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

# memoizedParseDateFormat Const

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

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

# memoizedParseTimeFormat Const

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

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

# numDays Const

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

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

# numberFormatRegex Const

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

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

# prefSumDays Const

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

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

# privatePool Const

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

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

# Functions

# CellValueTypeOrd Const

▸ CellValueTypeOrd(arg: CellValueType): number

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

Parameters:

Name	Type
`arg`	CellValueType

Returns: number

# _cp Const

▸ _cp(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# _hd Const

▸ _hd(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# _nm Const

▸ _nm(v: any): string

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

Parameters:

Name	Type
`v`	any

Returns: string

# _pi Const

▸ _pi(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# _ss Const

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

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

Parameters:

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

Returns: any

# absoluteSheetReference Const

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

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

Parameters:

Name	Type
`address`	AddressWithSheet
`baseAddress`	SimpleCellAddress

Returns: number

# absolutizeDependencies Const

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

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

Converts dependencies from maybe relative addressing to absolute addressing.

Parameters:

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

Returns: CellDependency[]

# addressKey Const

▸ addressKey(address: SimpleCellAddress): string

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

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: string

# allowsFeature

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

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

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

Parameters:

Name	Type
`resolved`	ResolvedCapabilities
`feature`	FeatureId

Returns: boolean

# allowsFunction

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

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

Whether a resolved entitlement allows calling the given function.

Parameters:

Name	Type
`resolved`	ResolvedCapabilities
`functionId`	string

Returns: boolean

# arraySizeForBinaryOp

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

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

Parameters:

Name	Type
`leftArraySize`	ArraySize
`rightArraySize`	ArraySize

Returns: ArraySize

# arraySizeForUnaryOp

▸ arraySizeForUnaryOp(arraySize: ArraySize): ArraySize

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

Parameters:

Name	Type
`arraySize`	ArraySize

Returns: ArraySize

# base64ToBytes

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

Defined in src/license/vendor/utils.ts:177 (opens new window)

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

Parameters:

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

Returns: number[] | null

# base64ToString

▸ base64ToString(base64: string): string | null

Defined in src/license/vendor/utils.ts:214 (opens new window)

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

Parameters:

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

Returns: string | null

# buildColumnSearchStrategy

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

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

Parameters:

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

Returns: ColumnSearchStrategy

# checkKeySchema

▸ checkKeySchema(v: any): boolean

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

Parameters:

Name	Type
`v`	any

Returns: boolean

# checkLicenseKeyValidity

▸ checkLicenseKeyValidity(licenseKey: string): LicenseKeyValidityState

Defined in src/helpers/licenseKeyValidator.ts:147 (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 src/StringHelper.ts:8 (opens new window)

Parameters:

Name	Type
`config`	Config

Returns: Collator

# configCheckIfParametersNotInConflict

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

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

Parameters:

Name	Type
`...params`	object[]

Returns: void

# configValueFromParam

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

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

Parameters:

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

Returns: any

# configValueFromParamCheck

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

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

Parameters:

▪ inputValue: any

▪ typeCheck: function

▸ (object: any): boolean

Parameters:

Name	Type
`object`	any

▪ expectedType: string

▪ paramName: ConfigParamsList

Returns: any

# countChars

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

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

Parameters:

Name	Type
`text`	string
`char`	string

Returns: number

# createTokens

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

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

Parameters:

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

Returns: FormatToken[]

# dayToMonth

▸ dayToMonth(dayOfYear: number): number

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

Parameters:

Name	Type
`dayOfYear`	number

Returns: number

# deepFreeze

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

Defined in src/license/vendor/utils.ts:25 (opens new window)

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

Type parameters:

▪ T

Parameters:

Name	Type	Description
`value`	T	the value to freeze

Returns: T

# defaultParseToDate

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

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

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

Parameters:

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

Returns: Maybe‹SimpleDate›

# defaultParseToDateTime

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

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

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

Idea for more readable implementation:

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

Parameters:

Name	Type
`text`	string
`dateFormat`	Maybe‹string›
`timeFormat`	Maybe‹string›

Returns: Maybe‹DateTime›

# defaultParseToTime

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

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

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

Parameters:

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

Returns: Maybe‹SimpleTime›

# defaultStringifyCurrency

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

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

Default implementation of the stringifyCurrency config option.

Returning undefined instructs the formatter to fall through to the built-in number formatter, preserving HyperFormula's zero-dependency default behavior. Replace this default by setting the stringifyCurrency config option.

Parameters:

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

Returns: Maybe‹string›

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

# defaultStringifyDateTime

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

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

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

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

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

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

Parameters:

Name	Type	Description
`dateTime`	SimpleDateTime	parsed date/time value to render
`formatArg`	string	Excel-style format string

Returns: Maybe‹string›

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

# defaultStringifyDuration

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

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

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

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

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

Parameters:

Name	Type	Description
`time`	SimpleTime	parsed duration value to render
`formatArg`	string	Excel-style format string

Returns: Maybe‹string›

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

# doesContainRelativeReferences Const

▸ doesContainRelativeReferences(ast: Ast): boolean

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

Parameters:

Name	Type
`ast`	Ast

Returns: boolean

# doesItLookLikeADateTimeQuickCheck

▸ doesItLookLikeADateTimeQuickCheck(text: string): boolean

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

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

Parameters:

Name	Type
`text`	string

Returns: boolean

# empty

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

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

Type parameters:

▪ T

Returns: IterableIterator‹T›

# entitlementOf

▸ entitlementOf(terms: LicenseTerms): LicenseEntitlement

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

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

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

Parameters:

Name	Type	Description
`terms`	LicenseTerms	the reconciled terms of the key

Returns: LicenseEntitlement

# equalSimpleCellAddress Const

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

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

Parameters:

Name	Type
`left`	SimpleCellAddress
`right`	SimpleCellAddress

Returns: boolean

# expiryWithinNoticeWindow

▸ expiryWithinNoticeWindow(terms: LicenseTerms): Date | null

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

The day a VALID key's usage-until expiry falls on, if the current UTC instant is within its notice window — null otherwise, which covers "no notice window configured" (noticeDays is 0 for every non-rev-5 entry, enforced where the terms are read) just as much as "not close enough yet" or "already past its usage-until day".

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

release_until-axis keys never reach here with a non-null result — kind is 'release' for them (see licenseTermsOf) — matching rev 5's rule that notice and grace have no effect on that axis. The converse does NOT hold: kind === 'usage' also covers a rev-5 entry with no date of its own, whose expiryTimestamp fell through to the key envelope's exp, so such an entry carrying notice notices against that envelope date. Accepted for this PR standing alone — the entitlement-envelope re-port (#1740) removes the fallback entirely.

Parameters:

Name	Type	Description
`terms`	LicenseTerms	the reconciled terms of the key

Returns: Date | null

# extractTime

▸ extractTime(v: any): number

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

Parameters:

Name	Type
`v`	any

Returns: number

# extractTypedKeyData

▸ extractTypedKeyData(licenseKey: string): TypedKeyData | null

Defined in src/license/vendor/extractKeyData.ts:142 (opens new window)

Extracts the machine-readable data from a typed license key ([TRIAL], [FREE], [SUB] or [PERP]). The function verifies the checksum first, so the returned data is guaranteed to belong to an intact key. For a malformed or tampered key null is returned.

The expiration time itself is not checked here — it is up to the caller to compare it against the current time (trial, subscription) or the build release date (perpetual).

Parameters:

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

Returns: TypedKeyData | null

# filterDependenciesOutOfScope Const

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

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

Parameters:

Name	Type
`deps`	CellDependency[]

Returns: CellDependency[]

# findBoundaries

▸ findBoundaries(sheet: Sheet): SheetBoundaries

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

Returns actual width, height and fill ratio of a sheet

Parameters:

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

Returns: SheetBoundaries

# findInOrderedArray

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

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

Parameters:

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

Returns: number

# first

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

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

Type parameters:

▪ T

Parameters:

Name	Type
`iterable`	IterableIterator‹T›

Returns: Maybe‹T›

# format

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

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

Parameters:

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

Returns: RawScalarValue

# formatDate

▸ formatDate(date: Date): string

Defined in src/helpers/licenseKeyValidator.ts:188 (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 typed-key path from a calendar date in the payload — so local getters shifted the day backwards for anyone west of UTC and printed an expiry one day earlier than the one the key actually carries.

Parameters:

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

Returns: string

The date as MMMM DD, YYYY.

# formatToken

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

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

Parameters:

Name	Type
`type`	TokenType
`value`	string

Returns: FormatToken

# getCellType Const

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

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

Parameters:

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

Returns: CellType

# getCellValueDetailedType Const

▸ getCellValueDetailedType(cellValue: InterpreterValue): CellValueDetailedType

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

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueDetailedType

# getCellValueFormat Const

▸ getCellValueFormat(cellValue: InterpreterValue): string | undefined

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

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: string | undefined

# getCellValueType Const

▸ getCellValueType(cellValue: InterpreterValue): CellValueType

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

Parameters:

Name	Type
`cellValue`	InterpreterValue

Returns: CellValueType

# getDefaultConfig

▸ getDefaultConfig(): ConfigParams

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

Returns: ConfigParams

# getFullConfigFromPartial

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

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

Parameters:

Name	Type
`partialConfig`	Partial‹ConfigParams›

Returns: ConfigParams

# instanceOfSimpleDate

▸ instanceOfSimpleDate(obj: any): obj is SimpleDate

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

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleDate

# instanceOfSimpleTime

▸ instanceOfSimpleTime(obj: any): obj is SimpleTime

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

Parameters:

Name	Type
`obj`	any

Returns: obj is SimpleTime

# invalidSimpleColumnAddress Const

▸ invalidSimpleColumnAddress(address: SimpleColumnAddress): boolean

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

Parameters:

Name	Type
`address`	SimpleColumnAddress

Returns: boolean

# invalidSimpleRowAddress Const

▸ invalidSimpleRowAddress(address: SimpleRowAddress): boolean

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

Parameters:

Name	Type
`address`	SimpleRowAddress

Returns: boolean

# isBoolean

▸ isBoolean(text: string): boolean

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

Parameters:

Name	Type
`text`	string

Returns: boolean

# isColOrRowInvalid Const

▸ isColOrRowInvalid(address: SimpleCellAddress): boolean

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

Checks if the column or row id is negative.

Parameters:

Name	Type
`address`	SimpleCellAddress

Returns: boolean

# isError

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

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

Parameters:

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

Returns: boolean

# isEscapeToken

▸ isEscapeToken(token: RegExpExecArray): boolean

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

Parameters:

Name	Type
`token`	RegExpExecArray

Returns: boolean

# isFormula

▸ isFormula(text: string): boolean

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

Checks whether string looks like formula or not.

Parameters:

Name	Type	Description
`text`	string	formula

Returns: boolean

# isNonnegativeInteger

▸ isNonnegativeInteger(x: number): boolean

Defined in src/CrudOperations.ts:668 (opens new window)

Parameters:

Name	Type
`x`	number

Returns: boolean

# isPositiveInteger

▸ isPositiveInteger(x: number): boolean

Defined in src/CrudOperations.ts:664 (opens new window)

Parameters:

Name	Type
`x`	number

Returns: boolean

# isProductGrant

▸ isProductGrant(value: unknown): value is TypedKeyProductGrant & Rev5ProductGrant

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

Whether a payload product entry is a usable object rather than null, an array or a scalar.

Parameters:

Name	Type
`value`	unknown

Returns: value is TypedKeyProductGrant & Rev5ProductGrant

# isRowOrColumnRange

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

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

Parameters:

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

Returns: boolean

# isSimpleCellAddress

▸ isSimpleCellAddress(obj: unknown): obj is SimpleCellAddress

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

Checks if the object is a simple cell address.

Parameters:

Name	Type
`obj`	unknown

Returns: obj is SimpleCellAddress

# isSimpleCellRange

▸ isSimpleCellRange(val: unknown): val is SimpleCellRange

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

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

Parameters:

Name	Type	Description
`val`	unknown	Value to check

Returns: val is SimpleCellRange

True if and only if the object is a valid SimpleCellRange

# licenseAllowsFunction

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

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

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

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

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

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

Parameters:

Name	Type	Description
`registry`	CapabilityRegistry	the registry the capabilities were resolved against
`resolved`	ResolvedCapabilities	the instance's resolved capabilities
`canonicalFunctionId`	string	the function id, already resolved through the alias map

Returns: boolean

# licenseTermsOf

▸ licenseTermsOf(data: TypedKeyData): LicenseTerms | null

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

Reconciles the two payload shapes into one set of terms, or null when the payload carries a term it cannot read — a date that is present but malformed, for instance. Returning null makes the key INVALID, which is what the shipped shape already does for a malformed exp; the alternative, treating an unreadable expiry as "never expires", would turn a minting typo into a permanent licence.

Parameters:

Name	Type	Description
`data`	TypedKeyData	the extracted key data

Returns: LicenseTerms | null

# matchDateFormat

▸ matchDateFormat(str: string): RegExpExecArray[]

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

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

# matchNumberFormat

▸ matchNumberFormat(str: string): RegExpExecArray[]

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

Parameters:

Name	Type
`str`	string

Returns: RegExpExecArray[]

# memoize

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

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

Function memoization for improved performance.

Type parameters:

▪ T

Parameters:

▪ fn: function

▸ (arg: string): T

Parameters:

Name	Type
`arg`	string

Returns: (Anonymous function)

# movedSimpleCellAddress Const

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

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

Parameters:

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

Returns: SimpleCellAddress

# normalizeAddedIndexes

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

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

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

# normalizeRemovedIndexes

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

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

Parameters:

Name	Type
`indexes`	ColumnRowIndex[]

Returns: ColumnRowIndex[]

# noticeIdentityOf

▸ noticeIdentityOf(licenseKey: string): string

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

The warn-once identity of a key: its trailing 128 characters — for an intact typed key, the sha512 checksum, unique per distinct key content — after trimming.

Trimmed because extractTypedKeyData trims before validating, so 'KEY' and 'KEY\n' are one license to the validator and must be one identity here too. Truncated because the set retains its entries for the life of the process: a multi-tenant server building one engine per customer-supplied key would otherwise accumulate every full key string it has ever warned about; 128 characters per entry bounds that to the checksum alone.

Parameters:

Name	Type
`licenseKey`	string

Returns: string

# notifyLicenseKeyNotice

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

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

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

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

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

Parameters:

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

Returns: void

# notifyLicenseKeyState

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

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

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

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

Parameters:

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

Returns: void

# numberFormat

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

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

Parameters:

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

Returns: RawScalarValue

# numberToSimpleTime

▸ numberToSimpleTime(arg: number): SimpleTime

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

Parameters:

Name	Type
`arg`	number

Returns: SimpleTime

# objectDestroy

▸ objectDestroy(object: any): void

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

Parameters:

Name	Type
`object`	any

Returns: void

# offsetMonth

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

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

Parameters:

Name	Type
`date`	SimpleDate
`offset`	number

Returns: SimpleDate

# padLeft

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

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

Parameters:

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

Returns: string

# padRight

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

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

Parameters:

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

Returns: string

# parse

▸ parse(str: string): FormatExpression

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

Parameters:

Name	Type
`str`	string

Returns: FormatExpression

# parseDateFormat

▸ parseDateFormat(dateFormat: string): object

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

Parses a date format string into a format object.

Parameters:

Name	Type
`dateFormat`	string

Returns: object

dayItem: number
itemsCount: number
longYearItem: number
monthItem: number
shortYearItem: number

# parseForDateTimeFormat

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

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

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

# parseForNumberFormat

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

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

Parameters:

Name	Type
`str`	string

Returns: Maybe‹FormatExpression›

# parseIsoDate

▸ parseIsoDate(isoDate: string, dateLabel: string): ParsedIsoDate

Defined in src/license/vendor/utils.ts:54 (opens new window)

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

Parameters:

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

Returns: ParsedIsoDate

# parseTimeFormat

▸ parseTimeFormat(timeFormat: string): object

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

Parses a time format string into a format object.

Parameters:

Name	Type
`timeFormat`	string

Returns: object

hourItem: number
itemsCount: number
minuteItem: number
secondItem: number

# postMortem

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

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

Parameters:

Name	Type
`method`	any

Returns: (Anonymous function)

# readDate

▸ readDate(value: unknown): number | null

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

Reads a date that may arrive either as a YYYY-MM-DD string or as a numeric timestamp, and returns it as epoch milliseconds at UTC midnight. Returns null when the value is present but cannot be read — the caller rejects the whole key in that case rather than treating it as "no expiry", which would silently turn a subscription into a perpetual licence.

Both forms are accepted because key spec rev 5 contradicts itself about them: §1.2 mandates "bare YYYY-MM-DD everywhere, no time component", while §2.1 types the same fields as timestamp and its example payload carries integers.

The string form goes through the vendored parseIsoDate, so it gets the same calendar round-trip check the shipped shape's exp gets: 2027-02-30 is rejected rather than rolling over into March and quietly granting two extra days.

Parameters:

Name	Type	Description
`value`	unknown	the raw payload value, known not to be `undefined`

Returns: number | null

# readDays

▸ readDays(value: unknown): number

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

A non-negative integer count of days from a payload field, or 0 when it is absent or not one.

Parameters:

Name	Type	Description
`value`	unknown	the raw payload value

Returns: number

# readStrings

▸ readStrings(value: unknown): string[]

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

The strings of a payload array field, ignoring anything that is not a non-empty string.

Parameters:

Name	Type	Description
`value`	unknown	the raw payload value

Returns: string[]

# releaseDateTimestamp

▸ releaseDateTimestamp(): number | null

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

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

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

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

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

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

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

Returns: number | null

# replacer

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

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

Parameters:

Name	Type
`key`	string
`val`	any

Returns: any

# resolveLicense

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

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

Resolves a license key into both gates' inputs.

A typed key is recognized first; anything else — gpl-v3, a legacy key, an empty string, or a malformed typed key — falls through to checkLicenseKeyValidity completely unchanged, which is what keeps this from touching existing behaviour.

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

A checksum-valid key whose terms 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.

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

# resolveLicensedProduct

▸ resolveLicensedProduct(payload: TypedKeyPayload): LicensedProduct | null

Defined in src/license/vendor/extractKeyData.ts:92 (opens new window)

Resolves the licensed product of the payload and derives its expiration time. The expiration date (exp, in the YYYY-MM-DD format) is converted to epoch milliseconds (UTC midnight). A payload without the expiration date (a freemium key) maps to null, which means the key never expires. Returns null when the payload does not have the expected shape.

Upstream returns only the timestamp, using undefined as its "malformed" sentinel because null already means "never expires"; folding the product name in lets this return one unambiguous null instead.

Parameters:

Name	Type	Description
`payload`	TypedKeyPayload	the key payload

Returns: LicensedProduct | null

# roundToEpsilon

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

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

Parameters:

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

Returns: number

# roundToNearestSecond

▸ roundToNearestSecond(arg: number): number

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

Parameters:

Name	Type
`arg`	number

Returns: number

# sha512

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

Defined in src/license/vendor/sha512.ts:78 (opens new window)

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

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

Parameters:

Name	Type	Description
`bytes`	number[] \| Uint8Array	the bytes to calculate the checksum from

Returns: string

# simpleCellAddress Const

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

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

Parameters:

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

Returns: SimpleCellAddress

# simpleCellRange Const

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

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

Parameters:

Name	Type
`start`	SimpleCellAddress
`end`	SimpleCellAddress

Returns: object

end: SimpleCellAddress
start: SimpleCellAddress

# simpleColumnAddress Const

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

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

Parameters:

Name	Type
`sheet`	number
`col`	number

Returns: SimpleColumnAddress

# simpleRowAddress Const

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

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

Parameters:

Name	Type
`sheet`	number
`row`	number

Returns: SimpleRowAddress

# split

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

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

Type parameters:

▪ T

Parameters:

Name	Type
`iterable`	IterableIterator‹T›

Returns: object

rest: IterableIterator‹T›
value? : T

# stringToUtf8Bytes

▸ stringToUtf8Bytes(text: string): number[]

Defined in src/license/vendor/utils.ts:92 (opens new window)

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

Parameters:

Name	Type	Description
`text`	string	the string to encode

Returns: number[]

# timeToNumber

▸ timeToNumber(time: SimpleTime): number

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

Parameters:

Name	Type
`time`	SimpleTime

Returns: number

# toBasisEU

▸ toBasisEU(date: SimpleDate): SimpleDate

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

Parameters:

Name	Type
`date`	SimpleDate

Returns: SimpleDate

# toHex32

▸ toHex32(value: number): string

Defined in src/license/vendor/sha512.ts:63 (opens new window)

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

Parameters:

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

Returns: string

# truncateDayInMonth

▸ truncateDayInMonth(date: SimpleDate): SimpleDate

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

Parameters:

Name	Type
`date`	SimpleDate

Returns: SimpleDate

# unrestrictedEntitlement

▸ unrestrictedEntitlement(): LicenseEntitlement

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

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

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

Returns: LicenseEntitlement

# utf8BytesToString

▸ utf8BytesToString(bytes: number[]): string

Defined in src/license/vendor/utils.ts:136 (opens new window)

Decodes UTF-8 bytes back into a string.

Parameters:

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

Returns: string

# validateArgToType

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

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

Parameters:

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

Returns: void

# validateAsSheet

▸ validateAsSheet(sheet: Sheet): void

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

Parameters:

Name	Type
`sheet`	Sheet

Returns: void

# validateNumberToBeAtLeast

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

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

Parameters:

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

Returns: void

# validityOf

▸ validityOf(terms: LicenseTerms): object

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

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

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

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

Parameters: