handsontable 18.0.0 → 18.1.0-rc7

package/cellTypes/intlDatetimeType/intlDatetimeType.js

@@ -0,0 +1,31 @@
+"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 CELL_TYPE () {
+        return CELL_TYPE;
+    },
+    get IntlDatetimeCellType () {
+        return IntlDatetimeCellType;
+    }
+});
+const _intlDatetimeEditor = require("../../editors/intlDatetimeEditor");
+const _intlDatetimeRenderer = require("../../renderers/intlDatetimeRenderer");
+const _intlDatetimeValidator = require("../../validators/intlDatetimeValidator");
+const CELL_TYPE = 'intl-datetime';
+const IntlDatetimeCellType = {
+    CELL_TYPE,
+    editor: _intlDatetimeEditor.IntlDatetimeEditor,
+    renderer: _intlDatetimeRenderer.intlDatetimeRenderer,
+    validator: _intlDatetimeValidator.intlDatetimeValidator,
+    sourceDataValidator: _intlDatetimeValidator.sourceDataValidator,
+    sourceDataWarningMessage: _intlDatetimeValidator.SOURCE_DATA_WARNING_MESSAGE,
+    valueFormatter: _intlDatetimeRenderer.valueFormatter
+};

package/cellTypes/intlDatetimeType/intlDatetimeType.mjs

@@ -0,0 +1,15 @@
+import { IntlDatetimeEditor } from '../../editors/intlDatetimeEditor/index.mjs';
+import { intlDatetimeRenderer, valueFormatter } from '../../renderers/intlDatetimeRenderer/index.mjs';
+import { SOURCE_DATA_WARNING_MESSAGE, intlDatetimeValidator, sourceDataValidator } from '../../validators/intlDatetimeValidator/index.mjs';
+export const CELL_TYPE = 'intl-datetime';
+/**
+ * Intl datetime cell type configuration object that bundles the editor, renderer, and validator.
+ */ export const IntlDatetimeCellType = {
+    CELL_TYPE,
+    editor: IntlDatetimeEditor,
+    renderer: intlDatetimeRenderer,
+    validator: intlDatetimeValidator,
+    sourceDataValidator,
+    sourceDataWarningMessage: SOURCE_DATA_WARNING_MESSAGE,
+    valueFormatter
+};

package/cellTypes/multiSelectType/index.d.ts

@@ -1 +1 @@
-export { CELL_TYPE, MultiSelectCellType, } from './multiSelectType';
+export { CELL_TYPE, LEGACY_CELL_TYPE, MultiSelectCellType, } from './multiSelectType';

package/cellTypes/multiSelectType/index.js

