handsontable 18.0.0 → 18.1.0-rc1

package/translations/maps/utils/indexesSequence.js

@@ -17,6 +17,13 @@ _export(exports, {
     }
 });
 const _array = require("../../../helpers/array");
+/**
+ * Above this many removed indexes a `Set` lookup is used instead of `Array.prototype.includes`,
+ * turning the removal scan from O(n × k) into O(n + k). Below it, a linear `includes` is cheaper
+ * than building a `Set`.
+ *
+ * @type {number}
+ */ const SET_LOOKUP_THRESHOLD = 16;
 function getListWithInsertedItems(indexedValues, insertionIndex, insertedIndexes) {
     return [
         ...indexedValues.slice(0, insertionIndex),
@@ -25,7 +32,9 @@ function getListWithInsertedItems(indexedValues, insertionIndex, insertedIndexes
     ];
 }
 function getListWithRemovedItems(indexedValues, removedIndexes) {
-    return (0, _array.arrayFilter)(indexedValues, (index)=>{
-        return removedIndexes.includes(index) === false;
-    });
+    if (removedIndexes.length <= SET_LOOKUP_THRESHOLD) {
+        return (0, _array.arrayFilter)(indexedValues, (index)=>removedIndexes.includes(index) === false);
+    }
+    const removed = new Set(removedIndexes);
+    return (0, _array.arrayFilter)(indexedValues, (index)=>removed.has(index) === false);
 }

package/translations/maps/utils/indexesSequence.mjs

@@ -1,4 +1,11 @@
 import { arrayFilter } from '../../../helpers/array.mjs';
+/**
+ * Above this many removed indexes a `Set` lookup is used instead of `Array.prototype.includes`,
+ * turning the removal scan from O(n × k) into O(n + k). Below it, a linear `includes` is cheaper
+ * than building a `Set`.
+ *
+ * @type {number}
+ */ const SET_LOOKUP_THRESHOLD = 16;
 /**
  * Insert new items to the list.
  *
@@ -22,7 +29,9 @@ import { arrayFilter } from '../../../helpers/array.mjs';
  * @param {Array} removedIndexes List of removed indexes.
  * @returns {Array} Reduced list of mappings.
  */ export function getListWithRemovedItems(indexedValues, removedIndexes) {
-    return arrayFilter(indexedValues, (index)=>{
-        return removedIndexes.includes(index) === false;
-    });
+    if (removedIndexes.length <= SET_LOOKUP_THRESHOLD) {
+        return arrayFilter(indexedValues, (index)=>removedIndexes.includes(index) === false);
+    }
+    const removed = new Set(removedIndexes);
+    return arrayFilter(indexedValues, (index)=>removed.has(index) === false);
 }

package/translations/maps/utils/physicallyIndexed.js

@@ -18,6 +18,13 @@ _export(exports, {
 });
 const _function = require("../../../helpers/function");
 const _array = require("../../../helpers/array");
+/**
+ * Above this many removed indexes a `Set` lookup is used instead of `Array.prototype.includes`,
+ * turning the removal scan from O(n × k) into O(n + k). Below it, a linear `includes` is cheaper
+ * than building a `Set` (avoids a single-row-removal regression on large datasets).
+ *
+ * @type {number}
+ */ const SET_LOOKUP_THRESHOLD = 16;
 function getListWithInsertedItems(indexedValues, insertionIndex, insertedIndexes, insertedValuesMapping) {
     const firstInsertedIndex = insertedIndexes.length ? insertedIndexes[0] : undefined;
     return [
@@ -32,5 +39,9 @@ function getListWithInsertedItems(indexedValues, insertionIndex, insertedIndexes
     ];
 }
 function getListWithRemovedItems(indexedValues, removedIndexes) {
-    return (0, _array.arrayFilter)(indexedValues, (_, index)=>removedIndexes.includes(index) === false);
+    if (removedIndexes.length <= SET_LOOKUP_THRESHOLD) {
+        return (0, _array.arrayFilter)(indexedValues, (_, index)=>removedIndexes.includes(index) === false);
+    }
+    const removed = new Set(removedIndexes);
+    return (0, _array.arrayFilter)(indexedValues, (_, index)=>removed.has(index) === false);
 }

package/translations/maps/utils/physicallyIndexed.mjs

@@ -1,5 +1,12 @@
 import { isFunction } from '../../../helpers/function.mjs';
 import { arrayFilter } from '../../../helpers/array.mjs';
+/**
+ * Above this many removed indexes a `Set` lookup is used instead of `Array.prototype.includes`,
+ * turning the removal scan from O(n × k) into O(n + k). Below it, a linear `includes` is cheaper
+ * than building a `Set` (avoids a single-row-removal regression on large datasets).
+ *
+ * @type {number}
+ */ const SET_LOOKUP_THRESHOLD = 16;
 /**
  * Insert new items to the list.
  *
@@ -30,5 +37,9 @@ import { arrayFilter } from '../../../helpers/array.mjs';
  * @param {Array} removedIndexes List of removed indexes.
  * @returns {Array} Reduced list of mappings.
  */ export function getListWithRemovedItems(indexedValues, removedIndexes) {
-    return arrayFilter(indexedValues, (_, index)=>removedIndexes.includes(index) === false);
+    if (removedIndexes.length <= SET_LOOKUP_THRESHOLD) {
+        return arrayFilter(indexedValues, (_, index)=>removedIndexes.includes(index) === false);
+    }
+    const removed = new Set(removedIndexes);
+    return arrayFilter(indexedValues, (_, index)=>removed.has(index) === false);
 }

package/utils/entitlementLicenseKey/classify.d.mts

@@ -0,0 +1 @@
+export * from './classify.js';

package/utils/entitlementLicenseKey/classify.d.ts

@@ -0,0 +1,34 @@
+import type { ProductEntitlement, LicenseLifecycle, LicenseChannels } from './types';
+/**
+ * The time references a license is measured against: the current instant for a
+ * `usage_until` entitlement, and the build release date (as the bare
+ * "YYYY-MM-DD" text it is compared to) for a `release_until` one. The build
+ * date is text on purpose - the maintenance check is static against static, so
+ * it holds on a machine with no clock and cannot disagree between two
+ * timezones.
+ */
+export interface LicenseTimeReference {
+    now: number;
+    buildDate: string;
+}
+/**
+ * Classifies one product entitlement into its lifecycle facet.
+ *
+ * Which of the two dates the entry carries decides how it is measured; the
+ * `trial` flag decides only what the user is told. Nothing here branches on a
+ * contract type, because the payload does not carry one.
+ *
+ * @param {ProductEntitlement} entitlement The verified product entry.
+ * @param {LicenseTimeReference} time The time references to measure against.
+ * @returns {LicenseLifecycle}
+ */
+export declare function classifyEntitlement(entitlement: ProductEntitlement, time: LicenseTimeReference): LicenseLifecycle;
+/**
+ * Reads which notification channels a product entitlement leaves open. Both
+ * flags are per product and default to open; a key issued for external,
+ * end-user-facing use carries both.
+ *
+ * @param {ProductEntitlement} entitlement The verified product entry.
+ * @returns {LicenseChannels}
+ */
+export declare function resolveChannels(entitlement: ProductEntitlement): LicenseChannels;

package/utils/entitlementLicenseKey/classify.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get classifyEntitlement () {
+        return classifyEntitlement;
+    },
+    get resolveChannels () {
+        return resolveChannels;
+    }
+});
+const _encoding = require("./encoding");
+const _constants = require("./constants");
+/**
+ * The UTC midnight of the day an instant falls on. Every window boundary is a
+ * UTC midnight, so both sides of every comparison are snapped to one - the
+ * local calendar, the locale and DST are inputs the classification must not
+ * read at all.
+ *
+ * @param {number} timestamp The instant, in epoch milliseconds.
+ * @returns {number}
+ */ function utcMidnightOf(timestamp) {
+    return Math.floor(timestamp / _constants.MILLISECONDS_PER_DAY) * _constants.MILLISECONDS_PER_DAY;
+}
+/**
+ * Whole UTC days from today until the last licensed day. `0` on the last
+ * licensed day (which is still licensed in full) and negative once it has
+ * passed. Both sides are UTC midnights, so the count is a whole number of
+ * calendar days and never a rounded fraction.
+ *
+ * @param {number} expiryTimestamp The UTC midnight of the last licensed day.
+ * @param {number} now The current instant, in epoch milliseconds.
+ * @returns {number}
+ */ function daysUntil(expiryTimestamp, now) {
+    return (expiryTimestamp - utcMidnightOf(now)) / _constants.MILLISECONDS_PER_DAY;
+}
+/**
+ * Places a `usage_until` license in its window.
+ *
+ * The named day is licensed in full: the license runs until the UTC midnight
+ * that FOLLOWS it, and the grace period is measured from there. A `notice` of
+ * `0` means no advance warning at all, so the notice window is empty rather
+ * than one day long.
+ *
+ * @param {number} expiryTimestamp The UTC midnight of the last licensed day.
+ * @param {ProductEntitlement} entitlement The product entry the windows come from.
+ * @param {number} now The current instant, in epoch milliseconds.
+ * @returns {UsageWindow}
+ */ function resolveUsageWindow(expiryTimestamp, entitlement, now) {
+    const expiryBoundary = expiryTimestamp + _constants.MILLISECONDS_PER_DAY;
+    if (now >= expiryBoundary) {
+        return now < expiryBoundary + entitlement.grace * _constants.MILLISECONDS_PER_DAY ? 'soft_stop' : 'hard_stop';
+    }
+    const daysRemaining = daysUntil(expiryTimestamp, now);
+    return entitlement.notice > 0 && daysRemaining <= entitlement.notice ? 'notice' : 'valid';
+}
+function classifyEntitlement(entitlement, time) {
+    const isTrial = entitlement.flags.indexOf(_constants.TRIAL_FLAG) !== -1;
+    if (entitlement.release_until !== undefined) {
+        const releaseUntil = entitlement.release_until;
+        // Fail OPEN when the build release date is unavailable (a bundler consuming the source without
+        // the build-time define step, a broken build): a paying customer must never be told their
+        // license lapsed because of a build defect. The legacy path stays valid in the same
+        // environment.
+        const covered = releaseUntil >= time.buildDate || (0, _encoding.parseIsoDateToTimestamp)(time.buildDate) === null;
+        return {
+            state: covered ? 'release_valid' : 'release_expired',
+            isTrial,
+            daysRemaining: null,
+            licensedUntil: releaseUntil
+        };
+    }
+    const usageUntil = `${entitlement.usage_until}`;
+    // Verified at read time, so the date always parses here; the fallback only keeps the arithmetic
+    // finite if this is ever called with an unverified entry.
+    const expiryTimestamp = (0, _encoding.parseIsoDateToTimestamp)(usageUntil) ?? utcMidnightOf(time.now);
+    const window = resolveUsageWindow(expiryTimestamp, entitlement, time.now);
+    return {
+        state: `${isTrial ? 'trial' : 'usage'}_${window}`,
+        isTrial,
+        daysRemaining: daysUntil(expiryTimestamp, time.now),
+        licensedUntil: usageUntil
+    };
+}
+function resolveChannels(entitlement) {
+    return {
+        console: entitlement.flags.indexOf(_constants.NO_CONSOLE_WARNS_FLAG) === -1,
+        ui: entitlement.flags.indexOf(_constants.NO_UI_WARNS_FLAG) === -1
+    };
+}

