handsontable 18.0.0 → 18.1.0-rc7

package/translations/maps/indexesSequence.mjs

@@ -1,11 +1,103 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 import { IndexMap } from './indexMap.mjs';
 import { getListWithRemovedItems, getListWithInsertedItems } from './utils/indexesSequence.mjs';
 import { getDecreasedIndexes, getIncreasedIndexes } from './utils/index.mjs';
+var /**
+   * Whether the sequence is currently the identity (`0..#length-1`). When `true`, `indexedValues` is
+   * not materialized and `#length` is the source of truth.
+   *
+   * @type {boolean}
+   */ _isIdentity = /*#__PURE__*/ new WeakMap(), /**
+   * Length of the sequence while it is the identity. Ignored once materialized.
+   *
+   * @type {number}
+   */ _length = /*#__PURE__*/ new WeakMap(), /**
+   * Materializes the identity sequence into `indexedValues` so the array-based paths can run.
+   *
+   * @private
+   */ _materialize = /*#__PURE__*/ new WeakSet(), /**
+   * Checks whether the given values are the identity sequence (`0, 1, …, length-1`).
+   *
+   * @private
+   * @param {Array} values Candidate sequence.
+   * @returns {boolean}
+   */ _isIdentitySequence = /*#__PURE__*/ new WeakSet(), /**
+   * Checks whether `insertedIndexes` is the contiguous block `[insertionIndex, …]` — the only shape
+   * that keeps an identity sequence identity after an insert.
+   *
+   * @private
+   * @param {number} insertionIndex Position inside the list.
+   * @param {Array} insertedIndexes List of inserted indexes.
+   * @returns {boolean}
+   */ _isContiguousBlockAt = /*#__PURE__*/ new WeakSet(), /**
+   * Counts how many distinct removed indexes fall inside the current identity range `[0, #length)`.
+   *
+   * @private
+   * @param {Array} removedIndexes List of removed indexes.
+   * @returns {number}
+   */ _countInRange = /*#__PURE__*/ new WeakSet();
 /**
  * Map for storing mappings from an index to a physical index.
  *
  * It also updates the physical indexes (remaining in the map) on remove/add row or column action.
  *
+ * Representation: while the sequence is the identity (`0, 1, …, n-1` — the state of an unsorted,
+ * unmoved grid) it is kept as a single `length` number, not a materialized array. Insert, remove,
+ * and init then run in O(1)/O(k) instead of rebuilding an n-element array, because inserting a
+ * contiguous block at its own position or removing any subset of an identity sequence yields another
+ * identity sequence. The array is materialized lazily only when a real reorder (sort/move) sets a
+ * non-identity sequence. `getValues()` still returns a plain `number[]`, so the public contract is
+ * unchanged.
+ *
  * @class IndexesSequence
  */ export class IndexesSequence extends IndexMap {
     /**
@@ -13,33 +105,171 @@ import { getDecreasedIndexes, getIncreasedIndexes } from './utils/index.mjs';
    *
    * @returns {number[]} Physical indexes.
    */ getValues() {
+        if (_class_private_field_get(this, _isIdentity)) {
+            const values = new Array(_class_private_field_get(this, _length));
+            for(let index = 0; index < _class_private_field_get(this, _length); index += 1){
+                values[index] = index;
+            }
+            return values;
+        }
         return this.indexedValues;
     }
     /**
-   * Add values to list and reorganize.
+   * Get the physical index at the given position.
+   *
+   * @param {number} index Position in the sequence.
+   * @returns {T | undefined}
+   */ getValueAtIndex(index) {
+        if (_class_private_field_get(this, _isIdentity)) {
+            if (index >= 0 && index < _class_private_field_get(this, _length)) {
+                return index;
+            }
+            return undefined;
+        }
+        return super.getValueAtIndex(index);
+    }
+    /**
+   * Get length of the sequence.
+   *
+   * @returns {number}
+   */ getLength() {
+        return _class_private_field_get(this, _isIdentity) ? _class_private_field_get(this, _length) : this.indexedValues.length;
+    }
+    /**
+   * Set a completely new sequence. Detects the identity case to keep the compact representation.
+   *
+   * @param {Array} values List of physical indexes.
+   */ setValues(values) {
+        if (_class_private_method_get(this, _isIdentitySequence, isIdentitySequence).call(this, values)) {
+            _class_private_field_set(this, _isIdentity, true);
+            _class_private_field_set(this, _length, values.length);
+            this.indexedValues = [];
+        } else {
+            _class_private_field_set(this, _isIdentity, false);
+            this.indexedValues = values.slice();
+        }
+        this.runLocalHooks('change');
+    }
+    /**
+   * Set the physical index at a single position. Materializes the sequence first.
+   *
+   * @param {number} index The position.
+   * @param {*} value The physical index to store.
+   * @returns {boolean}
+   */ setValueAtIndex(index, value) {
+        if (index < this.getLength()) {
+            // Check before materializing: re-writing the value the position already holds must not
+            // degrade the compact identity representation into a materialized array.
+            if (this.skipUnchangedWrites && this.getValueAtIndex(index) === value) {
+                return true;
+            }
+            _class_private_method_get(this, _materialize, materialize).call(this);
+            return super.setValueAtIndex(index, value);
+        }
+        return false;
+    }
+    /**
+   * Reset to the identity sequence of the given length. O(1) — no array is built.
+   *
+   * @private
+   * @param {number} [length] Length of the sequence.
+   */ setDefaultValues(length = this.getLength()) {
+        _class_private_field_set(this, _isIdentity, true);
+        _class_private_field_set(this, _length, length);
+        this.indexedValues = [];
+        this.runLocalHooks('change');
+    }
+    /**
+   * Add values to the sequence and reorganize.
    *
    * @private
    * @param {number} insertionIndex Position inside the list.
    * @param {Array} insertedIndexes List of inserted indexes.
    */ insert(insertionIndex, insertedIndexes) {
+        // Fast path: inserting a contiguous physical block at its own position into an identity sequence
+        // yields another identity sequence, so only the length changes.
+        if (_class_private_field_get(this, _isIdentity) && _class_private_method_get(this, _isContiguousBlockAt, isContiguousBlockAt).call(this, insertionIndex, insertedIndexes)) {
+            _class_private_field_set(this, _length, _class_private_field_get(this, _length) + insertedIndexes.length);
+            super.insert(insertionIndex, insertedIndexes);
+            return;
+        }
+        _class_private_method_get(this, _materialize, materialize).call(this);
         const listAfterUpdate = getIncreasedIndexes(this.getValues(), insertedIndexes);
         this.indexedValues = getListWithInsertedItems(listAfterUpdate, insertionIndex, insertedIndexes);
         super.insert(insertionIndex, insertedIndexes);
     }
     /**
-   * Remove values from the list and reorganize.
+   * Remove values from the sequence and reorganize.
    *
    * @private
    * @param {Array} removedIndexes List of removed indexes.
    */ remove(removedIndexes) {
+        // Fast path: removing any subset of an identity sequence and reindexing the survivors yields
+        // another identity sequence, so only the length changes.
+        if (_class_private_field_get(this, _isIdentity)) {
+            _class_private_field_set(this, _length, _class_private_field_get(this, _length) - _class_private_method_get(this, _countInRange, countInRange).call(this, removedIndexes));
+            super.remove(removedIndexes);
+            return;
+        }
         const listAfterUpdate = getListWithRemovedItems(this.getValues(), removedIndexes);
         this.indexedValues = getDecreasedIndexes(listAfterUpdate, removedIndexes);
         super.remove(removedIndexes);
     }
     /**
+   * Destroys the map instance.
+   */ destroy() {
+        _class_private_field_set(this, _isIdentity, true);
+        _class_private_field_set(this, _length, 0);
+        super.destroy();
+    }
+    /**
    * Initializes the sequence map with an identity function so each index maps to its own physical value.
+   *
+   * The sequence stores physical indexes (numbers), so a write of an unchanged index is provably a
+   * no-op — `skipUnchangedWrites` is always on, which also preserves the compact identity
+   * representation when an identity value is re-written.
    */ constructor(){
         // Not handling custom init function or init value.
-        super((index)=>index);
+        super((index)=>index, {
+            skipUnchangedWrites: true
+        }), _class_private_method_init(this, _materialize), _class_private_method_init(this, _isIdentitySequence), _class_private_method_init(this, _isContiguousBlockAt), _class_private_method_init(this, _countInRange), _class_private_field_init(this, _isIdentity, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _length, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_set(this, _isIdentity, true), _class_private_field_set(this, _length, 0);
+    }
+}
+function materialize() {
+    if (_class_private_field_get(this, _isIdentity)) {
+        this.indexedValues = this.getValues();
+        _class_private_field_set(this, _isIdentity, false);
+    }
+}
+function isIdentitySequence(values) {
+    for(let index = 0; index < values.length; index += 1){
+        if (values[index] !== index) {
+            return false;
+        }
+    }
+    return true;
+}
+function isContiguousBlockAt(insertionIndex, insertedIndexes) {
+    for(let offset = 0; offset < insertedIndexes.length; offset += 1){
+        if (insertedIndexes[offset] !== insertionIndex + offset) {
+            return false;
+        }
+    }
+    return true;
+}
+function countInRange(removedIndexes) {
+    const seen = new Set();
+    for(let i = 0; i < removedIndexes.length; i += 1){
+        const removedIndex = removedIndexes[i];
+        if (removedIndex >= 0 && removedIndex < _class_private_field_get(this, _length)) {
+            seen.add(removedIndex);
+        }
     }
+    return seen.size;
 }

package/translations/maps/trimmingMap.d.ts

@@ -1,13 +1,16 @@
-import { PhysicalIndexToValueMap } from './physicalIndexToValueMap';
+import { BooleanMap } from './booleanMap';
 /**
  * Map for storing mappings from an physical index to a boolean value. It stores information whether physical index is
  * NOT included in a dataset and skipped in the process of rendering.
  *
  * @class TrimmingMap
  */
-export declare class TrimmingMap extends PhysicalIndexToValueMap {
+export declare class TrimmingMap extends BooleanMap {
     /**
      * Initializes the trimming map with an optional default value, defaulting to `false` (not trimmed).
+     *
+     * The map stores flags coerced to booleans, so a write of an unchanged flag is provably a no-op —
+     * `skipUnchangedWrites` is always on, keeping no-op writes from rebuilding the index caches.
      */
     constructor(initValueOrFn?: boolean);
     /**

package/translations/maps/trimmingMap.js

@@ -8,9 +8,9 @@ Object.defineProperty(exports, "TrimmingMap", {
         return TrimmingMap;
     }
 });
-const _physicalIndexToValueMap = require("./physicalIndexToValueMap");
+const _booleanMap = require("./booleanMap");
 const _array = require("../../helpers/array");
-class TrimmingMap extends _physicalIndexToValueMap.PhysicalIndexToValueMap {
+class TrimmingMap extends _booleanMap.BooleanMap {
     /**
    * Get physical indexes which are trimmed.
    *
@@ -27,7 +27,12 @@ class TrimmingMap extends _physicalIndexToValueMap.PhysicalIndexToValueMap {
     }
     /**
    * Initializes the trimming map with an optional default value, defaulting to `false` (not trimmed).
+   *
+   * The map stores flags coerced to booleans, so a write of an unchanged flag is provably a no-op —
+   * `skipUnchangedWrites` is always on, keeping no-op writes from rebuilding the index caches.
    */ constructor(initValueOrFn = false){
-        super(initValueOrFn);
+        super(initValueOrFn, {
+            skipUnchangedWrites: true
+        });
     }
 }

package/translations/maps/trimmingMap.mjs

@@ -1,11 +1,11 @@
-import { PhysicalIndexToValueMap } from './physicalIndexToValueMap.mjs';
+import { BooleanMap } from './booleanMap.mjs';
 import { arrayReduce } from '../../helpers/array.mjs';
 /**
  * Map for storing mappings from an physical index to a boolean value. It stores information whether physical index is
  * NOT included in a dataset and skipped in the process of rendering.
  *
  * @class TrimmingMap
- */ export class TrimmingMap extends PhysicalIndexToValueMap {
+ */ export class TrimmingMap extends BooleanMap {
     /**
    * Get physical indexes which are trimmed.
    *
@@ -22,7 +22,12 @@ import { arrayReduce } from '../../helpers/array.mjs';
     }
     /**
    * Initializes the trimming map with an optional default value, defaulting to `false` (not trimmed).
+   *
+   * The map stores flags coerced to booleans, so a write of an unchanged flag is provably a no-op —
+   * `skipUnchangedWrites` is always on, keeping no-op writes from rebuilding the index caches.
    */ constructor(initValueOrFn = false){
-        super(initValueOrFn);
+        super(initValueOrFn, {
+            skipUnchangedWrites: true
+        });
     }
 }

package/translations/maps/utils/actionsOnIndexes.js

@@ -18,7 +18,26 @@ _export(exports, {
 });
 const _array = require("../../../helpers/array");
 function getDecreasedIndexes(indexedValues, removedIndexes) {
-    return (0, _array.arrayMap)(indexedValues, (index)=>index - removedIndexes.filter((removedIndex)=>removedIndex < index).length);
+    if (removedIndexes.length === 0) {
+        return indexedValues.slice();
+    }
+    // Sort the removed indexes once, then for each value count how many removed indexes are below it
+    // with a binary search. This replaces a per-element `removedIndexes.filter(...)` (O(n × k)) with
+    // O(n log k) — the dominant cost when removing many rows from a large dataset.
+    const sortedRemoved = Int32Array.from(removedIndexes).sort();
+    return (0, _array.arrayMap)(indexedValues, (index)=>{
+        let low = 0;
+        let high = sortedRemoved.length;
+        while(low < high){
+            const mid = Math.floor((low + high) / 2);
+            if (sortedRemoved[mid] < index) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        return index - low;
+    });
 }
 function getIncreasedIndexes(indexedValues, insertedIndexes) {
     const firstInsertedIndex = insertedIndexes[0];

package/translations/maps/utils/actionsOnIndexes.mjs

@@ -7,7 +7,26 @@ import { arrayMap } from '../../../helpers/array.mjs';
  * @param {Array} removedIndexes List of removed indexes.
  * @returns {Array} List with decreased indexes.
  */ export function getDecreasedIndexes(indexedValues, removedIndexes) {
-    return arrayMap(indexedValues, (index)=>index - removedIndexes.filter((removedIndex)=>removedIndex < index).length);
+    if (removedIndexes.length === 0) {
+        return indexedValues.slice();
+    }
+    // Sort the removed indexes once, then for each value count how many removed indexes are below it
+    // with a binary search. This replaces a per-element `removedIndexes.filter(...)` (O(n × k)) with
+    // O(n log k) — the dominant cost when removing many rows from a large dataset.
+    const sortedRemoved = Int32Array.from(removedIndexes).sort();
+    return arrayMap(indexedValues, (index)=>{
+        let low = 0;
+        let high = sortedRemoved.length;
+        while(low < high){
+            const mid = Math.floor((low + high) / 2);
+            if (sortedRemoved[mid] < index) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        return index - low;
+    });
 }
 /**
  * Transform mappings after insertion.

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
+    };
+}