@@ -12,6 +12,9 @@ _export(exports, {
     get CELL_TYPE () {
         return _multiSelectType.CELL_TYPE;
     },
+    get LEGACY_CELL_TYPE () {
+        return _multiSelectType.LEGACY_CELL_TYPE;
+    },
     get MultiSelectCellType () {
         return _multiSelectType.MultiSelectCellType;
     }

package/cellTypes/multiSelectType/index.mjs

@@ -1 +1 @@
-export { CELL_TYPE, MultiSelectCellType } from './multiSelectType.mjs';
+export { CELL_TYPE, LEGACY_CELL_TYPE, MultiSelectCellType } from './multiSelectType.mjs';

package/cellTypes/multiSelectType/multiSelectType.d.ts

@@ -3,6 +3,7 @@ import { multiSelectRenderer } from '../../renderers/multiSelectRenderer';
 import { multiSelectValidator } from '../../validators/multiSelectValidator';
 import { valueGetter, valueSetter } from './accessors';
 export declare const CELL_TYPE = "multiselect";
+export declare const LEGACY_CELL_TYPE = "multiSelect";
 export declare const MultiSelectCellType: {
     CELL_TYPE: string;
     _complexDataFormat: boolean;

package/cellTypes/multiSelectType/multiSelectType.js

@@ -12,6 +12,9 @@ _export(exports, {
     get CELL_TYPE () {
         return CELL_TYPE;
     },
+    get LEGACY_CELL_TYPE () {
+        return LEGACY_CELL_TYPE;
+    },
     get MultiSelectCellType () {
         return MultiSelectCellType;
     }
@@ -21,6 +24,7 @@ const _multiSelectRenderer = require("../../renderers/multiSelectRenderer");
 const _multiSelectValidator = require("../../validators/multiSelectValidator");
 const _accessors = require("./accessors");
 const CELL_TYPE = 'multiselect';
+const LEGACY_CELL_TYPE = 'multiSelect';
 const MultiSelectCellType = {
     CELL_TYPE,
     _complexDataFormat: true,

package/cellTypes/multiSelectType/multiSelectType.mjs

@@ -3,6 +3,7 @@ import { multiSelectRenderer } from '../../renderers/multiSelectRenderer/index.m
 import { multiSelectValidator } from '../../validators/multiSelectValidator/index.mjs';
 import { valueGetter, valueSetter } from './accessors/index.mjs';
 export const CELL_TYPE = 'multiselect';
+export const LEGACY_CELL_TYPE = 'multiSelect';
 export const MultiSelectCellType = {
     CELL_TYPE,
     _complexDataFormat: true,

package/cellTypes/numericType/accessors/valueSetter.js

@@ -48,11 +48,39 @@ function valueSetter(newValue, _row, _column, cellMeta) {
         return newValue;
     }
     const decimalSeparator = getCellDecimalSeparator(cellMeta);
-    if ((0, _number.isNumericLike)(newValue) || (0, _number.isCommaThousandsGroupedInteger)(newValue, decimalSeparator) || (0, _number.isDotThousandsGroupedInteger)(newValue, decimalSeparator) || (0, _number.isDotThousandsGroupedFloat)(newValue, decimalSeparator)) {
+    const isCommaGrouped = (0, _number.isCommaThousandsGroupedInteger)(newValue, decimalSeparator);
+    const isDotGroupedInteger = (0, _number.isDotThousandsGroupedInteger)(newValue, decimalSeparator);
+    const isDotGroupedFloat = (0, _number.isDotThousandsGroupedFloat)(newValue, decimalSeparator);
+    if ((0, _number.isNumericLike)(newValue) || isCommaGrouped || isDotGroupedInteger || isDotGroupedFloat) {
         const parsedNumber = (0, _number.getParsedNumber)(newValue, {
             decimalSeparator
         });
-        return (0, _utils.isNullish)(parsedNumber) ? newValue : parsedNumber;
+        if ((0, _utils.isNullish)(parsedNumber)) {
+            return newValue;
+        }
+        const isGrouped = isCommaGrouped || isDotGroupedInteger || isDotGroupedFloat;
+        // `isNumeric` also accepts hexadecimal literals (`0x1A`), but `getParsedNumber` reads them
+        // with `parseFloat`, which stops at the `x` — that mismatch is a parser artifact, not
+        // information loss, so hex input must never be preserved.
+        const isHexLiteral = /^[+-]?0x/i.test(newValue.trim());
+        // Literals outside the finite double range (`1e400` → `Infinity`) and non-zero literals that
+        // underflow to zero (`1e-400` → `0`) overflow the number's magnitude rather than losing
+        // trailing zeros or integer precision, so they are stored as the parsed number like any
+        // other input. The underflow check reads only mantissa digits — exponent digits must not
+        // make a genuine zero literal (`0.0e-5`) look non-zero.
+        const mantissaDigits = newValue.trim().replace(/e[+-]?\d+$/i, '');
+        const isMagnitudeOverflow = !Number.isFinite(parsedNumber) || parsedNumber === 0 && /[1-9]/.test(mantissaDigits);
+        // Opt-in: keep the original literal when parsing to a JS number would lose information
+        // (trailing fractional zeros like `9.0`, or precision beyond Number.MAX_SAFE_INTEGER). This
+        // preserves what the user typed in the editor, matching spreadsheet behavior. Gated behind
+        // `preserveNumericLiteral` (default `false`) so existing configurations are unchanged. The
+        // guard is limited to plain, dot-decimal literals (`isNumeric`): grouping removal
+        // (e.g. `7.000` → 7000) is intended, and preserving a comma-bearing literal (`9,0`, `0,100`)
+        // would break numeric rendering and validation, which do not accept a comma decimal separator.
+        if (cellMeta.preserveNumericLiteral === true && !isGrouped && !isHexLiteral && !isMagnitudeOverflow && (0, _number.isNumeric)(newValue) && (0, _number.isLossyNumericConversion)(newValue, parsedNumber)) {
+            return newValue.trim();
+        }
+        return parsedNumber;
     }
     return newValue;
 }

package/cellTypes/numericType/accessors/valueSetter.mjs

@@ -1,4 +1,4 @@
-import { isCommaThousandsGroupedInteger, isDotThousandsGroupedInteger, isDotThousandsGroupedFloat, isNumericLike, getParsedNumber } from '../../../helpers/number.mjs';
+import { isCommaThousandsGroupedInteger, isDotThousandsGroupedInteger, isDotThousandsGroupedFloat, isLossyNumericConversion, isNumeric, isNumericLike, getParsedNumber } from '../../../helpers/number.mjs';
 import { isNullish } from '../../../dataMap/metaManager/utils.mjs';
 /**
  * Gets the decimal separator preferred by the cell.
@@ -46,11 +46,39 @@ import { isNullish } from '../../../dataMap/metaManager/utils.mjs';
         return newValue;
     }
     const decimalSeparator = getCellDecimalSeparator(cellMeta);
-    if (isNumericLike(newValue) || isCommaThousandsGroupedInteger(newValue, decimalSeparator) || isDotThousandsGroupedInteger(newValue, decimalSeparator) || isDotThousandsGroupedFloat(newValue, decimalSeparator)) {
+    const isCommaGrouped = isCommaThousandsGroupedInteger(newValue, decimalSeparator);
+    const isDotGroupedInteger = isDotThousandsGroupedInteger(newValue, decimalSeparator);
+    const isDotGroupedFloat = isDotThousandsGroupedFloat(newValue, decimalSeparator);
+    if (isNumericLike(newValue) || isCommaGrouped || isDotGroupedInteger || isDotGroupedFloat) {
         const parsedNumber = getParsedNumber(newValue, {
             decimalSeparator
         });
-        return isNullish(parsedNumber) ? newValue : parsedNumber;
+        if (isNullish(parsedNumber)) {
+            return newValue;
+        }
+        const isGrouped = isCommaGrouped || isDotGroupedInteger || isDotGroupedFloat;
+        // `isNumeric` also accepts hexadecimal literals (`0x1A`), but `getParsedNumber` reads them
+        // with `parseFloat`, which stops at the `x` — that mismatch is a parser artifact, not
+        // information loss, so hex input must never be preserved.
+        const isHexLiteral = /^[+-]?0x/i.test(newValue.trim());
+        // Literals outside the finite double range (`1e400` → `Infinity`) and non-zero literals that
+        // underflow to zero (`1e-400` → `0`) overflow the number's magnitude rather than losing
+        // trailing zeros or integer precision, so they are stored as the parsed number like any
+        // other input. The underflow check reads only mantissa digits — exponent digits must not
+        // make a genuine zero literal (`0.0e-5`) look non-zero.
+        const mantissaDigits = newValue.trim().replace(/e[+-]?\d+$/i, '');
+        const isMagnitudeOverflow = !Number.isFinite(parsedNumber) || parsedNumber === 0 && /[1-9]/.test(mantissaDigits);
+        // Opt-in: keep the original literal when parsing to a JS number would lose information
+        // (trailing fractional zeros like `9.0`, or precision beyond Number.MAX_SAFE_INTEGER). This
+        // preserves what the user typed in the editor, matching spreadsheet behavior. Gated behind
+        // `preserveNumericLiteral` (default `false`) so existing configurations are unchanged. The
+        // guard is limited to plain, dot-decimal literals (`isNumeric`): grouping removal
+        // (e.g. `7.000` → 7000) is intended, and preserving a comma-bearing literal (`9,0`, `0,100`)
+        // would break numeric rendering and validation, which do not accept a comma decimal separator.
+        if (cellMeta.preserveNumericLiteral === true && !isGrouped && !isHexLiteral && !isMagnitudeOverflow && isNumeric(newValue) && isLossyNumericConversion(newValue, parsedNumber)) {
+            return newValue.trim();
+        }
+        return parsedNumber;
     }
     return newValue;
 }

package/core/hooks/bucket.d.ts

@@ -1,14 +1,37 @@
-export type HookCallback = (...args: unknown[]) => unknown;
+/**
+ * The storage type for hook listeners. `(...args: never[]) => unknown` is the "top type" of
+ * functions: every function is assignable to it (parameter contravariance -- `never` is assignable
+ * to every type), yet it cannot be invoked without a deliberate cast. This lets the hooks system
+ * accept any correctly-typed listener without resorting to `any`, while confining the unavoidable
+ * dynamically-typed call to a single cast at the dispatch boundary (`fastCall`).
+ */
+export type HookCallback = (...args: never[]) => unknown;
 export interface HookEntry {
     callback: HookCallback;
     orderIndex: number;
     runOnce: boolean;
     initialHook: boolean;
-    skip: boolean;
+    /**
+     * Intrusive singly-linked-list pointer to the next entry. The entry IS the list node (no wrapper
+     * object) so dispatch reads `entry.callback` with a single indirection. `null` marks the tail.
+     */
+    next: HookEntry | null;
+}
+/**
+ * A per-hook singly-linked list. `head`/`tail` allow O(1) append; dispatch walks `head` → `next`.
+ */
+interface HookList {
+    head: HookEntry | null;
+    tail: HookEntry | null;
 }
 /**
  * The class represents a collection that allows to manage hooks (add, remove).
  *
+ * Storage is a `Map<hookName, singly-linked list of entries>`. Removal is a true delete (relink) — there
+ * is no soft-delete `skip` flag and no periodic compaction. An in-flight `run()` stays correct because it
+ * reads `entry.next` fresh after each callback (a later entry removed mid-run is skipped) and never nulls a
+ * removed node's `next` (a callback removing itself can still advance).
+ *
  * @class HooksBucket
  */
 export declare class HooksBucket {
@@ -18,7 +41,17 @@ export declare class HooksBucket {
      */
     constructor();
     /**
-     * Gets all hooks for the provided hook name.
+     * Gets the internal linked list for the provided hook name. Used by the dispatcher (`Hooks#runHandlers`)
+     * to walk entries without materializing an array on the hot path.
+     *
+     * @param {string} hookName The name of the hook.
+     * @returns {HookList|null}
+     */
+    getList(hookName: string): HookList | null;
+    /**
+     * Gets all live hooks for the provided hook name as an array, in execution order. The returned entries are
+     * the live list nodes (not copies), so an in-place `addAsFixed` callback swap is reflected in a
+     * previously returned array — relied on by the framework wrappers.
      *
      * @param {string} hookName The name of the hook.
      * @returns {HookEntry[]}
@@ -37,15 +70,15 @@ export declare class HooksBucket {
         initialHook?: boolean;
     }): void;
     /**
-     * Checks if there are any hooks for the provided hook name.
+     * Checks if there are any live hooks for the provided hook name.
      *
      * @param {string} hookName The name of the hook.
      * @returns {boolean}
      */
     has(hookName: string): boolean;
     /**
-     * Removes a hook from the collection. If the hook was found and removed,
-     * the method returns `true`, otherwise `false`.
+     * Removes a hook from the collection (true delete). Returns `true` if the callback was found and removed,
+     * `false` otherwise.
      *
      * @param {string} hookName The name of the hook.
      * @param {*} callback The callback function to remove.
@@ -57,3 +90,4 @@ export declare class HooksBucket {
      */
     destroy(): void;
 }
+export {};

package/core/hooks/bucket.js

@@ -59,28 +59,49 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
-/**
- * The maximum number of hooks that can be skipped before the bucket is cleaned up.
- */ const MAX_SKIPPED_HOOKS_COUNT = 100;
 var /**
-   * A map that stores hooks.
+   * A map that stores the per-hook linked lists.
    */ _hooks = /*#__PURE__*/ new WeakMap(), /**
-   * A map that stores the number of skipped hooks.
-   */ _skippedHooksCount = /*#__PURE__*/ new WeakMap(), /**
-   * A set that stores hook names that need to be re-sorted.
-   */ _needsSort = /*#__PURE__*/ new WeakMap(), /**
-   * Creates a initial collection for the provided hook name.
+   * Inserts an entry keeping the list sorted by ascending `orderIndex`. Entries with an equal `orderIndex`
+   * keep insertion order (stable). The common case (`orderIndex` 0, appended after equal entries) is an
+   * O(1) tail append.
+   *
+   * @param {HookList} list The list to insert into.
+   * @param {HookEntry} entry The entry to insert.
+   */ _insertByOrder = /*#__PURE__*/ new WeakSet(), /**
+   * Creates an initial (empty) collection for the provided hook name.
    *
    * @param {string} hookName The name of the hook.
+   * @returns {HookList}
    */ _createHooksCollection = /*#__PURE__*/ new WeakSet();
 class HooksBucket {
     /**
-   * Gets all hooks for the provided hook name.
+   * Gets the internal linked list for the provided hook name. Used by the dispatcher (`Hooks#runHandlers`)
+   * to walk entries without materializing an array on the hot path.
+   *
+   * @param {string} hookName The name of the hook.
+   * @returns {HookList|null}
+   */ getList(hookName) {
+        return _class_private_field_get(this, _hooks).get(hookName) ?? null;
+    }
+    /**
+   * Gets all live hooks for the provided hook name as an array, in execution order. The returned entries are
+   * the live list nodes (not copies), so an in-place `addAsFixed` callback swap is reflected in a
+   * previously returned array — relied on by the framework wrappers.
    *
    * @param {string} hookName The name of the hook.
    * @returns {HookEntry[]}
    */ getHooks(hookName) {
-        return _class_private_field_get(this, _hooks).get(hookName) ?? [];
+        const list = _class_private_field_get(this, _hooks).get(hookName);
+        const result = [];
+        if (list) {
+            let node = list.head;
+            while(node){
+                result.push(node);
+                node = node.next;
+            }
+        }
+        return result;
     }
     /**
    * Adds a new hook to the collection.
@@ -89,80 +110,76 @@ class HooksBucket {
    * @param {Function} callback The callback function to add.
    * @param {{ orderIndex?: number, runOnce?: boolean, initialHook?: boolean }} options The options object.
    */ add(hookName, callback, options = {}) {
-        if (!_class_private_field_get(this, _hooks).has(hookName)) {
-            _class_private_method_get(this, _createHooksCollection, createHooksCollection).call(this, hookName);
+        let list = _class_private_field_get(this, _hooks).get(hookName);
+        if (!list) {
+            list = _class_private_method_get(this, _createHooksCollection, createHooksCollection).call(this, hookName);
             _constants.REGISTERED_HOOKS.push(hookName);
         }
-        const hooks = _class_private_field_get(this, _hooks).get(hookName) ?? [];
-        const existingHook = hooks.find((hook)=>hook.callback === callback);
-        if (existingHook) {
-            if (existingHook.skip === true) {
-                // Re-enable the hook if it was previously added and then removed.
-                existingHook.skip = false;
+        // Adding the same callback twice is silently ignored. With true-delete a match is always a live entry.
+        for(let node = list.head; node !== null; node = node.next){
+            if (node.callback === callback) {
+                return;
             }
-            // adding the same hook twice is now silently ignored
-            return;
         }
         const orderIndex = Number.isInteger(options.orderIndex) ? options.orderIndex ?? 0 : 0;
         const runOnce = !!options.runOnce;
         const initialHook = !!options.initialHook;
-        let foundInitialHook = false;
         if (initialHook) {
-            const initialHookEntry = hooks.find((hook)=>hook.initialHook);
-            if (initialHookEntry) {
-                initialHookEntry.callback = callback;
-                foundInitialHook = true;
-            }
-        }
-        if (!foundInitialHook) {
-            hooks.push({
-                callback,
-                orderIndex,
-                runOnce,
-                initialHook,
-                skip: false
-            });
-            let needsSort = _class_private_field_get(this, _needsSort).has(hookName);
-            if (!needsSort && orderIndex !== 0) {
-                needsSort = true;
-                _class_private_field_get(this, _needsSort).add(hookName);
-            }
-            if (needsSort && hooks.length > 1) {
-                _class_private_field_get(this, _hooks).set(hookName, hooks.toSorted((a, b)=>a.orderIndex - b.orderIndex));
+            // Replace the callback of the existing initial hook IN PLACE — keeps the entry object and its
+            // position, so an array previously returned by getHooks() reflects the swap (wrapper contract).
+            for(let node = list.head; node !== null; node = node.next){
+                if (node.initialHook) {
+                    node.callback = callback;
+                    return;
+                }
             }
         }
+        _class_private_method_get(this, _insertByOrder, insertByOrder).call(this, list, {
+            callback,
+            orderIndex,
+            runOnce,
+            initialHook,
+            next: null
+        });
     }
     /**
-   * Checks if there are any hooks for the provided hook name.
+   * Checks if there are any live hooks for the provided hook name.
    *
    * @param {string} hookName The name of the hook.
    * @returns {boolean}
    */ has(hookName) {
-        return _class_private_field_get(this, _hooks).has(hookName) && (_class_private_field_get(this, _hooks).get(hookName)?.length ?? 0) > 0;
+        const list = _class_private_field_get(this, _hooks).get(hookName);
+        return !!list && list.head !== null;
     }
     /**
-   * Removes a hook from the collection. If the hook was found and removed,
-   * the method returns `true`, otherwise `false`.
+   * Removes a hook from the collection (true delete). Returns `true` if the callback was found and removed,
+   * `false` otherwise.
    *
    * @param {string} hookName The name of the hook.
    * @param {*} callback The callback function to remove.
    * @returns {boolean}
    */ remove(hookName, callback) {
-        if (!_class_private_field_get(this, _hooks).has(hookName)) {
+        const list = _class_private_field_get(this, _hooks).get(hookName);
+        if (!list) {
             return false;
         }
-        const hooks = _class_private_field_get(this, _hooks).get(hookName) ?? [];
-        const hookEntry = hooks.find((hook)=>hook.callback === callback);
-        if (hookEntry) {
-            let skippedHooksCount = _class_private_field_get(this, _skippedHooksCount).get(hookName) ?? 0;
-            hookEntry.skip = true;
-            skippedHooksCount += 1;
-            if (skippedHooksCount > MAX_SKIPPED_HOOKS_COUNT) {
-                _class_private_field_get(this, _hooks).set(hookName, hooks.filter((hook)=>!hook.skip));
-                skippedHooksCount = 0;
+        let prev = null;
+        let node = list.head;
+        while(node !== null){
+            if (node.callback === callback) {
+                if (prev) {
+                    prev.next = node.next;
+                } else {
+                    list.head = node.next;
+                }
+                if (node === list.tail) {
+                    list.tail = prev;
+                }
+                // Intentionally do NOT null `node.next`: an in-flight run() may hold this node and needs to advance.
+                return true;
             }
-            _class_private_field_get(this, _skippedHooksCount).set(hookName, skippedHooksCount);
-            return true;
+            prev = node;
+            node = node.next;
         }
         return false;
     }
@@ -170,31 +187,50 @@ class HooksBucket {
    * Destroys the bucket.
    */ destroy() {
         _class_private_field_get(this, _hooks).clear();
-        _class_private_field_get(this, _skippedHooksCount).clear();
     }
     /**
    * Initializes the bucket and pre-creates empty hook collections for all currently registered hook names.
    */ constructor(){
+        _class_private_method_init(this, _insertByOrder);
         _class_private_method_init(this, _createHooksCollection);
         _class_private_field_init(this, _hooks, {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _skippedHooksCount, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _needsSort, {
-            writable: true,
-            value: void 0
-        });
         _class_private_field_set(this, _hooks, new Map());
-        _class_private_field_set(this, _skippedHooksCount, new Map());
-        _class_private_field_set(this, _needsSort, new Set());
         _constants.REGISTERED_HOOKS.forEach((hookName)=>_class_private_method_get(this, _createHooksCollection, createHooksCollection).call(this, hookName));
     }
 }
+function insertByOrder(list, entry) {
+    if (list.head === null) {
+        list.head = entry;
+        list.tail = entry;
+        return;
+    }
+    if (entry.orderIndex >= list.tail.orderIndex) {
+        list.tail.next = entry;
+        list.tail = entry;
+        return;
+    }
+    let prev = null;
+    let node = list.head;
+    while(node !== null && node.orderIndex <= entry.orderIndex){
+        prev = node;
+        node = node.next;
+    }
+    if (prev === null) {
+        entry.next = list.head;
+        list.head = entry;
+    } else {
+        entry.next = node;
+        prev.next = entry;
+    }
+}
 function createHooksCollection(hookName) {
-    _class_private_field_get(this, _hooks).set(hookName, []);
-    _class_private_field_get(this, _skippedHooksCount).set(hookName, 0);
+    const list = {
+        head: null,
+        tail: null
+    };
+    _class_private_field_get(this, _hooks).set(hookName, list);
+    return list;
 }