package/utils/entitlementLicenseKey/classify.mjs

@@ -0,0 +1,96 @@
+import { parseIsoDateToTimestamp } from './encoding.mjs';
+import { TRIAL_FLAG, NO_CONSOLE_WARNS_FLAG, NO_UI_WARNS_FLAG, MILLISECONDS_PER_DAY } from './constants.mjs';
+/**
+ * The UTC midnight of the day an instant falls on. Every window boundary is a
+ * UTC midnight, so both sides of every comparison are snapped to one - the
+ * local calendar, the locale and DST are inputs the classification must not
+ * read at all.
+ *
+ * @param {number} timestamp The instant, in epoch milliseconds.
+ * @returns {number}
+ */ function utcMidnightOf(timestamp) {
+    return Math.floor(timestamp / MILLISECONDS_PER_DAY) * MILLISECONDS_PER_DAY;
+}
+/**
+ * Whole UTC days from today until the last licensed day. `0` on the last
+ * licensed day (which is still licensed in full) and negative once it has
+ * passed. Both sides are UTC midnights, so the count is a whole number of
+ * calendar days and never a rounded fraction.
+ *
+ * @param {number} expiryTimestamp The UTC midnight of the last licensed day.
+ * @param {number} now The current instant, in epoch milliseconds.
+ * @returns {number}
+ */ function daysUntil(expiryTimestamp, now) {
+    return (expiryTimestamp - utcMidnightOf(now)) / MILLISECONDS_PER_DAY;
+}
+/**
+ * Places a `usage_until` license in its window.
+ *
+ * The named day is licensed in full: the license runs until the UTC midnight
+ * that FOLLOWS it, and the grace period is measured from there. A `notice` of
+ * `0` means no advance warning at all, so the notice window is empty rather
+ * than one day long.
+ *
+ * @param {number} expiryTimestamp The UTC midnight of the last licensed day.
+ * @param {ProductEntitlement} entitlement The product entry the windows come from.
+ * @param {number} now The current instant, in epoch milliseconds.
+ * @returns {UsageWindow}
+ */ function resolveUsageWindow(expiryTimestamp, entitlement, now) {
+    const expiryBoundary = expiryTimestamp + MILLISECONDS_PER_DAY;
+    if (now >= expiryBoundary) {
+        return now < expiryBoundary + entitlement.grace * MILLISECONDS_PER_DAY ? 'soft_stop' : 'hard_stop';
+    }
+    const daysRemaining = daysUntil(expiryTimestamp, now);
+    return entitlement.notice > 0 && daysRemaining <= entitlement.notice ? 'notice' : 'valid';
+}
+/**
+ * Classifies one product entitlement into its lifecycle facet.
+ *
+ * Which of the two dates the entry carries decides how it is measured; the
+ * `trial` flag decides only what the user is told. Nothing here branches on a
+ * contract type, because the payload does not carry one.
+ *
+ * @param {ProductEntitlement} entitlement The verified product entry.
+ * @param {LicenseTimeReference} time The time references to measure against.
+ * @returns {LicenseLifecycle}
+ */ export function classifyEntitlement(entitlement, time) {
+    const isTrial = entitlement.flags.indexOf(TRIAL_FLAG) !== -1;
+    if (entitlement.release_until !== undefined) {
+        const releaseUntil = entitlement.release_until;
+        // Fail OPEN when the build release date is unavailable (a bundler consuming the source without
+        // the build-time define step, a broken build): a paying customer must never be told their
+        // license lapsed because of a build defect. The legacy path stays valid in the same
+        // environment.
+        const covered = releaseUntil >= time.buildDate || parseIsoDateToTimestamp(time.buildDate) === null;
+        return {
+            state: covered ? 'release_valid' : 'release_expired',
+            isTrial,
+            daysRemaining: null,
+            licensedUntil: releaseUntil
+        };
+    }
+    const usageUntil = `${entitlement.usage_until}`;
+    // Verified at read time, so the date always parses here; the fallback only keeps the arithmetic
+    // finite if this is ever called with an unverified entry.
+    const expiryTimestamp = parseIsoDateToTimestamp(usageUntil) ?? utcMidnightOf(time.now);
+    const window = resolveUsageWindow(expiryTimestamp, entitlement, time.now);
+    return {
+        state: `${isTrial ? 'trial' : 'usage'}_${window}`,
+        isTrial,
+        daysRemaining: daysUntil(expiryTimestamp, time.now),
+        licensedUntil: usageUntil
+    };
+}
+/**
+ * Reads which notification channels a product entitlement leaves open. Both
+ * flags are per product and default to open; a key issued for external,
+ * end-user-facing use carries both.
+ *
+ * @param {ProductEntitlement} entitlement The verified product entry.
+ * @returns {LicenseChannels}
+ */ export function resolveChannels(entitlement) {
+    return {
+        console: entitlement.flags.indexOf(NO_CONSOLE_WARNS_FLAG) === -1,
+        ui: entitlement.flags.indexOf(NO_UI_WARNS_FLAG) === -1
+    };
+}

package/utils/entitlementLicenseKey/constants.d.mts

@@ -0,0 +1 @@
+export * from './constants.js';

package/utils/entitlementLicenseKey/constants.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The length of the checksum (SHA-512 as hex) that closes the machine-readable
+ * block of every entitlement license key.
+ *
+ * @type {number}
+ */
+export declare const CHECKSUM_LENGTH = 128;
+/**
+ * The two mutually exclusive date fields of a product entry. Exactly one of
+ * them is present:
+ *
+ *   - "usage_until"   the last licensed day (inclusive, compared in UTC),
+ *   - "release_until" builds released on or before that day may be used
+ *                     forever (compared against the build release date as
+ *                     text, no clock involved).
+ *
+ * The pair replaces the contract type - nothing in the payload says
+ * "subscription" or "perpetual".
+ *
+ * @type {string[]}
+ */
+export declare const DATE_FIELDS: string[];
+/**
+ * The name of the product this build reads its own license from. A key that
+ * does not grant it is not a Handsontable license, however many other products
+ * it grants. Product names are append-only - renaming one silently drops the
+ * entitlement it used to carry.
+ *
+ * @type {string}
+ */
+export declare const HANDSONTABLE_PRODUCT = "handsontable";
+/**
+ * The capability tokens this build understands. The key asserts an entitlement;
+ * what a token unlocks is defined here, never in the key. Unknown tokens are
+ * ignored, so a token added on the issuing side cannot break a build already in
+ * the field.
+ *
+ * @type {string[]}
+ */
+export declare const KNOWN_CAPABILITIES: string[];
+/**
+ * Marks a license as an evaluation one. A flag is present or absent - there is
+ * no `false` value - and an unrecognized flag is ignored, for the same reason
+ * an unrecognized capability token is.
+ *
+ * @type {string}
+ */
+export declare const TRIAL_FLAG = "trial";
+/**
+ * Closes the console channel: nothing this module has to say reaches it.
+ *
+ * @type {string}
+ */
+export declare const NO_CONSOLE_WARNS_FLAG = "no-console-warns";
+/**
+ * Closes the UI channel: no badge, no bar, no lock screen. Both this flag and
+ * the one above are the default for a key issued for external, end-user-facing
+ * use.
+ *
+ * @type {string}
+ */
+export declare const NO_UI_WARNS_FLAG = "no-ui-warns";
+/**
+ * The number of milliseconds in a day, used to walk from one UTC midnight to
+ * the next.
+ *
+ * @type {number}
+ */
+export declare const MILLISECONDS_PER_DAY = 86400000;

package/utils/entitlementLicenseKey/constants.js

@@ -0,0 +1,54 @@
+/**
+ * The length of the checksum (SHA-512 as hex) that closes the machine-readable
+ * block of every entitlement license key.
+ *
+ * @type {number}
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CHECKSUM_LENGTH () {
+        return CHECKSUM_LENGTH;
+    },
+    get DATE_FIELDS () {
+        return DATE_FIELDS;
+    },
+    get HANDSONTABLE_PRODUCT () {
+        return HANDSONTABLE_PRODUCT;
+    },
+    get KNOWN_CAPABILITIES () {
+        return KNOWN_CAPABILITIES;
+    },
+    get MILLISECONDS_PER_DAY () {
+        return MILLISECONDS_PER_DAY;
+    },
+    get NO_CONSOLE_WARNS_FLAG () {
+        return NO_CONSOLE_WARNS_FLAG;
+    },
+    get NO_UI_WARNS_FLAG () {
+        return NO_UI_WARNS_FLAG;
+    },
+    get TRIAL_FLAG () {
+        return TRIAL_FLAG;
+    }
+});
+const CHECKSUM_LENGTH = 128;
+const DATE_FIELDS = [
+    'usage_until',
+    'release_until'
+];
+const HANDSONTABLE_PRODUCT = 'handsontable';
+const KNOWN_CAPABILITIES = [
+    'core'
+];
+const TRIAL_FLAG = 'trial';
+const NO_CONSOLE_WARNS_FLAG = 'no-console-warns';
+const NO_UI_WARNS_FLAG = 'no-ui-warns';
+const MILLISECONDS_PER_DAY = 86400000;

package/utils/entitlementLicenseKey/constants.mjs

@@ -0,0 +1,66 @@
+/**
+ * The length of the checksum (SHA-512 as hex) that closes the machine-readable
+ * block of every entitlement license key.
+ *
+ * @type {number}
+ */ export const CHECKSUM_LENGTH = 128;
+/**
+ * The two mutually exclusive date fields of a product entry. Exactly one of
+ * them is present:
+ *
+ *   - "usage_until"   the last licensed day (inclusive, compared in UTC),
+ *   - "release_until" builds released on or before that day may be used
+ *                     forever (compared against the build release date as
+ *                     text, no clock involved).
+ *
+ * The pair replaces the contract type - nothing in the payload says
+ * "subscription" or "perpetual".
+ *
+ * @type {string[]}
+ */ export const DATE_FIELDS = [
+    'usage_until',
+    'release_until'
+];
+/**
+ * The name of the product this build reads its own license from. A key that
+ * does not grant it is not a Handsontable license, however many other products
+ * it grants. Product names are append-only - renaming one silently drops the
+ * entitlement it used to carry.
+ *
+ * @type {string}
+ */ export const HANDSONTABLE_PRODUCT = 'handsontable';
+/**
+ * The capability tokens this build understands. The key asserts an entitlement;
+ * what a token unlocks is defined here, never in the key. Unknown tokens are
+ * ignored, so a token added on the issuing side cannot break a build already in
+ * the field.
+ *
+ * @type {string[]}
+ */ export const KNOWN_CAPABILITIES = [
+    'core'
+];
+/**
+ * Marks a license as an evaluation one. A flag is present or absent - there is
+ * no `false` value - and an unrecognized flag is ignored, for the same reason
+ * an unrecognized capability token is.
+ *
+ * @type {string}
+ */ export const TRIAL_FLAG = 'trial';
+/**
+ * Closes the console channel: nothing this module has to say reaches it.
+ *
+ * @type {string}
+ */ export const NO_CONSOLE_WARNS_FLAG = 'no-console-warns';
+/**
+ * Closes the UI channel: no badge, no bar, no lock screen. Both this flag and
+ * the one above are the default for a key issued for external, end-user-facing
+ * use.
+ *
+ * @type {string}
+ */ export const NO_UI_WARNS_FLAG = 'no-ui-warns';
+/**
+ * The number of milliseconds in a day, used to walk from one UTC midnight to
+ * the next.
+ *
+ * @type {number}
+ */ export const MILLISECONDS_PER_DAY = 86400000;

package/utils/entitlementLicenseKey/detectFormat.d.mts

@@ -0,0 +1 @@
+export * from './detectFormat.js';

package/utils/entitlementLicenseKey/detectFormat.d.ts

@@ -0,0 +1,23 @@
+import type { LicenseKeyFormat } from './types';
+/**
+ * Tells which format a license key is in, without validating it. The
+ * entitlement key carries no leading tag - it starts with prose and ends with
+ * the bracketed machine-readable block - so the formats have to be told apart
+ * in one place, and this is it.
+ *
+ * The answer is about SHAPE only. An "entitlement" result means "read this with
+ * the entitlement reader", not "this key is valid".
+ *
+ * @param {string} licenseKey The license key to inspect.
+ * @returns {LicenseKeyFormat}
+ */
+export declare function detectLicenseKeyFormat(licenseKey: unknown): LicenseKeyFormat;
+/**
+ * Tells whether a license key has the shape of an entitlement key. This is the
+ * cheap routing test taken before any parsing - a legacy key pays two string
+ * scans for it.
+ *
+ * @param {string} licenseKey The license key to test.
+ * @returns {boolean}
+ */
+export declare function isEntitlementKey(licenseKey: unknown): boolean;

package/utils/entitlementLicenseKey/detectFormat.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get detectLicenseKeyFormat () {
+        return detectLicenseKeyFormat;
+    },
+    get isEntitlementKey () {
+        return isEntitlementKey;
+    }
+});
+/**
+ * The literal keys that stand for a license rather than encode one.
+ *
+ * Only formats Handsontable itself honors belong here. `gpl-v3` is deliberately absent: the
+ * specification lists it among the unchanged legacy keys, but that list covers HyperFormula too and
+ * nothing in this library has ever recognized it - the frozen validator rejects it like any other
+ * unknown string. Naming it here advertised support that does not exist, and since an unreadable key
+ * now blocks the grid, a reader who trusted the table would ship a blocked grid.
+ *
+ * @type {Record<string, LicenseKeyFormat>}
+ */ const LITERAL_KEYS = {
+    'non-commercial-and-evaluation': 'non-commercial-and-evaluation'
+};
+/**
+ * The classic 25-character key, once its dashes are stripped.
+ *
+ * @type {RegExp}
+ */ const LEGACY_KEY = /^[0-9a-fA-F]{25}$/;
+function detectLicenseKeyFormat(licenseKey) {
+    if (typeof licenseKey !== 'string') {
+        return 'unknown';
+    }
+    const key = licenseKey.trim();
+    const literalKey = key.toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(LITERAL_KEYS, literalKey)) {
+        return LITERAL_KEYS[literalKey];
+    }
+    // The bracketed block closes an entitlement key. Its presence is what
+    // separates the new format from everything else, so it is checked before the
+    // shape-based ones.
+    const blockStart = key.lastIndexOf('[');
+    if (blockStart !== -1 && key.indexOf(']', blockStart) !== -1) {
+        return 'entitlement';
+    }
+    if (LEGACY_KEY.test(key.replace(/-/g, ''))) {
+        return 'legacy';
+    }
+    return 'unknown';
+}
+function isEntitlementKey(licenseKey) {
+    return detectLicenseKeyFormat(licenseKey) === 'entitlement';
+}