ng-virtual-list 14.12.0 → 14.12.2

package/esm2020/lib/ng-virtual-list.component.mjs

@@ -0,0 +1,3255 @@
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, inject, Input, Output, ViewChild, ViewContainerRef, ViewEncapsulation, } from '@angular/core';
+import { BehaviorSubject, combineLatest, debounceTime, delay, distinctUntilChanged, filter, fromEvent, map, of, skip, Subject, switchMap, take, takeUntil, tap, } from 'rxjs';
+import { NgVirtualListItemComponent } from './components/ng-list-item/ng-virtual-list-item.component';
+import { BEHAVIOR_INSTANT, CLASS_LIST_HORIZONTAL, CLASS_LIST_VERTICAL, DEFAULT_DIRECTION, DEFAULT_DYNAMIC_SIZE, DEFAULT_ENABLED_BUFFER_OPTIMIZATION, DEFAULT_ITEM_SIZE, DEFAULT_BUFFER_SIZE, DEFAULT_LIST_SIZE, DEFAULT_STICKY_ENABLED, DEFAULT_SNAPPING_METHOD, HEIGHT_PROP_NAME, LEFT_PROP_NAME, MAX_SCROLL_TO_ITERATIONS, PX, FOCUS, TOP_PROP_NAME, TRACK_BY_PROPERTY_NAME, WIDTH_PROP_NAME, DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SELECTING_MODES, DEFAULT_SELECT_BY_CLICK, DEFAULT_COLLAPSE_BY_CLICK, DEFAULT_COLLECTION_MODE, DEFAULT_SCREEN_READER_MESSAGE, DEFAULT_SNAP_TO_END_TRANSITION_INSTANT_OFFSET, DEFAULT_SNAP_SCROLLTO_END, MIN_PIXELS_FOR_PREVENT_SNAPPING, MOUSE_DOWN, TOUCH_START, DEFAULT_LANG_TEXT_DIR, DEFAULT_CLICK_DISTANCE, DEFAULT_WAIT_FOR_PREPARATION, DEFAULT_SCROLLBAR_THICKNESS, DEFAULT_SCROLLBAR_MIN_SIZE, KEY_DOWN, BEHAVIOR_AUTO, DEFAULT_SCROLLBAR_ENABLED, DEFAULT_SCROLLBAR_INTERACTIVE, DEFAULT_OVERSCROLL_ENABLED, DEFAULT_ANIMATION_PARAMS, DEFAULT_SCROLL_BEHAVIOR, DEFAULT_SNAP_SCROLLTO_START, EMPTY_SCROLL_STATE_VERSION, MAX_REGULAR_SNAPED_COMPONENTS, PREPARE_ITERATIONS, PREPARATION_REUPDATE_LENGTH, ROLE_LIST_BOX, ROLE_LIST, KEY_TAB, MAX_VELOCITY_FOR_SCROLL_QUALITY_OPTIMIZATION_LVL1, PREPARE_ITERATIONS_FOR_UPDATE_ITEMS, PREPARATION_REUPDATE_LENGTH_FOR_UPDATE_ITEMS, PREPARE_ITERATIONS_FOR_COLLAPSE_ITEMS, PREPARATION_REUPDATE_LENGTH_FOR_COLLAPSE_ITEMS, MAX_NUMBERS_OF_SKIPS_FOR_QUALITY_OPTIMIZATION_LVL1, DEFAULT_SCROLLING_SETTINGS, DEFAULT_SNAP_TO_ITEM, DEFAULT_SNAP_TO_ITEM_ALIGN, VIEWPORT, DEFAULT_MOTION_BLUR, DEFAULT_MAX_MOTION_BLUR, DEFAULT_SCROLLING_ONE_BY_ONE, DEFAULT_MOTION_BLUR_ENABLED, DEFAULT_DIVIDES, DEFAULT_SNAPPING_DISTANCE, DEFAULT_MAX_ITEM_SIZE, DEFAULT_MIN_ITEM_SIZE, DEFAULT_ALIGNMENT, DEFAULT_COLLAPSING_MODES, DEFAULT_SPREADING_MODE, DEFAULT_ZINDEX_WHEN_SELECTING, DEFAULT_OVERLAPPING_SCROLLBAR, } from './const';
+import { Alignments, CollectionModes, Directions, FocusAlignments, SelectingModes, SnappingMethods, SnapToItemAligns, SpreadingModes, TextDirections, } from './enums';
+import { debounce, ScrollEvent, toggleClassName } from './utils';
+import { TrackBox } from './core/track-box';
+import { isSnappingMethodAdvenced } from './utils/snapping-method';
+import { isDirection } from './utils/is-direction';
+import { NgVirtualListService } from './ng-virtual-list.service';
+import { isSelectMode } from './utils/is-select-mode';
+import { isCollapseMode } from './utils/is-collapse-mode';
+import { SelectingModesTypes } from './enums/selecting-modes-types';
+import { CMap } from './utils/cmap';
+import { validateArray, validateBoolean, validateFloat, validateFunction, validateInt, validateObject, validateString, } from './utils/validation';
+import { copyValueAsReadonly, objectAsReadonly } from './utils/object';
+import { isCollectionMode } from './utils/is-collection-mode';
+import { NgScrollerComponent } from './components/ng-scroller/ng-scroller.component';
+import { NgPrerenderContainer } from './components/ng-prerender-container/ng-prerender-container.component';
+import { formatActualDisplayItems, formatScreenReaderMessage } from './utils/screen-reader-formatter';
+import { validateId, validateIteration, validateScrollBehavior, validateScrollIteration } from './utils/list-validators';
+import { EVENT_KEY_DOWN, KEY_ARR_DOWN, KEY_ARR_LEFT, KEY_ARR_RIGHT, KEY_ARR_UP } from './components/ng-list-item/const';
+import { NgVirtualListPublicService } from './ng-virtual-list-public.service';
+import { isPercentageValue } from './utils/is-persentage-value';
+import { parseArithmeticExpression } from './utils/parse-arithmetic-expression';
+import { normalizeCollection } from './utils/normalize-collection';
+import { CollapsingModes } from './enums';
+import { isSpreadingMode } from './utils/is-spreading-mode';
+import { getScrollStateVersion } from './utils/get-scroll-state-version';
+import { DisposableComponent } from './utils/disposable-component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./components/ng-scroller/ng-scroller.component";
+import * as i3 from "./components/ng-prerender-container/ng-prerender-container.component";
+import * as i4 from "./directives/locale-sensitive/locale-sensitive.directive";
+/**
+ * Virtual list component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/ng-virtual-list.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class NgVirtualListComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this._id = NgVirtualListComponent.__nextId;
+        this._service = inject(NgVirtualListService);
+        this._$scroller = new BehaviorSubject(undefined);
+        this.$scroller = this._$scroller.asObservable();
+        this._$list = new BehaviorSubject(undefined);
+        this.$list = this._$list.asObservable();
+        /**
+         * Fires when the list has been scrolled.
+         */
+        this.onScroll = new EventEmitter();
+        /**
+         * Fires when the list has completed scrolling.
+         */
+        this.onScrollEnd = new EventEmitter();
+        /**
+         * Fires when the viewport size is changed.
+         */
+        this.onViewportChange = new EventEmitter();
+        /**
+         * Emit the component ID when an element crosses the alignment line specified by the snapToItemAlign property.
+         */
+        this.onSnapItem = new EventEmitter();
+        /**
+         * Fires when an element is clicked.
+         */
+        this.onItemClick = new EventEmitter();
+        /**
+         * Fires when elements are selected.
+         */
+        this.onSelect = new EventEmitter();
+        /**
+         * Fires when elements are collapsed.
+         */
+        this.onCollapse = new EventEmitter();
+        /**
+         * Fires when the scroll reaches the start.
+         */
+        this.onScrollReachStart = new EventEmitter();
+        /**
+         * Fires when the scroll reaches the end.
+         */
+        this.onScrollReachEnd = new EventEmitter();
+        this._$show = new BehaviorSubject(false);
+        this.$show = this._$show.asObservable();
+        this._$initialized = new BehaviorSubject(false);
+        this.$initialized = this._$initialized.asObservable();
+        this._$scrollbarThickness = new BehaviorSubject(DEFAULT_SCROLLBAR_THICKNESS);
+        this.$scrollbarThickness = this._$scrollbarThickness.asObservable();
+        this._scrollbarThicknessTransform = (v) => {
+            const valid = validateInt(v, true);
+            if (!valid) {
+                console.error('The "scrollbarThickness" parameter must be of type `number`.');
+                return DEFAULT_SCROLLBAR_THICKNESS;
+            }
+            return v;
+        };
+        this._$scrollbarMinSize = new BehaviorSubject(DEFAULT_SCROLLBAR_MIN_SIZE);
+        this.$scrollbarMinSize = this._$scrollbarMinSize.asObservable();
+        this._scrollbarMinSizeTransform = (v) => {
+            const valid = validateInt(v);
+            if (!valid) {
+                console.error('The "scrollbarMinSize" parameter must be of type `number`.');
+                return DEFAULT_SCROLLBAR_MIN_SIZE;
+            }
+            return v;
+        };
+        this._$scrollbarThumbRenderer = new BehaviorSubject(null);
+        this.$scrollbarThumbRenderer = this._$scrollbarThumbRenderer.asObservable();
+        this._scrollbarThumbRendererTransform = (v) => {
+            const valid = validateObject(v, true, true);
+            if (!valid) {
+                console.error('The "scrollbarThumbRenderer" parameter must be of type `object`.');
+                return null;
+            }
+            return v;
+        };
+        this._$scrollbarThumbParams = new BehaviorSubject({});
+        this.$scrollbarThumbParams = this._$scrollbarThumbParams.asObservable();
+        this._scrollbarThumbParamsTransform = (v) => {
+            const valid = validateObject(v, true, true);
+            if (!valid) {
+                console.error('The "scrollbarThumbParams" parameter must be of type `object`.');
+                return null;
+            }
+            return v;
+        };
+        this._loading = {
+            transform: (v) => {
+                const valid = validateBoolean(v);
+                if (!valid) {
+                    console.error('The "loading" parameter must be of type `boolean`.');
+                    return false;
+                }
+                return v;
+            },
+        };
+        this._$loading = new BehaviorSubject(false);
+        this.$loading = this._$loading.asObservable();
+        this._loadingTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "loading" parameter must be of type `boolean`.');
+                return false;
+            }
+            return v;
+        };
+        this._$waitForPreparation = new BehaviorSubject(DEFAULT_WAIT_FOR_PREPARATION);
+        this.$waitForPreparation = this._$waitForPreparation.asObservable();
+        this._waitForPreparationTransform = (v) => {
+            const valid = validateObject(v);
+            if (!valid) {
+                console.error('The "waitForPreparation" parameter must be of type `boolean`.');
+                return DEFAULT_WAIT_FOR_PREPARATION;
+            }
+            return v;
+        };
+        this._$clickDistance = new BehaviorSubject(DEFAULT_CLICK_DISTANCE);
+        this.$clickDistance = this._$clickDistance.asObservable();
+        this._clickDistanceTransform = (v) => {
+            const valid = validateInt(v);
+            if (!valid) {
+                console.error('The "clickDistance" parameter must be of type `number`.');
+                return DEFAULT_CLICK_DISTANCE;
+            }
+            return v;
+        };
+        this._$items = new BehaviorSubject([]);
+        this.$items = this._$items.asObservable();
+        this._itemsTransform = (v) => {
+            let valid = validateArray(v, true, true);
+            if (valid) {
+                if (v) {
+                    const trackBy = this.trackBy;
+                    for (let i = 0, l = v.length; i < l; i++) {
+                        const item = v[i];
+                        valid = validateObject(item, true, true);
+                        if (valid) {
+                            if (item && !(validateFloat(item?.[trackBy], true) || validateString(item?.[trackBy], true, true))) {
+                                valid = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!valid) {
+                console.error('The "items" parameter must be of type `IVirtualListCollection` or `null`.');
+                return [];
+            }
+            return v;
+        };
+        this._$selectedIds = new BehaviorSubject(null);
+        this.$selectedIds = this._$selectedIds.asObservable();
+        this._selectedIdsTransform = (v) => {
+            let valid = validateArray(v, true, true) || validateString(v, true, true) || validateFloat(v, true);
+            if (valid) {
+                if (v && Array.isArray(v)) {
+                    for (let i = 0, l = v.length; i < l; i++) {
+                        const item = v[i];
+                        valid = validateString(item) || validateFloat(item);
+                        if (!valid) {
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!valid) {
+                console.error('The "selectedIds" parameter must be of type `Array<Id> | Id` or `null`.');
+                return this._isMultiSelection ? [] : null;
+            }
+            return v;
+        };
+        this._$defaultItemValue = new BehaviorSubject(null);
+        this.$defaultItemValue = this._$defaultItemValue.asObservable();
+        this._$collapsedIds = new BehaviorSubject([]);
+        this.$collapsedIds = this._$collapsedIds.asObservable();
+        this._collapsedIdsTransform = (v) => {
+            let valid = validateArray(v, true, true);
+            if (valid) {
+                if (v && Array.isArray(v)) {
+                    for (let i = 0, l = v.length; i < l; i++) {
+                        const item = v[i];
+                        valid = validateString(item) || validateFloat(item);
+                        if (!valid) {
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!valid) {
+                console.error('The "collapsedIds" parameter must be of type `Array<Id>`.');
+                return [];
+            }
+            return v;
+        };
+        this._$selectByClick = new BehaviorSubject(DEFAULT_SELECT_BY_CLICK);
+        this.$selectByClick = this._$selectByClick.asObservable();
+        this._selectByClickTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "selectByClick" parameter must be of type `boolean`.');
+                return DEFAULT_SELECT_BY_CLICK;
+            }
+            return v;
+        };
+        this._$collapseByClick = new BehaviorSubject(DEFAULT_COLLAPSE_BY_CLICK);
+        this.$collapseByClick = this._$collapseByClick.asObservable();
+        this._collapseByClickTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "collapseByClick" parameter must be of type `boolean`.');
+                return DEFAULT_COLLAPSE_BY_CLICK;
+            }
+            return v;
+        };
+        this._$stickyEnabled = new BehaviorSubject(DEFAULT_STICKY_ENABLED);
+        this.$stickyEnabled = this._$stickyEnabled.asObservable();
+        this._stickyEnabledTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "stickyEnabled" parameter must be of type `boolean`.');
+                return DEFAULT_STICKY_ENABLED;
+            }
+            return v;
+        };
+        this._$snapToEndTransitionInstantOffset = new BehaviorSubject(DEFAULT_SNAP_TO_END_TRANSITION_INSTANT_OFFSET);
+        this.$snapToEndTransitionInstantOffset = this._$snapToEndTransitionInstantOffset.asObservable();
+        this._snapToEndTransitionInstantOffsetTransform = (v) => {
+            const valid = validateFloat(v);
+            if (!valid) {
+                console.error('The "snapToEndTransitionInstantOffset" parameter must be of type `number`.');
+                return DEFAULT_SNAP_TO_END_TRANSITION_INSTANT_OFFSET;
+            }
+            return v;
+        };
+        this._$scrollStartOffset = new BehaviorSubject(0);
+        this.$scrollStartOffset = this._$scrollStartOffset.asObservable();
+        this._scrollStartOffsetTransform = (v) => {
+            const valid = validateFloat(v, true) || isPercentageValue(v);
+            if (!valid) {
+                console.error('The "scrollStartOffset" parameter must be one of type `number` or `string`.');
+                return 0;
+            }
+            return v;
+        };
+        this._$scrollEndOffset = new BehaviorSubject(0);
+        this.$scrollEndOffset = this._$scrollEndOffset.asObservable();
+        this._scrollEndOffsetTransform = (v) => {
+            const valid = validateFloat(v, true) || isPercentageValue(v);
+            if (!valid) {
+                console.error('The "scrollEndOffset" parameter must be one of type `number` or `string`.');
+                return 0;
+            }
+            return v;
+        };
+        this._$snapScrollToStart = new BehaviorSubject(DEFAULT_SNAP_SCROLLTO_START);
+        this.$snapScrollToStart = this._$snapScrollToStart.asObservable();
+        this._snapScrollToStartTransform = (v) => {
+            const valid = validateBoolean(v, true);
+            if (!valid) {
+                console.error('The "snapScrollToStart" parameter must be of type `boolean`.');
+                return DEFAULT_SNAP_SCROLLTO_START;
+            }
+            return v;
+        };
+        this._$snapScrollToEnd = new BehaviorSubject(DEFAULT_SNAP_SCROLLTO_END);
+        this.$snapScrollToEnd = this._$snapScrollToEnd.asObservable();
+        this._snapScrollToEndTransform = (v) => {
+            const valid = validateBoolean(v, true);
+            if (!valid) {
+                console.error('The "snapScrollToEnd" parameter must be of type `boolean`.');
+                return DEFAULT_SNAP_SCROLLTO_END;
+            }
+            return v;
+        };
+        this._$scrollbarEnabled = new BehaviorSubject(DEFAULT_SCROLLBAR_ENABLED);
+        this.$scrollbarEnabled = this._$scrollbarEnabled.asObservable();
+        this._scrollbarEnabledTransform = (v) => {
+            const valid = validateBoolean(v, true);
+            if (!valid) {
+                console.error('The "scrollbarEnabled" parameter must be of type `boolean`.');
+                return DEFAULT_SCROLLBAR_ENABLED;
+            }
+            return v;
+        };
+        this._$scrollbarInteractive = new BehaviorSubject(DEFAULT_SCROLLBAR_INTERACTIVE);
+        this.$scrollbarInteractive = this._$scrollbarInteractive.asObservable();
+        this._scrollbarInteractiveTransform = (v) => {
+            const valid = validateBoolean(v, true);
+            if (!valid) {
+                console.error('The "scrollbarInteractive" parameter must be of type `boolean`.');
+                return DEFAULT_SCROLLBAR_INTERACTIVE;
+            }
+            return v;
+        };
+        this._$overlappingScrollbar = new BehaviorSubject(DEFAULT_OVERLAPPING_SCROLLBAR);
+        this.$overlappingScrollbar = this._$overlappingScrollbar.asObservable();
+        this._overlappingScrollbarTransform = (v) => {
+            const valid = validateBoolean(v, true);
+            if (!valid) {
+                console.error('The "overlappingScrollbar" parameter must be of type `boolean`.');
+                return DEFAULT_OVERLAPPING_SCROLLBAR;
+            }
+            return v;
+        };
+        this._$scrollBehavior = new BehaviorSubject(DEFAULT_SCROLL_BEHAVIOR);
+        this.$scrollBehavior = this._$scrollBehavior.asObservable();
+        this._scrollBehaviorTransform = (v) => {
+            const valid = validateString(v, true, true);
+            if (!valid) {
+                console.error('The "scrollBehavior" parameter must be of type `boolean`.');
+                return DEFAULT_SCROLL_BEHAVIOR;
+            }
+            return v;
+        };
+        this._$scrollingSettings = new BehaviorSubject(DEFAULT_SCROLLING_SETTINGS);
+        this.$scrollingSettings = this._$scrollingSettings.asObservable();
+        this._scrollingSettingsTransform = (v) => {
+            let valid = validateObject(v, true, true);
+            if (valid && !!v) {
+                const { frictionalForce, mass, maxDistance, maxDuration, speedScale, optimization } = v;
+                valid = validateFloat(frictionalForce, true);
+                if (!valid) {
+                    console.error('The "frictionalForce" parameter must be of type `number` or `undefined`.');
+                    return DEFAULT_SCROLLING_SETTINGS;
+                }
+                valid = validateFloat(mass, true);
+                if (!valid) {
+                    console.error('The "mass" parameter must be of type `number` or `undefined`.');
+                    return DEFAULT_SCROLLING_SETTINGS;
+                }
+                valid = validateFloat(maxDistance, true);
+                if (!valid) {
+                    console.error('The "maxDistance" parameter must be of type `number` or `undefined`.');
+                    return DEFAULT_SCROLLING_SETTINGS;
+                }
+                valid = validateFloat(maxDuration, true);
+                if (!valid) {
+                    console.error('The "maxDuration" parameter must be of type `number` or `undefined`.');
+                    return DEFAULT_SCROLLING_SETTINGS;
+                }
+                valid = validateFloat(speedScale, true);
+                if (!valid) {
+                    console.error('The "speedScale" parameter must be of type `number` or `undefined`.');
+                    return DEFAULT_SCROLLING_SETTINGS;
+                }
+                valid = validateBoolean(optimization, true);
+                if (!valid) {
+                    console.error('The "optimization" parameter must be of type `boolean` or `undefined`.');
+                    return DEFAULT_SCROLLING_SETTINGS;
+                }
+            }
+            if (!valid) {
+                console.error('The "scrollingSettings" parameter must be of type `object` or null.');
+                return DEFAULT_SCROLLING_SETTINGS;
+            }
+            return {
+                frictionalForce: v.frictionalForce !== undefined && v.frictionalForce > 0 ? v.frictionalForce : DEFAULT_SCROLLING_SETTINGS.frictionalForce,
+                mass: v.mass !== undefined && v.mass > 0 ? v.mass : DEFAULT_SCROLLING_SETTINGS.mass,
+                maxDistance: v.maxDistance !== undefined && v.maxDistance > 0 ? v.maxDistance : DEFAULT_SCROLLING_SETTINGS.maxDistance,
+                maxDuration: v.maxDuration !== undefined && v.maxDuration > 0 ? v.maxDuration : DEFAULT_SCROLLING_SETTINGS.maxDuration,
+                speedScale: v.speedScale !== undefined && v.speedScale > 0 ? v.speedScale : DEFAULT_SCROLLING_SETTINGS.speedScale,
+                optimization: v.optimization ?? DEFAULT_SCROLLING_SETTINGS.optimization,
+            };
+        };
+        this._$itemTransform = new BehaviorSubject(null);
+        this.$itemTransform = this._$itemTransform.asObservable();
+        this._itemTransformTransform = (v) => {
+            let valid = validateFunction(v, true, true);
+            if (!valid) {
+                console.error('The "itemTransform" parameter must be of type `ItemTransform` or `null`.');
+                return null;
+            }
+            return v;
+        };
+        this._$snapToItem = new BehaviorSubject(DEFAULT_SNAP_TO_ITEM);
+        this.$snapToItem = this._$snapToItem.asObservable();
+        this._snapToItemTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "snapToItem" parameter must be of type `boolean`.');
+                return DEFAULT_SNAP_TO_ITEM;
+            }
+            return v;
+        };
+        this._$snapToItemAlign = new BehaviorSubject(DEFAULT_SNAP_TO_ITEM_ALIGN);
+        this.$snapToItemAlign = this._$snapToItemAlign.asObservable();
+        this._snapToItemAlignTransform = (v) => {
+            const valid = validateString(v) && (v === 'start' || v === 'center' || v === 'end');
+            if (!valid) {
+                console.error('The "snapToItemAlign" parameter must be one of `start`, `center` or `end`.');
+                return DEFAULT_SNAP_TO_ITEM_ALIGN;
+            }
+            return v;
+        };
+        this._$snappingDistance = new BehaviorSubject(DEFAULT_SNAPPING_DISTANCE);
+        this.$snappingDistance = this._$snappingDistance.asObservable();
+        this._snappingDistanceTransform = (v) => {
+            const valid = validateString(v) || validateFloat(v);
+            if (!valid) {
+                console.error('The "snappingDistance" parameter must be of type `number` or `string`.');
+                return DEFAULT_SNAPPING_DISTANCE;
+            }
+            return v;
+        };
+        this._$scrollingOneByOne = new BehaviorSubject(DEFAULT_SCROLLING_ONE_BY_ONE);
+        this.$scrollingOneByOne = this._$scrollingOneByOne.asObservable();
+        this._scrollingOneByOneTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "scrollingOneByOne" parameter must be of type `boolean`.');
+                return DEFAULT_SCROLLING_ONE_BY_ONE;
+            }
+            return v;
+        };
+        this._$alignment = new BehaviorSubject(DEFAULT_ALIGNMENT);
+        this.$alignment = this._$alignment.asObservable();
+        this._alignmentTransform = (v) => {
+            const valid = validateString(v) && (v === 'none' || v === 'center');
+            if (!valid) {
+                console.error('The "alignment" parameter must be one of `none` or `centert`.');
+                return DEFAULT_ALIGNMENT;
+            }
+            return v;
+        };
+        this._$zIndexWhenSelecting = new BehaviorSubject(DEFAULT_ZINDEX_WHEN_SELECTING);
+        this.$zIndexWhenSelecting = this._$zIndexWhenSelecting.asObservable();
+        this._zIndexWhenSelectingTransform = (v) => {
+            const valid = validateString(v, true, true);
+            if (!valid) {
+                console.error('The "zIndexWhenSelecting" parameter must be of type `number` or `null`.');
+                return DEFAULT_ZINDEX_WHEN_SELECTING;
+            }
+            return v ?? null;
+        };
+        this._$spreadingMode = new BehaviorSubject(DEFAULT_SPREADING_MODE);
+        this.$spreadingMode = this._$spreadingMode.asObservable();
+        this._spreadingModeTransform = (v) => {
+            const valid = validateString(v) && (v === 'normal' || v === 'infinity');
+            if (!valid) {
+                console.error('The "spreadingMode" parameter must be one of `normal` or `infinity`.');
+                return DEFAULT_SPREADING_MODE;
+            }
+            return v;
+        };
+        this._$divides = new BehaviorSubject(DEFAULT_DIVIDES);
+        this.$divides = this._$divides.asObservable();
+        this._dividesTransform = (v) => {
+            const valid = validateFloat(v);
+            if (!valid) {
+                console.error('The "divides" parameter must be of type `number`.');
+                return DEFAULT_DIVIDES;
+            }
+            return v <= 0 ? DEFAULT_DIVIDES : v;
+        };
+        this._$motionBlur = new BehaviorSubject(DEFAULT_MOTION_BLUR);
+        this.$motionBlur = this._$motionBlur.asObservable();
+        this._motionBlurTransform = (v) => {
+            const valid = validateFloat(v);
+            if (!valid) {
+                console.error('The "motionBlur" parameter must be of type `number`.');
+                return DEFAULT_DIVIDES;
+            }
+            return v <= 0 ? DEFAULT_DIVIDES : v;
+        };
+        this._$maxMotionBlur = new BehaviorSubject(DEFAULT_MAX_MOTION_BLUR);
+        this.$maxMotionBlur = this._$maxMotionBlur.asObservable();
+        this._maxMotionBlurTransform = (v) => {
+            const valid = validateFloat(v);
+            if (!valid) {
+                console.error('The "maxMotionBlur" parameter must be of type `number`.');
+                return DEFAULT_MAX_MOTION_BLUR;
+            }
+            return v <= 0 ? DEFAULT_MAX_MOTION_BLUR : v;
+        };
+        this._$motionBlurEnabled = new BehaviorSubject(DEFAULT_MOTION_BLUR_ENABLED);
+        this.$motionBlurEnabled = this._$motionBlurEnabled.asObservable();
+        this._motionBlurEnabledTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "motionBlurEnabled" parameter must be of type `boolean`.');
+                return DEFAULT_MOTION_BLUR_ENABLED;
+            }
+            return v;
+        };
+        this._$animationParams = new BehaviorSubject(DEFAULT_ANIMATION_PARAMS);
+        this.$animationParams = this._$animationParams.asObservable();
+        this._animationParamsTransform = (v) => {
+            const valid = validateObject(v, true, true);
+            if (!validateFloat(v.scrollToItem)) {
+                console.error('The "scrollToItem" parameter must be of type `number`.');
+                return DEFAULT_ANIMATION_PARAMS;
+            }
+            if (!validateFloat(v.snapToItem)) {
+                console.error('The "snapToItem" parameter must be of type `number`.');
+                return DEFAULT_ANIMATION_PARAMS;
+            }
+            if (!validateFloat(v.navigateByKeyboard)) {
+                console.error('The "navigateByKeyboard" parameter must be of type `number`.');
+                return DEFAULT_ANIMATION_PARAMS;
+            }
+            if (!validateFloat(v.navigateToItem)) {
+                console.error('The "navigateToItem" parameter must be of type `number`.');
+                return DEFAULT_ANIMATION_PARAMS;
+            }
+            if (!valid) {
+                console.error('The "animationParams" parameter must be of type `object`.');
+                return DEFAULT_ANIMATION_PARAMS;
+            }
+            return v;
+        };
+        this._$overscrollEnabled = new BehaviorSubject(DEFAULT_OVERSCROLL_ENABLED);
+        this.$overscrollEnabled = this._$overscrollEnabled.asObservable();
+        this._overscrollEnabledTransform = (v) => {
+            const valid = validateBoolean(v, true);
+            if (!valid) {
+                console.error('The "overscrollEnabled" parameter must be of type `boolean`.');
+                return DEFAULT_OVERSCROLL_ENABLED;
+            }
+            return v;
+        };
+        this._$enabledBufferOptimization = new BehaviorSubject(DEFAULT_ENABLED_BUFFER_OPTIMIZATION);
+        this.$enabledBufferOptimization = this._$enabledBufferOptimization.asObservable();
+        this._enabledBufferOptimizationTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "enabledBufferOptimization" parameter must be of type `boolean`.');
+                return DEFAULT_ENABLED_BUFFER_OPTIMIZATION;
+            }
+            return v;
+        };
+        this._$itemRenderer = new BehaviorSubject(undefined);
+        this.$itemRenderer = this._$itemRenderer.asObservable();
+        this._itemRendererTransform = (v) => {
+            let valid = validateObject(v);
+            if (v && !(typeof v.elementRef === 'object' && typeof v.createEmbeddedView === 'function')) {
+                valid = false;
+            }
+            if (!valid) {
+                throw Error('The "itemRenderer" parameter must be of type `TemplateRef`.');
+            }
+            return v;
+        };
+        this._$itemConfigMap = new BehaviorSubject({});
+        this.$itemConfigMap = this._$itemConfigMap.asObservable();
+        this._itemConfigMapTransform = (v) => {
+            let valid = validateObject(v);
+            if (valid) {
+                if (v) {
+                    for (let id in v) {
+                        const item = v[id];
+                        if (!item ||
+                            !validateBoolean(item.collapsable, true) ||
+                            !validateBoolean(item.selectable, true) ||
+                            !(item.sticky === undefined || item.sticky === 0 || item.sticky === 1 || item.sticky === 2)) {
+                            valid = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!valid) {
+                console.error('The "itemConfigMap" parameter must be of type `IVirtualListItemConfigMap`.');
+                return {};
+            }
+            return v;
+        };
+        this._$itemSize = new BehaviorSubject(DEFAULT_ITEM_SIZE);
+        this.$itemSize = this._$itemSize.asObservable();
+        this._itemSizeTransform = (v) => {
+            const valid = validateFloat(v) || v === VIEWPORT;
+            if (!valid) {
+                console.error('The "itemSize" parameter must be one of `number`, `viewport` or `undefined`.');
+                return DEFAULT_ITEM_SIZE;
+            }
+            return v;
+        };
+        this._$minItemSize = new BehaviorSubject(DEFAULT_ITEM_SIZE);
+        this.$minItemSize = this._$minItemSize.asObservable();
+        this._minItemSizeTransform = (v) => {
+            const valid = validateFloat(v) || v === VIEWPORT;
+            if (!valid) {
+                console.error('The "minItemSize" parameter must be one of `number`, `viewport` or `undefined`.');
+                return DEFAULT_ITEM_SIZE;
+            }
+            return v;
+        };
+        this._$maxItemSize = new BehaviorSubject(DEFAULT_MAX_ITEM_SIZE);
+        this.$maxItemSize = this._$maxItemSize.asObservable();
+        this._maxItemSizeTransform = (v) => {
+            const valid = validateFloat(v) || v === VIEWPORT;
+            if (!valid) {
+                console.error('The "maxItemSize" parameter must be one of `number`, `viewport` or `undefined`.');
+                return DEFAULT_ITEM_SIZE;
+            }
+            return v;
+        };
+        this._$dynamicSize = new BehaviorSubject(DEFAULT_DYNAMIC_SIZE);
+        this.$dynamicSize = this._$dynamicSize.asObservable();
+        this._dynamicSizeTransform = (v) => {
+            const valid = validateBoolean(v);
+            if (!valid) {
+                console.error('The "dynamicSize" parameter must be of type `boolean`.');
+                return DEFAULT_DYNAMIC_SIZE;
+            }
+            return v;
+        };
+        this._$direction = new BehaviorSubject(DEFAULT_DIRECTION);
+        this.$direction = this._$direction.asObservable();
+        this._directionTransform = (v) => {
+            const valid = validateString(v) && (v === 'horizontal' || v === 'vertical');
+            if (!valid) {
+                console.error('The "direction" parameter must be one of `horizontal` or `vertical`.');
+                return DEFAULT_DIRECTION;
+            }
+            return v;
+        };
+        this._$collectionMode = new BehaviorSubject(DEFAULT_COLLECTION_MODE);
+        this.$collectionMode = this._$collectionMode.asObservable();
+        this._collectionModeTransform = (v) => {
+            const valid = validateString(v) && (v === 'normal' || v === 'lazy');
+            if (!valid) {
+                console.error('The "direction" parameter must be one of `normal` or `lazy`.');
+                return DEFAULT_COLLECTION_MODE;
+            }
+            return v;
+        };
+        this._$bufferSize = new BehaviorSubject(DEFAULT_BUFFER_SIZE);
+        this.$bufferSize = this._$bufferSize.asObservable();
+        this._bufferSizeTransform = (v) => {
+            const valid = validateInt(v);
+            if (!valid) {
+                console.error('The "bufferSize" parameter must be of type `number`.');
+                return DEFAULT_BUFFER_SIZE;
+            }
+            return v;
+        };
+        this._$maxBufferSize = new BehaviorSubject(DEFAULT_MAX_BUFFER_SIZE);
+        this.$maxBufferSize = this._$maxBufferSize.asObservable();
+        this._maxBufferSizeTransform = (v) => {
+            let val = v;
+            const valid = validateInt(v, true);
+            if (!valid) {
+                console.error('The "maxBufferSize" parameter must be of type `number`.');
+                val = DEFAULT_MAX_BUFFER_SIZE;
+            }
+            const bufferSize = this.bufferSize;
+            if (val === undefined || val <= bufferSize) {
+                return bufferSize;
+            }
+            return val;
+        };
+        this._$snappingMethod = new BehaviorSubject(DEFAULT_SNAPPING_METHOD);
+        this.$snappingMethod = this._$snappingMethod.asObservable();
+        this._snappingMethodTransform = (v) => {
+            const valid = validateString(v) && (v === SnappingMethods.ADVANCED || v === SnappingMethods.STANDART);
+            if (!valid) {
+                console.error(`The "snappingMethod" parameter must have the value '${SnappingMethods.ADVANCED}' or '${SnappingMethods.STANDART}'.`);
+                return DEFAULT_SNAPPING_METHOD;
+            }
+            return v;
+        };
+        this._$collapsingMode = new BehaviorSubject(DEFAULT_COLLAPSING_MODES);
+        this.$collapsingMode = this._$collapsingMode.asObservable();
+        this._collapsingModeTransform = (v) => {
+            const valid = validateString(v) && (v === CollapsingModes.NONE || v === CollapsingModes.MULTI_COLLAPSE || v === CollapsingModes.ACCORDION);
+            if (!valid) {
+                console.error(`The "collapsingMode" parameter must have the value '${SnappingMethods.ADVANCED}' or '${SnappingMethods.STANDART}'.`);
+                return DEFAULT_COLLAPSING_MODES;
+            }
+            return v;
+        };
+        this._$selectingMode = new BehaviorSubject(DEFAULT_SELECTING_MODES);
+        this.$selectingMode = this._$selectingMode.asObservable();
+        this._selectingModeTransform = (v) => {
+            const valid = validateString(v) && (v === 'none' || v === 'select' || v === 'multi-select');
+            if (!valid) {
+                console.error('The "selectingMode" parameter must be one of `none`, `select` or `multi-select`.');
+                return DEFAULT_SELECTING_MODES;
+            }
+            return v;
+        };
+        this._$trackBy = new BehaviorSubject(TRACK_BY_PROPERTY_NAME);
+        this.$trackBy = this._$trackBy.asObservable();
+        this._trackByTransform = (v) => {
+            const valid = validateString(v);
+            if (!valid) {
+                console.error('The "trackBy" parameter must be of type `string`.');
+                return TRACK_BY_PROPERTY_NAME;
+            }
+            return v;
+        };
+        this._$screenReaderMessage = new BehaviorSubject(DEFAULT_SCREEN_READER_MESSAGE);
+        this.$screenReaderMessage = this._$screenReaderMessage.asObservable();
+        this._screenReaderMessageTransform = (v) => {
+            const valid = validateString(v);
+            if (!valid) {
+                console.error('The "screenReaderMessage" parameter must be of type `string`.');
+                return DEFAULT_SCREEN_READER_MESSAGE;
+            }
+            return v;
+        };
+        this._$screenReaderFormattedMessage = new BehaviorSubject(DEFAULT_SCREEN_READER_MESSAGE);
+        this.$screenReaderFormattedMessage = this._$screenReaderFormattedMessage.asObservable();
+        this._$langTextDir = new BehaviorSubject(DEFAULT_LANG_TEXT_DIR);
+        this.$langTextDir = this._$langTextDir.asObservable();
+        this._langTextDirTransform = (v) => {
+            const valid = validateString(v);
+            if (!valid) {
+                console.error('The "langTextDir" parameter must be of type `string`.');
+                return DEFAULT_LANG_TEXT_DIR;
+            }
+            return v;
+        };
+        this._isSingleSelection = this.getIsSingleSelection();
+        this._isMultiSelection = this.getIsMultiSelection();
+        this._isMultipleCollapse = this.getIsMultipleCollapse();
+        this._isAccordionCollapse = this.getIsAccordionCollapse();
+        this._isSnappingMethodAdvanced = this.getIsSnappingMethodAdvanced();
+        this._$isInfinity = new BehaviorSubject(false);
+        this.$isInfinity = this._$isInfinity.asObservable();
+        this._isVertical = this.getIsVertical();
+        this._$isVertical = new BehaviorSubject(this.isVertical);
+        this.$isVertical = this._$isVertical.asObservable();
+        this._$focusedElement = new BehaviorSubject(null);
+        this.$focusedElement = this._$focusedElement.asObservable();
+        this._$classes = new BehaviorSubject({});
+        this.$classes = this._$classes.asObservable();
+        this._$prerenderEnabled = new BehaviorSubject(false);
+        this.$prerenderEnabled = this._$prerenderEnabled.asObservable();
+        this._$actualItems = new BehaviorSubject([]);
+        this._$collapsedItemIds = new BehaviorSubject([]);
+        this._displayComponents = [];
+        this._snappedDisplayComponents = [];
+        this._$bounds = new BehaviorSubject(null);
+        this.$bounds = this._$bounds.asObservable();
+        this._$actualScrollbarEnabled = new BehaviorSubject(this.scrollbarEnabled);
+        this.$actualScrollbarEnabled = this._$actualScrollbarEnabled.asObservable();
+        this._$actualAlignment = new BehaviorSubject(this.alignment);
+        this.$actualAlignment = this._$actualAlignment.asObservable();
+        this._$actualItemSize = new BehaviorSubject(0);
+        this.$actualItemSize = this._$actualItemSize.asObservable();
+        this._$actualMinItemSize = new BehaviorSubject(0);
+        this.$actualMinItemSize = this._$actualMinItemSize.asObservable();
+        this._$actualMaxItemSize = new BehaviorSubject(0);
+        this.$actualMaxItemSize = this._$actualMaxItemSize.asObservable();
+        this._$totalSize = new BehaviorSubject(0);
+        this._$listBounds = new BehaviorSubject(null);
+        this._$scrollSize = new BehaviorSubject(0);
+        this.$scrollSize = this._$scrollSize.asObservable();
+        this._$isScrollStart = new BehaviorSubject(true);
+        this._$isScrollEnd = new BehaviorSubject(false);
+        this._$precalculatedScrollStartOffset = new BehaviorSubject(0);
+        this._$precalculatedScrollEndOffset = new BehaviorSubject(0);
+        this._$actualScrollStartOffset = new BehaviorSubject(0);
+        this.$actualScrollStartOffset = this._$actualScrollStartOffset.asObservable();
+        this._$actualScrollEndOffset = new BehaviorSubject(0);
+        this.$actualScrollEndOffset = this._$actualScrollEndOffset.asObservable();
+        this._$startOffset = new BehaviorSubject(0);
+        this.$startOffset = this._$startOffset.asObservable();
+        this._$endOffset = new BehaviorSubject(0);
+        this.$endOffset = this._$endOffset.asObservable();
+        this._$actualSnapScrollToStart = new BehaviorSubject(false);
+        this._$actualSnapScrollToEnd = new BehaviorSubject(false);
+        this._$alignmentScrollStartOffset = new BehaviorSubject(0);
+        this.$alignmentScrollStartOffset = this._$alignmentScrollStartOffset.asObservable();
+        this._$alignmentScrollEndOffset = new BehaviorSubject(0);
+        this.$alignmentScrollEndOffset = this._$alignmentScrollEndOffset.asObservable();
+        this._resizeSnappedComponentHandler = () => {
+            const list = this._$list.getValue(), scroller = this._$scroller.getValue(), bounds = this._$bounds.getValue(), snappedComponents = this._snappedDisplayComponents;
+            if (!!list && !!scroller && snappedComponents.length > 0) {
+                const isVertical = this._isVertical, listBounds = list.nativeElement.getBoundingClientRect();
+                for (const comp of snappedComponents) {
+                    if (!!comp) {
+                        comp.instance.regularLength = `${isVertical ? listBounds.width : listBounds.height}${PX}`;
+                    }
+                }
+                const snappingMethod = this.snappingMethod;
+                if (snappingMethod === SnappingMethods.ADVANCED) {
+                    const snappedComponent = snappedComponents?.[0]?.instance;
+                    if (!!snappedComponent) {
+                        const { width, height } = bounds ?? { width: 0, height: 0 }, langTextDir = this.langTextDir;
+                        snappedComponent.element.style.clipPath = `path("M 0 0 L 0 ${snappedComponent.element.offsetHeight} L ${snappedComponent.element.offsetWidth} ${snappedComponent.element.offsetHeight} L ${snappedComponent.element.offsetWidth} 0 Z")`;
+                        const { width: sWidth, height: sHeight } = snappedComponent.getBounds() ?? { width: 0, height: 0 }, scrollerElement = scroller.nativeElement, delta = snappedComponent.item?.measures.delta ?? 0, scrollBarSize = this.scrollbarThickness;
+                        let right, top, bottom;
+                        if (isVertical) {
+                            right = width - scrollBarSize + 2;
+                            top = sHeight;
+                            bottom = height;
+                            if (langTextDir === TextDirections.RTL) {
+                                scrollerElement.style.clipPath = `path("M 0 0 L 0 ${height} L ${width} ${height} L ${width} ${top + delta} L ${scrollBarSize} ${top + delta} L ${scrollBarSize} 0 Z")`;
+                            }
+                            else {
+                                scrollerElement.style.clipPath = `path("M 0 ${top + delta} L 0 ${height} L ${width} ${height} L ${width} 0 L ${right} 0 L ${right} ${top + delta} Z")`;
+                            }
+                        }
+                        else {
+                            right = width;
+                            top = 0;
+                            bottom = height - scrollBarSize;
+                            scrollerElement.style.clipPath = `path("M ${width} 0 L ${width} ${bottom} L 0 ${bottom} L 0 0 L ${width} 0 Z")`;
+                        }
+                    }
+                }
+            }
+        };
+        this._resizeSnappedObserver = null;
+        this.focusItem = (element, position, align = FocusAlignments.CENTER, behavior = BEHAVIOR_AUTO) => {
+            if (!this._readyForShow) {
+                return;
+            }
+            const scroller = this._scrollerComponent;
+            if (!!scroller) {
+                const { width, height } = this._$bounds.getValue(), { width: elementWidth, height: elementHeight } = element.getBoundingClientRect(), isVertical = this._isVertical, viewportSize = isVertical ? height : width, elementSize = isVertical ? elementHeight : elementWidth;
+                let pos = Number.NaN;
+                switch (align) {
+                    case FocusAlignments.START: {
+                        pos = position + scroller.startLayoutOffset;
+                        break;
+                    }
+                    case FocusAlignments.CENTER: {
+                        pos = position - (viewportSize - elementSize) * .5 + scroller.startLayoutOffset;
+                        break;
+                    }
+                    case FocusAlignments.END: {
+                        pos = position - (viewportSize - elementSize) + scroller.startLayoutOffset;
+                        break;
+                    }
+                    case FocusAlignments.NONE:
+                    default: {
+                        break;
+                    }
+                }
+                if (!Number.isNaN(pos)) {
+                    this._trackBox.preventScrollSnapping(true);
+                    const params = {
+                        [this._isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: pos, behavior, snap: false, normalize: true,
+                        fireUpdate: false, blending: false, userAction: false,
+                        duration: this.snapToItem ? Math.max(this.animationParams.scrollToItem, this.animationParams.navigateToItem) : this.animationParams.navigateToItem,
+                    };
+                    scroller.scrollTo(params);
+                }
+            }
+        };
+        this._elementRef = inject(ElementRef);
+        /**
+         * Base class of the element component
+         */
+        this._itemComponentClass = NgVirtualListItemComponent;
+        /**
+         * Base class trackBox
+         */
+        this._trackBoxClass = TrackBox;
+        /**
+         * Dictionary of element sizes by their id
+         */
+        this._trackBox = new this._trackBoxClass(this.trackBy);
+        this._$update = new Subject();
+        this.$update = this._$update.asObservable();
+        this._$scrollTo = new Subject();
+        this.$scrollTo = this._$scrollTo.asObservable();
+        this._$scrollToExecutor = new Subject();
+        this.$scrollToExecutor = this._$scrollToExecutor.asObservable();
+        this._$scrollingTo = new BehaviorSubject(false);
+        this._$scroll = new Subject();
+        this.$scroll = this._$scroll.asObservable();
+        this._$tick = new Subject();
+        this.$tick = this._$tick.asObservable();
+        this._$fireUpdate = new Subject();
+        this.$fireUpdate = this._$fireUpdate.asObservable();
+        this._$fireUpdateNextFrame = new Subject();
+        this.$fireUpdateNextFrame = this._$fireUpdateNextFrame.asObservable();
+        this._$preventScrollSnapping = new BehaviorSubject(false);
+        this.$preventScrollSnapping = this._$preventScrollSnapping.asObservable();
+        this._readyForShow = false;
+        this._cached = false;
+        this._isLoading = false;
+        this._$viewInit = new BehaviorSubject(false);
+        this.$viewInit = this._$viewInit.asObservable();
+        this._$destroy = new Subject();
+        this.$destroy = this._$destroy.asObservable();
+        NgVirtualListComponent.__nextId = NgVirtualListComponent.__nextId + 1 === Number.MAX_SAFE_INTEGER
+            ? 0 : NgVirtualListComponent.__nextId + 1;
+        this._id = NgVirtualListComponent.__nextId;
+        this._service.initialize(this._id, this._trackBox);
+        const $dynamicSize = this.$dynamicSize, $snapScrollToEnd = this.$snapScrollToEnd;
+        combineLatest([$dynamicSize, $snapScrollToEnd]).pipe(takeUntil(this._$unsubscribe), tap(([dynamicSize, snapScrollToEnd]) => {
+            this._$prerenderEnabled.next(dynamicSize && snapScrollToEnd);
+        })).subscribe();
+        this.$animationParams.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.animationParams = v;
+        })).subscribe();
+        this.$spreadingMode.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._$isInfinity.next(isSpreadingMode(v, SpreadingModes.INFINITY));
+        })).subscribe();
+        this.$actualScrollStartOffset.pipe(takeUntil(this._$unsubscribe), debounceTime(0), tap(v => {
+            this._$startOffset.next(v);
+        })).subscribe();
+        this.$actualScrollEndOffset.pipe(takeUntil(this._$unsubscribe), debounceTime(0), tap(v => {
+            this._$endOffset.next(v);
+        })).subscribe();
+        const $isInfinity = this.$isInfinity;
+        $isInfinity.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._trackBox.isInfinity = this._service.isInfinity = v;
+        })).subscribe();
+        const $zIndexWhenSelecting = this.$zIndexWhenSelecting;
+        $zIndexWhenSelecting.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.zIndexWhenSelecting = v;
+        })).subscribe();
+        const $bounds = this._$bounds.asObservable().pipe(filter(b => !!b)), $rawScrollStartOffset = this.$scrollStartOffset, $rawScrollEndOffset = this.$scrollEndOffset;
+        combineLatest([$bounds, $rawScrollStartOffset]).pipe(takeUntil(this._$unsubscribe), filter(([v]) => !!v), tap(([bounds, value]) => {
+            const val = parseArithmeticExpression(value, this.isVertical ? bounds.height : bounds.width);
+            this._$precalculatedScrollStartOffset.next(val);
+        })).subscribe();
+        combineLatest([$bounds, $rawScrollEndOffset]).pipe(takeUntil(this._$unsubscribe), filter(([v]) => !!v), tap(([bounds, value]) => {
+            const val = parseArithmeticExpression(value, this.isVertical ? bounds.height : bounds.width);
+            this._$precalculatedScrollEndOffset.next(val);
+        })).subscribe();
+        this._service.$intersectionElementBySnapToItemAlign.pipe(takeUntil(this._$unsubscribe), filter(v => v !== null), tap(id => {
+            this.onSnapItem.emit(id);
+        })).subscribe();
+        this._service.$tick.pipe(takeUntil(this._$unsubscribe), tap(() => {
+            this._scrollerComponent?.tick();
+        })).subscribe();
+        this._service.$tick.pipe(takeUntil(this._$unsubscribe), filter(() => this.dynamicSize === true), tap(() => {
+            this.checkBoundsOfElements();
+            this._scrollerComponent?.tick();
+        })).subscribe();
+    }
+    /**
+     * Readonly. Returns the unique identifier of the component.
+     */
+    get id() { return this._id; }
+    /**
+     * Scrollbar thickness.
+     */
+    set scrollbarThickness(v) {
+        if (this._$scrollbarThickness.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollbarThicknessTransform(v);
+        this._$scrollbarThickness.next(transformedValue);
+    }
+    ;
+    get scrollbarThickness() { return this._$scrollbarThickness.getValue(); }
+    /**
+     * Minimum scrollbar size.
+     */
+    set scrollbarMinSize(v) {
+        if (this._$scrollbarMinSize.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollbarMinSizeTransform(v);
+        this._$scrollbarMinSize.next(transformedValue);
+    }
+    ;
+    get scrollbarMinSize() { return this._$scrollbarMinSize.getValue(); }
+    /**
+     * Scrollbar customization template.
+     */
+    set scrollbarThumbRenderer(v) {
+        if (this._$scrollbarThumbRenderer.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollbarThumbRendererTransform(v);
+        this._$scrollbarThumbRenderer.next(transformedValue);
+    }
+    ;
+    get scrollbarThumbRenderer() { return this._$scrollbarThumbRenderer.getValue(); }
+    /**
+     * Additional options for the scrollbar.
+     */
+    set scrollbarThumbParams(v) {
+        if (this._$scrollbarThumbParams.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollbarThumbParamsTransform(v);
+        this._$scrollbarThumbParams.next(transformedValue);
+    }
+    ;
+    get scrollbarThumbParams() { return this._$scrollbarThumbParams.getValue(); }
+    /**
+     * If `true`, the scrollBar goes into loading state. The default value is `false`.
+     */
+    set loading(v) {
+        if (this._$loading.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._loadingTransform(v);
+        this._$loading.next(transformedValue);
+    }
+    ;
+    get loading() { return this._$loading.getValue(); }
+    /**
+     * If true, it will wait until the list items are fully prepared before displaying them.. The default value is `true`.
+     */
+    set waitForPreparation(v) {
+        if (this._$waitForPreparation.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._waitForPreparationTransform(v);
+        this._$waitForPreparation.next(transformedValue);
+    }
+    ;
+    get waitForPreparation() { return this._$waitForPreparation.getValue(); }
+    /**
+     * The maximum scroll distance at which a click event is triggered.
+     */
+    set clickDistance(v) {
+        if (this._$clickDistance.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._clickDistanceTransform(v);
+        this._$clickDistance.next(transformedValue);
+    }
+    ;
+    get clickDistance() { return this._$clickDistance.getValue(); }
+    /**
+     * Collection of list items.
+     */
+    set items(v) {
+        if (this._$items.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._itemsTransform(v);
+        this._$items.next(transformedValue);
+    }
+    ;
+    get items() { return this._$items.getValue(); }
+    /**
+     * Sets the selected items.
+     */
+    set selectedIds(v) {
+        if (this._$selectedIds.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._selectedIdsTransform(v);
+        this._$selectedIds.next(transformedValue);
+    }
+    ;
+    get selectedIds() { return this._$selectedIds.getValue(); }
+    set defaultItemValue(v) {
+        if (this._$defaultItemValue.getValue() === v) {
+            return;
+        }
+        this._$defaultItemValue.next(v);
+    }
+    ;
+    get defaultItemValue() { return this._$defaultItemValue.getValue(); }
+    /**
+     * Sets the collapsed items.
+     */
+    set collapsedIds(v) {
+        if (this._$collapsedIds.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._collapsedIdsTransform(v);
+        this._$collapsedIds.next(transformedValue);
+    }
+    ;
+    get collapsedIds() { return this._$collapsedIds.getValue(); }
+    /**
+     * If `false`, the element is selected using the config.api method passed to the template;
+     * if `true`, the element is selected by clicking on it. The default value is `true`.
+     */
+    set selectByClick(v) {
+        if (this._$selectByClick.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._selectByClickTransform(v);
+        this._$selectByClick.next(transformedValue);
+    }
+    ;
+    get selectByClick() { return this._$selectByClick.getValue(); }
+    /**
+     * If `false`, the element is collapsed using the config.collapse method passed to the template;
+     * if `true`, the element is collapsed by clicking on it. The default value is `true`.
+     */
+    set collapseByClick(v) {
+        if (this._$collapseByClick.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._collapseByClickTransform(v);
+        this._$collapseByClick.next(transformedValue);
+    }
+    ;
+    get collapseByClick() { return this._$collapseByClick.getValue(); }
+    /**
+     * @deprecated
+     * Use the `stickyEnabled` property instead.
+     */
+    set snap(v) {
+        throw Error(`Property snap is deprecated. Use the \`stickyEnabled\` property instead.`);
+    }
+    ;
+    /**
+     * Determines whether items with the given `sticky` in `itemConfigMap` will stick to the edges. Default value is "true".
+     */
+    set stickyEnabled(v) {
+        if (this._$stickyEnabled.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._stickyEnabledTransform(v);
+        this._$stickyEnabled.next(transformedValue);
+    }
+    ;
+    get stickyEnabled() { return this._$stickyEnabled.getValue(); }
+    /**
+     * Sets the offset value; if the scroll area value is exceeded, the scroll animation will be disabled. Default value is "0".
+     */
+    set snapToEndTransitionInstantOffset(v) {
+        if (this._$snapToEndTransitionInstantOffset.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snapToEndTransitionInstantOffsetTransform(v);
+        this._$snapToEndTransitionInstantOffset.next(transformedValue);
+    }
+    ;
+    get snapToEndTransitionInstantOffset() { return this._$snapToEndTransitionInstantOffset.getValue(); }
+    /**
+     * Sets the scroll start offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    set scrollStartOffset(v) {
+        if (this._$scrollStartOffset.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollStartOffsetTransform(v);
+        this._$scrollStartOffset.next(transformedValue);
+    }
+    ;
+    get scrollStartOffset() { return this._$scrollStartOffset.getValue(); }
+    /**
+     * Sets the scroll end offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    set scrollEndOffset(v) {
+        if (this._$scrollEndOffset.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollEndOffsetTransform(v);
+        this._$scrollEndOffset.next(transformedValue);
+    }
+    ;
+    get scrollEndOffset() { return this._$scrollEndOffset.getValue(); }
+    /**
+     * Determines whether the scroll will be anchored to the start of the list. Default value is "true".
+     * This property takes precedence over the snapScrollToEnd property.
+     * That is, if snapScrollToStart and snapScrollToEnd are enabled, the list will initially snap
+     * to the beginning; if you move the scroll bar to the end, the list will snap to the end.
+     * If snapScrollToStart is disabled and snapScrollToEnd is enabled, the list will snap to the end;
+     * if you move the scroll bar to the beginning, the list will snap to the beginning.
+     * If both snapScrollToStart and snapScrollToEnd are disabled, the list will never snap to the beginning or end.
+     * In the `spreadingMode=SpreadingModes.INFINITY` mode, the `snapScrollToStart` property is automatically disabled, since the list has no beginning or end.
+     */
+    set snapScrollToStart(v) {
+        if (this._$snapScrollToStart.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snapScrollToStartTransform(v);
+        this._$snapScrollToStart.next(transformedValue);
+    }
+    ;
+    get snapScrollToStart() { return this._$snapScrollToStart.getValue(); }
+    /**
+     * Determines whether the scroll will be anchored to the утв of the list. Default value is "true".
+     * That is, if snapScrollToStart and snapScrollToEnd are enabled, the list will initially snap
+     * to the beginning; if you move the scroll bar to the end, the list will snap to the end.
+     * If snapScrollToStart is disabled and snapScrollToEnd is enabled, the list will snap to the end;
+     * if you move the scroll bar to the beginning, the list will snap to the beginning.
+     * If both snapScrollToStart and snapScrollToEnd are disabled, the list will never snap to the beginning or end.
+     * In the `spreadingMode=SpreadingModes.INFINITY` mode, the `snapScrollToEnd` property is automatically disabled, since the list has no beginning or end.
+     */
+    set snapScrollToEnd(v) {
+        if (this._$snapScrollToEnd.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snapScrollToEndTransform(v);
+        this._$snapScrollToEnd.next(transformedValue);
+    }
+    ;
+    get snapScrollToEnd() { return this._$snapScrollToEnd.getValue(); }
+    /**
+     * @deprecated
+     * The stopSnappingScrollToEnd property is deprecated. Use the snapScrollToEnd property.
+     */
+    set snapScrollToBottom(v) {
+        throw Error('The stopSnappingScrollToEnd property is deprecated. Use the snapScrollToEnd property.');
+    }
+    /**
+     * Determines whether the scrollbar is shown or not. The default value is "true".
+     */
+    set scrollbarEnabled(v) {
+        if (this._$scrollbarEnabled.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollbarEnabledTransform(v);
+        this._$scrollbarEnabled.next(transformedValue);
+    }
+    ;
+    get scrollbarEnabled() { return this._$scrollbarEnabled.getValue(); }
+    /**
+     * Determines whether scrolling using the scrollbar will be possible. The default value is "true".
+     */
+    set scrollbarInteractive(v) {
+        if (this._$scrollbarInteractive.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollbarInteractiveTransform(v);
+        this._$scrollbarInteractive.next(transformedValue);
+    }
+    ;
+    get scrollbarInteractive() { return this._$scrollbarInteractive.getValue(); }
+    /**
+     * Determines whether the scroll bar will overlap the list. The default value is "false".
+     */
+    set overlappingScrollbar(v) {
+        if (this._$overlappingScrollbar.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._overlappingScrollbarTransform(v);
+        this._$overlappingScrollbar.next(transformedValue);
+    }
+    ;
+    get overlappingScrollbar() { return this._$overlappingScrollbar.getValue(); }
+    /**
+     * Defines the scrolling behavior for any element on the page. The default value is "smooth".
+     */
+    set scrollBehavior(v) {
+        if (this._$scrollBehavior.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollBehaviorTransform(v);
+        this._$scrollBehavior.next(transformedValue);
+    }
+    ;
+    get scrollBehavior() { return this._$scrollBehavior.getValue(); }
+    /**
+     * Scrolling settings.
+     * - frictionalForce - Frictional force. Default value is 0.035.
+     * - mass - Mass. Default value is 0.005.
+     * - maxDistance - Maximum scrolling distance. Default value is 100000.
+     * - maxDuration - Maximum animation duration. Default value is 4000.
+     * - speedScale - Speed scale. Default value is 10.
+     * - optimization - Enables scrolling performance optimization. Default value is `true`.
+     */
+    set scrollingSettings(v) {
+        if (this._$scrollingSettings.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollingSettingsTransform(v);
+        this._$scrollingSettings.next(transformedValue);
+    }
+    ;
+    get scrollingSettings() { return this._$scrollingSettings.getValue(); }
+    /**
+     * Custom transformation of element's position, rotation, scale, opacity and zIndex. The default value is `null`.
+     */
+    set itemTransform(v) {
+        if (this._$itemTransform.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._itemTransformTransform(v);
+        this._$itemTransform.next(transformedValue);
+    }
+    ;
+    get itemTransform() { return this._$itemTransform.getValue(); }
+    /**
+     * Snap to an item. The default value is `false`.
+     */
+    set snapToItem(v) {
+        if (this._$snapToItem.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snapToItemTransform(v);
+        this._$snapToItem.next(transformedValue);
+    }
+    ;
+    get snapToItem() { return this._$snapToItem.getValue(); }
+    /**
+     * Alignment for snapToItem. Available values ​​are `start`, `center`, and `end`. The default value is `center`.
+     */
+    set snapToItemAlign(v) {
+        if (this._$snapToItemAlign.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snapToItemAlignTransform(v);
+        this._$snapToItemAlign.next(transformedValue);
+    }
+    ;
+    get snapToItemAlign() { return this._$snapToItemAlign.getValue(); }
+    /**
+     * Snapping activation distance. Can be specified as a percentage of the element size or in absolute values.
+     * The default value is `25%`.
+     */
+    set snappingDistance(v) {
+        if (this._$snappingDistance.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snappingDistanceTransform(v);
+        this._$snappingDistance.next(transformedValue);
+    }
+    ;
+    get snappingDistance() { return this._$snappingDistance.getValue(); }
+    /**
+     * Specifies whether to scroll one item at a time if true and the scrollToItem property is set. The default value is `false`.
+     */
+    set scrollingOneByOne(v) {
+        if (this._$scrollingOneByOne.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._scrollingOneByOneTransform(v);
+        this._$scrollingOneByOne.next(transformedValue);
+    }
+    ;
+    get scrollingOneByOne() { return this._$scrollingOneByOne.getValue(); }
+    /**
+     * Determines the alignment of the list. Two modes are available: `none` and `center`. The `center` mode aligns the list items to the center of the viewport, ideal for use with the `itemTransform` property.
+     * The `none` mode means no alignment. The default value is `none`.
+     */
+    set alignment(v) {
+        if (this._$alignment.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._alignmentTransform(v);
+        this._$alignment.next(transformedValue);
+    }
+    ;
+    get alignment() { return this._$alignment.getValue(); }
+    /**
+     * Defines the zIndex when a list item is selected. The default value is `null`.
+     */
+    set zIndexWhenSelecting(v) {
+        if (this._$zIndexWhenSelecting.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._zIndexWhenSelectingTransform(v);
+        this._$zIndexWhenSelecting.next(transformedValue);
+    }
+    ;
+    get zIndexWhenSelecting() { return this._$zIndexWhenSelecting.getValue(); }
+    /**
+     * The order of list elements. Available values ​​are `standard` and `infinity`.
+     * `normal` — list elements are ordered according to the collection sequence.
+     * `infinity` — list elements are ordered cyclically, forming an infinite list.
+     * When set to `infinity`, the `alignment` property is forced to the value `Alignments.CENTER`, the `scrollbarEnabled` property is forced to the `false`
+     * The default value is `standard`.
+     */
+    set spreadingMode(v) {
+        if (this._$spreadingMode.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._spreadingModeTransform(v);
+        this._$spreadingMode.next(transformedValue);
+    }
+    ;
+    get spreadingMode() { return this._$spreadingMode.getValue(); }
+    /**
+     * Column or row numbers. The default value is `1`.
+     */
+    set divides(v) {
+        if (this._$divides.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._dividesTransform(v);
+        this._$divides.next(transformedValue);
+    }
+    ;
+    get divides() { return this._$divides.getValue(); }
+    /**
+     * Motion blur effect. The default value is `0.15`.
+     */
+    set motionBlur(v) {
+        if (this._$motionBlur.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._motionBlurTransform(v);
+        this._$motionBlur.next(transformedValue);
+    }
+    ;
+    get motionBlur() { return this._$motionBlur.getValue(); }
+    /**
+     * Maximum motion blur effect. The default value is `0.5`.
+     */
+    set maxMotionBlur(v) {
+        if (this._$maxMotionBlur.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._maxMotionBlurTransform(v);
+        this._$maxMotionBlur.next(transformedValue);
+    }
+    ;
+    get maxMotionBlur() { return this._$maxMotionBlur.getValue(); }
+    /**
+     * Determines whether to apply motion blur or not. The default value is `false`.
+     */
+    set motionBlurEnabled(v) {
+        if (this._$motionBlurEnabled.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._motionBlurEnabledTransform(v);
+        this._$motionBlurEnabled.next(transformedValue);
+    }
+    ;
+    get motionBlurEnabled() { return this._$motionBlurEnabled.getValue(); }
+    /**
+     * Animation parameters. The default value is "{ scrollToItem: 50, snapToItem: 150, navigateToItem: 150, navigateByKeyboard: 50 }".
+     */
+    set animationParams(v) {
+        if (this._$animationParams.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._animationParamsTransform(v);
+        this._$animationParams.next(transformedValue);
+    }
+    ;
+    get animationParams() { return this._$animationParams.getValue(); }
+    /**
+     * Determines whether the overscroll (re-scroll) feature will work. The default value is "true".
+     */
+    set overscrollEnabled(v) {
+        if (this._$overscrollEnabled.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._overscrollEnabledTransform(v);
+        this._$overscrollEnabled.next(transformedValue);
+    }
+    ;
+    get overscrollEnabled() { return this._$overscrollEnabled.getValue(); }
+    /**
+     * Experimental!
+     * Enables buffer optimization.
+     * Can only be used if items in the collection are not added or updated. Otherwise, artifacts in the form of twitching of the scroll area are possible.
+     * Works only if the property dynamic = true
+     */
+    set enabledBufferOptimization(v) {
+        if (this._$enabledBufferOptimization.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._enabledBufferOptimizationTransform(v);
+        this._$enabledBufferOptimization.next(transformedValue);
+    }
+    ;
+    get enabledBufferOptimization() { return this._$enabledBufferOptimization.getValue(); }
+    /**
+     * Rendering element template.
+     */
+    set itemRenderer(v) {
+        if (this._$itemRenderer.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._itemRendererTransform(v);
+        this._$itemRenderer.next(transformedValue);
+    }
+    ;
+    get itemRenderer() { return this._$itemRenderer.getValue(); }
+    /**
+     * Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied.
+     * If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end.
+     *  Default value is `0`.
+     * `selectable` determines whether an element can be selected or not. Default value is `true`.
+     * `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and
+     *  collapse elements in front that do not have a `sticky` property.
+     * `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false.
+     * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/models/item-config-map.model.ts
+     * @author Evgenii Alexandrovich Grebennikov
+     * @email djonnyx@gmail.com
+     */
+    set itemConfigMap(v) {
+        if (this._$itemConfigMap.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._itemConfigMapTransform(v);
+        this._$itemConfigMap.next(transformedValue);
+    }
+    ;
+    get itemConfigMap() { return this._$itemConfigMap.getValue(); }
+    /**
+     * If direction = 'vertical', then the height of a typical element. If direction = 'horizontal', then the width of a typical element.
+     * If the `dynamicSize` property is true, the items in the list can have different sizes, and you must specify the `itemSize` property
+     * to adjust the sizes of the items in the unallocated area.
+     * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.
+     */
+    set itemSize(v) {
+        if (this._$itemSize.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._itemSizeTransform(v);
+        this._$itemSize.next(transformedValue);
+    }
+    ;
+    get itemSize() { return this._$itemSize.getValue(); }
+    /**
+     * If the `dynamicSize` property is enabled, the minimum size of the element is set.
+     * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.
+     */
+    set minItemSize(v) {
+        if (this._$minItemSize.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._minItemSizeTransform(v);
+        this._$minItemSize.next(transformedValue);
+    }
+    ;
+    get minItemSize() { return this._$minItemSize.getValue(); }
+    /**
+     * If the `dynamicSize` property is enabled, the maximum size of the element is set.
+     * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.
+     */
+    set maxItemSize(v) {
+        if (this._$maxItemSize.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._maxItemSizeTransform(v);
+        this._$maxItemSize.next(transformedValue);
+    }
+    ;
+    get maxItemSize() { return this._$maxItemSize.getValue(); }
+    /**
+     * If true, items in the list may have different sizes, and the itemSize property must be specified to adjust
+     * the sizes of items in the unallocated area.
+     * If false then the items in the list have a fixed size specified by the itemSize property. The default value is true.
+     */
+    set dynamicSize(v) {
+        if (this._$dynamicSize.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._dynamicSizeTransform(v);
+        this._$dynamicSize.next(transformedValue);
+    }
+    ;
+    get dynamicSize() { return this._$dynamicSize.getValue(); }
+    /**
+     * Determines the direction in which elements are placed. Default value is "vertical".
+     */
+    set direction(v) {
+        if (this._$direction.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._directionTransform(v);
+        this._$direction.next(transformedValue);
+    }
+    ;
+    get direction() { return this._$direction.getValue(); }
+    /**
+     * Determines the action modes for collection elements. Default value is "normal".
+     */
+    set collectionMode(v) {
+        if (this._$collectionMode.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._collectionModeTransform(v);
+        this._$collectionMode.next(transformedValue);
+    }
+    ;
+    get collectionMode() { return this._$collectionMode.getValue(); }
+    /**
+     * Number of elements outside the scope of visibility. Default value is 2.
+     */
+    set bufferSize(v) {
+        if (this._$bufferSize.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._bufferSizeTransform(v);
+        this._$bufferSize.next(transformedValue);
+    }
+    ;
+    get bufferSize() { return this._$bufferSize.getValue(); }
+    /**
+     * Maximum number of elements outside the scope of visibility. Default value is 100.
+     * If maxBufferSize is set to be greater than bufferSize, then adaptive buffer mode is enabled.
+     * The greater the scroll size, the more elements are allocated for rendering.
+     */
+    set maxBufferSize(v) {
+        const val = this._maxBufferSizeTransform(v);
+        if (this._$maxBufferSize.getValue() === val) {
+            return;
+        }
+        this._$maxBufferSize.next(val);
+    }
+    ;
+    get maxBufferSize() { return this._$maxBufferSize.getValue(); }
+    /**
+     * Snapping method. Default value is 'standart'.
+     * 'standart' - Classic group visualization.
+     * 'advanced' - A mask is applied to the viewport area so that the background is displayed underneath the attached group.
+     */
+    set snappingMethod(v) {
+        if (this._$snappingMethod.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._snappingMethodTransform(v);
+        this._$snappingMethod.next(transformedValue);
+    }
+    ;
+    get snappingMethod() { return this._$snappingMethod.getValue(); }
+    /**
+     * Mode for collapsing list items.
+     * `none` - List items are not selectable.
+     * `multi-collapse` - List items are collapsed one by one.
+     * 'accordion' - Accordion collapsible list items.
+     * Default value is `multi-collapse
+     */
+    set collapsingMode(v) {
+        if (this._$collapsingMode.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._collapsingModeTransform(v);
+        this._$collapsingMode.next(transformedValue);
+    }
+    ;
+    get collapsingMode() { return this._$collapsingMode.getValue(); }
+    /**
+     * @deprecated
+     * The "methodForSelecting" property is deprecated. Use the "selectMode" property.
+     */
+    set methodForSelecting(v) {
+        throw new Error('The "methodForSelecting" property is deprecated. Use the "selectMode" property instead.');
+    }
+    ;
+    /**
+     *  Method for selecting list items. Default value is 'none'.
+     * 'select' - List items are selected one by one.
+     * 'multi-select' - Multiple selection of list items.
+     * 'none' - List items are not selectable.
+     */
+    set selectingMode(v) {
+        if (this._$selectingMode.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._selectingModeTransform(v);
+        this._$selectingMode.next(transformedValue);
+    }
+    ;
+    get selectingMode() { return this._$selectingMode.getValue(); }
+    /**
+     * The name of the property by which tracking is performed
+     */
+    set trackBy(v) {
+        if (this._$trackBy.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._trackByTransform(v);
+        this._$trackBy.next(transformedValue);
+    }
+    ;
+    get trackBy() { return this._$trackBy.getValue(); }
+    /**
+     * Message for screen reader.
+     * The message format is: "some text $1 some text $2",
+     * where $1 is the number of the first element of the screen collection,
+     * $2 is the number of the last element of the screen collection.
+     */
+    set screenReaderMessage(v) {
+        if (this._$screenReaderMessage.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._screenReaderMessageTransform(v);
+        this._$screenReaderMessage.next(transformedValue);
+    }
+    ;
+    get screenReaderMessage() { return this._$screenReaderMessage.getValue(); }
+    /**
+     * A string indicating the direction of text for the locale.
+     * Can be either "ltr" (left-to-right) or "rtl" (right-to-left).
+     */
+    set langTextDir(v) {
+        if (this._$langTextDir.getValue() === v) {
+            return;
+        }
+        const transformedValue = this._langTextDirTransform(v);
+        this._$langTextDir.next(transformedValue);
+    }
+    ;
+    get langTextDir() { return this._$langTextDir.getValue(); }
+    get isInfinity() {
+        return this._$isInfinity.getValue();
+    }
+    get isVertical() {
+        return this._isVertical;
+    }
+    get actualAlignment() { return this._$actualAlignment.getValue(); }
+    get actualItemSize() { return this._$actualItemSize.getValue(); }
+    get actualMinItemSize() { return this._$actualMinItemSize.getValue(); }
+    get actualMaxItemSize() { return this._$actualMaxItemSize.getValue(); }
+    get itemComponentClass() { return this._itemComponentClass; }
+    get cachable() {
+        return this._prerender?.active ?? false;
+    }
+    get prerenderable() {
+        return this.dynamicSize && (this._trackBox?.isSnappedToEnd ?? false);
+    }
+    ngAfterViewInit() {
+        const _$created = new BehaviorSubject(false), $created = _$created.asObservable();
+        combineLatest([$created, this.$show]).pipe(takeUntil(this._$unsubscribe), filter(([created, shown]) => created && shown), debounceTime(1), tap(v => {
+            this._$initialized.next(true);
+        })).subscribe();
+        this._$scroller.next(this._scrollerComponent?.scrollViewport);
+        this._$list.next(this._scrollerComponent?.scrollContent);
+        const $bounds = this._$bounds.asObservable().pipe(filter(b => !!b)), $scrollerComponent = of(this._scrollerComponent), $resizeViewport = $scrollerComponent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(scroller => scroller.$resizeViewport)), $resizeContent = $scrollerComponent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(scroller => scroller.$resizeContent));
+        $scrollerComponent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(scroller => scroller.$scrollDirection), tap(v => {
+            this._trackBox.scrollDirection = v;
+        })).subscribe();
+        $resizeViewport.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), tap(v => {
+            this._$bounds.next(v);
+            this.onAfterResize(true);
+        })).subscribe();
+        $resizeContent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), tap(v => {
+            this._$listBounds.next(v);
+            this.onAfterResize();
+        })).subscribe();
+        const $trackBy = this.$trackBy;
+        $trackBy.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.trackBy = this._trackBox.trackBy = v;
+        })).subscribe();
+        this._trackBox.displayComponents = this._displayComponents;
+        let hasUserAction = false;
+        const $itemSize = this.$itemSize.pipe(map(v => typeof v === 'number' && v <= 0 ? DEFAULT_ITEM_SIZE : v)), $minItemSize = this.$minItemSize.pipe(map(v => typeof v === 'number' && v <= 0 ? DEFAULT_MIN_ITEM_SIZE : v)), $maxItemSize = this.$maxItemSize.pipe(map(v => typeof v === 'number' && v <= 0 ? DEFAULT_MAX_ITEM_SIZE : v)), $scrollStartOffset = this.$actualScrollStartOffset.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged()), $scrollEndOffset = this.$actualScrollEndOffset.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged());
+        combineLatest([$minItemSize, $bounds, $scrollStartOffset, $scrollEndOffset]).pipe(takeUntil(this._$unsubscribe), switchMap(([v, bounds, startOffset, endOffset]) => {
+            if (v === VIEWPORT) {
+                const isVertical = this.isVertical, viewportBounds = bounds, result = (isVertical ? (viewportBounds?.height ?? 0) : (viewportBounds?.width ?? 0)) - startOffset - endOffset;
+                return of(result <= 0 ? 1 : result);
+            }
+            return of(v);
+        }), tap(v => {
+            this._$actualMinItemSize.next(v);
+        })).subscribe();
+        combineLatest([$maxItemSize, $bounds, $scrollStartOffset, $scrollEndOffset]).pipe(takeUntil(this._$unsubscribe), switchMap(([v, bounds, startOffset, endOffset]) => {
+            if (v === VIEWPORT) {
+                const isVertical = this.isVertical, viewportBounds = bounds, result = (isVertical ? (viewportBounds?.height ?? 0) : (viewportBounds?.width ?? 0)) - startOffset - endOffset;
+                return of(result <= 0 ? 1 : result);
+            }
+            return of(v);
+        }), tap(v => {
+            this._$actualMaxItemSize.next(v);
+        })).subscribe();
+        const $actualMinItemSize = this.$actualMinItemSize, $actualMaxItemSize = this.$actualMaxItemSize;
+        combineLatest([$itemSize, $bounds, $actualMinItemSize, $actualMaxItemSize, $scrollStartOffset, $scrollEndOffset]).pipe(takeUntil(this._$unsubscribe), switchMap(([v, bounds, min, max, startOffset, endOffset]) => {
+            if (v === VIEWPORT) {
+                const isVertical = this.isVertical, viewportBounds = bounds, result = (isVertical ? (viewportBounds?.height ?? 0) : (viewportBounds?.width ?? 0)) - startOffset - endOffset;
+                return of(result < min ? min : (result > max ? max : result));
+            }
+            return of(v < min ? min : (v > max ? max : v));
+        }), tap(v => {
+            this._$actualItemSize.next(v);
+            this._service.itemSize = v;
+        })).subscribe();
+        const $actualItemSize = this.$actualItemSize, $actualItems = this._$actualItems.asObservable().pipe(takeUntil(this._$unsubscribe), distinctUntilChanged());
+        this._service.$focusItem.pipe(takeUntil(this._$unsubscribe), tap(params => {
+            const { element, position, align, behavior } = params;
+            this.focusItem(element, position, align, behavior);
+        })).subscribe();
+        const $list = this.$list.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), map(v => v.nativeElement), take(1));
+        const preventKeyboardEvent = (event, isVertical) => {
+            const scroller = this._scrollerComponent;
+            if (!!scroller) {
+                const scrollStartOffset = this._$actualScrollStartOffset.getValue(), scrollable = scroller.scrollable ?? false, scrollSize = isVertical ? scroller.scrollTop : scroller.scrollLeft, scrollWeight = isVertical ? scroller.scrollHeight : scroller.scrollWidth;
+                if (scrollable || scrollSize <= scrollStartOffset || scrollSize >= scrollWeight) {
+                    if (!!event && event.cancelable) {
+                        event.stopImmediatePropagation();
+                        event.preventDefault();
+                    }
+                }
+            }
+        };
+        $list.pipe(takeUntil(this._$unsubscribe), filter(element => !!element), switchMap(element => {
+            return fromEvent(element, EVENT_KEY_DOWN).pipe(takeUntil(this._$unsubscribe), switchMap(e => {
+                switch (e.key) {
+                    case KEY_ARR_LEFT:
+                        if (!this.isVertical) {
+                            preventKeyboardEvent(e, this.isVertical);
+                        }
+                        break;
+                    case KEY_ARR_UP:
+                        if (this.isVertical) {
+                            preventKeyboardEvent(e, this.isVertical);
+                        }
+                        break;
+                    case KEY_ARR_RIGHT:
+                        if (!this.isVertical) {
+                            preventKeyboardEvent(e, this.isVertical);
+                        }
+                        break;
+                    case KEY_ARR_DOWN:
+                        if (this.isVertical) {
+                            preventKeyboardEvent(e, this.isVertical);
+                        }
+                        break;
+                }
+                return of(null);
+            }));
+        })).subscribe();
+        const $scrollbarThickness = this.$scrollbarThickness;
+        $scrollbarThickness.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), tap(scrollbarThickness => {
+            this._service.scrollBarSize = scrollbarThickness;
+        })).subscribe();
+        this.$fireUpdateNextFrame.pipe(takeUntil(this._$unsubscribe), debounceTime(0), tap(userAction => {
+            this._$fireUpdate.next(userAction);
+        })).subscribe();
+        const $scrollToItem = this.$scrollTo.pipe(takeUntil(this._$unsubscribe)), $mouseDown = fromEvent(this._elementRef.nativeElement, MOUSE_DOWN).pipe(takeUntil(this._$unsubscribe)), $touchStart = fromEvent(this._elementRef.nativeElement, TOUCH_START).pipe(takeUntil(this._$unsubscribe));
+        fromEvent(document, KEY_DOWN).pipe(takeUntil(this._$unsubscribe), filter(e => e.key === KEY_TAB), switchMap(e => {
+            return fromEvent(this._elementRef.nativeElement, FOCUS).pipe(takeUntil(this._$unsubscribe), delay(0), takeUntil($scrollToItem), takeUntil($mouseDown), takeUntil($touchStart), tap(e => {
+                this._service.focusFirstElement();
+            }));
+        })).subscribe();
+        this._service.$scrollToStart.pipe(takeUntil(this._$unsubscribe), tap(options => {
+            this.scrollToStart(null, options);
+        })).subscribe();
+        this._service.$scrollTo.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), tap(params => {
+            const { id, cb, options } = params;
+            this.scrollTo(id, cb, options);
+        })).subscribe();
+        this._service.$scrollToEnd.pipe(takeUntil(this._$unsubscribe), tap(options => {
+            this.scrollToEnd(null, options);
+        })).subscribe();
+        this.$langTextDir.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            this._service.langTextDir = v;
+        })).subscribe();
+        this.$clickDistance.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            this._service.clickDistance = v;
+        })).subscribe();
+        combineLatest([this.$snapScrollToStart, this.$isInfinity]).pipe(takeUntil(this._$unsubscribe), tap(([snapScrollToStart, isInfinity]) => {
+            this._$actualSnapScrollToStart.next(isInfinity ? false : snapScrollToStart);
+        })).subscribe();
+        combineLatest([this.$snapScrollToEnd, this.$isInfinity]).pipe(takeUntil(this._$unsubscribe), tap(([snapScrollToEnd, isInfinity]) => {
+            this._$actualSnapScrollToEnd.next(isInfinity ? false : snapScrollToEnd);
+        })).subscribe();
+        const $viewInit = this.$viewInit, $prerenderContainer = of(this._prerender);
+        const $prerender = $viewInit.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(v => {
+            return $prerenderContainer.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(v => v.$render));
+        }));
+        const $fireUpdate = this.$fireUpdate;
+        $fireUpdate.pipe(takeUntil(this._$unsubscribe), tap(userAction => {
+            hasUserAction = userAction;
+        })).subscribe();
+        const $update = this.$update, renderStabilizer = (options) => {
+            let renderStabilizerPrevScrollStateVersion = EMPTY_SCROLL_STATE_VERSION, renderStabilizerUpdateIterations = 0;
+            const prepareIterations = options?.prepareIterations ?? PREPARE_ITERATIONS, prepareReupdateLength = options?.prepareReupdateLength ?? PREPARATION_REUPDATE_LENGTH;
+            return of(null).pipe(takeUntil(this._$unsubscribe), switchMap(() => {
+                renderStabilizerPrevScrollStateVersion = EMPTY_SCROLL_STATE_VERSION;
+                renderStabilizerUpdateIterations = 0;
+                this._cached = false;
+                return $update.pipe(takeUntil(this._$unsubscribe), debounceTime(0), switchMap(v => {
+                    if (((renderStabilizerPrevScrollStateVersion === EMPTY_SCROLL_STATE_VERSION) || (renderStabilizerPrevScrollStateVersion !== v)) &&
+                        (renderStabilizerUpdateIterations < prepareIterations)) {
+                        if (v !== EMPTY_SCROLL_STATE_VERSION) {
+                            renderStabilizerPrevScrollStateVersion = v;
+                        }
+                        this._$fireUpdate.next(false);
+                        return of(false);
+                    }
+                    if (renderStabilizerPrevScrollStateVersion === v) {
+                        if (renderStabilizerUpdateIterations < prepareReupdateLength) {
+                            renderStabilizerUpdateIterations++;
+                            this._$fireUpdate.next(false);
+                            return of(false);
+                        }
+                    }
+                    renderStabilizerPrevScrollStateVersion = v;
+                    return of(true);
+                }), filter(v => !!v), distinctUntilChanged());
+            }));
+        };
+        const $initialRenderStabilizer = renderStabilizer({
+            prepareIterations: PREPARE_ITERATIONS,
+            prepareReupdateLength: PREPARATION_REUPDATE_LENGTH,
+        }), $updateItemsRenderStabilizer = renderStabilizer({
+            prepareIterations: PREPARE_ITERATIONS_FOR_UPDATE_ITEMS,
+            prepareReupdateLength: PREPARATION_REUPDATE_LENGTH_FOR_UPDATE_ITEMS,
+        }), $chunkLoadingRenderStabilizer = renderStabilizer({
+            prepareIterations: PREPARE_ITERATIONS_FOR_UPDATE_ITEMS,
+            prepareReupdateLength: PREPARATION_REUPDATE_LENGTH_FOR_UPDATE_ITEMS,
+        }), $collapseItemsRenderStabilizer = renderStabilizer({
+            prepareIterations: PREPARE_ITERATIONS_FOR_COLLAPSE_ITEMS,
+            prepareReupdateLength: PREPARATION_REUPDATE_LENGTH_FOR_COLLAPSE_ITEMS,
+        }), $itemConfigMap = this.$itemConfigMap.pipe(map(v => !v ? {} : v)), $divides = this.$divides, $dynamicSize = this.$dynamicSize, $snapScrollToStart = this._$actualSnapScrollToStart.asObservable(), $snapScrollToEnd = this._$actualSnapScrollToEnd.asObservable(), $waitForPreparation = this.$waitForPreparation, $items = this.$items;
+        combineLatest([$viewInit, $prerenderContainer, $divides, $dynamicSize, $snapScrollToStart, $snapScrollToEnd, $waitForPreparation]).pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), filter(([init, prerenderContainer]) => !!init && !!prerenderContainer), debounceTime(0), switchMap(([, prerenderContainer, divides, dynamicSize, snapScrollToStart, snapScrollToEnd, waitForPreparation]) => {
+            if (!!dynamicSize && !snapScrollToStart && !!snapScrollToEnd && !!waitForPreparation) {
+                const $collection = (divides > 1 ? $actualItems : $items);
+                return $collection.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged((p, c) => {
+                    const pLength = p?.length ?? 0, cLength = c?.length ?? 0;
+                    return !((cLength > 0) || (pLength !== cLength && (pLength === 0 || cLength === 0)));
+                }), tap(items => {
+                    this._trackBox.resetCollection(items, this.actualItemSize);
+                }), switchMap(i => of((i ?? []).length > 0)), distinctUntilChanged(), tap(v => {
+                    if (!v) {
+                        this.cacheClean();
+                        this.cleanup();
+                        this._readyForShow = false;
+                        if (!snapScrollToStart && snapScrollToEnd) {
+                            this._trackBox.isScrollEnd = true;
+                        }
+                        const scrollerComponent = this._scrollerComponent;
+                        if (!!scrollerComponent) {
+                            scrollerComponent.prepared = false;
+                            scrollerComponent.stopScrolling();
+                            scrollerComponent.refresh();
+                        }
+                        this._$classes.next({ prepared: true });
+                        this._$show.next(true);
+                    }
+                    else {
+                        this._trackBox.isScrollEnd = true;
+                        const waitForPreparation = this.waitForPreparation;
+                        if (waitForPreparation) {
+                            if (this.prerenderable) {
+                                this._cached = false;
+                                prerenderContainer.on(this.items);
+                            }
+                        }
+                        this._$classes.next({ prepared: false });
+                        this._$show.next(false);
+                    }
+                }), switchMap(v => {
+                    if (!v) {
+                        if (this.prerenderable) {
+                            prerenderContainer.off();
+                        }
+                        return of(false);
+                    }
+                    const waitForPreparation = this.waitForPreparation;
+                    if (waitForPreparation) {
+                        this._trackBox.isScrollEnd = true;
+                        if (this.prerenderable) {
+                            this._cached = false;
+                            prerenderContainer.on(this.items);
+                        }
+                        return $initialRenderStabilizer.pipe(takeUntil(this._$unsubscribe), take(1), tap(() => {
+                            this._trackBox.isScrollEnd = true;
+                            if (this.prerenderable) {
+                                prerenderContainer.off();
+                            }
+                            this._readyForShow = true;
+                            const scrollerComponent = this._scrollerComponent;
+                            if (!!scrollerComponent) {
+                                scrollerComponent.prepared = true;
+                                scrollerComponent.refresh();
+                            }
+                            this._$classes.next({ prepared: true });
+                            this._$show.next(true);
+                        }));
+                    }
+                    if (this.prerenderable) {
+                        prerenderContainer.off();
+                    }
+                    this._readyForShow = true;
+                    if (!snapScrollToStart && snapScrollToEnd) {
+                        this._trackBox.isScrollEnd = true;
+                    }
+                    const scrollerComponent = this._scrollerComponent;
+                    if (!!scrollerComponent) {
+                        scrollerComponent.prepared = true;
+                        scrollerComponent.refresh();
+                    }
+                    this._$classes.next({ prepared: true });
+                    this._$show.next(true);
+                    return of(false);
+                }));
+            }
+            else {
+                prerenderContainer.off();
+                const $collection = (divides > 1 ? $actualItems : $items);
+                return $collection.pipe(takeUntil(this._$unsubscribe), tap(items => {
+                    if (!items || items.length === 0) {
+                        this.cacheClean();
+                        const scrollerComponent = this._scrollerComponent;
+                        if (!!scrollerComponent) {
+                            scrollerComponent.prepared = false;
+                        }
+                        this._$classes.next({ prepared: false });
+                        this._$show.next(false);
+                    }
+                    this._trackBox.resetCollection(items, this.actualItemSize);
+                }), switchMap(i => of((i ?? []).length > 0)), distinctUntilChanged(), filter(v => !!v), tap(() => {
+                    this._readyForShow = true;
+                    if (snapScrollToStart) {
+                        this._trackBox.isScrollStart = true;
+                    }
+                    else if (snapScrollToEnd) {
+                        this._trackBox.isScrollEnd = true;
+                    }
+                    const scrollerComponent = this._scrollerComponent;
+                    if (!!scrollerComponent) {
+                        scrollerComponent.prepared = true;
+                        scrollerComponent.refresh();
+                    }
+                    this._$classes.next({ prepared: true });
+                    this._$show.next(true);
+                    this._$fireUpdate.next(false);
+                }));
+            }
+        })).subscribe();
+        $items.pipe(map(v => v?.length > 0), distinctUntilChanged(), takeUntil(this._$unsubscribe), filter(v => !!v), tap(() => {
+            this._cached = false;
+        }), switchMap(() => {
+            return $prerender.pipe(takeUntil(this._$unsubscribe), debounceTime(0), take(1), tap(cache => {
+                if (!this._readyForShow) {
+                    this._trackBox.refreshCache(cache);
+                    this._cached = true;
+                    this._$fireUpdate.next(true);
+                }
+            }));
+        })).subscribe();
+        this._service.$focusedId.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._$focusedElement.next(v ?? null);
+        })).subscribe();
+        $list.pipe(takeUntil(this._$unsubscribe), filter(element => !!element), tap(element => {
+            this._service.listElement = element;
+        })).subscribe();
+        const $defaultItemValue = this.$defaultItemValue, $selectByClick = this.$selectByClick, $collapseByClick = this.$collapseByClick, $isScrollStart = this._$isScrollStart.asObservable(), $isScrollFinished = this._$isScrollEnd.asObservable(), $isVertical = this.$direction.pipe(map(v => this.getIsVertical(v || DEFAULT_DIRECTION)));
+        $snapScrollToStart.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.snapScrollToStart = v;
+        })).subscribe();
+        $snapScrollToEnd.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.snapScrollToEnd = v;
+        })).subscribe();
+        $isVertical.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.isVertical = v;
+        })).subscribe();
+        $dynamicSize.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.dynamic = v;
+        })).subscribe();
+        $defaultItemValue.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.defaultItemValue = v;
+        })).subscribe();
+        $scrollStartOffset.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            this._trackBox.scrollStartOffset = this._service.scrollStartOffset = v;
+        })).subscribe();
+        $scrollEndOffset.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            this._trackBox.scrollEndOffset = this._service.scrollEndOffset = v;
+        })).subscribe();
+        $isScrollStart.pipe(takeUntil(this._$unsubscribe), skip(1), distinctUntilChanged(), debounceTime(0), filter(v => !!v && this._readyForShow), tap(() => {
+            if (this._scrollerComponent?.scrollable) {
+                this.onScrollReachStart.emit();
+            }
+        })).subscribe();
+        $isScrollFinished.pipe(takeUntil(this._$unsubscribe), skip(1), distinctUntilChanged(), debounceTime(0), filter(v => !!v && this._readyForShow), tap(v => {
+            if (this._scrollerComponent?.scrollable) {
+                this.onScrollReachEnd.emit();
+            }
+        })).subscribe();
+        $selectByClick.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.selectByClick = v;
+        })).subscribe();
+        $collapseByClick.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.collapseByClick = v;
+        })).subscribe();
+        $trackBy.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._trackBox.trackingPropertyName = v;
+        })).subscribe();
+        $divides.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._trackBox.divides = v;
+        })).subscribe();
+        combineLatest([this.$alignment, this.$isInfinity]).pipe(takeUntil(this._$unsubscribe), tap(([alignment, isInfinity]) => {
+            this._$actualAlignment.next(isInfinity ? Alignments.CENTER : alignment);
+        })).subscribe();
+        combineLatest([this.$scrollbarEnabled, this.$isInfinity]).pipe(takeUntil(this._$unsubscribe), debounceTime(0), tap(([scrollbarEnabled, isInfinity]) => {
+            this._$actualScrollbarEnabled.next(isInfinity ? false : scrollbarEnabled);
+        })).subscribe();
+        const $alignment = this.$actualAlignment, $precalculatedScrollStartOffset = this._$precalculatedScrollStartOffset.asObservable(), $precalculatedScrollEndOffset = this._$precalculatedScrollEndOffset.asObservable(), $listBounds = this._$listBounds.asObservable().pipe(filter(b => !!b)), $scrollSize = this._$scrollSize.asObservable(), $bufferSize = this.$bufferSize.pipe(map(v => v < 0 ? DEFAULT_BUFFER_SIZE : v)), $maxBufferSize = this.$maxBufferSize.pipe(map(v => v < 0 ? DEFAULT_BUFFER_SIZE : v)), $snapToItem = this.$snapToItem, $snapToItemAlign = this.$snapToItemAlign, $stickyEnabled = this.$stickyEnabled, $isLazy = this.$collectionMode.pipe(map(v => this.getIsLazy(v || DEFAULT_COLLECTION_MODE))), $enabledBufferOptimization = this.$enabledBufferOptimization, $snappingMethod = this.$snappingMethod.pipe(map(v => this.getIsSnappingMethodAdvanced(v || DEFAULT_SNAPPING_METHOD))), $collapsingMode = this.$collapsingMode, $selectingMode = this.$selectingMode, $selectedIds = this.$selectedIds, $collapsedIds = this.$collapsedIds.pipe(distinctUntilChanged(), map(v => Array.isArray(v) ? v : [])), $collapsedItemIds = this._$collapsedItemIds.asObservable().pipe(distinctUntilChanged(), map(v => Array.isArray(v) ? v : [])), $itemTransform = this.$itemTransform, $screenReaderMessage = this.$screenReaderMessage, $displayItems = this._service.$displayItems, $cacheVersion = this._service.$cacheVersion;
+        $snapToItem.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.snapToItem = v;
+        })).subscribe();
+        $actualItems.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.items = v;
+        })).subscribe();
+        combineLatest([$actualItems, $viewInit]).pipe(takeUntil(this._$unsubscribe), filter(([, init]) => init), debounceTime(0), tap(() => {
+            this._scrollerComponent?.snapIfNeed();
+        })).subscribe();
+        $itemConfigMap.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.itemConfigMap = v;
+        })).subscribe();
+        $collapsedIds.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._service.collapsedIds = v;
+        })).subscribe();
+        combineLatest([$displayItems, $screenReaderMessage, $isVertical, $scrollSize, $bounds]).pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), debounceTime(100), takeUntil(this._$unsubscribe), tap(([items, screenReaderMessage, isVertical, scrollSize, bounds]) => {
+            this._$screenReaderFormattedMessage.next(formatScreenReaderMessage(items, screenReaderMessage, scrollSize, isVertical, bounds));
+        })).subscribe();
+        $isLazy.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._trackBox.isLazy = v;
+        })).subscribe();
+        const $itemsComposition = $items.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), switchMap(items => {
+            return combineLatest([$collapsedItemIds, $itemConfigMap, $trackBy, $divides]).pipe(takeUntil(this._$unsubscribe), debounceTime(0), switchMap(([collapsedIds, itemConfigMap, trackBy, divides]) => {
+                return of({ items, collapsedIds, itemConfigMap, trackBy, divides });
+            }));
+        }));
+        $itemsComposition.pipe(takeUntil(this._$unsubscribe), switchMap(({ items, collapsedIds, itemConfigMap, trackBy, divides }) => {
+            if (items.length === 0 || !this._readyForShow || !(this.cachable && !this._cached &&
+                !this._trackBox.isSnappedToStart && this._trackBox.isSnappedToEnd)) {
+                return of({ items, collapsedIds, itemConfigMap, trackBy, divides });
+            }
+            return $updateItemsRenderStabilizer.pipe(takeUntil(this._$unsubscribe), take(1), debounceTime(0), switchMap(() => {
+                return of({ items, collapsedIds, itemConfigMap, trackBy, divides });
+            }));
+        }), tap(({ items, collapsedIds, itemConfigMap, trackBy, divides }) => {
+            const hiddenItems = new CMap();
+            let isCollapsed = false;
+            for (let i = 0, l = items.length; i < l; i++) {
+                const item = items[i], id = item?.[trackBy];
+                if (!!item) {
+                    const group = (itemConfigMap[id]?.sticky ?? 0) > 0, collapsed = collapsedIds.includes(id);
+                    if (!!group) {
+                        isCollapsed = collapsed;
+                    }
+                    else {
+                        if (isCollapsed) {
+                            hiddenItems.set(id, true);
+                        }
+                    }
+                }
+            }
+            const actualItems = [];
+            for (let i = 0, l = items.length; i < l; i++) {
+                const item = items[i], id = item?.[trackBy];
+                if (!!item && hiddenItems.has(id)) {
+                    continue;
+                }
+                actualItems.push(item);
+            }
+            const normalizedCollection = normalizeCollection(actualItems, itemConfigMap, trackBy, divides);
+            this._$actualItems.next(normalizedCollection);
+        })).subscribe();
+        $isVertical.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._isVertical = v;
+            const el = this._elementRef.nativeElement;
+            toggleClassName(el, v ? CLASS_LIST_VERTICAL : CLASS_LIST_HORIZONTAL, v ? CLASS_LIST_HORIZONTAL : CLASS_LIST_VERTICAL);
+        })).subscribe();
+        $snappingMethod.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this._isSnappingMethodAdvanced = this._trackBox.isSnappingMethodAdvanced = v;
+        })).subscribe();
+        $selectingMode.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            const el = this._$list.getValue()?.nativeElement;
+            if (this.getIsMultiSelection(v || DEFAULT_SNAPPING_METHOD)) {
+                this._isMultiSelection = true;
+                this._isSingleSelection = false;
+                if (!!el) {
+                    el.role = ROLE_LIST_BOX;
+                }
+                this._service.selectingMode = SelectingModesTypes.MULTI_SELECT;
+            }
+            else if (this.getIsSingleSelection(v || DEFAULT_SNAPPING_METHOD)) {
+                this._isSingleSelection = true;
+                this._isMultiSelection = false;
+                if (!!el) {
+                    el.role = ROLE_LIST_BOX;
+                }
+                this._service.selectingMode = SelectingModesTypes.SELECT;
+            }
+            else if (this.getIsNoneSelection(v || DEFAULT_SNAPPING_METHOD)) {
+                this._isSingleSelection = this._isMultiSelection = false;
+                if (!!el) {
+                    el.role = ROLE_LIST;
+                }
+                this._service.selectingMode = SelectingModesTypes.NONE;
+            }
+        })).subscribe();
+        $collapsingMode.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            if (this.getIsNoneCollapse()) {
+                this._service.isNoneCollapse = true;
+                this._service.isAccordionCollapse = this._service.isMultipleCollapse = this._isAccordionCollapse = this._isMultipleCollapse = false;
+            }
+            else if (this.getIsMultipleCollapse()) {
+                this._service.isMultipleCollapse = this._isMultipleCollapse = true;
+                this._service.isAccordionCollapse = this._service.isNoneCollapse = this._isAccordionCollapse = false;
+            }
+            else if (this.getIsAccordionCollapse()) {
+                this._service.isAccordionCollapse = this._isAccordionCollapse = true;
+                this._service.isMultipleCollapse = this._service.isNoneCollapse = this._isMultipleCollapse = false;
+            }
+        })).subscribe();
+        const $preventScrollSnapping = this.$preventScrollSnapping;
+        $preventScrollSnapping.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), tap(() => {
+            if (this._readyForShow) {
+                this._trackBox.isScrollEnd;
+                this._trackBox.isScrollStart = this._trackBox.isScrollEnd = false;
+                this._$isScrollStart.next(false);
+                this._$isScrollEnd.next(false);
+                const scroller = this._scrollerComponent;
+                if (!!scroller) {
+                    this._trackBox.preventScrollSnapping(true);
+                }
+            }
+        }), tap(() => {
+            if (this._readyForShow) {
+                this._$preventScrollSnapping.next(false);
+            }
+        })).subscribe();
+        $collapsedItemIds.pipe(takeUntil(this._$unsubscribe), filter(() => this._readyForShow), switchMap(() => {
+            return $collapseItemsRenderStabilizer.pipe(takeUntil(this._$unsubscribe), take(1), tap(() => {
+                this._$fireUpdate.next(true);
+            }));
+        })).subscribe();
+        let isChunkLoading = false;
+        const $loading = this.$loading;
+        $loading.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), skip(1), filter(v => !v), switchMap(() => {
+            isChunkLoading = true;
+            const scrollbar = this._scrollerComponent;
+            if (!!scrollbar) {
+                scrollbar.stopScrollbar();
+                scrollbar.refreshScrollbar();
+            }
+            return $actualItems.pipe(takeUntil(this._$unsubscribe), take(1), tap(() => {
+                this._$fireUpdateNextFrame.next(true);
+            }), switchMap(() => $chunkLoadingRenderStabilizer.pipe(takeUntil(this._$unsubscribe), take(1), tap(() => {
+                isChunkLoading = false;
+                this._trackBox.resetCacheChunkInfo();
+                const scrollbar = this._scrollerComponent;
+                if (!!scrollbar) {
+                    scrollbar.stopScrollbar();
+                    scrollbar.refreshScrollbar();
+                }
+            }))));
+        })).subscribe();
+        $loading.pipe(takeUntil(this._$unsubscribe), skip(1), distinctUntilChanged(), tap(v => {
+            if (v) {
+                this._isLoading = true;
+            }
+        }), filter(v => !v), tap(() => {
+            if (this._readyForShow) {
+                this._$preventScrollSnapping.next(true);
+            }
+        }), debounceTime(100), tap(() => {
+            this._isLoading = false;
+        })).subscribe();
+        const update = (params) => {
+            const { alignment, snapScrollToStart, snapScrollToEnd, bounds, items, itemConfigMap, scrollSize, itemSize, minItemSize, maxItemSize, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, enabledBufferOptimization, snapToItem, snapToItemAlign, userAction, collapsedIds, itemTransform, } = params;
+            const scroller = this._scrollerComponent;
+            let totalSize = 0;
+            if (!!scroller) {
+                const isInfinity = this.isInfinity, collapsable = collapsedIds.length > 0, cachable = this.cachable, cached = this._cached, waitingCache = cachable && !cached, emitUpdate = !this._readyForShow || waitingCache || collapsable || isChunkLoading, fireUpdate = !this._readyForShow || this._$scrollingTo.getValue(), fireUpdateAtEdges = fireUpdate || !isInfinity;
+                if (this._readyForShow || (cachable && cached)) {
+                    const currentScrollSize = (isVertical ? scroller.scrollTop : scroller.scrollLeft);
+                    let actualScrollSize = !this._readyForShow && snapScrollToEnd ? (isVertical ? scroller.scrollHeight : scroller.scrollWidth) :
+                        (isVertical ? scroller.scrollTop : scroller.scrollLeft), leftLayoutOffset = 0, displayItems;
+                    const { width, height } = bounds, viewportSize = (isVertical ? height : width), opts = {
+                        alignment, bounds: { width, height }, dynamicSize, isVertical, itemSize, minItemSize, maxItemSize, bufferSize, maxBufferSize,
+                        scrollSize: actualScrollSize, stickyEnabled, enabledBufferOptimization, snapToItem, snapToItemAlign, itemTransform,
+                    };
+                    if (snapScrollToEnd && !this._readyForShow) {
+                        const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize1, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize });
+                        displayItems = calculatedDisplayItems;
+                        totalSize = calculatedTotalSize1;
+                        leftLayoutOffset = leftLayoutOffset1;
+                        if (!!itemTransform && dynamicSize && this._trackBox.delta !== 0) {
+                            const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize1, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize + this._trackBox.delta });
+                            displayItems = calculatedDisplayItems;
+                            totalSize = calculatedTotalSize1;
+                            leftLayoutOffset = leftLayoutOffset1;
+                        }
+                    }
+                    else {
+                        const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, opts);
+                        displayItems = calculatedDisplayItems;
+                        totalSize = calculatedTotalSize;
+                        leftLayoutOffset = leftLayoutOffset1;
+                        if (!!itemTransform && dynamicSize && this._trackBox.delta !== 0) {
+                            const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize + this._trackBox.delta });
+                            displayItems = calculatedDisplayItems;
+                            totalSize = calculatedTotalSize;
+                            leftLayoutOffset = leftLayoutOffset1;
+                        }
+                    }
+                    scroller.totalSize = totalSize;
+                    scroller.startLayoutOffset = leftLayoutOffset;
+                    this._$totalSize.next(totalSize);
+                    this._service.collection = displayItems;
+                    this.resetBoundsSize(isVertical, totalSize);
+                    this.createDisplayComponentsIfNeed(displayItems);
+                    this.tracking();
+                    this.snappingHandler();
+                    if (!_$created.getValue()) {
+                        _$created.next(true);
+                    }
+                    const delta = this._trackBox.delta, scrollPositionAfterUpdate = actualScrollSize + delta, roundedScrollPositionAfterUpdate = scrollPositionAfterUpdate, roundedMaxPositionAfterUpdate = isVertical ? scroller.scrollHeight : scroller.scrollWidth;
+                    if (this._isSnappingMethodAdvanced) {
+                        this.updateRegularRenderer();
+                    }
+                    this.updateOffsetsByAllignment();
+                    scroller.delta = delta;
+                    if ((snapScrollToStart && this._trackBox.isSnappedToStart && scroller.scrollable) ||
+                        (snapScrollToStart && currentScrollSize <= MIN_PIXELS_FOR_PREVENT_SNAPPING)) {
+                        if (currentScrollSize !== roundedScrollPositionAfterUpdate) {
+                            this._trackBox.clearDelta();
+                            if (this._readyForShow) {
+                                this.emitScrollEvent(true, false, userAction);
+                            }
+                            this._trackBox.isScrollEnd;
+                            const params = {
+                                [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: 0, userAction,
+                                fireUpdate: fireUpdateAtEdges, behavior: BEHAVIOR_INSTANT,
+                                blending: false, duration: this.animationParams.scrollToItem,
+                            };
+                            scroller?.scrollTo?.(params);
+                            if (emitUpdate) {
+                                this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));
+                            }
+                        }
+                        return;
+                    }
+                    if ((snapScrollToEnd && this._trackBox.isSnappedToEnd) || (snapScrollToEnd && !scroller.scrollable) ||
+                        (scrollPositionAfterUpdate + MIN_PIXELS_FOR_PREVENT_SNAPPING >= roundedMaxPositionAfterUpdate) ||
+                        (roundedScrollPositionAfterUpdate >= scrollPositionAfterUpdate + MIN_PIXELS_FOR_PREVENT_SNAPPING)) {
+                        this._trackBox.clearDelta();
+                        if (!this._trackBox.isSnappedToEnd) {
+                            this._trackBox.isScrollEnd = true;
+                            this._trackBox.isScrollStart = false;
+                        }
+                        if (this._readyForShow) {
+                            this.emitScrollEvent(true, false, false);
+                        }
+                        const params = {
+                            [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: roundedMaxPositionAfterUpdate,
+                            fireUpdate: fireUpdateAtEdges, behavior: BEHAVIOR_INSTANT, userAction: false,
+                            blending: false, duration: this.animationParams.scrollToItem,
+                        };
+                        scroller?.scrollTo?.(params);
+                        if (emitUpdate) {
+                            this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));
+                        }
+                        return;
+                    }
+                    if (scrollSize !== scrollPositionAfterUpdate &&
+                        ((scrollPositionAfterUpdate >= 0 && scrollPositionAfterUpdate < roundedMaxPositionAfterUpdate) ||
+                            (scrollSize !== roundedMaxPositionAfterUpdate || currentScrollSize !== scrollPositionAfterUpdate))) {
+                        this._trackBox.clearDelta();
+                        if (this._readyForShow) {
+                            this.emitScrollEvent(true, false, userAction);
+                        }
+                        const params = {
+                            [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollPositionAfterUpdate, blending: true, userAction,
+                            fireUpdate, behavior: BEHAVIOR_INSTANT, duration: this.animationParams.scrollToItem,
+                        };
+                        scroller.scrollTo(params);
+                        if (emitUpdate) {
+                            this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));
+                        }
+                        return;
+                    }
+                }
+                if (emitUpdate) {
+                    this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));
+                }
+            }
+        };
+        let prevItems = [];
+        const debouncedUpdate = debounce(update, 0, MAX_NUMBERS_OF_SKIPS_FOR_QUALITY_OPTIMIZATION_LVL1);
+        $viewInit.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(() => {
+            return combineLatest([$trackBy, this.$isInfinity, $snapScrollToStart, $snapScrollToEnd, $bounds, $listBounds, $scrollEndOffset, $actualItems, $itemConfigMap, $scrollSize,
+                $actualItemSize, $actualMinItemSize, $actualMaxItemSize, $collapsedItemIds, $bufferSize, $maxBufferSize, $stickyEnabled, $isVertical,
+                $dynamicSize, $divides, $snapToItem, $snapToItemAlign, $enabledBufferOptimization, $itemTransform, $alignment,
+                $precalculatedScrollStartOffset, $precalculatedScrollEndOffset, $cacheVersion, this.$fireUpdate,
+            ]).pipe(takeUntil(this._$unsubscribe), tap(([trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds, listBounds, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize, maxItemSize, collapsedIds, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, divides, snapToItem, snapToItemAlign, enabledBufferOptimization, itemTransform, alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, cacheVersion,]) => {
+                let itemsChanged = false;
+                if (prevItems !== items) {
+                    itemsChanged = true;
+                    prevItems = items;
+                }
+                const enabledOptimization = this.scrollingSettings?.optimization ?? DEFAULT_SCROLLING_SETTINGS.optimization, velocity = this._scrollerComponent?.averageVelocity ?? 0, isScrolling = this._$scrollingTo.getValue(), useDebouncedUpdate = (dynamicSize && !itemTransform) && !(snapScrollToEnd && this._trackBox.isSnappedToEnd) && !itemsChanged && hasUserAction && !isScrolling &&
+                    (velocity > 0 && velocity < MAX_VELOCITY_FOR_SCROLL_QUALITY_OPTIMIZATION_LVL1);
+                if (enabledOptimization) {
+                    if (useDebouncedUpdate) {
+                        debouncedUpdate.execute({
+                            trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds: bounds, listBounds: listBounds, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize,
+                            maxItemSize, collapsedIds, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, divides, enabledBufferOptimization, itemTransform,
+                            snapToItem, snapToItemAlign, alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, cacheVersion, userAction: hasUserAction,
+                        });
+                        return;
+                    }
+                    debouncedUpdate.dispose();
+                }
+                if (!isScrolling) {
+                    update({
+                        trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds: bounds, listBounds: listBounds, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize,
+                        maxItemSize, collapsedIds, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, divides, enabledBufferOptimization, itemTransform,
+                        snapToItem, snapToItemAlign, alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, cacheVersion, userAction: hasUserAction,
+                    });
+                }
+            }));
+        })).subscribe();
+        const $scroller = this.$scroller.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), map(v => v.nativeElement), take(1)), $scrollerScroll = $scrollerComponent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), take(1), switchMap(scroller => scroller.$scroll)), $scrollerScrollEnd = $scrollerComponent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), take(1), switchMap(scroller => scroller.$scrollEnd)), $scrollbarScroll = $scrollerComponent.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), take(1), switchMap(scroller => scroller.$scrollbarScroll));
+        const scrollHandler = (userAction = false) => {
+            const scroller = this._scrollerComponent;
+            if (!!scroller) {
+                const isVertical = this._isVertical, scrollSize = (isVertical ? scroller.scrollTop : scroller.scrollLeft), actualScrollSize = scrollSize;
+                if (this._readyForShow) {
+                    if (userAction) {
+                        this._$preventScrollSnapping.next(true);
+                    }
+                }
+                this._$scrollSize.next(actualScrollSize);
+            }
+        };
+        $scroller.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), switchMap(scroller => {
+            return $scrollbarScroll.pipe(takeUntil(this._$unsubscribe), tap(userAction => {
+                const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;
+                if (!!scrollerEl && !!scrollerComponent) {
+                    this.emitScrollEvent(false, this._readyForShow, hasUserAction);
+                }
+                if (this._readyForShow) {
+                    if (userAction) {
+                        if (this._trackBox.isSnappedToStart) {
+                            this._$preventScrollSnapping.next(true);
+                        }
+                        if (this._trackBox.isSnappedToEnd) {
+                            this._$preventScrollSnapping.next(true);
+                        }
+                    }
+                }
+            }));
+        })).subscribe();
+        $scroller.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), switchMap(scroller => {
+            return $scrollerScroll.pipe(takeUntil(this._$unsubscribe));
+        }), tap(userAction => {
+            hasUserAction = userAction;
+            const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;
+            if (!!scrollerEl && !!scrollerComponent) {
+                this.emitScrollEvent(false, this._readyForShow, userAction);
+            }
+            scrollHandler(userAction);
+        })).subscribe();
+        $scroller.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), switchMap(scroller => {
+            return $scrollerScrollEnd.pipe(takeUntil(this._$unsubscribe));
+        }), tap(userAction => {
+            hasUserAction = userAction;
+            const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;
+            if (!!scrollerEl && !!scrollerComponent) {
+                this.emitScrollEvent(true, this._readyForShow, userAction);
+            }
+            scrollHandler(userAction);
+        })).subscribe();
+        const $scrollTo = this.$scrollTo, $scrollToExecutor = this.$scrollToExecutor;
+        combineLatest([$scroller, $trackBy, $scrollTo]).pipe(filter(([scroller, , event]) => !!scroller && !!event), map(([scroller, trackBy, event]) => ({ scroller: scroller, trackBy, event })), switchMap(({ event }) => {
+            const d = event?.delay ?? 0;
+            if (d > 0) {
+                return of(event).pipe(takeUntil(this._$unsubscribe), delay(d));
+            }
+            return of(event);
+        }), tap(event => {
+            this._$scrollingTo.next(true);
+            this._$scrollToExecutor.next(event);
+        })).subscribe();
+        $scrollToExecutor.pipe(takeUntil(this._$unsubscribe), switchMap(event => {
+            const trackBy = this.trackBy, scrollerComponent = this._scrollerComponent, { id, iteration = 0, blending = false, isLastIteration = false, cb } = event;
+            const nextIteration = iteration + 1, finished = nextIteration >= MAX_SCROLL_TO_ITERATIONS, fireUpdate = false;
+            if (!this._readyForShow) {
+                return of([finished, { id, iteration: nextIteration, blending, cb }]).pipe(delay(0));
+            }
+            debouncedUpdate.dispose();
+            this._$preventScrollSnapping.next(true);
+            if (!!scrollerComponent) {
+                scrollerComponent.startScrollTo();
+                const items = this._$actualItems.getValue();
+                if (!!items && items.length) {
+                    const dynamicSize = this.dynamicSize, itemSize = this.actualItemSize, minItemSize = this.actualMinItemSize, maxItemSize = this.actualMaxItemSize, snapScrollToEnd = this.snapScrollToEnd;
+                    if (dynamicSize) {
+                        const { width, height } = this._$bounds.getValue() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE }, itemConfigMap = this.itemConfigMap, isVertical = this._isVertical, currentScrollSize = isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft, opts = {
+                            alignment: this._$actualAlignment.getValue(),
+                            bounds: { width, height }, collection: items, dynamicSize, isVertical: this._isVertical, itemSize, minItemSize, maxItemSize,
+                            bufferSize: this.bufferSize, maxBufferSize: this.maxBufferSize, itemTransform: this.itemTransform,
+                            scrollSize: (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),
+                            snapToItem: this.snapToItem, snapToItemAlign: this.snapToItemAlign,
+                            stickyEnabled: this.stickyEnabled, fromItemId: id, enabledBufferOptimization: this.enabledBufferOptimization,
+                        };
+                        let scrollSize = snapScrollToEnd && this._trackBox.isSnappedToEnd ?
+                            (isVertical ? scrollerComponent.scrollHeight : scrollerComponent.scrollWidth) :
+                            this._trackBox.getItemPosition(id, itemConfigMap, opts);
+                        if (scrollSize === -1) {
+                            return of([finished, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));
+                        }
+                        this._trackBox.clearDelta();
+                        const viewportSize = (isVertical ? height : width), { displayItems, totalSize, leftLayoutOffset } = this._trackBox.updateCollection(items, itemConfigMap, {
+                            ...opts, scrollSize, fromItemId: isLastIteration ? undefined : id,
+                        }), delta1 = this._trackBox.delta;
+                        const normalizedTotalSize = totalSize < viewportSize ? viewportSize : totalSize;
+                        scrollerComponent.startLayoutOffset = leftLayoutOffset;
+                        scrollerComponent.totalSize = normalizedTotalSize;
+                        this._service.collection = displayItems;
+                        let actualScrollSize = scrollSize + delta1;
+                        this.resetBoundsSize(isVertical, normalizedTotalSize);
+                        this.createDisplayComponentsIfNeed(displayItems);
+                        this.tracking();
+                        this.snappingHandler();
+                        this.updateOffsetsByAllignment();
+                        scrollSize = this._trackBox.getItemPosition(id, itemConfigMap, { ...opts, scrollSize: actualScrollSize, fromItemId: id });
+                        if (scrollSize === -1) {
+                            return of([finished, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));
+                        }
+                        const notChanged = scrollSize === currentScrollSize;
+                        if (!notChanged && iteration < MAX_SCROLL_TO_ITERATIONS) {
+                            this._trackBox.clearDelta();
+                            const params = {
+                                [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollSize, behavior: BEHAVIOR_INSTANT,
+                                fireUpdate, blending, force: true, snap: false, normalize: false,
+                            };
+                            scrollerComponent?.scrollTo?.(params);
+                            return of([finished, {
+                                    id, iteration: nextIteration, blending,
+                                    isLastIteration: nextIteration < MAX_SCROLL_TO_ITERATIONS, cb
+                                }]).pipe(delay(0));
+                        }
+                        else {
+                            this._$scrollSize.next(actualScrollSize);
+                            return of([true, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));
+                        }
+                    }
+                    else {
+                        const index = items.findIndex(item => item[trackBy] === id);
+                        if (index > -1) {
+                            const isVertical = this._isVertical, itemSize = this.actualItemSize;
+                            let scrollSize = index * itemSize;
+                            if (this.isInfinity) {
+                                if (this.snapToItem) {
+                                    switch (this.snapToItemAlign) {
+                                        case SnapToItemAligns.CENTER: {
+                                            scrollSize += itemSize * .5;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                            const { width, height } = this._$bounds.getValue() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE }, itemConfigMap = this.itemConfigMap, items = this._$actualItems.getValue(), opts = {
+                                alignment: this._$actualAlignment.getValue(),
+                                bounds: { width, height }, collection: items, dynamicSize, isVertical: this._isVertical, itemSize, minItemSize, maxItemSize,
+                                bufferSize: this.bufferSize, maxBufferSize: this.maxBufferSize, itemTransform: this.itemTransform,
+                                scrollSize: (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),
+                                snapToItem: this.snapToItem, snapToItemAlign: this.snapToItemAlign,
+                                stickyEnabled: this.stickyEnabled, fromItemId: id, enabledBufferOptimization: this.enabledBufferOptimization,
+                            };
+                            this._trackBox.clearDelta();
+                            const viewportSize = (isVertical ? height : width), { displayItems, totalSize, leftLayoutOffset } = this._trackBox.updateCollection(items, itemConfigMap, {
+                                ...opts, scrollSize, fromItemId: isLastIteration ? undefined : id,
+                            });
+                            const actualTotalSize = this.isInfinity ? (totalSize + viewportSize) : totalSize;
+                            const normalizedTotalSize = actualTotalSize < viewportSize ? viewportSize : actualTotalSize;
+                            scrollerComponent.startLayoutOffset = leftLayoutOffset;
+                            scrollerComponent.totalSize = normalizedTotalSize;
+                            this._service.collection = displayItems;
+                            this.resetBoundsSize(isVertical, normalizedTotalSize);
+                            this.createDisplayComponentsIfNeed(displayItems);
+                            this.tracking();
+                            this.snappingHandler();
+                            this.updateOffsetsByAllignment();
+                            this._$preventScrollSnapping.next(true);
+                            const params = {
+                                [this._isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollSize, fireUpdate: false,
+                                behavior: BEHAVIOR_INSTANT, blending, force: true, snap: false, normalize: false,
+                            };
+                            scrollerComponent?.scrollTo?.(params);
+                            return of([true, { id, blending, iteration: nextIteration, cb }]);
+                        }
+                    }
+                }
+            }
+            return of([finished, { id, iteration: nextIteration, blending, cb }]);
+        }), takeUntil(this._$unsubscribe), tap(([finished, params]) => {
+            if (!finished) {
+                this._$scrollToExecutor.next(params);
+                return;
+            }
+            if (this._readyForShow) {
+                this._trackBox.preventScrollSnapping(true);
+            }
+            this._$scrollingTo.next(false);
+            this._scrollerComponent?.finishedScrollTo();
+            this._$fireUpdate.next(true);
+            this.emitScrollEvent(true, false, true);
+            const scrollParams = params;
+            scrollParams?.cb?.();
+        }), delay(0), tap(([finished]) => {
+            if (finished) {
+                this._scrollerComponent?.snapIfNeed();
+            }
+        })).subscribe();
+        const $itemRenderer = this.$itemRenderer;
+        $itemRenderer.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), filter(v => !!v), tap(v => {
+            this._$itemRenderer.next(v);
+        })).subscribe();
+        $bounds.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), filter(v => !!v), tap(value => {
+            const size = { width: value.width, height: value.height };
+            this.onViewportChange.emit(objectAsReadonly(size));
+        })).subscribe();
+        this._service.$virtualClick.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            this.onItemClick.emit(objectAsReadonly(v));
+        })).subscribe();
+        let isSelectedIdsFirstEmit = 0;
+        this._service.$selectedIds.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            if (this._isSingleSelection || (this._isMultiSelection && isSelectedIdsFirstEmit >= 2)) {
+                const curr = this.selectedIds;
+                if ((this._isSingleSelection && JSON.stringify(v) !== JSON.stringify(curr)) ||
+                    (isSelectedIdsFirstEmit === 2 && JSON.stringify(v) !== JSON.stringify(curr)) || isSelectedIdsFirstEmit > 2) {
+                    this.onSelect.emit(copyValueAsReadonly(v));
+                }
+            }
+            if (isSelectedIdsFirstEmit < 3) {
+                isSelectedIdsFirstEmit++;
+            }
+        })).subscribe();
+        $selectedIds.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            this._service.selectedIds = v;
+        })).subscribe();
+        $viewInit.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), switchMap(() => {
+            return this._service.$collapsedIds.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+                const curr = this._$collapsedItemIds.getValue();
+                if ((this._isAccordionCollapse || this._isMultipleCollapse) && (JSON.stringify(v) !== JSON.stringify(curr))) {
+                    this._$collapsedItemIds.next(v);
+                    this.onCollapse.emit(copyValueAsReadonly(v));
+                }
+            }));
+        })).subscribe();
+        combineLatest([$itemConfigMap, $dynamicSize, $divides]).pipe(takeUntil(this._$unsubscribe), filter(([itemConfigMap, dynamicSize, divides]) => !!itemConfigMap && !dynamicSize && divides > 1), tap(([itemConfigMap]) => {
+            for (const id in itemConfigMap) {
+                const metaData = itemConfigMap[id];
+                if (metaData?.fullSize || metaData?.sticky === 1 || metaData?.sticky === 2) {
+                    throw Error('The accelerated rendering algorithm `[dynamicSize]="false"` cannot correctly handle non-uniform lists (the itemConfigMap specifies full-size elements). For correct rendering, specify `[dynamicSize]="true"`.');
+                }
+            }
+        })).subscribe();
+        combineLatest([$collapsingMode, $items, $itemConfigMap, $trackBy]).pipe(takeUntil(this._$unsubscribe), tap(([collapsingMode, items, itemConfigMap, trackBy]) => {
+            const isAccordion = isCollapseMode(collapsingMode, CollapsingModes.ACCORDION);
+            if (isAccordion) {
+                const allGroups = [];
+                if (this._isAccordionCollapse) {
+                    for (let i = 0, l = items.length; i < l; i++) {
+                        const item = items[i], id = item[trackBy], collapsable = itemConfigMap?.[id]?.collapsable === true;
+                        if (!collapsable) {
+                            continue;
+                        }
+                        allGroups.push(id);
+                    }
+                }
+                if ((this._isAccordionCollapse || this._isMultipleCollapse) && (JSON.stringify(this._$collapsedItemIds.getValue()) !== JSON.stringify(allGroups))) {
+                    this._$collapsedItemIds.next(allGroups);
+                    this.onCollapse.emit(copyValueAsReadonly(allGroups));
+                }
+            }
+        })).subscribe();
+        $collapsedItemIds.pipe(takeUntil(this._$unsubscribe), distinctUntilChanged(), tap(v => {
+            this._service.collapsedIds = v;
+        })).subscribe();
+        this.$destroy.pipe(takeUntil(this._$unsubscribe), tap(() => {
+            debouncedUpdate.dispose();
+        })).subscribe();
+        this._$viewInit.next(true);
+        this._$fireUpdate.next(false);
+    }
+    onAfterResize(update = false) {
+        this.snappingHandler();
+        if (this._isSnappingMethodAdvanced) {
+            this.updateRegularRenderer();
+        }
+        if (this._readyForShow && update) {
+            const scroller = this._scrollerComponent;
+            if (!!scroller) {
+                const updatebale = this._readyForShow;
+                if (updatebale) {
+                    this._$fireUpdate.next(false);
+                }
+                scroller.refresh(updatebale, updatebale);
+            }
+        }
+    }
+    checkBoundsOfElements() {
+        const changed = this._trackBox.checkBoundsOfElements();
+        if (changed) {
+            const readyForShow = this._readyForShow, isScrolling = this._$scrollingTo.getValue();
+            this._trackBox.changes(true, readyForShow && !isScrolling);
+        }
+    }
+    snappingHandler() {
+        const scroller = this._scrollerComponent;
+        if (!!scroller) {
+            const isVertical = this.isVertical, maxScrollSize = Math.round(isVertical ? scroller.scrollHeight ?? 0 : scroller.scrollWidth ?? 0), scrollSize = isVertical ? scroller.scrollTop ?? 0 : scroller.scrollLeft ?? 0, actualScrollSize = Math.round(scrollSize);
+            if (this._readyForShow && !this._isLoading) {
+                const isScrollEnd = (actualScrollSize >= (maxScrollSize - MIN_PIXELS_FOR_PREVENT_SNAPPING)) || !scroller.scrollable || this._trackBox.isScrollEnd;
+                if (isScrollEnd) {
+                    this._$isScrollStart.next(false);
+                    this._$isScrollEnd.next(true);
+                    this._trackBox.isScrollStart = false;
+                    this._trackBox.isScrollEnd = true;
+                }
+                else {
+                    const isScrollStart = (actualScrollSize <= MIN_PIXELS_FOR_PREVENT_SNAPPING);
+                    this._$isScrollStart.next(isScrollStart);
+                    this._$isScrollEnd.next(false);
+                    this._trackBox.isScrollStart = isScrollStart;
+                    this._trackBox.isScrollEnd = false;
+                }
+            }
+            else if (!this._readyForShow) {
+                const snapScrollToStart = this._$actualSnapScrollToStart.getValue(), snapScrollToEnd = this._$actualSnapScrollToEnd.getValue();
+                if (!snapScrollToStart && snapScrollToEnd) {
+                    this._$isScrollStart.next(false);
+                    this._$isScrollEnd.next(true);
+                    this._trackBox.isScrollStart = false;
+                    this._trackBox.isScrollEnd = true;
+                }
+                else if (snapScrollToStart && snapScrollToEnd) {
+                    this._$isScrollStart.next(true);
+                    this._$isScrollEnd.next(false);
+                    this._trackBox.isScrollStart = true;
+                    this._trackBox.isScrollEnd = false;
+                }
+                else {
+                    this._$isScrollStart.next(false);
+                    this._$isScrollEnd.next(false);
+                    this._trackBox.isScrollStart = false;
+                    this._trackBox.isScrollEnd = false;
+                }
+            }
+        }
+    }
+    ;
+    emitScrollEvent(isScrollEnd = false, update = true, userAction = false) {
+        if (!this._readyForShow) {
+            return;
+        }
+        const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;
+        if (scrollerEl && scrollerComponent) {
+            const isVertical = this._isVertical, scrollSize = (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft), maxScrollSize = (isVertical ? scrollerComponent.scrollHeight : scrollerComponent.scrollWidth), bounds = this._$bounds.getValue() || { x: 0, y: 0, width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE };
+            const itemsRange = formatActualDisplayItems(this._service.displayItems, this._$actualScrollStartOffset.getValue(), this._$actualScrollEndOffset.getValue(), scrollSize, isVertical, bounds), event = new ScrollEvent({
+                direction: this._scrollerComponent?.scrollDirection ?? 0, container: scrollerEl,
+                list: this._$list.getValue().nativeElement, delta: this._trackBox.delta,
+                deltaOfNewItems: this._trackBox.deltaOfNewItems, isVertical,
+                scrollSize,
+                itemsRange,
+                isEnd: !scrollerComponent.scrollable || this._trackBox.isSnappedToEnd || (Math.round(scrollSize) === Math.round(maxScrollSize)),
+                userAction,
+            });
+            if (update) {
+                this._$scroll.next(event);
+            }
+            if (isScrollEnd) {
+                this.onScrollEnd.emit(event);
+            }
+            else {
+                this.onScroll.emit(event);
+            }
+        }
+    }
+    getIsSnappingMethodAdvanced(m) {
+        const method = m || this.snappingMethod;
+        return isSnappingMethodAdvenced(method);
+    }
+    getIsNoneSelection(m) {
+        const mode = m || this.selectingMode;
+        return isSelectMode(mode, SelectingModes.NONE);
+    }
+    getIsSingleSelection(m) {
+        const mode = m || this.selectingMode;
+        return isSelectMode(mode, SelectingModes.SELECT);
+    }
+    getIsMultiSelection(m) {
+        const mode = m || this.selectingMode;
+        return isSelectMode(mode, SelectingModes.MULTI_SELECT);
+    }
+    getIsNoneCollapse(m) {
+        const mode = m || this.collapsingMode;
+        return isCollapseMode(mode, CollapsingModes.NONE);
+    }
+    getIsMultipleCollapse(m) {
+        const mode = m || this.collapsingMode;
+        return isCollapseMode(mode, CollapsingModes.MULTI_COLLAPSE);
+    }
+    getIsAccordionCollapse(m) {
+        const mode = m || this.collapsingMode;
+        return isCollapseMode(mode, CollapsingModes.ACCORDION);
+    }
+    getIsVertical(d) {
+        const dir = d || this.direction;
+        return isDirection(dir, Directions.VERTICAL);
+    }
+    getIsLazy(m) {
+        const mode = m || this.collectionMode;
+        return isCollectionMode(mode, CollectionModes.LAZY);
+    }
+    createDisplayComponentsIfNeed(displayItems) {
+        if (!displayItems || !this._listContainerRef) {
+            this._trackBox.setDisplayObjectIndexMapById({});
+            return;
+        }
+        if (this._isSnappingMethodAdvanced && this.stickyEnabled) {
+            if (this._snappedDisplayComponents.length < MAX_REGULAR_SNAPED_COMPONENTS && !!this._snapContainerRef) {
+                while (this._snappedDisplayComponents.length < MAX_REGULAR_SNAPED_COMPONENTS) {
+                    const comp = this._snapContainerRef.createComponent(this._itemComponentClass);
+                    comp.instance.renderer = this._$itemRenderer.getValue();
+                    comp.instance.regular = true;
+                    this._snappedDisplayComponents.push(comp);
+                    this._trackBox.snappedDisplayComponents = this._snappedDisplayComponents;
+                    this._resizeSnappedObserver = new ResizeObserver(this._resizeSnappedComponentHandler);
+                    this._resizeSnappedObserver.observe(comp.instance.element);
+                }
+            }
+        }
+        this._trackBox.items = displayItems;
+        const listContainerRef = this._listContainerRef;
+        const maxLength = displayItems.length, components = this._displayComponents;
+        if (!!listContainerRef) {
+            const doMap = {};
+            let i = 0;
+            for (let l = components.length; i < l; i++) {
+                const item = components[i];
+                if (!!item) {
+                    const id = item.instance.id;
+                    item.instance.renderer = this._$itemRenderer.getValue();
+                    doMap[id] = i;
+                }
+            }
+            while (components.length < maxLength) {
+                const comp = listContainerRef.createComponent(this._itemComponentClass);
+                const id = comp.instance.id;
+                comp.instance.renderer = this._$itemRenderer.getValue();
+                doMap[id] = i;
+                components.push(comp);
+                i++;
+            }
+            this._trackBox.setDisplayObjectIndexMapById(doMap);
+        }
+    }
+    updateOffsetsByAllignment() {
+        const alignment = this._$actualAlignment.getValue(), items = this._$actualItems.getValue(), trackBy = this.trackBy, isInfinity = this.isInfinity, isVertical = this._isVertical, { width, height } = this._$bounds.getValue() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE }, viewportSize = isVertical ? height : width, precalculatedScrollStartOffset = this._$precalculatedScrollStartOffset.getValue(), precalculatedScrollEndOffset = this._$precalculatedScrollEndOffset.getValue();
+        switch (alignment) {
+            case Alignments.NONE: {
+                this._$actualScrollStartOffset.next(precalculatedScrollStartOffset);
+                this._$actualScrollEndOffset.next(precalculatedScrollEndOffset);
+                break;
+            }
+            case Alignments.CENTER: {
+                const firstItemId = items.length > 0 ? (items[0]?.[trackBy] ?? null) : null, endItemId = items.length > 0 ? (items?.[items.length - 1]?.[trackBy] ?? null) : null, alignmentStartOffset = viewportSize * .5 - (firstItemId !== null ? (isVertical ? (this._service.getItemBounds(firstItemId)?.height ?? 0) :
+                    (this._service.getItemBounds(firstItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5), alignmentEndOffset = viewportSize * .5 - (endItemId !== null ? (isVertical ? (this._service.getItemBounds(endItemId)?.height ?? 0) :
+                    (this._service.getItemBounds(endItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5);
+                this._$alignmentScrollStartOffset.next(alignmentStartOffset);
+                this._$alignmentScrollEndOffset.next(alignmentEndOffset);
+                this._$actualScrollStartOffset.next(precalculatedScrollStartOffset + alignmentStartOffset);
+                this._$actualScrollEndOffset.next(precalculatedScrollEndOffset + alignmentEndOffset);
+                break;
+            }
+        }
+    }
+    updateRegularRenderer() {
+        this._resizeSnappedComponentHandler();
+    }
+    /**
+     * Tracking by id
+     */
+    tracking() {
+        this._trackBox.track();
+    }
+    resetBoundsSize(isVertical, totalSize) {
+        const l = this._$list.getValue(), prop = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME, size = totalSize;
+        if (!!l && parseInt(l.nativeElement.style[prop]) !== size) {
+            l.nativeElement.style[prop] = `${size}${PX}`;
+        }
+    }
+    /**
+     * Returns the bounds of an element with a given id
+     */
+    getItemBounds(id) {
+        return this._service.getItemBounds(id);
+    }
+    /**
+     * Focus an list item by a given id.
+     */
+    focus(id, align = FocusAlignments.NONE) {
+        this._elementRef.nativeElement.focus();
+        this._service.focusById(id, align, this.scrollBehavior);
+    }
+    /**
+     * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.
+     */
+    scrollTo(id, cb = null, options = null) {
+        const behavior = options?.behavior ?? BEHAVIOR_INSTANT, blending = options?.blending ?? false, focused = options?.focused ?? true, delay = options?.delay ?? 0, iteration = options?.iteration ?? 0;
+        validateId(id);
+        validateScrollBehavior(behavior);
+        validateIteration(iteration);
+        const actualIteration = validateScrollIteration(iteration);
+        this._elementRef.nativeElement.focus();
+        if (!this._scrollerComponent?.scrollable && !this.isInfinity) {
+            this.scrollToFinalize(id, focused, cb);
+            return;
+        }
+        this._$scrollTo.next({
+            id, behavior, blending, delay, iteration: actualIteration, isLastIteration: actualIteration === MAX_SCROLL_TO_ITERATIONS, cb: () => {
+                this.scrollToFinalize(id, focused, cb);
+            }
+        });
+    }
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToStart(cb = null, options = null) {
+        const scroller = this._scrollerComponent;
+        if (!!scroller) {
+            const scrollSize = this.isVertical ? scroller.scrollTop : scroller.scrollLeft;
+            if (scrollSize === 0) {
+                return;
+            }
+            scroller.stopScrolling();
+        }
+        const behavior = options?.behavior ?? BEHAVIOR_INSTANT, blending = options?.blending ?? false, focused = options?.focused ?? true, delay = options?.delay ?? 0, iteration = options?.iteration ?? 0;
+        validateScrollBehavior(behavior);
+        validateIteration(iteration);
+        const trackBy = this.trackBy, items = this._$actualItems.getValue(), firstItem = items.length > 0 ? items[0] ?? null : null, id = firstItem?.[trackBy] ?? null, actualIteration = validateScrollIteration(iteration);
+        if (!!firstItem) {
+            this._elementRef.nativeElement.focus();
+            this._$scrollTo.next({
+                id, behavior, blending, delay, iteration: actualIteration, isLastIteration: actualIteration === MAX_SCROLL_TO_ITERATIONS, cb: () => {
+                    this._$isScrollStart.next(true);
+                    this._trackBox.isScrollStart = true;
+                    this._trackBox.isScrollEnd = false;
+                    this._$fireUpdate.next(true);
+                    this.scrollToFinalize(id, focused, cb);
+                }
+            });
+        }
+    }
+    /**
+     * @deprecated
+     * The scrollToEndItem method is deprecated. Use the scrollToEnd method.
+     */
+    scrollToEndItem(cb, options) {
+        throw Error('The scrollToEndItem method is deprecated. Use the scrollToEnd method.');
+    }
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToEnd(cb = null, options = null) {
+        const scroller = this._scrollerComponent;
+        if (!!scroller) {
+            const isVertical = this.isVertical, scrollSize = isVertical ? scroller.scrollTop : scroller.scrollLeft, maxScrollSize = isVertical ? scroller.scrollHeight : scroller.scrollTop;
+            if (scrollSize === maxScrollSize) {
+                return;
+            }
+            scroller.stopScrolling();
+        }
+        const behavior = options?.behavior ?? BEHAVIOR_INSTANT, blending = options?.blending ?? false, focused = options?.focused ?? true, delay = options?.delay ?? 0, iteration = options?.iteration ?? 0;
+        validateScrollBehavior(behavior);
+        validateIteration(iteration);
+        const trackBy = this.trackBy, items = this._$actualItems.getValue(), latItem = items[items.length > 0 ? items.length - 1 : 0], id = latItem?.[trackBy] ?? null, actualIteration = validateScrollIteration(iteration);
+        if (latItem === null) {
+            return;
+        }
+        this._elementRef.nativeElement.focus();
+        if (!this._scrollerComponent?.scrollable) {
+            this.scrollToFinalize(id, focused, cb);
+            return;
+        }
+        this._$scrollTo.next({
+            id, behavior, blending, delay, iteration: actualIteration, isLastIteration: actualIteration === MAX_SCROLL_TO_ITERATIONS, cb: () => {
+                this._$isScrollEnd.next(true);
+                this._trackBox.isScrollStart = false;
+                this._trackBox.isScrollEnd = true;
+                this._$fireUpdate.next(true);
+                this.scrollToFinalize(id, focused, cb);
+            }
+        });
+    }
+    scrollToFinalize(id, focused, cb) {
+        if (focused) {
+            const el = this._service.getFocusedElementById(id);
+            if (!!el) {
+                this._service.focus(el, FocusAlignments.NONE);
+            }
+        }
+        if (typeof cb === 'function') {
+            cb?.();
+        }
+    }
+    cleanup() {
+        const displayItems = [];
+        this._service.collection = displayItems;
+        this.createDisplayComponentsIfNeed(displayItems);
+        this.tracking();
+        this.emitScrollEvent(true, false, false);
+    }
+    /**
+     * Force clearing the cache.
+     */
+    cacheClean() {
+        this._cached = false;
+        if (this.dynamicSize) {
+            this._trackBox.cacheClean();
+        }
+        const prerenderContainer = this._prerender;
+        if (!!prerenderContainer) {
+            prerenderContainer.clear();
+            prerenderContainer.off();
+        }
+        this._$collapsedItemIds.next([]);
+        this._$isScrollStart.next(true);
+        this._$isScrollEnd.next(false);
+        this._$totalSize.next(0);
+        this._$scrollSize.next(0);
+        const scroller = this._scrollerComponent;
+        if (!!scroller) {
+            scroller.reset();
+        }
+    }
+    /**
+     * @deprecated
+     * The stopSnappingScrollToEnd method is deprecated. Use the preventSnapping method.
+     */
+    stopSnappingScrollToEnd() {
+        throw Error('The stopSnappingScrollToEnd method is deprecated. Use the preventSnapping method.');
+    }
+    /**
+     * Prevents the list from snapping to its start or end edge.
+     */
+    preventSnapping() {
+        if (!this._readyForShow) {
+            return;
+        }
+        const scroller = this._scrollerComponent;
+        this._$isScrollStart.next(false);
+        this._$isScrollEnd.next(false);
+        this._trackBox.preventScrollSnapping(true);
+        if (scroller) {
+            scroller.stopScrolling();
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.dispose();
+    }
+    dispose() {
+        this._$destroy.next();
+        const updateId = this._updateId;
+        if (updateId !== undefined) {
+            cancelAnimationFrame(updateId);
+            this._updateId = undefined;
+        }
+        if (this._service) {
+            this._service.dispose();
+        }
+        if (!!this._trackBox) {
+            this._trackBox.dispose();
+        }
+        if (!!this._resizeSnappedObserver) {
+            this._resizeSnappedObserver.disconnect();
+        }
+        if (!!this._snappedDisplayComponents) {
+            while (this._snappedDisplayComponents.length > 0) {
+                const comp = this._snappedDisplayComponents.shift();
+                comp?.destroy();
+            }
+        }
+        if (this._displayComponents) {
+            while (this._displayComponents.length > 0) {
+                const comp = this._displayComponents.shift();
+                comp?.destroy();
+            }
+        }
+    }
+}
+NgVirtualListComponent.__nextId = 0;
+NgVirtualListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgVirtualListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: NgVirtualListComponent, selector: "ng-virtual-list", inputs: { scrollbarThickness: "scrollbarThickness", scrollbarMinSize: "scrollbarMinSize", scrollbarThumbRenderer: "scrollbarThumbRenderer", scrollbarThumbParams: "scrollbarThumbParams", loading: "loading", waitForPreparation: "waitForPreparation", clickDistance: "clickDistance", items: "items", selectedIds: "selectedIds", defaultItemValue: "defaultItemValue", collapsedIds: "collapsedIds", selectByClick: "selectByClick", collapseByClick: "collapseByClick", snap: "snap", stickyEnabled: "stickyEnabled", snapToEndTransitionInstantOffset: "snapToEndTransitionInstantOffset", scrollStartOffset: "scrollStartOffset", scrollEndOffset: "scrollEndOffset", snapScrollToStart: "snapScrollToStart", snapScrollToEnd: "snapScrollToEnd", snapScrollToBottom: "snapScrollToBottom", scrollbarEnabled: "scrollbarEnabled", scrollbarInteractive: "scrollbarInteractive", overlappingScrollbar: "overlappingScrollbar", scrollBehavior: "scrollBehavior", scrollingSettings: "scrollingSettings", itemTransform: "itemTransform", snapToItem: "snapToItem", snapToItemAlign: "snapToItemAlign", snappingDistance: "snappingDistance", scrollingOneByOne: "scrollingOneByOne", alignment: "alignment", zIndexWhenSelecting: "zIndexWhenSelecting", spreadingMode: "spreadingMode", divides: "divides", motionBlur: "motionBlur", maxMotionBlur: "maxMotionBlur", motionBlurEnabled: "motionBlurEnabled", animationParams: "animationParams", overscrollEnabled: "overscrollEnabled", enabledBufferOptimization: "enabledBufferOptimization", itemRenderer: "itemRenderer", itemConfigMap: "itemConfigMap", itemSize: "itemSize", minItemSize: "minItemSize", maxItemSize: "maxItemSize", dynamicSize: "dynamicSize", direction: "direction", collectionMode: "collectionMode", bufferSize: "bufferSize", maxBufferSize: "maxBufferSize", snappingMethod: "snappingMethod", collapsingMode: "collapsingMode", methodForSelecting: "methodForSelecting", selectingMode: "selectingMode", trackBy: "trackBy", screenReaderMessage: "screenReaderMessage", langTextDir: "langTextDir" }, outputs: { onScroll: "onScroll", onScrollEnd: "onScrollEnd", onViewportChange: "onViewportChange", onSnapItem: "onSnapItem", onItemClick: "onItemClick", onSelect: "onSelect", onCollapse: "onCollapse", onScrollReachStart: "onScrollReachStart", onScrollReachEnd: "onScrollReachEnd" }, host: { styleAttribute: "position: relative;" }, providers: [NgVirtualListService, NgVirtualListPublicService], viewQueries: [{ propertyName: "_prerender", first: true, predicate: ["prerender"], descendants: true, read: NgPrerenderContainer }, { propertyName: "_listContainerRef", first: true, predicate: ["renderersContainer"], descendants: true, read: ViewContainerRef }, { propertyName: "_snapContainerRef", first: true, predicate: ["snapRendererContainer"], descendants: true, read: ViewContainerRef }, { propertyName: "_scrollerComponent", first: true, predicate: ["scroller"], descendants: true, read: NgScrollerComponent }], usesInheritance: true, ngImport: i0, template: "<div aria-live=\"polite\" aria-atomic=\"true\" class=\"ngvl__screen-reader\">\r\n  {{ $screenReaderFormattedMessage | async }}\r\n</div>\r\n\r\n<ng-prerender-container #prerender [bounds]=\"($bounds | async)!\" [direction]=\"($direction | async)!\"\r\n  [dynamic]=\"($dynamicSize | async)!\" [divides]=\"($divides | async)!\" [isVertical]=\"($isVertical | async)!\"\r\n  [itemSize]=\"($actualItemSize | async)!\" [trackBy]=\"($trackBy | async)!\" [itemRenderer]=\"($itemRenderer | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\"\r\n  [scrollbarEnabled]=\"(scroller.$scrollbarShow | async)!\"\r\n  [enabled]=\"($prerenderEnabled | async)!\"></ng-prerender-container>\r\n\r\n<ng-container *ngIf=\"($stickyEnabled | async)!\">\r\n  <div localeSensitive [langTextDir]=\"($langTextDir | async)!\" #snappedContainer class=\"ngvl__snapped-container\"\r\n    [ngClass]=\"($classes | async)\">\r\n    <div #snapped part=\"snapped-item\" class=\"ngvl__list-snapper\">\r\n      <ng-container #snapRendererContainer></ng-container>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n\r\n<ng-scroller #scroller class=\"ngvl__list-scroller\" [classes]=\"($classes | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\"\r\n  [alignmentStartOffset]=\"($alignmentScrollStartOffset | async)!\"\r\n  [alignmentEndOffset]=\"($alignmentScrollEndOffset | async)!\" [direction]=\"($direction | async)!\"\r\n  [scrollbarThumbRenderer]=\"($scrollbarThumbRenderer | async)!\" [isInfinity]=\"($isInfinity | async)!\"\r\n  [scrollbarThickness]=\"($scrollbarThickness | async)!\" [scrollbarThumbParams]=\"($scrollbarThumbParams | async)!\"\r\n  [animationParams]=\"($animationParams | async)!\" [focusedElement]=\"($focusedElement | async)!\"\r\n  [loading]=\"($loading | async)!\" [overscrollEnabled]=\"($overscrollEnabled | async)!\"\r\n  [snappingDistance]=\"($snappingDistance | async)!\" [overlappingScrollbar]=\"($overlappingScrollbar | async)!\"\r\n  [scrollbarEnabled]=\"($actualScrollbarEnabled | async)!\" [scrollbarInteractive]=\"($scrollbarInteractive | async)!\"\r\n  [snapToItem]=\"($snapToItem | async)!\" [snapToItemAlign]=\"($snapToItemAlign | async)!\"\r\n  [scrollbarMinSize]=\"($scrollbarMinSize | async)!\" [scrollBehavior]=\"($scrollBehavior | async)!\"\r\n  [scrollingSettings]=\"($scrollingSettings | async)!\" [scrollingOneByOne]=\"($scrollingOneByOne | async)!\"\r\n  [motionBlur]=\"($motionBlur | async)!\" [maxMotionBlur]=\"($maxMotionBlur | async)!\"\r\n  [motionBlurEnabled]=\"($motionBlurEnabled | async)!\">\r\n  <ng-container #renderersContainer></ng-container>\r\n</ng-scroller>", styles: [":host{position:relative;display:block;width:400px;overflow:hidden}:host(.horizontal){height:48px}:host(.vertical){height:320px}.ngvl__snapped-container{position:relative;width:100%;opacity:0}.ngvl__snapped-container.prepared{opacity:1}.ngvl__list-snapper{-webkit-tap-highlight-color:transparent;position:absolute;list-style:none;left:0;top:0;z-index:1}.ngvl__list-scroller{-webkit-tap-highlight-color:transparent;position:absolute;left:0;top:0;width:100%;height:100%;z-index:0}.ngvl__screen-reader{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.NgScrollerComponent, selector: "ng-scroller", inputs: ["scrollbarEnabled", "scrollbarInteractive", "focusedElement", "overlappingScrollbar", "content", "loading", "classes", "scrollbarMinSize", "scrollbarThickness", "scrollbarThumbRenderer", "scrollbarThumbParams", "motionBlur", "maxMotionBlur", "motionBlurEnabled"], outputs: ["onScrollbarVisible"] }, { kind: "component", type: i3.NgPrerenderContainer, selector: "ng-prerender-container", inputs: ["enabled", "direction", "isVertical", "scrollbarEnabled", "startOffset", "endOffset", "bounds", "dynamic", "itemSize", "trackBy", "divides"] }, { kind: "directive", type: i4.LocaleSensitiveDirective, selector: "[localeSensitive]", inputs: ["langTextDir", "listDir"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.ShadowDom });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ng-virtual-list', host: {
+                        'style': 'position: relative;'
+                    }, standalone: false, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.ShadowDom, providers: [NgVirtualListService, NgVirtualListPublicService], template: "<div aria-live=\"polite\" aria-atomic=\"true\" class=\"ngvl__screen-reader\">\r\n  {{ $screenReaderFormattedMessage | async }}\r\n</div>\r\n\r\n<ng-prerender-container #prerender [bounds]=\"($bounds | async)!\" [direction]=\"($direction | async)!\"\r\n  [dynamic]=\"($dynamicSize | async)!\" [divides]=\"($divides | async)!\" [isVertical]=\"($isVertical | async)!\"\r\n  [itemSize]=\"($actualItemSize | async)!\" [trackBy]=\"($trackBy | async)!\" [itemRenderer]=\"($itemRenderer | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\"\r\n  [scrollbarEnabled]=\"(scroller.$scrollbarShow | async)!\"\r\n  [enabled]=\"($prerenderEnabled | async)!\"></ng-prerender-container>\r\n\r\n<ng-container *ngIf=\"($stickyEnabled | async)!\">\r\n  <div localeSensitive [langTextDir]=\"($langTextDir | async)!\" #snappedContainer class=\"ngvl__snapped-container\"\r\n    [ngClass]=\"($classes | async)\">\r\n    <div #snapped part=\"snapped-item\" class=\"ngvl__list-snapper\">\r\n      <ng-container #snapRendererContainer></ng-container>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n\r\n<ng-scroller #scroller class=\"ngvl__list-scroller\" [classes]=\"($classes | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\"\r\n  [alignmentStartOffset]=\"($alignmentScrollStartOffset | async)!\"\r\n  [alignmentEndOffset]=\"($alignmentScrollEndOffset | async)!\" [direction]=\"($direction | async)!\"\r\n  [scrollbarThumbRenderer]=\"($scrollbarThumbRenderer | async)!\" [isInfinity]=\"($isInfinity | async)!\"\r\n  [scrollbarThickness]=\"($scrollbarThickness | async)!\" [scrollbarThumbParams]=\"($scrollbarThumbParams | async)!\"\r\n  [animationParams]=\"($animationParams | async)!\" [focusedElement]=\"($focusedElement | async)!\"\r\n  [loading]=\"($loading | async)!\" [overscrollEnabled]=\"($overscrollEnabled | async)!\"\r\n  [snappingDistance]=\"($snappingDistance | async)!\" [overlappingScrollbar]=\"($overlappingScrollbar | async)!\"\r\n  [scrollbarEnabled]=\"($actualScrollbarEnabled | async)!\" [scrollbarInteractive]=\"($scrollbarInteractive | async)!\"\r\n  [snapToItem]=\"($snapToItem | async)!\" [snapToItemAlign]=\"($snapToItemAlign | async)!\"\r\n  [scrollbarMinSize]=\"($scrollbarMinSize | async)!\" [scrollBehavior]=\"($scrollBehavior | async)!\"\r\n  [scrollingSettings]=\"($scrollingSettings | async)!\" [scrollingOneByOne]=\"($scrollingOneByOne | async)!\"\r\n  [motionBlur]=\"($motionBlur | async)!\" [maxMotionBlur]=\"($maxMotionBlur | async)!\"\r\n  [motionBlurEnabled]=\"($motionBlurEnabled | async)!\">\r\n  <ng-container #renderersContainer></ng-container>\r\n</ng-scroller>", styles: [":host{position:relative;display:block;width:400px;overflow:hidden}:host(.horizontal){height:48px}:host(.vertical){height:320px}.ngvl__snapped-container{position:relative;width:100%;opacity:0}.ngvl__snapped-container.prepared{opacity:1}.ngvl__list-snapper{-webkit-tap-highlight-color:transparent;position:absolute;list-style:none;left:0;top:0;z-index:1}.ngvl__list-scroller{-webkit-tap-highlight-color:transparent;position:absolute;left:0;top:0;width:100%;height:100%;z-index:0}.ngvl__screen-reader{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _prerender: [{
+                type: ViewChild,
+                args: ['prerender', { read: NgPrerenderContainer }]
+            }], _listContainerRef: [{
+                type: ViewChild,
+                args: ['renderersContainer', { read: ViewContainerRef }]
+            }], _snapContainerRef: [{
+                type: ViewChild,
+                args: ['snapRendererContainer', { read: ViewContainerRef }]
+            }], _scrollerComponent: [{
+                type: ViewChild,
+                args: ['scroller', { read: NgScrollerComponent }]
+            }], onScroll: [{
+                type: Output
+            }], onScrollEnd: [{
+                type: Output
+            }], onViewportChange: [{
+                type: Output
+            }], onSnapItem: [{
+                type: Output
+            }], onItemClick: [{
+                type: Output
+            }], onSelect: [{
+                type: Output
+            }], onCollapse: [{
+                type: Output
+            }], onScrollReachStart: [{
+                type: Output
+            }], onScrollReachEnd: [{
+                type: Output
+            }], scrollbarThickness: [{
+                type: Input
+            }], scrollbarMinSize: [{
+                type: Input
+            }], scrollbarThumbRenderer: [{
+                type: Input
+            }], scrollbarThumbParams: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], waitForPreparation: [{
+                type: Input
+            }], clickDistance: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], selectedIds: [{
+                type: Input
+            }], defaultItemValue: [{
+                type: Input
+            }], collapsedIds: [{
+                type: Input
+            }], selectByClick: [{
+                type: Input
+            }], collapseByClick: [{
+                type: Input
+            }], snap: [{
+                type: Input
+            }], stickyEnabled: [{
+                type: Input
+            }], snapToEndTransitionInstantOffset: [{
+                type: Input
+            }], scrollStartOffset: [{
+                type: Input
+            }], scrollEndOffset: [{
+                type: Input
+            }], snapScrollToStart: [{
+                type: Input
+            }], snapScrollToEnd: [{
+                type: Input
+            }], snapScrollToBottom: [{
+                type: Input
+            }], scrollbarEnabled: [{
+                type: Input
+            }], scrollbarInteractive: [{
+                type: Input
+            }], overlappingScrollbar: [{
+                type: Input
+            }], scrollBehavior: [{
+                type: Input
+            }], scrollingSettings: [{
+                type: Input
+            }], itemTransform: [{
+                type: Input
+            }], snapToItem: [{
+                type: Input
+            }], snapToItemAlign: [{
+                type: Input
+            }], snappingDistance: [{
+                type: Input
+            }], scrollingOneByOne: [{
+                type: Input
+            }], alignment: [{
+                type: Input
+            }], zIndexWhenSelecting: [{
+                type: Input
+            }], spreadingMode: [{
+                type: Input
+            }], divides: [{
+                type: Input
+            }], motionBlur: [{
+                type: Input
+            }], maxMotionBlur: [{
+                type: Input
+            }], motionBlurEnabled: [{
+                type: Input
+            }], animationParams: [{
+                type: Input
+            }], overscrollEnabled: [{
+                type: Input
+            }], enabledBufferOptimization: [{
+                type: Input
+            }], itemRenderer: [{
+                type: Input
+            }], itemConfigMap: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], minItemSize: [{
+                type: Input
+            }], maxItemSize: [{
+                type: Input
+            }], dynamicSize: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], collectionMode: [{
+                type: Input
+            }], bufferSize: [{
+                type: Input
+            }], maxBufferSize: [{
+                type: Input
+            }], snappingMethod: [{
+                type: Input
+            }], collapsingMode: [{
+                type: Input
+            }], methodForSelecting: [{
+                type: Input
+            }], selectingMode: [{
+                type: Input
+            }], trackBy: [{
+                type: Input
+            }], screenReaderMessage: [{
+                type: Input
+            }], langTextDir: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-virtual-list.component.js","sourceRoot":"","sources":["../../../../projects/ng-virtual-list/src/lib/ng-virtual-list.component.ts","../../../../projects/ng-virtual-list/src/lib/ng-virtual-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectionStrategy, Component, ComponentRef, ElementRef, EventEmitter, inject, Input,\r\n  OnDestroy, Output, TemplateRef, ViewChild, ViewContainerRef, ViewEncapsulation,\r\n} from '@angular/core';\r\nimport {\r\n  BehaviorSubject, combineLatest, debounceTime, delay, distinctUntilChanged, filter, fromEvent, map,\r\n  Observable,\r\n  of, skip, Subject, switchMap, take, takeUntil, tap,\r\n} from 'rxjs';\r\nimport { NgVirtualListItemComponent } from './components/ng-list-item/ng-virtual-list-item.component';\r\nimport {\r\n  BEHAVIOR_INSTANT, CLASS_LIST_HORIZONTAL, CLASS_LIST_VERTICAL, DEFAULT_DIRECTION, DEFAULT_DYNAMIC_SIZE,\r\n  DEFAULT_ENABLED_BUFFER_OPTIMIZATION, DEFAULT_ITEM_SIZE, DEFAULT_BUFFER_SIZE, DEFAULT_LIST_SIZE, DEFAULT_STICKY_ENABLED, DEFAULT_SNAPPING_METHOD,\r\n  HEIGHT_PROP_NAME, LEFT_PROP_NAME, MAX_SCROLL_TO_ITERATIONS, PX, FOCUS, TOP_PROP_NAME, TRACK_BY_PROPERTY_NAME, WIDTH_PROP_NAME,\r\n  DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SELECTING_MODES, DEFAULT_SELECT_BY_CLICK, DEFAULT_COLLAPSE_BY_CLICK, DEFAULT_COLLECTION_MODE,\r\n  DEFAULT_SCREEN_READER_MESSAGE, DEFAULT_SNAP_TO_END_TRANSITION_INSTANT_OFFSET, DEFAULT_SNAP_SCROLLTO_END, MIN_PIXELS_FOR_PREVENT_SNAPPING,\r\n  MOUSE_DOWN, TOUCH_START, DEFAULT_LANG_TEXT_DIR, DEFAULT_CLICK_DISTANCE, DEFAULT_WAIT_FOR_PREPARATION, DEFAULT_SCROLLBAR_THICKNESS,\r\n  DEFAULT_SCROLLBAR_MIN_SIZE, KEY_DOWN, BEHAVIOR_AUTO, DEFAULT_SCROLLBAR_ENABLED, DEFAULT_SCROLLBAR_INTERACTIVE, DEFAULT_OVERSCROLL_ENABLED,\r\n  DEFAULT_ANIMATION_PARAMS, DEFAULT_SCROLL_BEHAVIOR, DEFAULT_SNAP_SCROLLTO_START, EMPTY_SCROLL_STATE_VERSION, MAX_REGULAR_SNAPED_COMPONENTS,\r\n  PREPARE_ITERATIONS, PREPARATION_REUPDATE_LENGTH, ROLE_LIST_BOX, ROLE_LIST, KEY_TAB, MAX_VELOCITY_FOR_SCROLL_QUALITY_OPTIMIZATION_LVL1,\r\n  PREPARE_ITERATIONS_FOR_UPDATE_ITEMS, PREPARATION_REUPDATE_LENGTH_FOR_UPDATE_ITEMS, PREPARE_ITERATIONS_FOR_COLLAPSE_ITEMS,\r\n  PREPARATION_REUPDATE_LENGTH_FOR_COLLAPSE_ITEMS, MAX_NUMBERS_OF_SKIPS_FOR_QUALITY_OPTIMIZATION_LVL1, DEFAULT_SCROLLING_SETTINGS,\r\n  DEFAULT_SNAP_TO_ITEM, DEFAULT_SNAP_TO_ITEM_ALIGN, VIEWPORT, DEFAULT_MOTION_BLUR, DEFAULT_MAX_MOTION_BLUR, DEFAULT_SCROLLING_ONE_BY_ONE,\r\n  DEFAULT_MOTION_BLUR_ENABLED, DEFAULT_DIVIDES, DEFAULT_SNAPPING_DISTANCE, DEFAULT_MAX_ITEM_SIZE, DEFAULT_MIN_ITEM_SIZE,\r\n  DEFAULT_ALIGNMENT, DEFAULT_COLLAPSING_MODES, DEFAULT_SPREADING_MODE, DEFAULT_ZINDEX_WHEN_SELECTING,\r\n  DEFAULT_OVERLAPPING_SCROLLBAR,\r\n} from './const';\r\nimport {\r\n  IRenderVirtualListItem, IVirtualListCollection, IVirtualListItem, IVirtualListItemConfigMap,\r\n} from './models';\r\nimport {\r\n  IScrollEvent, IScrollOptions, IAnimationParams, ISize, IRenderStabilizerOptions, IScrollingSettings,\r\n} from './interfaces';\r\nimport {\r\n  Alignment, ArithmeticExpression, FocusAlignment, Id, ItemTransform, SnappingDistance, CollectionMode, Direction, SelectingMode,\r\n  SnappingMethod, SnapToItemAlign, TextDirection, CollapsingMode,\r\n  SpreadingMode,\r\n} from './types';\r\nimport { IRenderVirtualListCollection } from './models/render-collection.model';\r\nimport {\r\n  Alignments, CollectionModes, Directions, FocusAlignments, SelectingModes, SnappingMethods, SnapToItemAligns, SpreadingModes, TextDirections,\r\n} from './enums';\r\nimport { debounce, ScrollEvent, toggleClassName } from './utils';\r\nimport { TrackBox } from './core/track-box';\r\nimport { isSnappingMethodAdvenced } from './utils/snapping-method';\r\nimport { BaseVirtualListItemComponent } from './components/ng-list-item/base';\r\nimport { Component$1 } from './models/component.model';\r\nimport { isDirection } from './utils/is-direction';\r\nimport { NgVirtualListService } from './ng-virtual-list.service';\r\nimport { isSelectMode } from './utils/is-select-mode';\r\nimport { isCollapseMode } from './utils/is-collapse-mode';\r\nimport { SelectingModesTypes } from './enums/selecting-modes-types';\r\nimport { CMap } from './utils/cmap';\r\nimport {\r\n  validateArray, validateBoolean, validateFloat, validateFunction, validateInt, validateObject, validateString,\r\n} from './utils/validation';\r\nimport { copyValueAsReadonly, objectAsReadonly } from './utils/object';\r\nimport { isCollectionMode } from './utils/is-collection-mode';\r\nimport { NgScrollerComponent } from './components/ng-scroller/ng-scroller.component';\r\nimport { IScrollToParams } from './components/ng-scroll-view';\r\nimport { NgPrerenderContainer } from './components/ng-prerender-container/ng-prerender-container.component';\r\nimport { IScrollParams } from './interfaces';\r\nimport { formatActualDisplayItems, formatScreenReaderMessage } from './utils/screen-reader-formatter';\r\nimport { validateId, validateIteration, validateScrollBehavior, validateScrollIteration } from './utils/list-validators';\r\nimport { EVENT_KEY_DOWN, KEY_ARR_DOWN, KEY_ARR_LEFT, KEY_ARR_RIGHT, KEY_ARR_UP } from './components/ng-list-item/const';\r\nimport { NgVirtualListPublicService } from './ng-virtual-list-public.service';\r\nimport { isPercentageValue } from './utils/is-persentage-value';\r\nimport { parseArithmeticExpression } from './utils/parse-arithmetic-expression';\r\nimport { normalizeCollection } from './utils/normalize-collection';\r\nimport { CollapsingModes } from './enums';\r\nimport { isSpreadingMode } from './utils/is-spreading-mode';\r\nimport { IGetItemPositionOptions, IUpdateCollectionOptions } from './core/interfaces';\r\nimport { getScrollStateVersion } from './utils/get-scroll-state-version';\r\nimport { DisposableComponent } from './utils/disposable-component';\r\n\r\n/**\r\n * Virtual list component.\r\n * Maximum performance for extremely large lists.\r\n * It is based on algorithms for virtualization of screen objects.\r\n * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/ng-virtual-list.component.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\n@Component({\r\n  selector: 'ng-virtual-list',\r\n  templateUrl: './ng-virtual-list.component.html',\r\n  styleUrls: ['./ng-virtual-list.component.scss'],\r\n  host: {\r\n    'style': 'position: relative;'\r\n  },\r\n  standalone: false,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.ShadowDom,\r\n  providers: [NgVirtualListService, NgVirtualListPublicService],\r\n})\r\nexport class NgVirtualListComponent extends DisposableComponent implements OnDestroy {\r\n  private static __nextId: number = 0;\r\n\r\n  private _id: number = NgVirtualListComponent.__nextId;\r\n\r\n  /**\r\n   * Readonly. Returns the unique identifier of the component.\r\n   */\r\n  get id() { return this._id; }\r\n\r\n  private _service = inject(NgVirtualListService);\r\n\r\n  @ViewChild('prerender', { read: NgPrerenderContainer })\r\n  private _prerender: NgPrerenderContainer | undefined;\r\n\r\n  @ViewChild('renderersContainer', { read: ViewContainerRef })\r\n  private _listContainerRef: ViewContainerRef | undefined;\r\n\r\n  @ViewChild('snapRendererContainer', { read: ViewContainerRef })\r\n  private _snapContainerRef: ViewContainerRef | undefined;\r\n\r\n  @ViewChild('scroller', { read: NgScrollerComponent })\r\n  private _scrollerComponent: NgScrollerComponent | undefined;\r\n\r\n  private _$scroller = new BehaviorSubject<ElementRef<HTMLDivElement> | undefined>(undefined);\r\n  protected readonly $scroller = this._$scroller.asObservable();\r\n\r\n  private _$list = new BehaviorSubject<ElementRef<HTMLDivElement> | undefined>(undefined);\r\n  protected readonly $list = this._$list.asObservable();\r\n\r\n  /**\r\n   * Fires when the list has been scrolled.\r\n   */\r\n  @Output()\r\n  onScroll = new EventEmitter<IScrollEvent>();\r\n\r\n  /**\r\n   * Fires when the list has completed scrolling.\r\n   */\r\n  @Output()\r\n  onScrollEnd = new EventEmitter<IScrollEvent>();\r\n\r\n  /**\r\n   * Fires when the viewport size is changed.\r\n   */\r\n  @Output()\r\n  onViewportChange = new EventEmitter<ISize>();\r\n\r\n  /**\r\n   * Emit the component ID when an element crosses the alignment line specified by the snapToItemAlign property.\r\n   */\r\n  @Output()\r\n  onSnapItem = new EventEmitter<Id>();\r\n\r\n  /**\r\n   * Fires when an element is clicked.\r\n   */\r\n  @Output()\r\n  onItemClick = new EventEmitter<IRenderVirtualListItem<any> | null>();\r\n\r\n  /**\r\n   * Fires when elements are selected.\r\n   */\r\n  @Output()\r\n  onSelect = new EventEmitter<Array<Id> | Id | null>();\r\n\r\n  /**\r\n   * Fires when elements are collapsed.\r\n   */\r\n  @Output()\r\n  onCollapse = new EventEmitter<Array<Id>>();\r\n\r\n  /**\r\n   * Fires when the scroll reaches the start.\r\n   */\r\n  @Output()\r\n  onScrollReachStart = new EventEmitter<void>();\r\n\r\n  /**\r\n   * Fires when the scroll reaches the end.\r\n   */\r\n  @Output()\r\n  onScrollReachEnd = new EventEmitter<void>();\r\n\r\n  private _$show = new BehaviorSubject<boolean>(false);\r\n  readonly $show = this._$show.asObservable();\r\n\r\n  private _$initialized = new BehaviorSubject<boolean>(false);\r\n  readonly $initialized = this._$initialized.asObservable();\r\n\r\n  private _$scrollbarThickness = new BehaviorSubject<number>(DEFAULT_SCROLLBAR_THICKNESS);\r\n  protected readonly $scrollbarThickness = this._$scrollbarThickness.asObservable();\r\n\r\n  private _scrollbarThicknessTransform = (v: number) => {\r\n    const valid = validateInt(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollbarThickness\" parameter must be of type `number`.');\r\n      return DEFAULT_SCROLLBAR_THICKNESS;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Scrollbar thickness.\r\n   */\r\n  @Input()\r\n  set scrollbarThickness(v: number) {\r\n    if (this._$scrollbarThickness.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollbarThicknessTransform(v);\r\n\r\n    this._$scrollbarThickness.next(transformedValue);\r\n  };\r\n  get scrollbarThickness() { return this._$scrollbarThickness.getValue(); }\r\n\r\n  private _$scrollbarMinSize = new BehaviorSubject<number>(DEFAULT_SCROLLBAR_MIN_SIZE);\r\n  protected readonly $scrollbarMinSize = this._$scrollbarMinSize.asObservable();\r\n\r\n  private _scrollbarMinSizeTransform = (v: number) => {\r\n    const valid = validateInt(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollbarMinSize\" parameter must be of type `number`.');\r\n      return DEFAULT_SCROLLBAR_MIN_SIZE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Minimum scrollbar size.\r\n   */\r\n  @Input()\r\n  set scrollbarMinSize(v: number) {\r\n    if (this._$scrollbarMinSize.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollbarMinSizeTransform(v);\r\n\r\n    this._$scrollbarMinSize.next(transformedValue);\r\n  };\r\n  get scrollbarMinSize() { return this._$scrollbarMinSize.getValue() as number; }\r\n\r\n  private _$scrollbarThumbRenderer = new BehaviorSubject<TemplateRef<any> | null>(null);\r\n  protected readonly $scrollbarThumbRenderer = this._$scrollbarThumbRenderer.asObservable();\r\n\r\n  private _scrollbarThumbRendererTransform = (v: TemplateRef<any> | null) => {\r\n    const valid = validateObject(v, true, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollbarThumbRenderer\" parameter must be of type `object`.');\r\n      return null;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Scrollbar customization template.\r\n   */\r\n  @Input()\r\n  set scrollbarThumbRenderer(v: TemplateRef<any> | null) {\r\n    if (this._$scrollbarThumbRenderer.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollbarThumbRendererTransform(v);\r\n\r\n    this._$scrollbarThumbRenderer.next(transformedValue);\r\n  };\r\n  get scrollbarThumbRenderer() { return this._$scrollbarThumbRenderer.getValue(); }\r\n\r\n  private _$scrollbarThumbParams = new BehaviorSubject<{ [propName: string]: any } | null>({});\r\n  protected readonly $scrollbarThumbParams = this._$scrollbarThumbParams.asObservable();\r\n\r\n  private _scrollbarThumbParamsTransform = (v: { [propName: string]: any } | null) => {\r\n    const valid = validateObject(v, true, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollbarThumbParams\" parameter must be of type `object`.');\r\n      return null;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Additional options for the scrollbar.\r\n   */\r\n  @Input()\r\n  set scrollbarThumbParams(v: { [propName: string]: any } | null) {\r\n    if (this._$scrollbarThumbParams.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollbarThumbParamsTransform(v);\r\n\r\n    this._$scrollbarThumbParams.next(transformedValue);\r\n  };\r\n  get scrollbarThumbParams() { return this._$scrollbarThumbParams.getValue(); }\r\n\r\n  private _loading = {\r\n    transform: (v: boolean) => {\r\n      const valid = validateBoolean(v);\r\n\r\n      if (!valid) {\r\n        console.error('The \"loading\" parameter must be of type `boolean`.');\r\n        return false;\r\n      }\r\n      return v;\r\n    },\r\n  } as any;\r\n\r\n  private _$loading = new BehaviorSubject<boolean>(false);\r\n  protected readonly $loading = this._$loading.asObservable();\r\n\r\n  private _loadingTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"loading\" parameter must be of type `boolean`.');\r\n      return false;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If `true`, the scrollBar goes into loading state. The default value is `false`.\r\n   */\r\n  @Input()\r\n  set loading(v: boolean) {\r\n    if (this._$loading.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._loadingTransform(v);\r\n\r\n    this._$loading.next(transformedValue);\r\n  };\r\n  get loading() { return this._$loading.getValue() as boolean; }\r\n\r\n  private _$waitForPreparation = new BehaviorSubject<boolean>(DEFAULT_WAIT_FOR_PREPARATION);\r\n  protected readonly $waitForPreparation = this._$waitForPreparation.asObservable();\r\n\r\n  private _waitForPreparationTransform = (v: boolean) => {\r\n    const valid = validateObject(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"waitForPreparation\" parameter must be of type `boolean`.');\r\n      return DEFAULT_WAIT_FOR_PREPARATION;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If true, it will wait until the list items are fully prepared before displaying them.. The default value is `true`.\r\n   */\r\n  @Input()\r\n  set waitForPreparation(v: boolean) {\r\n    if (this._$waitForPreparation.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._waitForPreparationTransform(v);\r\n\r\n    this._$waitForPreparation.next(transformedValue);\r\n  };\r\n  get waitForPreparation() { return this._$waitForPreparation.getValue() as boolean; }\r\n\r\n  private _$clickDistance = new BehaviorSubject<number>(DEFAULT_CLICK_DISTANCE);\r\n  protected readonly $clickDistance = this._$clickDistance.asObservable();\r\n\r\n  private _clickDistanceTransform = (v: number) => {\r\n    const valid = validateInt(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"clickDistance\" parameter must be of type `number`.');\r\n      return DEFAULT_CLICK_DISTANCE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * The maximum scroll distance at which a click event is triggered.\r\n   */\r\n  @Input()\r\n  set clickDistance(v: number) {\r\n    if (this._$clickDistance.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._clickDistanceTransform(v);\r\n\r\n    this._$clickDistance.next(transformedValue);\r\n  };\r\n  get clickDistance() { return this._$clickDistance.getValue() as number; }\r\n\r\n  private _$items = new BehaviorSubject<IVirtualListCollection>([]);\r\n  protected readonly $items = this._$items.asObservable();\r\n\r\n  private _itemsTransform = (v: IVirtualListCollection) => {\r\n    let valid = validateArray(v, true, true);\r\n    if (valid) {\r\n      if (v) {\r\n        const trackBy = this.trackBy;\r\n        for (let i = 0, l = v.length; i < l; i++) {\r\n          const item = v[i];\r\n          valid = validateObject(item, true, true);\r\n          if (valid) {\r\n            if (item && !(validateFloat(item?.[trackBy] as number, true) || validateString(item?.[trackBy] as string, true, true))) {\r\n              valid = false;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (!valid) {\r\n      console.error('The \"items\" parameter must be of type `IVirtualListCollection` or `null`.');\r\n      return [];\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Collection of list items.\r\n   */\r\n  @Input()\r\n  set items(v: IVirtualListCollection) {\r\n    if (this._$items.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._itemsTransform(v);\r\n\r\n    this._$items.next(transformedValue);\r\n  };\r\n  get items() { return this._$items.getValue() as IVirtualListCollection; }\r\n\r\n  private _$selectedIds = new BehaviorSubject<Array<Id> | Id | null>(null);\r\n  protected readonly $selectedIds = this._$selectedIds.asObservable();\r\n\r\n  private _selectedIdsTransform = (v: Array<Id> | Id | null) => {\r\n    let valid = validateArray(v as any, true, true) || validateString(v as any, true, true) || validateFloat(v as any, true);\r\n    if (valid) {\r\n      if (v && Array.isArray(v)) {\r\n        for (let i = 0, l = v.length; i < l; i++) {\r\n          const item = v[i];\r\n          valid = validateString(item as any) || validateFloat(item as any);\r\n          if (!valid) {\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (!valid) {\r\n      console.error('The \"selectedIds\" parameter must be of type `Array<Id> | Id` or `null`.');\r\n      return this._isMultiSelection ? [] : null;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Sets the selected items.\r\n   */\r\n  @Input()\r\n  set selectedIds(v: Array<Id> | Id | null) {\r\n    if (this._$selectedIds.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._selectedIdsTransform(v);\r\n\r\n    this._$selectedIds.next(transformedValue);\r\n  };\r\n  get selectedIds() { return this._$selectedIds.getValue(); }\r\n\r\n  private _$defaultItemValue = new BehaviorSubject<IVirtualListItem | null>(null);\r\n  protected readonly $defaultItemValue = this._$defaultItemValue.asObservable();\r\n\r\n  @Input()\r\n  set defaultItemValue(v: IVirtualListItem | null) {\r\n    if (this._$defaultItemValue.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    this._$defaultItemValue.next(v);\r\n  };\r\n  get defaultItemValue() { return this._$defaultItemValue.getValue(); }\r\n\r\n  private _$collapsedIds = new BehaviorSubject<Array<Id>>([]);\r\n  protected readonly $collapsedIds = this._$collapsedIds.asObservable();\r\n\r\n  private _collapsedIdsTransform = (v: Array<Id>) => {\r\n    let valid = validateArray(v as any, true, true);\r\n    if (valid) {\r\n      if (v && Array.isArray(v)) {\r\n        for (let i = 0, l = v.length; i < l; i++) {\r\n          const item = v[i];\r\n          valid = validateString(item as any) || validateFloat(item as any);\r\n          if (!valid) {\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (!valid) {\r\n      console.error('The \"collapsedIds\" parameter must be of type `Array<Id>`.');\r\n      return [];\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Sets the collapsed items.\r\n   */\r\n  @Input()\r\n  set collapsedIds(v: Array<Id>) {\r\n    if (this._$collapsedIds.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._collapsedIdsTransform(v);\r\n\r\n    this._$collapsedIds.next(transformedValue);\r\n  };\r\n  get collapsedIds() { return this._$collapsedIds.getValue(); }\r\n\r\n  private _$selectByClick = new BehaviorSubject<boolean>(DEFAULT_SELECT_BY_CLICK);\r\n  protected readonly $selectByClick = this._$selectByClick.asObservable();\r\n\r\n  private _selectByClickTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"selectByClick\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SELECT_BY_CLICK;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If `false`, the element is selected using the config.api method passed to the template; \r\n   * if `true`, the element is selected by clicking on it. The default value is `true`.\r\n   */\r\n  @Input()\r\n  set selectByClick(v: boolean) {\r\n    if (this._$selectByClick.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._selectByClickTransform(v);\r\n\r\n    this._$selectByClick.next(transformedValue);\r\n  };\r\n  get selectByClick() { return this._$selectByClick.getValue(); }\r\n\r\n  private _$collapseByClick = new BehaviorSubject<boolean>(DEFAULT_COLLAPSE_BY_CLICK);\r\n  protected readonly $collapseByClick = this._$collapseByClick.asObservable();\r\n\r\n  private _collapseByClickTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"collapseByClick\" parameter must be of type `boolean`.');\r\n      return DEFAULT_COLLAPSE_BY_CLICK;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If `false`, the element is collapsed using the config.collapse method passed to the template; \r\n   * if `true`, the element is collapsed by clicking on it. The default value is `true`.\r\n   */\r\n  @Input()\r\n  set collapseByClick(v: boolean) {\r\n    if (this._$collapseByClick.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._collapseByClickTransform(v);\r\n\r\n    this._$collapseByClick.next(transformedValue);\r\n  };\r\n  get collapseByClick() { return this._$collapseByClick.getValue(); }\r\n\r\n  /**\r\n   * @deprecated\r\n   * Use the `stickyEnabled` property instead.\r\n   */\r\n  @Input()\r\n  set snap(v: boolean) {\r\n    throw Error(`Property snap is deprecated. Use the \\`stickyEnabled\\` property instead.`);\r\n  };\r\n\r\n  private _$stickyEnabled = new BehaviorSubject<boolean>(DEFAULT_STICKY_ENABLED);\r\n  protected readonly $stickyEnabled = this._$stickyEnabled.asObservable();\r\n\r\n  private _stickyEnabledTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"stickyEnabled\" parameter must be of type `boolean`.');\r\n      return DEFAULT_STICKY_ENABLED;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether items with the given `sticky` in `itemConfigMap` will stick to the edges. Default value is \"true\".\r\n   */\r\n  @Input()\r\n  set stickyEnabled(v: boolean) {\r\n    if (this._$stickyEnabled.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._stickyEnabledTransform(v);\r\n\r\n    this._$stickyEnabled.next(transformedValue);\r\n  };\r\n  get stickyEnabled() { return this._$stickyEnabled.getValue(); }\r\n\r\n  private _$snapToEndTransitionInstantOffset = new BehaviorSubject<number>(DEFAULT_SNAP_TO_END_TRANSITION_INSTANT_OFFSET);\r\n  protected readonly $snapToEndTransitionInstantOffset = this._$snapToEndTransitionInstantOffset.asObservable();\r\n\r\n  private _snapToEndTransitionInstantOffsetTransform = (v: number) => {\r\n    const valid = validateFloat(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"snapToEndTransitionInstantOffset\" parameter must be of type `number`.');\r\n      return DEFAULT_SNAP_TO_END_TRANSITION_INSTANT_OFFSET;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Sets the offset value; if the scroll area value is exceeded, the scroll animation will be disabled. Default value is \"0\".\r\n   */\r\n  @Input()\r\n  set snapToEndTransitionInstantOffset(v: number) {\r\n    if (this._$snapToEndTransitionInstantOffset.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snapToEndTransitionInstantOffsetTransform(v);\r\n\r\n    this._$snapToEndTransitionInstantOffset.next(transformedValue);\r\n  };\r\n  get snapToEndTransitionInstantOffset() { return this._$snapToEndTransitionInstantOffset.getValue(); }\r\n\r\n  private _$scrollStartOffset = new BehaviorSubject<ArithmeticExpression>(0);\r\n  protected readonly $scrollStartOffset = this._$scrollStartOffset.asObservable();\r\n\r\n  private _scrollStartOffsetTransform = (v: number) => {\r\n    const valid = validateFloat(v, true) || isPercentageValue(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollStartOffset\" parameter must be one of type `number` or `string`.');\r\n      return 0;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Sets the scroll start offset value. Can be specified in absolute or percentage values.\r\n   * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is \"0\".\r\n   */\r\n  @Input()\r\n  set scrollStartOffset(v: ArithmeticExpression) {\r\n    if (this._$scrollStartOffset.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollStartOffsetTransform(v as any);\r\n\r\n    this._$scrollStartOffset.next(transformedValue);\r\n  };\r\n  get scrollStartOffset() { return this._$scrollStartOffset.getValue(); }\r\n\r\n  private _$scrollEndOffset = new BehaviorSubject<ArithmeticExpression>(0);\r\n  protected readonly $scrollEndOffset = this._$scrollEndOffset.asObservable();\r\n\r\n  private _scrollEndOffsetTransform = (v: number) => {\r\n    const valid = validateFloat(v, true) || isPercentageValue(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollEndOffset\" parameter must be one of type `number` or `string`.');\r\n      return 0;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Sets the scroll end offset value. Can be specified in absolute or percentage values.\r\n   * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is \"0\".\r\n   */\r\n  @Input()\r\n  set scrollEndOffset(v: ArithmeticExpression) {\r\n    if (this._$scrollEndOffset.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollEndOffsetTransform(v as any);\r\n\r\n    this._$scrollEndOffset.next(transformedValue);\r\n  };\r\n  get scrollEndOffset() { return this._$scrollEndOffset.getValue(); }\r\n\r\n  private _$snapScrollToStart = new BehaviorSubject<boolean>(DEFAULT_SNAP_SCROLLTO_START);\r\n  protected readonly $snapScrollToStart = this._$snapScrollToStart.asObservable();\r\n\r\n  private _snapScrollToStartTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"snapScrollToStart\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SNAP_SCROLLTO_START;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether the scroll will be anchored to the start of the list. Default value is \"true\".\r\n   * This property takes precedence over the snapScrollToEnd property.\r\n   * That is, if snapScrollToStart and snapScrollToEnd are enabled, the list will initially snap \r\n   * to the beginning; if you move the scroll bar to the end, the list will snap to the end. \r\n   * If snapScrollToStart is disabled and snapScrollToEnd is enabled, the list will snap to the end; \r\n   * if you move the scroll bar to the beginning, the list will snap to the beginning. \r\n   * If both snapScrollToStart and snapScrollToEnd are disabled, the list will never snap to the beginning or end.\r\n   * In the `spreadingMode=SpreadingModes.INFINITY` mode, the `snapScrollToStart` property is automatically disabled, since the list has no beginning or end.\r\n   */\r\n  @Input()\r\n  set snapScrollToStart(v: boolean) {\r\n    if (this._$snapScrollToStart.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snapScrollToStartTransform(v);\r\n\r\n    this._$snapScrollToStart.next(transformedValue);\r\n  };\r\n  get snapScrollToStart() { return this._$snapScrollToStart.getValue(); }\r\n\r\n  private _$snapScrollToEnd = new BehaviorSubject<boolean>(DEFAULT_SNAP_SCROLLTO_END);\r\n  protected readonly $snapScrollToEnd = this._$snapScrollToEnd.asObservable();\r\n\r\n  private _snapScrollToEndTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"snapScrollToEnd\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SNAP_SCROLLTO_END;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether the scroll will be anchored to the утв of the list. Default value is \"true\".\r\n   * That is, if snapScrollToStart and snapScrollToEnd are enabled, the list will initially snap \r\n   * to the beginning; if you move the scroll bar to the end, the list will snap to the end. \r\n   * If snapScrollToStart is disabled and snapScrollToEnd is enabled, the list will snap to the end; \r\n   * if you move the scroll bar to the beginning, the list will snap to the beginning. \r\n   * If both snapScrollToStart and snapScrollToEnd are disabled, the list will never snap to the beginning or end.\r\n   * In the `spreadingMode=SpreadingModes.INFINITY` mode, the `snapScrollToEnd` property is automatically disabled, since the list has no beginning or end.\r\n   */\r\n  @Input()\r\n  set snapScrollToEnd(v: boolean) {\r\n    if (this._$snapScrollToEnd.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snapScrollToEndTransform(v);\r\n\r\n    this._$snapScrollToEnd.next(transformedValue);\r\n  };\r\n  get snapScrollToEnd() { return this._$snapScrollToEnd.getValue(); }\r\n\r\n  /**\r\n   * @deprecated\r\n   * The stopSnappingScrollToEnd property is deprecated. Use the snapScrollToEnd property.\r\n   */\r\n  @Input()\r\n  set snapScrollToBottom(v: boolean) {\r\n    throw Error('The stopSnappingScrollToEnd property is deprecated. Use the snapScrollToEnd property.');\r\n  }\r\n\r\n\r\n  private _$scrollbarEnabled = new BehaviorSubject<boolean>(DEFAULT_SCROLLBAR_ENABLED);\r\n  protected readonly $scrollbarEnabled = this._$scrollbarEnabled.asObservable();\r\n\r\n  private _scrollbarEnabledTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollbarEnabled\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SCROLLBAR_ENABLED;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether the scrollbar is shown or not. The default value is \"true\".\r\n   */\r\n  @Input()\r\n  set scrollbarEnabled(v: boolean) {\r\n    if (this._$scrollbarEnabled.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollbarEnabledTransform(v);\r\n\r\n    this._$scrollbarEnabled.next(transformedValue);\r\n  };\r\n  get scrollbarEnabled() { return this._$scrollbarEnabled.getValue(); }\r\n\r\n  private _$scrollbarInteractive = new BehaviorSubject<boolean>(DEFAULT_SCROLLBAR_INTERACTIVE);\r\n  protected readonly $scrollbarInteractive = this._$scrollbarInteractive.asObservable();\r\n\r\n  private _scrollbarInteractiveTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollbarInteractive\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SCROLLBAR_INTERACTIVE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether scrolling using the scrollbar will be possible. The default value is \"true\".\r\n   */\r\n  @Input()\r\n  set scrollbarInteractive(v: boolean) {\r\n    if (this._$scrollbarInteractive.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollbarInteractiveTransform(v);\r\n\r\n    this._$scrollbarInteractive.next(transformedValue);\r\n  };\r\n  get scrollbarInteractive() { return this._$scrollbarInteractive.getValue(); }\r\n\r\n  private _$overlappingScrollbar = new BehaviorSubject<boolean>(DEFAULT_OVERLAPPING_SCROLLBAR);\r\n  protected readonly $overlappingScrollbar = this._$overlappingScrollbar.asObservable();\r\n\r\n  private _overlappingScrollbarTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"overlappingScrollbar\" parameter must be of type `boolean`.');\r\n      return DEFAULT_OVERLAPPING_SCROLLBAR;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether the scroll bar will overlap the list. The default value is \"false\".\r\n   */\r\n  @Input()\r\n  set overlappingScrollbar(v: boolean) {\r\n    if (this._$overlappingScrollbar.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._overlappingScrollbarTransform(v);\r\n\r\n    this._$overlappingScrollbar.next(transformedValue);\r\n  };\r\n  get overlappingScrollbar() { return this._$overlappingScrollbar.getValue(); }\r\n\r\n  private _$scrollBehavior = new BehaviorSubject<ScrollBehavior>(DEFAULT_SCROLL_BEHAVIOR);\r\n  protected readonly $scrollBehavior = this._$scrollBehavior.asObservable();\r\n\r\n  private _scrollBehaviorTransform = (v: ScrollBehavior) => {\r\n    const valid = validateString(v, true, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollBehavior\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SCROLL_BEHAVIOR;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Defines the scrolling behavior for any element on the page. The default value is \"smooth\".\r\n   */\r\n  @Input()\r\n  set scrollBehavior(v: ScrollBehavior) {\r\n    if (this._$scrollBehavior.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollBehaviorTransform(v);\r\n\r\n    this._$scrollBehavior.next(transformedValue);\r\n  };\r\n  get scrollBehavior() { return this._$scrollBehavior.getValue(); }\r\n\r\n\r\n\r\n\r\n\r\n\r\n  private _$scrollingSettings = new BehaviorSubject<IScrollingSettings>(DEFAULT_SCROLLING_SETTINGS);\r\n  protected readonly $scrollingSettings = this._$scrollingSettings.asObservable();\r\n\r\n  private _scrollingSettingsTransform = (v: IScrollingSettings): IScrollingSettings => {\r\n    let valid = validateObject(v, true, true);\r\n    if (valid && !!v) {\r\n      const { frictionalForce, mass, maxDistance, maxDuration, speedScale, optimization } = v;\r\n      valid = validateFloat(frictionalForce, true);\r\n      if (!valid) {\r\n        console.error('The \"frictionalForce\" parameter must be of type `number` or `undefined`.');\r\n        return DEFAULT_SCROLLING_SETTINGS;\r\n      }\r\n      valid = validateFloat(mass, true);\r\n      if (!valid) {\r\n        console.error('The \"mass\" parameter must be of type `number` or `undefined`.');\r\n        return DEFAULT_SCROLLING_SETTINGS;\r\n      }\r\n      valid = validateFloat(maxDistance, true);\r\n      if (!valid) {\r\n        console.error('The \"maxDistance\" parameter must be of type `number` or `undefined`.');\r\n        return DEFAULT_SCROLLING_SETTINGS;\r\n      }\r\n      valid = validateFloat(maxDuration, true);\r\n      if (!valid) {\r\n        console.error('The \"maxDuration\" parameter must be of type `number` or `undefined`.');\r\n        return DEFAULT_SCROLLING_SETTINGS;\r\n      }\r\n      valid = validateFloat(speedScale, true);\r\n      if (!valid) {\r\n        console.error('The \"speedScale\" parameter must be of type `number` or `undefined`.');\r\n        return DEFAULT_SCROLLING_SETTINGS;\r\n      }\r\n      valid = validateBoolean(optimization, true);\r\n      if (!valid) {\r\n        console.error('The \"optimization\" parameter must be of type `boolean` or `undefined`.');\r\n        return DEFAULT_SCROLLING_SETTINGS;\r\n      }\r\n    }\r\n    if (!valid) {\r\n      console.error('The \"scrollingSettings\" parameter must be of type `object` or null.');\r\n      return DEFAULT_SCROLLING_SETTINGS;\r\n    }\r\n    return {\r\n      frictionalForce: v.frictionalForce !== undefined && v.frictionalForce > 0 ? v.frictionalForce : DEFAULT_SCROLLING_SETTINGS.frictionalForce,\r\n      mass: v.mass !== undefined && v.mass > 0 ? v.mass : DEFAULT_SCROLLING_SETTINGS.mass,\r\n      maxDistance: v.maxDistance !== undefined && v.maxDistance > 0 ? v.maxDistance : DEFAULT_SCROLLING_SETTINGS.maxDistance,\r\n      maxDuration: v.maxDuration !== undefined && v.maxDuration > 0 ? v.maxDuration : DEFAULT_SCROLLING_SETTINGS.maxDuration,\r\n      speedScale: v.speedScale !== undefined && v.speedScale > 0 ? v.speedScale : DEFAULT_SCROLLING_SETTINGS.speedScale,\r\n      optimization: v.optimization ?? DEFAULT_SCROLLING_SETTINGS.optimization,\r\n    };\r\n  };\r\n\r\n  /**\r\n   * Scrolling settings.\r\n   * - frictionalForce - Frictional force. Default value is 0.035.\r\n   * - mass - Mass. Default value is 0.005.\r\n   * - maxDistance - Maximum scrolling distance. Default value is 100000.\r\n   * - maxDuration - Maximum animation duration. Default value is 4000.\r\n   * - speedScale - Speed scale. Default value is 10.\r\n   * - optimization - Enables scrolling performance optimization. Default value is `true`.\r\n   */\r\n  @Input()\r\n  set scrollingSettings(v: IScrollingSettings) {\r\n    if (this._$scrollingSettings.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollingSettingsTransform(v);\r\n\r\n    this._$scrollingSettings.next(transformedValue);\r\n  };\r\n  get scrollingSettings() { return this._$scrollingSettings.getValue(); }\r\n\r\n  private _$itemTransform = new BehaviorSubject<ItemTransform | null>(null);\r\n  protected readonly $itemTransform = this._$itemTransform.asObservable();\r\n\r\n  private _itemTransformTransform = (v: any) => {\r\n    let valid = validateFunction(v, true, true);\r\n    if (!valid) {\r\n      console.error('The \"itemTransform\" parameter must be of type `ItemTransform` or `null`.');\r\n      return null;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Custom transformation of element's position, rotation, scale, opacity and zIndex. The default value is `null`.\r\n   */\r\n  @Input()\r\n  set itemTransform(v: ItemTransform | null) {\r\n    if (this._$itemTransform.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._itemTransformTransform(v);\r\n\r\n    this._$itemTransform.next(transformedValue);\r\n  };\r\n  get itemTransform() { return this._$itemTransform.getValue(); }\r\n\r\n  private _$snapToItem = new BehaviorSubject<boolean>(DEFAULT_SNAP_TO_ITEM);\r\n  protected readonly $snapToItem = this._$snapToItem.asObservable();\r\n\r\n  private _snapToItemTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"snapToItem\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SNAP_TO_ITEM;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Snap to an item. The default value is `false`.\r\n   */\r\n  @Input()\r\n  set snapToItem(v: boolean) {\r\n    if (this._$snapToItem.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snapToItemTransform(v);\r\n\r\n    this._$snapToItem.next(transformedValue);\r\n  };\r\n  get snapToItem() { return this._$snapToItem.getValue(); }\r\n\r\n  private _$snapToItemAlign = new BehaviorSubject<SnapToItemAlign>(DEFAULT_SNAP_TO_ITEM_ALIGN);\r\n  protected readonly $snapToItemAlign = this._$snapToItemAlign.asObservable();\r\n\r\n  private _snapToItemAlignTransform = (v: SnapToItemAlign) => {\r\n    const valid = validateString(v) && (v === 'start' || v === 'center' || v === 'end');\r\n\r\n    if (!valid) {\r\n      console.error('The \"snapToItemAlign\" parameter must be one of `start`, `center` or `end`.');\r\n      return DEFAULT_SNAP_TO_ITEM_ALIGN;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Alignment for snapToItem. Available values ​​are `start`, `center`, and `end`. The default value is `center`.\r\n   */\r\n  @Input()\r\n  set snapToItemAlign(v: SnapToItemAlign) {\r\n    if (this._$snapToItemAlign.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snapToItemAlignTransform(v);\r\n\r\n    this._$snapToItemAlign.next(transformedValue);\r\n  };\r\n  get snapToItemAlign() { return this._$snapToItemAlign.getValue(); }\r\n\r\n  private _$snappingDistance = new BehaviorSubject<SnappingDistance>(DEFAULT_SNAPPING_DISTANCE);\r\n  protected readonly $snappingDistance = this._$snappingDistance.asObservable();\r\n\r\n  private _snappingDistanceTransform = (v: SnappingDistance | any) => {\r\n    const valid = validateString(v) || validateFloat(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"snappingDistance\" parameter must be of type `number` or `string`.');\r\n      return DEFAULT_SNAPPING_DISTANCE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Snapping activation distance. Can be specified as a percentage of the element size or in absolute values.\r\n   * The default value is `25%`.\r\n   */\r\n  @Input()\r\n  set snappingDistance(v: SnappingDistance) {\r\n    if (this._$snappingDistance.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snappingDistanceTransform(v);\r\n\r\n    this._$snappingDistance.next(transformedValue);\r\n  };\r\n  get snappingDistance() { return this._$snappingDistance.getValue(); }\r\n\r\n  private _$scrollingOneByOne = new BehaviorSubject<boolean>(DEFAULT_SCROLLING_ONE_BY_ONE);\r\n  protected readonly $scrollingOneByOne = this._$scrollingOneByOne.asObservable();\r\n\r\n  private _scrollingOneByOneTransform = (v: any) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"scrollingOneByOne\" parameter must be of type `boolean`.');\r\n      return DEFAULT_SCROLLING_ONE_BY_ONE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Specifies whether to scroll one item at a time if true and the scrollToItem property is set. The default value is `false`.\r\n   */\r\n  @Input()\r\n  set scrollingOneByOne(v: boolean) {\r\n    if (this._$scrollingOneByOne.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._scrollingOneByOneTransform(v);\r\n\r\n    this._$scrollingOneByOne.next(transformedValue);\r\n  };\r\n  get scrollingOneByOne() { return this._$scrollingOneByOne.getValue(); }\r\n\r\n  private _$alignment = new BehaviorSubject<Alignment>(DEFAULT_ALIGNMENT);\r\n  protected readonly $alignment = this._$alignment.asObservable();\r\n\r\n  private _alignmentTransform = (v: Alignment) => {\r\n    const valid = validateString(v) && (v === 'none' || v === 'center');\r\n\r\n    if (!valid) {\r\n      console.error('The \"alignment\" parameter must be one of `none` or `centert`.');\r\n      return DEFAULT_ALIGNMENT;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines the alignment of the list. Two modes are available: `none` and `center`. The `center` mode aligns the list items to the center of the viewport, ideal for use with the `itemTransform` property.\r\n   * The `none` mode means no alignment. The default value is `none`.\r\n   */\r\n  @Input()\r\n  set alignment(v: Alignment) {\r\n    if (this._$alignment.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._alignmentTransform(v);\r\n\r\n    this._$alignment.next(transformedValue);\r\n  };\r\n  get alignment() { return this._$alignment.getValue(); }\r\n\r\n  private _$zIndexWhenSelecting = new BehaviorSubject<string | null>(DEFAULT_ZINDEX_WHEN_SELECTING);\r\n  protected readonly $zIndexWhenSelecting = this._$zIndexWhenSelecting.asObservable();\r\n\r\n  private _zIndexWhenSelectingTransform = (v: string | null) => {\r\n    const valid = validateString(v, true, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"zIndexWhenSelecting\" parameter must be of type `number` or `null`.');\r\n      return DEFAULT_ZINDEX_WHEN_SELECTING;\r\n    }\r\n    return v ?? null;\r\n  };\r\n\r\n  /**\r\n   * Defines the zIndex when a list item is selected. The default value is `null`.\r\n   */\r\n  @Input()\r\n  set zIndexWhenSelecting(v: string | null) {\r\n    if (this._$zIndexWhenSelecting.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._zIndexWhenSelectingTransform(v);\r\n\r\n    this._$zIndexWhenSelecting.next(transformedValue);\r\n  };\r\n  get zIndexWhenSelecting() { return this._$zIndexWhenSelecting.getValue(); }\r\n\r\n  private _$spreadingMode = new BehaviorSubject<SpreadingMode>(DEFAULT_SPREADING_MODE);\r\n  protected readonly $spreadingMode = this._$spreadingMode.asObservable();\r\n\r\n  private _spreadingModeTransform = (v: SpreadingMode) => {\r\n    const valid = validateString(v) && (v === 'normal' || v === 'infinity');\r\n\r\n    if (!valid) {\r\n      console.error('The \"spreadingMode\" parameter must be one of `normal` or `infinity`.');\r\n      return DEFAULT_SPREADING_MODE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * The order of list elements. Available values ​​are `standard` and `infinity`.\r\n   * `normal` — list elements are ordered according to the collection sequence.\r\n   * `infinity` — list elements are ordered cyclically, forming an infinite list.\r\n   * When set to `infinity`, the `alignment` property is forced to the value `Alignments.CENTER`, the `scrollbarEnabled` property is forced to the `false`\r\n   * The default value is `standard`.\r\n   */\r\n  @Input()\r\n  set spreadingMode(v: SpreadingMode) {\r\n    if (this._$spreadingMode.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._spreadingModeTransform(v);\r\n\r\n    this._$spreadingMode.next(transformedValue);\r\n  };\r\n  get spreadingMode() { return this._$spreadingMode.getValue(); }\r\n\r\n  private _$divides = new BehaviorSubject<number>(DEFAULT_DIVIDES);\r\n  protected readonly $divides = this._$divides.asObservable();\r\n\r\n  private _dividesTransform = (v: number) => {\r\n    const valid = validateFloat(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"divides\" parameter must be of type `number`.');\r\n      return DEFAULT_DIVIDES;\r\n    }\r\n    return v <= 0 ? DEFAULT_DIVIDES : v;\r\n  };\r\n\r\n  /**\r\n   * Column or row numbers. The default value is `1`.\r\n   */\r\n  @Input()\r\n  set divides(v: number) {\r\n    if (this._$divides.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._dividesTransform(v);\r\n\r\n    this._$divides.next(transformedValue);\r\n  };\r\n  get divides() { return this._$divides.getValue(); }\r\n\r\n  private _$motionBlur = new BehaviorSubject<number>(DEFAULT_MOTION_BLUR);\r\n  protected readonly $motionBlur = this._$motionBlur.asObservable();\r\n\r\n  private _motionBlurTransform = (v: number) => {\r\n    const valid = validateFloat(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"motionBlur\" parameter must be of type `number`.');\r\n      return DEFAULT_DIVIDES;\r\n    }\r\n    return v <= 0 ? DEFAULT_DIVIDES : v;\r\n  };\r\n\r\n  /**\r\n   * Motion blur effect. The default value is `0.15`.\r\n   */\r\n  @Input()\r\n  set motionBlur(v: number) {\r\n    if (this._$motionBlur.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._motionBlurTransform(v);\r\n\r\n    this._$motionBlur.next(transformedValue);\r\n  };\r\n  get motionBlur() { return this._$motionBlur.getValue(); }\r\n\r\n  private _$maxMotionBlur = new BehaviorSubject<number>(DEFAULT_MAX_MOTION_BLUR);\r\n  protected readonly $maxMotionBlur = this._$maxMotionBlur.asObservable();\r\n\r\n  private _maxMotionBlurTransform = (v: number) => {\r\n    const valid = validateFloat(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"maxMotionBlur\" parameter must be of type `number`.');\r\n      return DEFAULT_MAX_MOTION_BLUR;\r\n    }\r\n    return v <= 0 ? DEFAULT_MAX_MOTION_BLUR : v;\r\n  };\r\n\r\n  /**\r\n   * Maximum motion blur effect. The default value is `0.5`.\r\n   */\r\n  @Input()\r\n  set maxMotionBlur(v: number) {\r\n    if (this._$maxMotionBlur.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._maxMotionBlurTransform(v);\r\n\r\n    this._$maxMotionBlur.next(transformedValue);\r\n  };\r\n  get maxMotionBlur() { return this._$maxMotionBlur.getValue(); }\r\n\r\n  private _$motionBlurEnabled = new BehaviorSubject<boolean>(DEFAULT_MOTION_BLUR_ENABLED);\r\n  protected readonly $motionBlurEnabled = this._$motionBlurEnabled.asObservable();\r\n\r\n  private _motionBlurEnabledTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"motionBlurEnabled\" parameter must be of type `boolean`.');\r\n      return DEFAULT_MOTION_BLUR_ENABLED;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether to apply motion blur or not. The default value is `false`.\r\n   */\r\n  @Input()\r\n  set motionBlurEnabled(v: boolean) {\r\n    if (this._$motionBlurEnabled.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._motionBlurEnabledTransform(v);\r\n\r\n    this._$motionBlurEnabled.next(transformedValue);\r\n  };\r\n  get motionBlurEnabled() { return this._$motionBlurEnabled.getValue(); }\r\n\r\n\r\n\r\n  private _$animationParams = new BehaviorSubject<IAnimationParams>(DEFAULT_ANIMATION_PARAMS);\r\n  protected readonly $animationParams = this._$animationParams.asObservable();\r\n\r\n  private _animationParamsTransform = (v: IAnimationParams) => {\r\n    const valid = validateObject(v, true, true);\r\n\r\n    if (!validateFloat(v.scrollToItem)) {\r\n      console.error('The \"scrollToItem\" parameter must be of type `number`.');\r\n      return DEFAULT_ANIMATION_PARAMS;\r\n    }\r\n    if (!validateFloat(v.snapToItem)) {\r\n      console.error('The \"snapToItem\" parameter must be of type `number`.');\r\n      return DEFAULT_ANIMATION_PARAMS;\r\n    }\r\n    if (!validateFloat(v.navigateByKeyboard)) {\r\n      console.error('The \"navigateByKeyboard\" parameter must be of type `number`.');\r\n      return DEFAULT_ANIMATION_PARAMS;\r\n    }\r\n    if (!validateFloat(v.navigateToItem)) {\r\n      console.error('The \"navigateToItem\" parameter must be of type `number`.');\r\n      return DEFAULT_ANIMATION_PARAMS;\r\n    }\r\n    if (!valid) {\r\n      console.error('The \"animationParams\" parameter must be of type `object`.');\r\n      return DEFAULT_ANIMATION_PARAMS;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Animation parameters. The default value is \"{ scrollToItem: 50, snapToItem: 150, navigateToItem: 150, navigateByKeyboard: 50 }\".\r\n   */\r\n  @Input()\r\n  set animationParams(v: IAnimationParams) {\r\n    if (this._$animationParams.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._animationParamsTransform(v);\r\n\r\n    this._$animationParams.next(transformedValue);\r\n  };\r\n  get animationParams() { return this._$animationParams.getValue(); }\r\n\r\n  private _$overscrollEnabled = new BehaviorSubject<boolean>(DEFAULT_OVERSCROLL_ENABLED);\r\n  protected readonly $overscrollEnabled = this._$overscrollEnabled.asObservable();\r\n\r\n  private _overscrollEnabledTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v, true);\r\n\r\n    if (!valid) {\r\n      console.error('The \"overscrollEnabled\" parameter must be of type `boolean`.');\r\n      return DEFAULT_OVERSCROLL_ENABLED;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines whether the overscroll (re-scroll) feature will work. The default value is \"true\".\r\n   */\r\n  @Input()\r\n  set overscrollEnabled(v: boolean) {\r\n    if (this._$overscrollEnabled.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._overscrollEnabledTransform(v);\r\n\r\n    this._$overscrollEnabled.next(transformedValue);\r\n  };\r\n  get overscrollEnabled() { return this._$overscrollEnabled.getValue(); }\r\n\r\n  private _$enabledBufferOptimization = new BehaviorSubject<boolean>(DEFAULT_ENABLED_BUFFER_OPTIMIZATION);\r\n  protected readonly $enabledBufferOptimization = this._$enabledBufferOptimization.asObservable();\r\n\r\n  private _enabledBufferOptimizationTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n\r\n    if (!valid) {\r\n      console.error('The \"enabledBufferOptimization\" parameter must be of type `boolean`.');\r\n      return DEFAULT_ENABLED_BUFFER_OPTIMIZATION;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Experimental!\r\n   * Enables buffer optimization.\r\n   * Can only be used if items in the collection are not added or updated. Otherwise, artifacts in the form of twitching of the scroll area are possible.\r\n   * Works only if the property dynamic = true\r\n   */\r\n  @Input()\r\n  set enabledBufferOptimization(v: boolean) {\r\n    if (this._$enabledBufferOptimization.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._enabledBufferOptimizationTransform(v);\r\n\r\n    this._$enabledBufferOptimization.next(transformedValue);\r\n  };\r\n  get enabledBufferOptimization() { return this._$enabledBufferOptimization.getValue(); }\r\n\r\n  private _$itemRenderer = new BehaviorSubject<TemplateRef<any> | undefined>(undefined);\r\n  protected readonly $itemRenderer = this._$itemRenderer.asObservable();\r\n\r\n  private _itemRendererTransform = (v: TemplateRef<any>) => {\r\n    let valid = validateObject(v);\r\n    if (v && !(typeof v.elementRef === 'object' && typeof v.createEmbeddedView === 'function')) {\r\n      valid = false;\r\n    }\r\n\r\n    if (!valid) {\r\n      throw Error('The \"itemRenderer\" parameter must be of type `TemplateRef`.');\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Rendering element template.\r\n   */\r\n  @Input()\r\n  set itemRenderer(v: TemplateRef<any>) {\r\n    if (this._$itemRenderer.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._itemRendererTransform(v);\r\n\r\n    this._$itemRenderer.next(transformedValue);\r\n  };\r\n  get itemRenderer() { return this._$itemRenderer.getValue() as TemplateRef<any>; }\r\n\r\n  private _$itemConfigMap = new BehaviorSubject<IVirtualListItemConfigMap>({});\r\n  protected readonly $itemConfigMap = this._$itemConfigMap.asObservable();\r\n\r\n  private _itemConfigMapTransform = (v: IVirtualListItemConfigMap) => {\r\n    let valid = validateObject(v);\r\n    if (valid) {\r\n      if (v) {\r\n        for (let id in v) {\r\n          const item = v[id];\r\n          if (!item ||\r\n            !validateBoolean(item.collapsable, true) ||\r\n            !validateBoolean(item.selectable, true) ||\r\n            !(item.sticky === undefined || item.sticky === 0 || item.sticky === 1 || item.sticky === 2)\r\n          ) {\r\n            valid = false;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    if (!valid) {\r\n      console.error('The \"itemConfigMap\" parameter must be of type `IVirtualListItemConfigMap`.');\r\n      return {};\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied. \r\n   * If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end.\r\n   *  Default value is `0`.\r\n   * `selectable` determines whether an element can be selected or not. Default value is `true`.\r\n   * `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and\r\n   *  collapse elements in front that do not have a `sticky` property.\r\n   * `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false.\r\n   * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/models/item-config-map.model.ts\r\n   * @author Evgenii Alexandrovich Grebennikov\r\n   * @email djonnyx@gmail.com\r\n   */\r\n  @Input()\r\n  set itemConfigMap(v: IVirtualListItemConfigMap) {\r\n    if (this._$itemConfigMap.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._itemConfigMapTransform(v);\r\n\r\n    this._$itemConfigMap.next(transformedValue);\r\n  };\r\n  get itemConfigMap() { return this._$itemConfigMap.getValue(); }\r\n\r\n  private _$itemSize = new BehaviorSubject<number>(DEFAULT_ITEM_SIZE);\r\n  protected readonly $itemSize = this._$itemSize.asObservable();\r\n\r\n  private _itemSizeTransform = (v: any) => {\r\n    const valid = validateFloat(v) || v === VIEWPORT;\r\n    if (!valid) {\r\n      console.error('The \"itemSize\" parameter must be one of `number`, `viewport` or `undefined`.');\r\n      return DEFAULT_ITEM_SIZE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If direction = 'vertical', then the height of a typical element. If direction = 'horizontal', then the width of a typical element.\r\n   * If the `dynamicSize` property is true, the items in the list can have different sizes, and you must specify the `itemSize` property \r\n   * to adjust the sizes of the items in the unallocated area.\r\n   * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.\r\n   */\r\n  @Input()\r\n  set itemSize(v: number | 'viewport') {\r\n    if (this._$itemSize.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._itemSizeTransform(v);\r\n\r\n    this._$itemSize.next(transformedValue);\r\n  };\r\n  get itemSize() { return this._$itemSize.getValue(); }\r\n\r\n  private _$minItemSize = new BehaviorSubject<number>(DEFAULT_ITEM_SIZE);\r\n  protected readonly $minItemSize = this._$minItemSize.asObservable();\r\n\r\n  private _minItemSizeTransform = (v: any) => {\r\n    const valid = validateFloat(v) || v === VIEWPORT;\r\n    if (!valid) {\r\n      console.error('The \"minItemSize\" parameter must be one of `number`, `viewport` or `undefined`.');\r\n      return DEFAULT_ITEM_SIZE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If the `dynamicSize` property is enabled, the minimum size of the element is set.\r\n   * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.\r\n   */\r\n  @Input()\r\n  set minItemSize(v: number | 'viewport') {\r\n    if (this._$minItemSize.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._minItemSizeTransform(v);\r\n\r\n    this._$minItemSize.next(transformedValue);\r\n  };\r\n  get minItemSize() { return this._$minItemSize.getValue(); }\r\n\r\n  private _$maxItemSize = new BehaviorSubject<number>(DEFAULT_MAX_ITEM_SIZE);\r\n  protected readonly $maxItemSize = this._$maxItemSize.asObservable();\r\n\r\n  private _maxItemSizeTransform = (v: any) => {\r\n    const valid = validateFloat(v) || v === VIEWPORT;\r\n    if (!valid) {\r\n      console.error('The \"maxItemSize\" parameter must be one of `number`, `viewport` or `undefined`.');\r\n      return DEFAULT_ITEM_SIZE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If the `dynamicSize` property is enabled, the maximum size of the element is set.\r\n   * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.\r\n   */\r\n  @Input()\r\n  set maxItemSize(v: number | 'viewport') {\r\n    if (this._$maxItemSize.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._maxItemSizeTransform(v);\r\n\r\n    this._$maxItemSize.next(transformedValue);\r\n  };\r\n  get maxItemSize() { return this._$maxItemSize.getValue(); }\r\n\r\n  private _$dynamicSize = new BehaviorSubject<boolean>(DEFAULT_DYNAMIC_SIZE);\r\n  protected readonly $dynamicSize = this._$dynamicSize.asObservable();\r\n\r\n  private _dynamicSizeTransform = (v: boolean) => {\r\n    const valid = validateBoolean(v);\r\n    if (!valid) {\r\n      console.error('The \"dynamicSize\" parameter must be of type `boolean`.');\r\n      return DEFAULT_DYNAMIC_SIZE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * If true, items in the list may have different sizes, and the itemSize property must be specified to adjust\r\n   * the sizes of items in the unallocated area.\r\n   * If false then the items in the list have a fixed size specified by the itemSize property. The default value is true.\r\n   */\r\n  @Input()\r\n  set dynamicSize(v: boolean) {\r\n    if (this._$dynamicSize.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._dynamicSizeTransform(v);\r\n\r\n    this._$dynamicSize.next(transformedValue);\r\n  };\r\n  get dynamicSize() { return this._$dynamicSize.getValue(); }\r\n\r\n  private _$direction = new BehaviorSubject<Direction>(DEFAULT_DIRECTION);\r\n  protected readonly $direction = this._$direction.asObservable();\r\n\r\n  private _directionTransform = (v: Direction) => {\r\n    const valid = validateString(v) && (v === 'horizontal' || v === 'vertical');\r\n    if (!valid) {\r\n      console.error('The \"direction\" parameter must be one of `horizontal` or `vertical`.');\r\n      return DEFAULT_DIRECTION;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines the direction in which elements are placed. Default value is \"vertical\".\r\n   */\r\n  @Input()\r\n  set direction(v: Direction) {\r\n    if (this._$direction.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._directionTransform(v);\r\n\r\n    this._$direction.next(transformedValue);\r\n  };\r\n  get direction() { return this._$direction.getValue(); }\r\n\r\n  private _$collectionMode = new BehaviorSubject<CollectionMode>(DEFAULT_COLLECTION_MODE);\r\n  protected readonly $collectionMode = this._$collectionMode.asObservable();\r\n\r\n  private _collectionModeTransform = (v: CollectionMode) => {\r\n    const valid = validateString(v) && (v === 'normal' || v === 'lazy');\r\n    if (!valid) {\r\n      console.error('The \"direction\" parameter must be one of `normal` or `lazy`.');\r\n      return DEFAULT_COLLECTION_MODE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Determines the action modes for collection elements. Default value is \"normal\".\r\n   */\r\n  @Input()\r\n  set collectionMode(v: CollectionMode) {\r\n    if (this._$collectionMode.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._collectionModeTransform(v);\r\n\r\n    this._$collectionMode.next(transformedValue);\r\n  };\r\n  get collectionMode() { return this._$collectionMode.getValue(); }\r\n\r\n  private _$bufferSize = new BehaviorSubject<number>(DEFAULT_BUFFER_SIZE);\r\n  protected readonly $bufferSize = this._$bufferSize.asObservable();\r\n\r\n  private _bufferSizeTransform = (v: number) => {\r\n    const valid = validateInt(v);\r\n    if (!valid) {\r\n      console.error('The \"bufferSize\" parameter must be of type `number`.');\r\n      return DEFAULT_BUFFER_SIZE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Number of elements outside the scope of visibility. Default value is 2.\r\n   */\r\n  @Input()\r\n  set bufferSize(v: number) {\r\n    if (this._$bufferSize.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._bufferSizeTransform(v);\r\n\r\n    this._$bufferSize.next(transformedValue);\r\n  };\r\n  get bufferSize() { return this._$bufferSize.getValue(); }\r\n\r\n  private _$maxBufferSize = new BehaviorSubject<number>(DEFAULT_MAX_BUFFER_SIZE);\r\n  protected readonly $maxBufferSize = this._$maxBufferSize.asObservable();\r\n\r\n  private _maxBufferSizeTransform = (v: number) => {\r\n    let val = v;\r\n    const valid = validateInt(v, true);\r\n    if (!valid) {\r\n      console.error('The \"maxBufferSize\" parameter must be of type `number`.');\r\n      val = DEFAULT_MAX_BUFFER_SIZE;\r\n    }\r\n\r\n    const bufferSize = this.bufferSize;\r\n    if (val === undefined || val <= bufferSize) {\r\n      return bufferSize;\r\n    }\r\n    return val;\r\n  };\r\n\r\n  /**\r\n   * Maximum number of elements outside the scope of visibility. Default value is 100.\r\n   * If maxBufferSize is set to be greater than bufferSize, then adaptive buffer mode is enabled.\r\n   * The greater the scroll size, the more elements are allocated for rendering.\r\n   */\r\n  @Input()\r\n  set maxBufferSize(v: number) {\r\n    const val = this._maxBufferSizeTransform(v);\r\n    if (this._$maxBufferSize.getValue() === val) {\r\n      return;\r\n    }\r\n\r\n    this._$maxBufferSize.next(val);\r\n  };\r\n  get maxBufferSize() { return this._$maxBufferSize.getValue(); }\r\n\r\n  private _$snappingMethod = new BehaviorSubject<SnappingMethod>(DEFAULT_SNAPPING_METHOD);\r\n  protected readonly $snappingMethod = this._$snappingMethod.asObservable();\r\n\r\n  private _snappingMethodTransform = (v: SnappingMethod) => {\r\n    const valid = validateString(v) && (v === SnappingMethods.ADVANCED || v === SnappingMethods.STANDART);\r\n    if (!valid) {\r\n      console.error(`The \"snappingMethod\" parameter must have the value '${SnappingMethods.ADVANCED}' or '${SnappingMethods.STANDART}'.`);\r\n      return DEFAULT_SNAPPING_METHOD;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Snapping method. Default value is 'standart'.\r\n   * 'standart' - Classic group visualization.\r\n   * 'advanced' - A mask is applied to the viewport area so that the background is displayed underneath the attached group.\r\n   */\r\n  @Input()\r\n  set snappingMethod(v: SnappingMethod) {\r\n    if (this._$snappingMethod.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._snappingMethodTransform(v);\r\n\r\n    this._$snappingMethod.next(transformedValue);\r\n  };\r\n  get snappingMethod() { return this._$snappingMethod.getValue(); }\r\n\r\n  private _$collapsingMode = new BehaviorSubject<CollapsingMode>(DEFAULT_COLLAPSING_MODES);\r\n  protected readonly $collapsingMode = this._$collapsingMode.asObservable();\r\n\r\n  private _collapsingModeTransform = (v: CollapsingMode) => {\r\n    const valid = validateString(v) && (v === CollapsingModes.NONE || v === CollapsingModes.MULTI_COLLAPSE || v === CollapsingModes.ACCORDION);\r\n    if (!valid) {\r\n      console.error(`The \"collapsingMode\" parameter must have the value '${SnappingMethods.ADVANCED}' or '${SnappingMethods.STANDART}'.`);\r\n      return DEFAULT_COLLAPSING_MODES;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Mode for collapsing list items. \r\n   * `none` - List items are not selectable.\r\n   * `multi-collapse` - List items are collapsed one by one.\r\n   * 'accordion' - Accordion collapsible list items.\r\n   * Default value is `multi-collapse\r\n   */\r\n  @Input()\r\n  set collapsingMode(v: CollapsingMode) {\r\n    if (this._$collapsingMode.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._collapsingModeTransform(v);\r\n\r\n    this._$collapsingMode.next(transformedValue);\r\n  };\r\n  get collapsingMode() { return this._$collapsingMode.getValue(); }\r\n\r\n  /**\r\n   * @deprecated\r\n   * The \"methodForSelecting\" property is deprecated. Use the \"selectMode\" property.\r\n   */\r\n  @Input()\r\n  set methodForSelecting(v: any) {\r\n    throw new Error('The \"methodForSelecting\" property is deprecated. Use the \"selectMode\" property instead.');\r\n  };\r\n\r\n  private _$selectingMode = new BehaviorSubject<SelectingMode>(DEFAULT_SELECTING_MODES);\r\n  protected readonly $selectingMode = this._$selectingMode.asObservable();\r\n\r\n  private _selectingModeTransform = (v: SelectingMode) => {\r\n    const valid = validateString(v) && (v === 'none' || v === 'select' || v === 'multi-select');\r\n    if (!valid) {\r\n      console.error('The \"selectingMode\" parameter must be one of `none`, `select` or `multi-select`.');\r\n      return DEFAULT_SELECTING_MODES;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   *  Method for selecting list items. Default value is 'none'.\r\n   * 'select' - List items are selected one by one.\r\n   * 'multi-select' - Multiple selection of list items.\r\n   * 'none' - List items are not selectable.\r\n   */\r\n  @Input()\r\n  set selectingMode(v: SelectingMode) {\r\n    if (this._$selectingMode.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._selectingModeTransform(v);\r\n\r\n    this._$selectingMode.next(transformedValue);\r\n  };\r\n  get selectingMode() { return this._$selectingMode.getValue(); }\r\n\r\n  private _$trackBy = new BehaviorSubject<string>(TRACK_BY_PROPERTY_NAME);\r\n  protected readonly $trackBy = this._$trackBy.asObservable();\r\n\r\n  private _trackByTransform = (v: string) => {\r\n    const valid = validateString(v);\r\n    if (!valid) {\r\n      console.error('The \"trackBy\" parameter must be of type `string`.');\r\n      return TRACK_BY_PROPERTY_NAME;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * The name of the property by which tracking is performed\r\n   */\r\n  @Input()\r\n  set trackBy(v: string) {\r\n    if (this._$trackBy.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._trackByTransform(v);\r\n\r\n    this._$trackBy.next(transformedValue);\r\n  };\r\n  get trackBy() { return this._$trackBy.getValue(); }\r\n\r\n  private _$screenReaderMessage = new BehaviorSubject<string>(DEFAULT_SCREEN_READER_MESSAGE);\r\n  protected readonly $screenReaderMessage = this._$screenReaderMessage.asObservable();\r\n\r\n  private _screenReaderMessageTransform = (v: string) => {\r\n    const valid = validateString(v);\r\n    if (!valid) {\r\n      console.error('The \"screenReaderMessage\" parameter must be of type `string`.');\r\n      return DEFAULT_SCREEN_READER_MESSAGE;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * Message for screen reader.\r\n   * The message format is: \"some text $1 some text $2\",\r\n   * where $1 is the number of the first element of the screen collection,\r\n   * $2 is the number of the last element of the screen collection.\r\n   */\r\n  @Input()\r\n  protected set screenReaderMessage(v: string) {\r\n    if (this._$screenReaderMessage.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._screenReaderMessageTransform(v);\r\n\r\n    this._$screenReaderMessage.next(transformedValue);\r\n  };\r\n  protected get screenReaderMessage() { return this._$screenReaderMessage.getValue(); }\r\n\r\n  private _$screenReaderFormattedMessage = new BehaviorSubject<string>(DEFAULT_SCREEN_READER_MESSAGE);\r\n  protected $screenReaderFormattedMessage = this._$screenReaderFormattedMessage.asObservable();\r\n\r\n  private _$langTextDir = new BehaviorSubject<TextDirection>(DEFAULT_LANG_TEXT_DIR);\r\n  protected readonly $langTextDir = this._$langTextDir.asObservable();\r\n\r\n  private _langTextDirTransform = (v: TextDirection) => {\r\n    const valid = validateString(v);\r\n    if (!valid) {\r\n      console.error('The \"langTextDir\" parameter must be of type `string`.');\r\n      return DEFAULT_LANG_TEXT_DIR;\r\n    }\r\n    return v;\r\n  };\r\n\r\n  /**\r\n   * A string indicating the direction of text for the locale.\r\n   * Can be either \"ltr\" (left-to-right) or \"rtl\" (right-to-left).\r\n   */\r\n  @Input()\r\n  set langTextDir(v: TextDirection) {\r\n    if (this._$langTextDir.getValue() === v) {\r\n      return;\r\n    }\r\n\r\n    const transformedValue = this._langTextDirTransform(v);\r\n\r\n    this._$langTextDir.next(transformedValue);\r\n  };\r\n  get langTextDir() { return this._$langTextDir.getValue(); }\r\n\r\n  private _isSingleSelection = this.getIsSingleSelection();\r\n\r\n  private _isMultiSelection = this.getIsMultiSelection();\r\n\r\n  private _isMultipleCollapse = this.getIsMultipleCollapse();\r\n\r\n  private _isAccordionCollapse = this.getIsAccordionCollapse();\r\n\r\n  private _isSnappingMethodAdvanced: boolean = this.getIsSnappingMethodAdvanced();\r\n\r\n  protected _$isInfinity = new BehaviorSubject<boolean>(false);\r\n  protected $isInfinity = this._$isInfinity.asObservable();\r\n  protected get isInfinity() {\r\n    return this._$isInfinity.getValue();\r\n  }\r\n\r\n  private _isVertical = this.getIsVertical();\r\n  protected get isVertical() {\r\n    return this._isVertical;\r\n  }\r\n\r\n  private _$isVertical = new BehaviorSubject<boolean>(this.isVertical);\r\n  protected $isVertical = this._$isVertical.asObservable();\r\n\r\n  private _$focusedElement = new BehaviorSubject<Id | null>(null);\r\n  protected $focusedElement = this._$focusedElement.asObservable();\r\n\r\n  private _$classes = new BehaviorSubject<{ [cName: string]: boolean }>({});\r\n  protected $classes = this._$classes.asObservable();\r\n\r\n  private _$prerenderEnabled = new BehaviorSubject<boolean>(false);\r\n  protected $prerenderEnabled = this._$prerenderEnabled.asObservable();\r\n\r\n  private _$actualItems = new BehaviorSubject<IVirtualListCollection>([]);\r\n\r\n  private _$collapsedItemIds = new BehaviorSubject<Array<Id>>([]);\r\n\r\n  private _displayComponents: Array<ComponentRef<BaseVirtualListItemComponent>> = [];\r\n\r\n  private _snappedDisplayComponents: Array<ComponentRef<BaseVirtualListItemComponent>> = [];\r\n\r\n  private _$bounds = new BehaviorSubject<ISize | null>(null);\r\n  protected $bounds: Observable<ISize | null> = this._$bounds.asObservable();\r\n\r\n  private _$actualScrollbarEnabled = new BehaviorSubject<boolean>(this.scrollbarEnabled);\r\n  protected $actualScrollbarEnabled: Observable<boolean> = this._$actualScrollbarEnabled.asObservable();\r\n\r\n  private _$actualAlignment = new BehaviorSubject<Alignment>(this.alignment);\r\n  protected $actualAlignment: Observable<Alignment> = this._$actualAlignment.asObservable();\r\n  protected get actualAlignment() { return this._$actualAlignment.getValue(); }\r\n\r\n  private _$actualItemSize = new BehaviorSubject<number>(0);\r\n  protected $actualItemSize: Observable<number> = this._$actualItemSize.asObservable();\r\n  protected get actualItemSize() { return this._$actualItemSize.getValue(); }\r\n\r\n  private _$actualMinItemSize = new BehaviorSubject<number>(0);\r\n  protected $actualMinItemSize: Observable<number> = this._$actualMinItemSize.asObservable();\r\n  protected get actualMinItemSize() { return this._$actualMinItemSize.getValue(); }\r\n\r\n  private _$actualMaxItemSize = new BehaviorSubject<number>(0);\r\n  protected $actualMaxItemSize: Observable<number> = this._$actualMaxItemSize.asObservable();\r\n  protected get actualMaxItemSize() { return this._$actualMaxItemSize.getValue(); }\r\n\r\n  private _$totalSize = new BehaviorSubject<number>(0);\r\n\r\n  private _$listBounds = new BehaviorSubject<ISize | null>(null);\r\n\r\n  private _$scrollSize = new BehaviorSubject<number>(0);\r\n  protected readonly $scrollSize = this._$scrollSize.asObservable();\r\n\r\n  private _$isScrollStart = new BehaviorSubject<boolean>(true);\r\n\r\n  private _$isScrollEnd = new BehaviorSubject<boolean>(false);\r\n\r\n  private _$precalculatedScrollStartOffset = new BehaviorSubject<number>(0);\r\n\r\n  private _$precalculatedScrollEndOffset = new BehaviorSubject<number>(0);\r\n\r\n  private _$actualScrollStartOffset = new BehaviorSubject<number>(0);\r\n  protected $actualScrollStartOffset = this._$actualScrollStartOffset.asObservable();\r\n\r\n  private _$actualScrollEndOffset = new BehaviorSubject<number>(0);\r\n  protected $actualScrollEndOffset = this._$actualScrollEndOffset.asObservable();\r\n\r\n  private _$startOffset = new BehaviorSubject<number>(0);\r\n  protected $startOffset = this._$startOffset.asObservable();\r\n\r\n  private _$endOffset = new BehaviorSubject<number>(0);\r\n  protected $endOffset = this._$endOffset.asObservable();\r\n\r\n  private _$actualSnapScrollToStart = new BehaviorSubject<boolean>(false);\r\n\r\n  private _$actualSnapScrollToEnd = new BehaviorSubject<boolean>(false);\r\n\r\n  private _$alignmentScrollStartOffset = new BehaviorSubject<number>(0);\r\n  protected $alignmentScrollStartOffset = this._$alignmentScrollStartOffset.asObservable();\r\n\r\n  private _$alignmentScrollEndOffset = new BehaviorSubject<number>(0);\r\n  protected $alignmentScrollEndOffset = this._$alignmentScrollEndOffset.asObservable();\r\n\r\n  private _resizeSnappedComponentHandler = () => {\r\n    const list = this._$list.getValue(), scroller = this._$scroller.getValue(), bounds = this._$bounds.getValue(), snappedComponents = this._snappedDisplayComponents;\r\n    if (!!list && !!scroller && snappedComponents.length > 0) {\r\n      const isVertical = this._isVertical, listBounds = list.nativeElement.getBoundingClientRect();\r\n\r\n      for (const comp of snappedComponents) {\r\n        if (!!comp) {\r\n          comp.instance.regularLength = `${isVertical ? listBounds.width : listBounds.height}${PX}`;\r\n        }\r\n      }\r\n\r\n      const snappingMethod = this.snappingMethod;\r\n      if (snappingMethod === SnappingMethods.ADVANCED) {\r\n        const snappedComponent = snappedComponents?.[0]?.instance;\r\n        if (!!snappedComponent) {\r\n          const { width, height } = bounds ?? { width: 0, height: 0 }, langTextDir = this.langTextDir;\r\n\r\n          snappedComponent.element.style.clipPath = `path(\"M 0 0 L 0 ${snappedComponent.element.offsetHeight} L ${snappedComponent.element.offsetWidth} ${snappedComponent.element.offsetHeight} L ${snappedComponent.element.offsetWidth} 0 Z\")`;\r\n\r\n          const { width: sWidth, height: sHeight } = snappedComponent.getBounds() ?? { width: 0, height: 0 },\r\n            scrollerElement = scroller.nativeElement, delta = snappedComponent.item?.measures.delta ?? 0,\r\n            scrollBarSize = this.scrollbarThickness;\r\n\r\n          let right: number, top: number, bottom: number;\r\n          if (isVertical) {\r\n            right = width - scrollBarSize + 2;\r\n            top = sHeight;\r\n            bottom = height;\r\n            if (langTextDir === TextDirections.RTL) {\r\n              scrollerElement.style.clipPath = `path(\"M 0 0 L 0 ${height} L ${width} ${height} L ${width} ${top + delta} L ${scrollBarSize} ${top + delta} L ${scrollBarSize} 0 Z\")`;\r\n            } else {\r\n              scrollerElement.style.clipPath = `path(\"M 0 ${top + delta} L 0 ${height} L ${width} ${height} L ${width} 0 L ${right} 0 L ${right} ${top + delta} Z\")`;\r\n            }\r\n          } else {\r\n            right = width;\r\n            top = 0;\r\n            bottom = height - scrollBarSize;\r\n            scrollerElement.style.clipPath = `path(\"M ${width} 0 L ${width} ${bottom} L 0 ${bottom} L 0 0 L ${width} 0 Z\")`;\r\n          }\r\n        }\r\n      }\r\n    }\r\n  };\r\n\r\n  private _resizeSnappedObserver: ResizeObserver | null = null;\r\n\r\n  private focusItem = (element: HTMLElement, position: number, align: FocusAlignment = FocusAlignments.CENTER,\r\n    behavior: ScrollBehavior = BEHAVIOR_AUTO) => {\r\n    if (!this._readyForShow) {\r\n      return;\r\n    }\r\n    const scroller = this._scrollerComponent;\r\n    if (!!scroller) {\r\n      const { width, height } = this._$bounds.getValue()!, { width: elementWidth, height: elementHeight } = element.getBoundingClientRect(),\r\n        isVertical = this._isVertical,\r\n        viewportSize = isVertical ? height : width,\r\n        elementSize = isVertical ? elementHeight : elementWidth;\r\n      let pos: number = Number.NaN;\r\n      switch (align) {\r\n        case FocusAlignments.START: {\r\n          pos = position + scroller.startLayoutOffset;\r\n          break;\r\n        }\r\n        case FocusAlignments.CENTER: {\r\n          pos = position - (viewportSize - elementSize) * .5 + scroller.startLayoutOffset;\r\n          break;\r\n        }\r\n        case FocusAlignments.END: {\r\n          pos = position - (viewportSize - elementSize) + scroller.startLayoutOffset;\r\n          break;\r\n        }\r\n        case FocusAlignments.NONE:\r\n        default: {\r\n          break;\r\n        }\r\n      }\r\n      if (!Number.isNaN(pos)) {\r\n        this._trackBox.preventScrollSnapping(true);\r\n        const params: IScrollToParams = {\r\n          [this._isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: pos, behavior, snap: false, normalize: true,\r\n          fireUpdate: false, blending: false, userAction: false,\r\n          duration: this.snapToItem ? Math.max(this.animationParams.scrollToItem, this.animationParams.navigateToItem) : this.animationParams.navigateToItem,\r\n        };\r\n        scroller.scrollTo(params);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\r\n\r\n  /**\r\n   * Base class of the element component\r\n   */\r\n  private _itemComponentClass: Component$1<BaseVirtualListItemComponent> = NgVirtualListItemComponent;\r\n  protected get itemComponentClass() { return this._itemComponentClass; }\r\n\r\n  /**\r\n   * Base class trackBox\r\n   */\r\n  private _trackBoxClass: Component$1<TrackBox> = TrackBox;\r\n\r\n  /**\r\n   * Dictionary of element sizes by their id\r\n   */\r\n  private _trackBox: TrackBox = new this._trackBoxClass(this.trackBy);\r\n\r\n  private _$update = new Subject<string>();\r\n  protected readonly $update = this._$update.asObservable();\r\n\r\n  private _$scrollTo = new Subject<IScrollParams>();\r\n  protected $scrollTo = this._$scrollTo.asObservable();\r\n\r\n  private _$scrollToExecutor = new Subject<IScrollParams>();\r\n  protected readonly $scrollToExecutor = this._$scrollToExecutor.asObservable();\r\n\r\n  private _$scrollingTo = new BehaviorSubject<boolean>(false);\r\n\r\n  private _$scroll = new Subject<IScrollEvent>();\r\n  readonly $scroll = this._$scroll.asObservable();\r\n\r\n  private _$tick = new Subject<void>();\r\n  readonly $tick = this._$tick.asObservable();\r\n\r\n  private _$fireUpdate = new Subject<boolean>();\r\n  protected readonly $fireUpdate = this._$fireUpdate.asObservable();\r\n\r\n  private _$fireUpdateNextFrame = new Subject<boolean>();\r\n  protected readonly $fireUpdateNextFrame = this._$fireUpdateNextFrame.asObservable();\r\n\r\n  private _$preventScrollSnapping = new BehaviorSubject<boolean>(false);\r\n  protected readonly $preventScrollSnapping = this._$preventScrollSnapping.asObservable();\r\n\r\n  private _updateId: number | undefined;\r\n\r\n  private _readyForShow = false;\r\n\r\n  private _cached = false;\r\n\r\n  private _isLoading = false;\r\n\r\n  protected get cachable() {\r\n    return this._prerender?.active ?? false;\r\n  }\r\n\r\n  protected get prerenderable() {\r\n    return this.dynamicSize && (this._trackBox?.isSnappedToEnd ?? false);\r\n  }\r\n\r\n  private _$viewInit = new BehaviorSubject<boolean>(false);\r\n  private readonly $viewInit = this._$viewInit.asObservable();\r\n\r\n  private _$destroy = new Subject<void>();\r\n  private readonly $destroy = this._$destroy.asObservable();\r\n\r\n  constructor() {\r\n    super();\r\n    NgVirtualListComponent.__nextId = NgVirtualListComponent.__nextId + 1 === Number.MAX_SAFE_INTEGER\r\n      ? 0 : NgVirtualListComponent.__nextId + 1;\r\n    this._id = NgVirtualListComponent.__nextId;\r\n\r\n    this._service.initialize(this._id, this._trackBox);\r\n\r\n    const $dynamicSize = this.$dynamicSize,\r\n      $snapScrollToEnd = this.$snapScrollToEnd;\r\n    combineLatest([$dynamicSize, $snapScrollToEnd]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([dynamicSize, snapScrollToEnd]) => {\r\n        this._$prerenderEnabled.next(dynamicSize && snapScrollToEnd);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$animationParams.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.animationParams = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$spreadingMode.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._$isInfinity.next(isSpreadingMode(v, SpreadingModes.INFINITY));\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$actualScrollStartOffset.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      debounceTime(0),\r\n      tap(v => {\r\n        this._$startOffset.next(v);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$actualScrollEndOffset.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      debounceTime(0),\r\n      tap(v => {\r\n        this._$endOffset.next(v);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $isInfinity = this.$isInfinity;\r\n    $isInfinity.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._trackBox.isInfinity = this._service.isInfinity = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $zIndexWhenSelecting = this.$zIndexWhenSelecting;\r\n    $zIndexWhenSelecting.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.zIndexWhenSelecting = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $bounds = this._$bounds.asObservable().pipe(\r\n      filter(b => !!b),\r\n    ),\r\n      $rawScrollStartOffset = this.$scrollStartOffset,\r\n      $rawScrollEndOffset = this.$scrollEndOffset;\r\n\r\n    combineLatest([$bounds, $rawScrollStartOffset]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(([v]) => !!v),\r\n      tap(([bounds, value]) => {\r\n        const val = parseArithmeticExpression(value, this.isVertical ? bounds!.height : bounds!.width);\r\n        this._$precalculatedScrollStartOffset.next(val);\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$bounds, $rawScrollEndOffset]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(([v]) => !!v),\r\n      tap(([bounds, value]) => {\r\n        const val = parseArithmeticExpression(value, this.isVertical ? bounds!.height : bounds!.width);\r\n        this._$precalculatedScrollEndOffset.next(val);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$intersectionElementBySnapToItemAlign.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => v !== null),\r\n      tap(id => {\r\n        this.onSnapItem.emit(id!);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$tick.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(() => {\r\n        this._scrollerComponent?.tick();\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$tick.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(() => this.dynamicSize === true),\r\n      tap(() => {\r\n        this.checkBoundsOfElements();\r\n        this._scrollerComponent?.tick();\r\n      }),\r\n    ).subscribe();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    const _$created = new BehaviorSubject<boolean>(false),\r\n      $created = _$created.asObservable();\r\n\r\n    combineLatest([$created, this.$show]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(([created, shown]) => created && shown),\r\n      debounceTime(1),\r\n      tap(v => {\r\n        this._$initialized.next(true);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._$scroller.next(this._scrollerComponent?.scrollViewport);\r\n    this._$list.next(this._scrollerComponent?.scrollContent);\r\n\r\n    const $bounds = this._$bounds.asObservable().pipe(\r\n      filter(b => !!b),\r\n    ),\r\n      $scrollerComponent = of(this._scrollerComponent),\r\n      $resizeViewport = $scrollerComponent.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        filter(v => !!v),\r\n        switchMap(scroller => scroller!.$resizeViewport),\r\n      ),\r\n      $resizeContent = $scrollerComponent.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        filter(v => !!v),\r\n        switchMap(scroller => scroller!.$resizeContent),\r\n      );\r\n\r\n    $scrollerComponent.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      switchMap(scroller => scroller!.$scrollDirection),\r\n      tap(v => {\r\n        this._trackBox.scrollDirection = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $resizeViewport.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      tap(v => {\r\n        this._$bounds.next(v);\r\n        this.onAfterResize(true);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $resizeContent.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      tap(v => {\r\n        this._$listBounds.next(v);\r\n        this.onAfterResize();\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $trackBy = this.$trackBy;\r\n    $trackBy.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.trackBy = this._trackBox.trackBy = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._trackBox.displayComponents = this._displayComponents;\r\n\r\n    let hasUserAction = false;\r\n\r\n    const $itemSize = this.$itemSize.pipe(\r\n      map(v => typeof v === 'number' && v <= 0 ? DEFAULT_ITEM_SIZE : v),\r\n    ),\r\n      $minItemSize = this.$minItemSize.pipe(\r\n        map(v => typeof v === 'number' && v <= 0 ? DEFAULT_MIN_ITEM_SIZE : v),\r\n      ),\r\n      $maxItemSize = this.$maxItemSize.pipe(\r\n        map(v => typeof v === 'number' && v <= 0 ? DEFAULT_MAX_ITEM_SIZE : v),\r\n      ),\r\n      $scrollStartOffset = this.$actualScrollStartOffset.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        distinctUntilChanged(),\r\n      ),\r\n      $scrollEndOffset = this.$actualScrollEndOffset.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        distinctUntilChanged(),\r\n      );\r\n\r\n    combineLatest([$minItemSize, $bounds, $scrollStartOffset, $scrollEndOffset]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      switchMap(([v, bounds, startOffset, endOffset]) => {\r\n        if ((v as any) === VIEWPORT) {\r\n          const isVertical = this.isVertical, viewportBounds = bounds,\r\n            result = (isVertical ? (viewportBounds?.height ?? 0) : (viewportBounds?.width ?? 0)) - startOffset - endOffset;\r\n          return of(result <= 0 ? 1 : result);\r\n        }\r\n        return of(v);\r\n      }),\r\n      tap(v => {\r\n        this._$actualMinItemSize.next(v);\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$maxItemSize, $bounds, $scrollStartOffset, $scrollEndOffset]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      switchMap(([v, bounds, startOffset, endOffset]) => {\r\n        if ((v as any) === VIEWPORT) {\r\n          const isVertical = this.isVertical, viewportBounds = bounds,\r\n            result = (isVertical ? (viewportBounds?.height ?? 0) : (viewportBounds?.width ?? 0)) - startOffset - endOffset;\r\n          return of(result <= 0 ? 1 : result);\r\n        }\r\n        return of(v);\r\n      }),\r\n      tap(v => {\r\n        this._$actualMaxItemSize.next(v);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $actualMinItemSize = this.$actualMinItemSize,\r\n      $actualMaxItemSize = this.$actualMaxItemSize;\r\n\r\n    combineLatest([$itemSize, $bounds, $actualMinItemSize, $actualMaxItemSize, $scrollStartOffset, $scrollEndOffset]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      switchMap(([v, bounds, min, max, startOffset, endOffset]) => {\r\n        if ((v as any) === VIEWPORT) {\r\n          const isVertical = this.isVertical, viewportBounds = bounds,\r\n            result = (isVertical ? (viewportBounds?.height ?? 0) : (viewportBounds?.width ?? 0)) - startOffset - endOffset;\r\n          return of(result < min ? min : (result > max ? max : result));\r\n        }\r\n        return of(v < min ? min : (v > max ? max : v));\r\n      }),\r\n      tap(v => {\r\n        this._$actualItemSize.next(v);\r\n        this._service.itemSize = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $actualItemSize = this.$actualItemSize,\r\n      $actualItems = this._$actualItems.asObservable().pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        distinctUntilChanged(),\r\n      );\r\n\r\n    this._service.$focusItem.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(params => {\r\n        const { element, position, align, behavior } = params;\r\n        this.focusItem(element, position, align, behavior);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $list = this.$list.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      map(v => v!.nativeElement),\r\n      take(1),\r\n    );\r\n\r\n    const preventKeyboardEvent = (event: KeyboardEvent, isVertical: boolean) => {\r\n      const scroller = this._scrollerComponent;\r\n      if (!!scroller) {\r\n        const scrollStartOffset = this._$actualScrollStartOffset.getValue(), scrollable = scroller.scrollable ?? false,\r\n          scrollSize = isVertical ? scroller.scrollTop : scroller.scrollLeft,\r\n          scrollWeight = isVertical ? scroller.scrollHeight : scroller.scrollWidth;\r\n        if (scrollable || scrollSize <= scrollStartOffset || scrollSize >= scrollWeight) {\r\n          if (!!event && event.cancelable) {\r\n            event.stopImmediatePropagation();\r\n            event.preventDefault();\r\n          }\r\n        }\r\n      }\r\n    };\r\n\r\n    $list.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(element => !!element),\r\n      switchMap(element => {\r\n        return fromEvent<KeyboardEvent>(element, EVENT_KEY_DOWN).pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          switchMap(e => {\r\n            switch (e.key) {\r\n              case KEY_ARR_LEFT:\r\n                if (!this.isVertical) {\r\n                  preventKeyboardEvent(e, this.isVertical);\r\n                }\r\n                break;\r\n              case KEY_ARR_UP:\r\n                if (this.isVertical) {\r\n                  preventKeyboardEvent(e, this.isVertical);\r\n                }\r\n                break;\r\n              case KEY_ARR_RIGHT:\r\n                if (!this.isVertical) {\r\n                  preventKeyboardEvent(e, this.isVertical);\r\n                }\r\n                break;\r\n              case KEY_ARR_DOWN:\r\n                if (this.isVertical) {\r\n                  preventKeyboardEvent(e, this.isVertical);\r\n                }\r\n                break;\r\n            }\r\n            return of(null);\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $scrollbarThickness = this.$scrollbarThickness;\r\n    $scrollbarThickness.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      tap(scrollbarThickness => {\r\n        this._service.scrollBarSize = scrollbarThickness;\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$fireUpdateNextFrame.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      debounceTime(0),\r\n      tap(userAction => {\r\n        this._$fireUpdate.next(userAction);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $scrollToItem = this.$scrollTo.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n    ),\r\n      $mouseDown = fromEvent(this._elementRef.nativeElement, MOUSE_DOWN).pipe(\r\n        takeUntil(this._$unsubscribe),\r\n      ),\r\n      $touchStart = fromEvent(this._elementRef.nativeElement, TOUCH_START).pipe(\r\n        takeUntil(this._$unsubscribe),\r\n      );\r\n\r\n    fromEvent<KeyboardEvent>(document, KEY_DOWN).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(e => e.key === KEY_TAB),\r\n      switchMap(e => {\r\n        return fromEvent(this._elementRef.nativeElement, FOCUS).pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          delay(0),\r\n          takeUntil($scrollToItem),\r\n          takeUntil($mouseDown),\r\n          takeUntil($touchStart),\r\n          tap(e => {\r\n            this._service.focusFirstElement();\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$scrollToStart.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(options => {\r\n        this.scrollToStart(null, options);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$scrollTo.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      tap(params => {\r\n        const { id, cb, options } = params!;\r\n        this.scrollTo(id, cb, options);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$scrollToEnd.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(options => {\r\n        this.scrollToEnd(null, options);\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$langTextDir.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        this._service.langTextDir = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$clickDistance.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        this._service.clickDistance = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([this.$snapScrollToStart, this.$isInfinity]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([snapScrollToStart, isInfinity]) => {\r\n        this._$actualSnapScrollToStart.next(isInfinity ? false : snapScrollToStart);\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([this.$snapScrollToEnd, this.$isInfinity]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([snapScrollToEnd, isInfinity]) => {\r\n        this._$actualSnapScrollToEnd.next(isInfinity ? false : snapScrollToEnd);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $viewInit = this.$viewInit,\r\n      $prerenderContainer = of(this._prerender);\r\n\r\n    const $prerender = $viewInit.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      switchMap(v => {\r\n        return $prerenderContainer.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          filter(v => !!v),\r\n          switchMap(v => v!.$render),\r\n        );\r\n      }),\r\n    );\r\n\r\n    const $fireUpdate = this.$fireUpdate;\r\n    $fireUpdate.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(userAction => {\r\n        hasUserAction = userAction;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $update = this.$update,\r\n      renderStabilizer = (options?: IRenderStabilizerOptions) => {\r\n        let renderStabilizerPrevScrollStateVersion = EMPTY_SCROLL_STATE_VERSION,\r\n          renderStabilizerUpdateIterations = 0;\r\n        const prepareIterations = options?.prepareIterations ?? PREPARE_ITERATIONS,\r\n          prepareReupdateLength = options?.prepareReupdateLength ?? PREPARATION_REUPDATE_LENGTH;\r\n        return of(null).pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          switchMap(() => {\r\n            renderStabilizerPrevScrollStateVersion = EMPTY_SCROLL_STATE_VERSION;\r\n            renderStabilizerUpdateIterations = 0;\r\n            this._cached = false;\r\n            return $update.pipe(\r\n              takeUntil(this._$unsubscribe),\r\n              debounceTime(0),\r\n              switchMap(v => {\r\n                if (((renderStabilizerPrevScrollStateVersion === EMPTY_SCROLL_STATE_VERSION) || (renderStabilizerPrevScrollStateVersion !== v)) &&\r\n                  (renderStabilizerUpdateIterations < prepareIterations)) {\r\n                  if (v !== EMPTY_SCROLL_STATE_VERSION) {\r\n                    renderStabilizerPrevScrollStateVersion = v;\r\n                  }\r\n                  this._$fireUpdate.next(false);\r\n                  return of(false);\r\n                }\r\n                if (renderStabilizerPrevScrollStateVersion === v) {\r\n                  if (renderStabilizerUpdateIterations < prepareReupdateLength) {\r\n                    renderStabilizerUpdateIterations++;\r\n                    this._$fireUpdate.next(false);\r\n                    return of(false);\r\n                  }\r\n                }\r\n                renderStabilizerPrevScrollStateVersion = v;\r\n                return of(true);\r\n              }),\r\n              filter(v => !!v),\r\n              distinctUntilChanged(),\r\n            )\r\n          }),\r\n        )\r\n      };\r\n    const $initialRenderStabilizer = renderStabilizer({\r\n      prepareIterations: PREPARE_ITERATIONS,\r\n      prepareReupdateLength: PREPARATION_REUPDATE_LENGTH,\r\n    }),\r\n      $updateItemsRenderStabilizer = renderStabilizer({\r\n        prepareIterations: PREPARE_ITERATIONS_FOR_UPDATE_ITEMS,\r\n        prepareReupdateLength: PREPARATION_REUPDATE_LENGTH_FOR_UPDATE_ITEMS,\r\n      }),\r\n      $chunkLoadingRenderStabilizer = renderStabilizer({\r\n        prepareIterations: PREPARE_ITERATIONS_FOR_UPDATE_ITEMS,\r\n        prepareReupdateLength: PREPARATION_REUPDATE_LENGTH_FOR_UPDATE_ITEMS,\r\n      }),\r\n      $collapseItemsRenderStabilizer = renderStabilizer({\r\n        prepareIterations: PREPARE_ITERATIONS_FOR_COLLAPSE_ITEMS,\r\n        prepareReupdateLength: PREPARATION_REUPDATE_LENGTH_FOR_COLLAPSE_ITEMS,\r\n      }),\r\n      $itemConfigMap = this.$itemConfigMap.pipe(\r\n        map(v => !v ? {} : v),\r\n      ),\r\n      $divides = this.$divides,\r\n      $dynamicSize = this.$dynamicSize,\r\n      $snapScrollToStart = this._$actualSnapScrollToStart.asObservable(),\r\n      $snapScrollToEnd = this._$actualSnapScrollToEnd.asObservable(),\r\n      $waitForPreparation = this.$waitForPreparation,\r\n      $items = this.$items;\r\n\r\n    combineLatest([$viewInit, $prerenderContainer, $divides, $dynamicSize, $snapScrollToStart, $snapScrollToEnd, $waitForPreparation]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      filter(([init, prerenderContainer]) => !!init && !!prerenderContainer),\r\n      debounceTime(0),\r\n      switchMap(([, prerenderContainer, divides, dynamicSize, snapScrollToStart, snapScrollToEnd, waitForPreparation]) => {\r\n        if (!!dynamicSize && !snapScrollToStart && !!snapScrollToEnd && !!waitForPreparation) {\r\n          const $collection = (divides > 1 ? $actualItems : $items);\r\n          return $collection.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            distinctUntilChanged((p, c) => {\r\n              const pLength = p?.length ?? 0, cLength = c?.length ?? 0;\r\n              return !((cLength > 0) || (pLength !== cLength && (pLength === 0 || cLength === 0)));\r\n            }),\r\n            tap(items => {\r\n              this._trackBox.resetCollection(items, this.actualItemSize);\r\n            }),\r\n            switchMap(i => of((i ?? []).length > 0)),\r\n            distinctUntilChanged(),\r\n            tap(v => {\r\n              if (!v) {\r\n                this.cacheClean();\r\n                this.cleanup();\r\n                this._readyForShow = false;\r\n                if (!snapScrollToStart && snapScrollToEnd) {\r\n                  this._trackBox.isScrollEnd = true;\r\n                }\r\n                const scrollerComponent = this._scrollerComponent;\r\n                if (!!scrollerComponent) {\r\n                  scrollerComponent.prepared = false;\r\n                  scrollerComponent.stopScrolling();\r\n                  scrollerComponent.refresh();\r\n                }\r\n                this._$classes.next({ prepared: true });\r\n                this._$show.next(true);\r\n              } else {\r\n                this._trackBox.isScrollEnd = true;\r\n                const waitForPreparation = this.waitForPreparation;\r\n                if (waitForPreparation) {\r\n                  if (this.prerenderable) {\r\n                    this._cached = false;\r\n                    prerenderContainer!.on(this.items);\r\n                  }\r\n                }\r\n                this._$classes.next({ prepared: false });\r\n                this._$show.next(false);\r\n              }\r\n            }),\r\n            switchMap(v => {\r\n              if (!v) {\r\n                if (this.prerenderable) {\r\n                  prerenderContainer!.off();\r\n                }\r\n                return of(false);\r\n              }\r\n              const waitForPreparation = this.waitForPreparation;\r\n              if (waitForPreparation) {\r\n                this._trackBox.isScrollEnd = true;\r\n                if (this.prerenderable) {\r\n                  this._cached = false;\r\n                  prerenderContainer!.on(this.items);\r\n                }\r\n                return $initialRenderStabilizer.pipe(\r\n                  takeUntil(this._$unsubscribe),\r\n                  take(1),\r\n                  tap(() => {\r\n                    this._trackBox.isScrollEnd = true;\r\n                    if (this.prerenderable) {\r\n                      prerenderContainer!.off();\r\n                    }\r\n                    this._readyForShow = true;\r\n                    const scrollerComponent = this._scrollerComponent;\r\n                    if (!!scrollerComponent) {\r\n                      scrollerComponent.prepared = true;\r\n                      scrollerComponent.refresh();\r\n                    }\r\n                    this._$classes.next({ prepared: true });\r\n                    this._$show.next(true);\r\n                  }),\r\n                );\r\n              }\r\n              if (this.prerenderable) {\r\n                prerenderContainer!.off();\r\n              }\r\n              this._readyForShow = true;\r\n              if (!snapScrollToStart && snapScrollToEnd) {\r\n                this._trackBox.isScrollEnd = true;\r\n              }\r\n              const scrollerComponent = this._scrollerComponent;\r\n              if (!!scrollerComponent) {\r\n                scrollerComponent.prepared = true;\r\n                scrollerComponent.refresh();\r\n              }\r\n              this._$classes.next({ prepared: true });\r\n              this._$show.next(true);\r\n              return of(false);\r\n            }),\r\n          );\r\n        } else {\r\n          prerenderContainer!.off();\r\n          const $collection = (divides > 1 ? $actualItems : $items);\r\n          return $collection.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            tap(items => {\r\n              if (!items || items.length === 0) {\r\n                this.cacheClean();\r\n                const scrollerComponent = this._scrollerComponent;\r\n                if (!!scrollerComponent) {\r\n                  scrollerComponent.prepared = false;\r\n                }\r\n                this._$classes.next({ prepared: false });\r\n                this._$show.next(false);\r\n              }\r\n              this._trackBox.resetCollection(items, this.actualItemSize);\r\n            }),\r\n            switchMap(i => of((i ?? []).length > 0)),\r\n            distinctUntilChanged(),\r\n            filter(v => !!v),\r\n            tap(() => {\r\n              this._readyForShow = true;\r\n              if (snapScrollToStart) {\r\n                this._trackBox.isScrollStart = true;\r\n              } else if (snapScrollToEnd) {\r\n                this._trackBox.isScrollEnd = true;\r\n              }\r\n              const scrollerComponent = this._scrollerComponent;\r\n              if (!!scrollerComponent) {\r\n                scrollerComponent.prepared = true;\r\n                scrollerComponent.refresh();\r\n              }\r\n              this._$classes.next({ prepared: true });\r\n              this._$show.next(true);\r\n              this._$fireUpdate.next(false);\r\n            }),\r\n          );\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $items.pipe(\r\n      map(v => v?.length > 0),\r\n      distinctUntilChanged(),\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      tap(() => {\r\n        this._cached = false;\r\n      }),\r\n      switchMap(() => {\r\n        return $prerender.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          debounceTime(0),\r\n          take(1),\r\n          tap(cache => {\r\n            if (!this._readyForShow) {\r\n              this._trackBox.refreshCache(cache);\r\n              this._cached = true;\r\n              this._$fireUpdate.next(true);\r\n            }\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$focusedId.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._$focusedElement.next(v ?? null);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $list.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(element => !!element),\r\n      tap(element => {\r\n        this._service.listElement = element;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $defaultItemValue = this.$defaultItemValue,\r\n      $selectByClick = this.$selectByClick,\r\n      $collapseByClick = this.$collapseByClick,\r\n      $isScrollStart = this._$isScrollStart.asObservable(),\r\n      $isScrollFinished = this._$isScrollEnd.asObservable(),\r\n      $isVertical = this.$direction.pipe(\r\n        map(v => this.getIsVertical(v || DEFAULT_DIRECTION)),\r\n      );\r\n\r\n    $snapScrollToStart.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.snapScrollToStart = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $snapScrollToEnd.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.snapScrollToEnd = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $isVertical.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.isVertical = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $dynamicSize.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.dynamic = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $defaultItemValue.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.defaultItemValue = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $scrollStartOffset.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        this._trackBox.scrollStartOffset = this._service.scrollStartOffset = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $scrollEndOffset.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        this._trackBox.scrollEndOffset = this._service.scrollEndOffset = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $isScrollStart.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      skip(1),\r\n      distinctUntilChanged(),\r\n      debounceTime(0),\r\n      filter(v => !!v && this._readyForShow),\r\n      tap(() => {\r\n        if (this._scrollerComponent?.scrollable) {\r\n          this.onScrollReachStart.emit();\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $isScrollFinished.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      skip(1),\r\n      distinctUntilChanged(),\r\n      debounceTime(0),\r\n      filter(v => !!v && this._readyForShow),\r\n      tap(v => {\r\n        if (this._scrollerComponent?.scrollable) {\r\n          this.onScrollReachEnd.emit();\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $selectByClick.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.selectByClick = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $collapseByClick.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.collapseByClick = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $trackBy.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._trackBox.trackingPropertyName = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $divides.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._trackBox.divides = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([this.$alignment, this.$isInfinity]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([alignment, isInfinity]) => {\r\n        this._$actualAlignment.next(isInfinity ? Alignments.CENTER : alignment);\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([this.$scrollbarEnabled, this.$isInfinity]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      debounceTime(0),\r\n      tap(([scrollbarEnabled, isInfinity]) => {\r\n        this._$actualScrollbarEnabled.next(isInfinity ? false : scrollbarEnabled);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $alignment = this.$actualAlignment,\r\n      $precalculatedScrollStartOffset = this._$precalculatedScrollStartOffset.asObservable(),\r\n      $precalculatedScrollEndOffset = this._$precalculatedScrollEndOffset.asObservable(),\r\n      $listBounds = this._$listBounds.asObservable().pipe(\r\n        filter(b => !!b),\r\n      ), $scrollSize = this._$scrollSize.asObservable(),\r\n      $bufferSize = this.$bufferSize.pipe(\r\n        map(v => v < 0 ? DEFAULT_BUFFER_SIZE : v),\r\n      ),\r\n      $maxBufferSize = this.$maxBufferSize.pipe(\r\n        map(v => v < 0 ? DEFAULT_BUFFER_SIZE : v),\r\n      ),\r\n      $snapToItem = this.$snapToItem,\r\n      $snapToItemAlign = this.$snapToItemAlign,\r\n      $stickyEnabled = this.$stickyEnabled,\r\n      $isLazy = this.$collectionMode.pipe(\r\n        map(v => this.getIsLazy(v || DEFAULT_COLLECTION_MODE)),\r\n      ),\r\n      $enabledBufferOptimization = this.$enabledBufferOptimization,\r\n      $snappingMethod = this.$snappingMethod.pipe(\r\n        map(v => this.getIsSnappingMethodAdvanced(v || DEFAULT_SNAPPING_METHOD)),\r\n      ),\r\n      $collapsingMode = this.$collapsingMode,\r\n      $selectingMode = this.$selectingMode,\r\n      $selectedIds = this.$selectedIds,\r\n      $collapsedIds = this.$collapsedIds.pipe(\r\n        distinctUntilChanged(),\r\n        map(v => Array.isArray(v) ? v : []),\r\n      ),\r\n      $collapsedItemIds = this._$collapsedItemIds.asObservable().pipe(\r\n        distinctUntilChanged(),\r\n        map(v => Array.isArray(v) ? v : []),\r\n      ),\r\n      $itemTransform = this.$itemTransform,\r\n      $screenReaderMessage = this.$screenReaderMessage,\r\n      $displayItems = this._service.$displayItems,\r\n      $cacheVersion = this._service.$cacheVersion;\r\n\r\n    $snapToItem.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.snapToItem = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $actualItems.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.items = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$actualItems, $viewInit]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(([, init]) => init),\r\n      debounceTime(0),\r\n      tap(() => {\r\n        this._scrollerComponent?.snapIfNeed();\r\n      }),\r\n    ).subscribe();\r\n\r\n    $itemConfigMap.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.itemConfigMap = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $collapsedIds.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._service.collapsedIds = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$displayItems, $screenReaderMessage, $isVertical, $scrollSize, $bounds]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      debounceTime(100),\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([items, screenReaderMessage, isVertical, scrollSize, bounds]) => {\r\n        this._$screenReaderFormattedMessage.next(\r\n          formatScreenReaderMessage(items, screenReaderMessage, scrollSize, isVertical, bounds!)\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    $isLazy.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._trackBox.isLazy = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $itemsComposition = $items.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      switchMap(items => {\r\n        return combineLatest([$collapsedItemIds, $itemConfigMap, $trackBy, $divides]).pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          debounceTime(0),\r\n          switchMap(([collapsedIds, itemConfigMap, trackBy, divides]) => {\r\n            return of({ items, collapsedIds, itemConfigMap, trackBy, divides });\r\n          }),\r\n        );\r\n      }),\r\n    );\r\n\r\n    $itemsComposition.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      switchMap(({ items, collapsedIds, itemConfigMap, trackBy, divides }) => {\r\n        if (items.length === 0 || !this._readyForShow || !(this.cachable && !this._cached &&\r\n          !this._trackBox.isSnappedToStart && this._trackBox.isSnappedToEnd)) {\r\n          return of({ items, collapsedIds, itemConfigMap, trackBy, divides });\r\n        }\r\n        return $updateItemsRenderStabilizer.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          take(1),\r\n          debounceTime(0),\r\n          switchMap(() => {\r\n            return of({ items, collapsedIds, itemConfigMap, trackBy, divides });\r\n          }),\r\n        );\r\n      }),\r\n      tap(({ items, collapsedIds, itemConfigMap, trackBy, divides }) => {\r\n        const hiddenItems = new CMap<Id, boolean>();\r\n\r\n        let isCollapsed = false;\r\n        for (let i = 0, l = items.length; i < l; i++) {\r\n          const item = items[i], id = item?.[trackBy];\r\n          if (!!item) {\r\n            const group = (itemConfigMap[id]?.sticky ?? 0) > 0, collapsed = collapsedIds.includes(id);\r\n            if (!!group) {\r\n              isCollapsed = collapsed;\r\n            } else {\r\n              if (isCollapsed) {\r\n                hiddenItems.set(id, true);\r\n              }\r\n            }\r\n          }\r\n        }\r\n\r\n        const actualItems: IVirtualListCollection = [];\r\n        for (let i = 0, l = items.length; i < l; i++) {\r\n          const item = items[i], id = item?.[trackBy];\r\n          if (!!item && hiddenItems.has(id)) {\r\n            continue;\r\n          }\r\n          actualItems.push(item);\r\n        }\r\n\r\n        const normalizedCollection = normalizeCollection(actualItems, itemConfigMap, trackBy, divides);\r\n\r\n        this._$actualItems.next(normalizedCollection);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $isVertical.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._isVertical = v;\r\n        const el: HTMLElement = this._elementRef.nativeElement;\r\n        toggleClassName(el, v ? CLASS_LIST_VERTICAL : CLASS_LIST_HORIZONTAL, v ? CLASS_LIST_HORIZONTAL : CLASS_LIST_VERTICAL);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $snappingMethod.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this._isSnappingMethodAdvanced = this._trackBox.isSnappingMethodAdvanced = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $selectingMode.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        const el = this._$list.getValue()?.nativeElement;\r\n        if (this.getIsMultiSelection(v || DEFAULT_SNAPPING_METHOD)) {\r\n          this._isMultiSelection = true;\r\n          this._isSingleSelection = false;\r\n          if (!!el) {\r\n            (el as any).role = ROLE_LIST_BOX;\r\n          }\r\n          this._service.selectingMode = SelectingModesTypes.MULTI_SELECT;\r\n        } else if (this.getIsSingleSelection(v || DEFAULT_SNAPPING_METHOD)) {\r\n          this._isSingleSelection = true;\r\n          this._isMultiSelection = false;\r\n          if (!!el) {\r\n            (el as any).role = ROLE_LIST_BOX;\r\n          }\r\n          this._service.selectingMode = SelectingModesTypes.SELECT;\r\n        } else if (this.getIsNoneSelection(v || DEFAULT_SNAPPING_METHOD)) {\r\n          this._isSingleSelection = this._isMultiSelection = false;\r\n          if (!!el) {\r\n            (el as any).role = ROLE_LIST;\r\n          }\r\n          this._service.selectingMode = SelectingModesTypes.NONE;\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $collapsingMode.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        if (this.getIsNoneCollapse()) {\r\n          this._service.isNoneCollapse = true;\r\n          this._service.isAccordionCollapse = this._service.isMultipleCollapse = this._isAccordionCollapse = this._isMultipleCollapse = false;\r\n        } else if (this.getIsMultipleCollapse()) {\r\n          this._service.isMultipleCollapse = this._isMultipleCollapse = true;\r\n          this._service.isAccordionCollapse = this._service.isNoneCollapse = this._isAccordionCollapse = false;\r\n        } else if (this.getIsAccordionCollapse()) {\r\n          this._service.isAccordionCollapse = this._isAccordionCollapse = true;\r\n          this._service.isMultipleCollapse = this._service.isNoneCollapse = this._isMultipleCollapse = false;\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $preventScrollSnapping = this.$preventScrollSnapping;\r\n\r\n    $preventScrollSnapping.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      tap(() => {\r\n        if (this._readyForShow) {\r\n          this._trackBox.isScrollEnd;\r\n          this._trackBox.isScrollStart = this._trackBox.isScrollEnd = false;\r\n          this._$isScrollStart.next(false);\r\n          this._$isScrollEnd.next(false);\r\n          const scroller = this._scrollerComponent;\r\n          if (!!scroller) {\r\n            this._trackBox.preventScrollSnapping(true);\r\n          }\r\n        }\r\n      }),\r\n      tap(() => {\r\n        if (this._readyForShow) {\r\n          this._$preventScrollSnapping.next(false);\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $collapsedItemIds.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(() => this._readyForShow),\r\n      switchMap(() => {\r\n        return $collapseItemsRenderStabilizer.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          take(1),\r\n          tap(() => {\r\n            this._$fireUpdate.next(true);\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    let isChunkLoading = false;\r\n    const $loading = this.$loading;\r\n    $loading.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      skip(1),\r\n      filter(v => !v),\r\n      switchMap(() => {\r\n        isChunkLoading = true;\r\n        const scrollbar = this._scrollerComponent;\r\n        if (!!scrollbar) {\r\n          scrollbar.stopScrollbar();\r\n          scrollbar.refreshScrollbar();\r\n        }\r\n        return $actualItems.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          take(1),\r\n          tap(() => {\r\n            this._$fireUpdateNextFrame.next(true);\r\n          }),\r\n          switchMap(() => $chunkLoadingRenderStabilizer.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            take(1),\r\n            tap(() => {\r\n              isChunkLoading = false;\r\n              this._trackBox.resetCacheChunkInfo();\r\n              const scrollbar = this._scrollerComponent;\r\n              if (!!scrollbar) {\r\n                scrollbar.stopScrollbar();\r\n                scrollbar.refreshScrollbar();\r\n              }\r\n            }),\r\n          )),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    $loading.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      skip(1),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        if (v) {\r\n          this._isLoading = true;\r\n        }\r\n      }),\r\n      filter(v => !v),\r\n      tap(() => {\r\n        if (this._readyForShow) {\r\n          this._$preventScrollSnapping.next(true);\r\n        }\r\n      }),\r\n      debounceTime(100),\r\n      tap(() => {\r\n        this._isLoading = false;\r\n      }),\r\n    ).subscribe();\r\n\r\n    const update = (params: {\r\n      alignment: Alignment; precalculatedScrollStartOffset: number; precalculatedScrollEndOffset: number; trackBy: string; isInfinity: boolean;\r\n      snapScrollToStart: boolean, snapScrollToEnd: boolean; bounds: ISize; listBounds: ISize; scrollEndOffset: number;\r\n      items: IVirtualListCollection<Object>; itemConfigMap: IVirtualListItemConfigMap; scrollSize: number; itemSize: number;\r\n      minItemSize: number; maxItemSize: number; bufferSize: number; maxBufferSize: number; stickyEnabled: boolean; isVertical: boolean;\r\n      dynamicSize: boolean; divides: number; enabledBufferOptimization: boolean; cacheVersion: number; userAction: boolean;\r\n      snapToItem: boolean, snapToItemAlign: SnapToItemAlign, collapsedIds: Array<Id>; itemTransform: ItemTransform | null;\r\n    }) => {\r\n      const {\r\n        alignment, snapScrollToStart, snapScrollToEnd, bounds, items, itemConfigMap, scrollSize, itemSize, minItemSize,\r\n        maxItemSize, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, enabledBufferOptimization, snapToItem,\r\n        snapToItemAlign, userAction, collapsedIds, itemTransform,\r\n      } = params;\r\n      const scroller = this._scrollerComponent;\r\n      let totalSize = 0;\r\n      if (!!scroller) {\r\n        const isInfinity = this.isInfinity, collapsable = collapsedIds.length > 0, cachable = this.cachable, cached = this._cached, waitingCache = cachable && !cached,\r\n          emitUpdate = !this._readyForShow || waitingCache || collapsable || isChunkLoading,\r\n          fireUpdate = !this._readyForShow || this._$scrollingTo.getValue(),\r\n          fireUpdateAtEdges = fireUpdate || !isInfinity;\r\n        if (this._readyForShow || (cachable && cached)) {\r\n          const currentScrollSize = (isVertical ? scroller.scrollTop : scroller.scrollLeft);\r\n          let actualScrollSize = !this._readyForShow && snapScrollToEnd ? (isVertical ? scroller.scrollHeight : scroller.scrollWidth) :\r\n            (isVertical ? scroller.scrollTop : scroller.scrollLeft),\r\n            leftLayoutOffset = 0,\r\n            displayItems: IRenderVirtualListCollection;\r\n\r\n          const { width, height } = bounds, viewportSize = (isVertical ? height : width),\r\n            opts: IUpdateCollectionOptions<IVirtualListItem, IVirtualListCollection> = {\r\n              alignment, bounds: { width, height }, dynamicSize, isVertical, itemSize, minItemSize, maxItemSize, bufferSize, maxBufferSize,\r\n              scrollSize: actualScrollSize, stickyEnabled, enabledBufferOptimization, snapToItem, snapToItemAlign, itemTransform,\r\n            };\r\n\r\n          if (snapScrollToEnd && !this._readyForShow) {\r\n            const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize1, leftLayoutOffset: leftLayoutOffset1 } =\r\n              this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize });\r\n            displayItems = calculatedDisplayItems;\r\n            totalSize = calculatedTotalSize1;\r\n            leftLayoutOffset = leftLayoutOffset1;\r\n\r\n            if (!!itemTransform && dynamicSize && this._trackBox.delta !== 0) {\r\n              const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize1, leftLayoutOffset: leftLayoutOffset1 } =\r\n                this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize + this._trackBox.delta });\r\n              displayItems = calculatedDisplayItems;\r\n              totalSize = calculatedTotalSize1;\r\n              leftLayoutOffset = leftLayoutOffset1;\r\n            }\r\n          } else {\r\n            const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, opts);\r\n            displayItems = calculatedDisplayItems;\r\n            totalSize = calculatedTotalSize;\r\n            leftLayoutOffset = leftLayoutOffset1;\r\n\r\n            if (!!itemTransform && dynamicSize && this._trackBox.delta !== 0) {\r\n              const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize + this._trackBox.delta });\r\n              displayItems = calculatedDisplayItems;\r\n              totalSize = calculatedTotalSize;\r\n              leftLayoutOffset = leftLayoutOffset1;\r\n            }\r\n          }\r\n\r\n          scroller.totalSize = totalSize;\r\n\r\n          scroller.startLayoutOffset = leftLayoutOffset;\r\n\r\n          this._$totalSize.next(totalSize);\r\n\r\n          this._service.collection = displayItems;\r\n\r\n          this.resetBoundsSize(isVertical, totalSize);\r\n\r\n          this.createDisplayComponentsIfNeed(displayItems);\r\n\r\n          this.tracking();\r\n\r\n          this.snappingHandler();\r\n\r\n          if (!_$created.getValue()) {\r\n            _$created.next(true);\r\n          }\r\n\r\n          const delta = this._trackBox.delta,\r\n            scrollPositionAfterUpdate = actualScrollSize + delta,\r\n            roundedScrollPositionAfterUpdate = scrollPositionAfterUpdate,\r\n            roundedMaxPositionAfterUpdate = isVertical ? scroller.scrollHeight : scroller.scrollWidth;\r\n\r\n          if (this._isSnappingMethodAdvanced) {\r\n            this.updateRegularRenderer();\r\n          }\r\n\r\n          this.updateOffsetsByAllignment();\r\n\r\n          scroller.delta = delta;\r\n\r\n          if ((snapScrollToStart && this._trackBox.isSnappedToStart && scroller.scrollable) ||\r\n            (snapScrollToStart && currentScrollSize <= MIN_PIXELS_FOR_PREVENT_SNAPPING)) {\r\n            if (currentScrollSize !== roundedScrollPositionAfterUpdate) {\r\n              this._trackBox.clearDelta();\r\n\r\n              if (this._readyForShow) {\r\n                this.emitScrollEvent(true, false, userAction);\r\n              }\r\n              this._trackBox.isScrollEnd;\r\n              const params: IScrollToParams = {\r\n                [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: 0, userAction,\r\n                fireUpdate: fireUpdateAtEdges, behavior: BEHAVIOR_INSTANT,\r\n                blending: false, duration: this.animationParams.scrollToItem,\r\n              };\r\n              scroller?.scrollTo?.(params);\r\n              if (emitUpdate) {\r\n                this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));\r\n              }\r\n            }\r\n            return;\r\n          }\r\n\r\n          if ((snapScrollToEnd && this._trackBox.isSnappedToEnd) || (snapScrollToEnd && !scroller.scrollable) ||\r\n            (scrollPositionAfterUpdate + MIN_PIXELS_FOR_PREVENT_SNAPPING >= roundedMaxPositionAfterUpdate) ||\r\n            (roundedScrollPositionAfterUpdate >= scrollPositionAfterUpdate + MIN_PIXELS_FOR_PREVENT_SNAPPING)) {\r\n            this._trackBox.clearDelta();\r\n\r\n            if (!this._trackBox.isSnappedToEnd) {\r\n              this._trackBox.isScrollEnd = true;\r\n              this._trackBox.isScrollStart = false;\r\n            }\r\n\r\n            if (this._readyForShow) {\r\n              this.emitScrollEvent(true, false, false);\r\n            }\r\n            const params: IScrollToParams = {\r\n              [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: roundedMaxPositionAfterUpdate,\r\n              fireUpdate: fireUpdateAtEdges, behavior: BEHAVIOR_INSTANT, userAction: false,\r\n              blending: false, duration: this.animationParams.scrollToItem,\r\n            };\r\n            scroller?.scrollTo?.(params);\r\n            if (emitUpdate) {\r\n              this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));\r\n            }\r\n            return;\r\n          }\r\n\r\n          if (scrollSize !== scrollPositionAfterUpdate &&\r\n            ((scrollPositionAfterUpdate >= 0 && scrollPositionAfterUpdate < roundedMaxPositionAfterUpdate) ||\r\n              (scrollSize !== roundedMaxPositionAfterUpdate || currentScrollSize !== scrollPositionAfterUpdate))) {\r\n            this._trackBox.clearDelta();\r\n\r\n            if (this._readyForShow) {\r\n              this.emitScrollEvent(true, false, userAction);\r\n            }\r\n            const params: IScrollToParams = {\r\n              [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollPositionAfterUpdate, blending: true, userAction,\r\n              fireUpdate, behavior: BEHAVIOR_INSTANT, duration: this.animationParams.scrollToItem,\r\n            };\r\n            scroller.scrollTo(params);\r\n            if (emitUpdate) {\r\n              this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));\r\n            }\r\n            return;\r\n          }\r\n        }\r\n        if (emitUpdate) {\r\n          this._$update.next(getScrollStateVersion(totalSize, this._isVertical ? scroller.scrollTop : scroller.scrollLeft));\r\n        }\r\n      }\r\n    };\r\n\r\n    let prevItems: IVirtualListCollection = [];\r\n    const debouncedUpdate = debounce(update, 0, MAX_NUMBERS_OF_SKIPS_FOR_QUALITY_OPTIMIZATION_LVL1);\r\n    $viewInit.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      switchMap(() => {\r\n        return combineLatest([$trackBy, this.$isInfinity, $snapScrollToStart, $snapScrollToEnd, $bounds, $listBounds, $scrollEndOffset, $actualItems, $itemConfigMap, $scrollSize,\r\n          $actualItemSize, $actualMinItemSize, $actualMaxItemSize, $collapsedItemIds, $bufferSize, $maxBufferSize, $stickyEnabled, $isVertical,\r\n          $dynamicSize, $divides, $snapToItem, $snapToItemAlign, $enabledBufferOptimization, $itemTransform, $alignment,\r\n          $precalculatedScrollStartOffset, $precalculatedScrollEndOffset, $cacheVersion, this.$fireUpdate,\r\n        ]).pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          tap(([\r\n            trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds, listBounds, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize,\r\n            maxItemSize, collapsedIds, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, divides, snapToItem, snapToItemAlign,\r\n            enabledBufferOptimization, itemTransform, alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, cacheVersion,\r\n          ]) => {\r\n            let itemsChanged = false;\r\n            if (prevItems !== items) {\r\n              itemsChanged = true;\r\n              prevItems = items;\r\n            }\r\n            const enabledOptimization = this.scrollingSettings?.optimization ?? DEFAULT_SCROLLING_SETTINGS.optimization,\r\n              velocity = this._scrollerComponent?.averageVelocity ?? 0,\r\n              isScrolling = this._$scrollingTo.getValue(),\r\n              useDebouncedUpdate = (dynamicSize && !itemTransform) && !(snapScrollToEnd && this._trackBox.isSnappedToEnd) && !itemsChanged && hasUserAction && !isScrolling &&\r\n                (velocity > 0 && velocity < MAX_VELOCITY_FOR_SCROLL_QUALITY_OPTIMIZATION_LVL1);\r\n            if (enabledOptimization) {\r\n              if (useDebouncedUpdate) {\r\n                debouncedUpdate.execute({\r\n                  trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds: bounds!, listBounds: listBounds!, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize,\r\n                  maxItemSize, collapsedIds, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, divides, enabledBufferOptimization, itemTransform,\r\n                  snapToItem, snapToItemAlign, alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, cacheVersion, userAction: hasUserAction,\r\n                });\r\n                return;\r\n              }\r\n\r\n              debouncedUpdate.dispose();\r\n            }\r\n\r\n            if (!isScrolling) {\r\n              update({\r\n                trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds: bounds!, listBounds: listBounds!, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize,\r\n                maxItemSize, collapsedIds, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, divides, enabledBufferOptimization, itemTransform,\r\n                snapToItem, snapToItemAlign, alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, cacheVersion, userAction: hasUserAction,\r\n              });\r\n            }\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $scroller = this.$scroller.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      map(v => v!.nativeElement),\r\n      take(1),\r\n    ),\r\n      $scrollerScroll = $scrollerComponent.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        filter(v => !!v),\r\n        take(1),\r\n        switchMap(scroller => scroller!.$scroll),\r\n      ),\r\n      $scrollerScrollEnd = $scrollerComponent.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        filter(v => !!v),\r\n        take(1),\r\n        switchMap(scroller => scroller!.$scrollEnd),\r\n      ),\r\n      $scrollbarScroll = $scrollerComponent.pipe(\r\n        takeUntil(this._$unsubscribe),\r\n        filter(v => !!v),\r\n        take(1),\r\n        switchMap(scroller => scroller!.$scrollbarScroll),\r\n      );\r\n\r\n    const scrollHandler = (userAction: boolean = false) => {\r\n      const scroller = this._scrollerComponent;\r\n      if (!!scroller) {\r\n        const isVertical = this._isVertical,\r\n          scrollSize = (isVertical ? scroller.scrollTop : scroller.scrollLeft),\r\n          actualScrollSize = scrollSize;\r\n\r\n        if (this._readyForShow) {\r\n          if (userAction) {\r\n            this._$preventScrollSnapping.next(true);\r\n          }\r\n        }\r\n\r\n        this._$scrollSize.next(actualScrollSize);\r\n      }\r\n    };\r\n\r\n    $scroller.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      switchMap(scroller => {\r\n        return $scrollbarScroll.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          tap(userAction => {\r\n            const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;\r\n            if (!!scrollerEl && !!scrollerComponent) {\r\n              this.emitScrollEvent(false, this._readyForShow, hasUserAction);\r\n            }\r\n            if (this._readyForShow) {\r\n              if (userAction) {\r\n                if (this._trackBox.isSnappedToStart) {\r\n                  this._$preventScrollSnapping.next(true);\r\n                }\r\n                if (this._trackBox.isSnappedToEnd) {\r\n                  this._$preventScrollSnapping.next(true);\r\n                }\r\n              }\r\n            }\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    $scroller.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      switchMap(scroller => {\r\n        return $scrollerScroll.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n        );\r\n      }),\r\n      tap(userAction => {\r\n        hasUserAction = userAction;\r\n        const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;\r\n        if (!!scrollerEl && !!scrollerComponent) {\r\n          this.emitScrollEvent(false, this._readyForShow, userAction);\r\n        }\r\n        scrollHandler(userAction);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $scroller.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      switchMap(scroller => {\r\n        return $scrollerScrollEnd.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n        );\r\n      }),\r\n      tap(userAction => {\r\n        hasUserAction = userAction;\r\n        const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;\r\n        if (!!scrollerEl && !!scrollerComponent) {\r\n          this.emitScrollEvent(true, this._readyForShow, userAction);\r\n        }\r\n        scrollHandler(userAction);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $scrollTo = this.$scrollTo,\r\n      $scrollToExecutor = this.$scrollToExecutor;\r\n\r\n    combineLatest([$scroller, $trackBy, $scrollTo]).pipe(\r\n      filter(([scroller, , event]) => !!scroller && !!event),\r\n      map(([scroller, trackBy, event]) => ({ scroller: scroller, trackBy, event })),\r\n      switchMap(({ event }) => {\r\n        const d = event?.delay ?? 0;\r\n        if (d > 0) {\r\n          return of(event).pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            delay(d),\r\n          );\r\n        }\r\n        return of(event);\r\n      }),\r\n      tap(event => {\r\n        this._$scrollingTo.next(true);\r\n        this._$scrollToExecutor.next(event);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $scrollToExecutor.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      switchMap(event => {\r\n        const trackBy = this.trackBy, scrollerComponent = this._scrollerComponent,\r\n          { id, iteration = 0, blending = false, isLastIteration = false, cb } = event;\r\n        const nextIteration = iteration + 1, finished = nextIteration >= MAX_SCROLL_TO_ITERATIONS, fireUpdate = false;\r\n\r\n        if (!this._readyForShow) {\r\n          return of([finished, { id, iteration: nextIteration, blending, cb }]).pipe(delay(0));\r\n        }\r\n\r\n        debouncedUpdate.dispose();\r\n        this._$preventScrollSnapping.next(true);\r\n\r\n        if (!!scrollerComponent) {\r\n          scrollerComponent.startScrollTo();\r\n\r\n          const items = this._$actualItems.getValue();\r\n          if (!!items && items.length) {\r\n            const dynamicSize = this.dynamicSize, itemSize = this.actualItemSize, minItemSize = this.actualMinItemSize,\r\n              maxItemSize = this.actualMaxItemSize, snapScrollToEnd = this.snapScrollToEnd;\r\n\r\n            if (dynamicSize) {\r\n              const { width, height } = this._$bounds.getValue() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE },\r\n                itemConfigMap = this.itemConfigMap, isVertical = this._isVertical,\r\n                currentScrollSize = isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft,\r\n                opts: IGetItemPositionOptions<IVirtualListItem, IVirtualListCollection> = {\r\n                  alignment: this._$actualAlignment.getValue(),\r\n                  bounds: { width, height }, collection: items, dynamicSize, isVertical: this._isVertical, itemSize, minItemSize, maxItemSize,\r\n                  bufferSize: this.bufferSize, maxBufferSize: this.maxBufferSize, itemTransform: this.itemTransform,\r\n                  scrollSize: (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),\r\n                  snapToItem: this.snapToItem, snapToItemAlign: this.snapToItemAlign,\r\n                  stickyEnabled: this.stickyEnabled, fromItemId: id, enabledBufferOptimization: this.enabledBufferOptimization,\r\n                };\r\n\r\n              let scrollSize = snapScrollToEnd && this._trackBox.isSnappedToEnd ?\r\n                (isVertical ? scrollerComponent.scrollHeight : scrollerComponent.scrollWidth) :\r\n                this._trackBox.getItemPosition(id, itemConfigMap, opts);\r\n\r\n              if (scrollSize === -1) {\r\n                return of([finished, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));\r\n              }\r\n\r\n              this._trackBox.clearDelta();\r\n\r\n              const viewportSize = (isVertical ? height : width),\r\n                { displayItems, totalSize, leftLayoutOffset } = this._trackBox.updateCollection(items, itemConfigMap, {\r\n                  ...opts, scrollSize, fromItemId: isLastIteration ? undefined : id,\r\n                }), delta1 = this._trackBox.delta;\r\n\r\n              const normalizedTotalSize = totalSize < viewportSize ? viewportSize : totalSize;\r\n\r\n              scrollerComponent.startLayoutOffset = leftLayoutOffset;\r\n\r\n              scrollerComponent.totalSize = normalizedTotalSize;\r\n\r\n              this._service.collection = displayItems;\r\n\r\n              let actualScrollSize = scrollSize + delta1;\r\n\r\n              this.resetBoundsSize(isVertical, normalizedTotalSize);\r\n\r\n              this.createDisplayComponentsIfNeed(displayItems);\r\n\r\n              this.tracking();\r\n\r\n              this.snappingHandler();\r\n\r\n              this.updateOffsetsByAllignment();\r\n\r\n              scrollSize = this._trackBox.getItemPosition(id, itemConfigMap, { ...opts, scrollSize: actualScrollSize, fromItemId: id });\r\n\r\n              if (scrollSize === -1) {\r\n                return of([finished, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));\r\n              }\r\n              const notChanged = scrollSize === currentScrollSize;\r\n              if (!notChanged && iteration < MAX_SCROLL_TO_ITERATIONS) {\r\n                this._trackBox.clearDelta();\r\n                const params: IScrollToParams = {\r\n                  [isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollSize, behavior: BEHAVIOR_INSTANT as ScrollBehavior,\r\n                  fireUpdate, blending, force: true, snap: false, normalize: false,\r\n                };\r\n                scrollerComponent?.scrollTo?.(params);\r\n                return of([finished, {\r\n                  id, iteration: nextIteration, blending,\r\n                  isLastIteration: nextIteration < MAX_SCROLL_TO_ITERATIONS, cb\r\n                }]).pipe(delay(0));\r\n              } else {\r\n                this._$scrollSize.next(actualScrollSize);\r\n                return of([true, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));\r\n              }\r\n            } else {\r\n              const index = items.findIndex(item => item[trackBy] === id);\r\n              if (index > -1) {\r\n                const isVertical = this._isVertical, itemSize = this.actualItemSize;\r\n                let scrollSize = index * itemSize;\r\n\r\n                if (this.isInfinity) {\r\n                  if (this.snapToItem) {\r\n                    switch (this.snapToItemAlign) {\r\n                      case SnapToItemAligns.CENTER: {\r\n                        scrollSize += itemSize * .5;\r\n                        break;\r\n                      }\r\n                    }\r\n                  }\r\n                }\r\n\r\n                const { width, height } = this._$bounds.getValue() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE },\r\n                  itemConfigMap = this.itemConfigMap, items = this._$actualItems.getValue(),\r\n                  opts: IGetItemPositionOptions<IVirtualListItem, IVirtualListCollection> = {\r\n                    alignment: this._$actualAlignment.getValue(),\r\n                    bounds: { width, height }, collection: items, dynamicSize, isVertical: this._isVertical, itemSize, minItemSize, maxItemSize,\r\n                    bufferSize: this.bufferSize, maxBufferSize: this.maxBufferSize, itemTransform: this.itemTransform,\r\n                    scrollSize: (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),\r\n                    snapToItem: this.snapToItem, snapToItemAlign: this.snapToItemAlign,\r\n                    stickyEnabled: this.stickyEnabled, fromItemId: id, enabledBufferOptimization: this.enabledBufferOptimization,\r\n                  };\r\n\r\n                this._trackBox.clearDelta();\r\n\r\n                const viewportSize = (isVertical ? height : width),\r\n                  { displayItems, totalSize, leftLayoutOffset } = this._trackBox.updateCollection(items, itemConfigMap, {\r\n                    ...opts, scrollSize, fromItemId: isLastIteration ? undefined : id,\r\n                  });\r\n\r\n                const actualTotalSize = this.isInfinity ? (totalSize + viewportSize) : totalSize;\r\n\r\n                const normalizedTotalSize = actualTotalSize < viewportSize ? viewportSize : actualTotalSize;\r\n\r\n                scrollerComponent.startLayoutOffset = leftLayoutOffset;\r\n\r\n                scrollerComponent.totalSize = normalizedTotalSize;\r\n\r\n                this._service.collection = displayItems;\r\n\r\n                this.resetBoundsSize(isVertical, normalizedTotalSize);\r\n\r\n                this.createDisplayComponentsIfNeed(displayItems);\r\n\r\n                this.tracking();\r\n\r\n                this.snappingHandler();\r\n\r\n                this.updateOffsetsByAllignment();\r\n\r\n                this._$preventScrollSnapping.next(true);\r\n\r\n                const params: IScrollToParams = {\r\n                  [this._isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollSize, fireUpdate: false,\r\n                  behavior: BEHAVIOR_INSTANT as ScrollBehavior, blending, force: true, snap: false, normalize: false,\r\n                };\r\n                scrollerComponent?.scrollTo?.(params);\r\n                return of([true, { id, blending, iteration: nextIteration, cb }]);\r\n              }\r\n            }\r\n          }\r\n        }\r\n        return of([finished, { id, iteration: nextIteration, blending, cb }]);\r\n      }),\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([finished, params]) => {\r\n        if (!finished) {\r\n          this._$scrollToExecutor.next(params as IScrollParams);\r\n          return;\r\n        }\r\n\r\n        if (this._readyForShow) {\r\n          this._trackBox.preventScrollSnapping(true);\r\n        }\r\n\r\n        this._$scrollingTo.next(false);\r\n        this._scrollerComponent?.finishedScrollTo();\r\n        this._$fireUpdate.next(true);\r\n        this.emitScrollEvent(true, false, true);\r\n        const scrollParams = params as IScrollParams & { scrollCalled: boolean; };\r\n        scrollParams?.cb?.();\r\n      }),\r\n      delay(0),\r\n      tap(([finished]) => {\r\n        if (finished) {\r\n          this._scrollerComponent?.snapIfNeed();\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $itemRenderer = this.$itemRenderer;\r\n\r\n    $itemRenderer.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      filter(v => !!v),\r\n      tap(v => {\r\n        this._$itemRenderer.next(v);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $bounds.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      filter(v => !!v),\r\n      tap(value => {\r\n        const size: ISize = { width: value!.width, height: value!.height };\r\n        this.onViewportChange.emit(objectAsReadonly(size));\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._service.$virtualClick.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        this.onItemClick.emit(objectAsReadonly(v));\r\n      }),\r\n    ).subscribe();\r\n\r\n    let isSelectedIdsFirstEmit = 0;\r\n\r\n    this._service.$selectedIds.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        if (this._isSingleSelection || (this._isMultiSelection && isSelectedIdsFirstEmit >= 2)) {\r\n          const curr = this.selectedIds;\r\n          if ((this._isSingleSelection && JSON.stringify(v) !== JSON.stringify(curr)) ||\r\n            (isSelectedIdsFirstEmit === 2 && JSON.stringify(v) !== JSON.stringify(curr)) || isSelectedIdsFirstEmit > 2) {\r\n            this.onSelect.emit(copyValueAsReadonly(v));\r\n          }\r\n        }\r\n        if (isSelectedIdsFirstEmit < 3) {\r\n          isSelectedIdsFirstEmit++;\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $selectedIds.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        this._service.selectedIds = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    $viewInit.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(v => !!v),\r\n      switchMap(() => {\r\n        return this._service.$collapsedIds.pipe(\r\n          takeUntil(this._$unsubscribe),\r\n          distinctUntilChanged(),\r\n          tap(v => {\r\n            const curr = this._$collapsedItemIds.getValue();\r\n            if ((this._isAccordionCollapse || this._isMultipleCollapse) && (JSON.stringify(v) !== JSON.stringify(curr))) {\r\n              this._$collapsedItemIds.next(v);\r\n              this.onCollapse.emit(copyValueAsReadonly(v));\r\n            }\r\n          }),\r\n        );\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$itemConfigMap, $dynamicSize, $divides]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      filter(([itemConfigMap, dynamicSize, divides]) => !!itemConfigMap && !dynamicSize && divides > 1),\r\n      tap(([itemConfigMap]) => {\r\n        for (const id in itemConfigMap) {\r\n          const metaData = itemConfigMap[id];\r\n          if (metaData?.fullSize || metaData?.sticky === 1 || metaData?.sticky === 2) {\r\n            throw Error('The accelerated rendering algorithm `[dynamicSize]=\"false\"` cannot correctly handle non-uniform lists (the itemConfigMap specifies full-size elements). For correct rendering, specify `[dynamicSize]=\"true\"`.');\r\n          }\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$collapsingMode, $items, $itemConfigMap, $trackBy]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([collapsingMode, items, itemConfigMap, trackBy]) => {\r\n        const isAccordion = isCollapseMode(collapsingMode, CollapsingModes.ACCORDION);\r\n        if (isAccordion) {\r\n          const allGroups: Array<Id> = [];\r\n          if (this._isAccordionCollapse) {\r\n            for (let i = 0, l = items.length; i < l; i++) {\r\n              const item = items[i], id = item[trackBy], collapsable = itemConfigMap?.[id]?.collapsable === true;\r\n              if (!collapsable) {\r\n                continue;\r\n              }\r\n              allGroups.push(id);\r\n            }\r\n          }\r\n          if ((this._isAccordionCollapse || this._isMultipleCollapse) && (JSON.stringify(this._$collapsedItemIds.getValue()) !== JSON.stringify(allGroups))) {\r\n            this._$collapsedItemIds.next(allGroups);\r\n            this.onCollapse.emit(copyValueAsReadonly(allGroups));\r\n          }\r\n        }\r\n      }),\r\n    ).subscribe();\r\n\r\n    $collapsedItemIds.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      distinctUntilChanged(),\r\n      tap(v => {\r\n        this._service.collapsedIds = v;\r\n      }),\r\n    ).subscribe();\r\n\r\n    this.$destroy.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(() => {\r\n        debouncedUpdate.dispose();\r\n      }),\r\n    ).subscribe();\r\n\r\n    this._$viewInit.next(true);\r\n\r\n    this._$fireUpdate.next(false);\r\n  }\r\n\r\n  private onAfterResize(update = false) {\r\n    this.snappingHandler();\r\n\r\n    if (this._isSnappingMethodAdvanced) {\r\n      this.updateRegularRenderer();\r\n    }\r\n\r\n    if (this._readyForShow && update) {\r\n      const scroller = this._scrollerComponent;\r\n      if (!!scroller) {\r\n        const updatebale = this._readyForShow;\r\n        if (updatebale) {\r\n          this._$fireUpdate.next(false);\r\n        }\r\n        scroller.refresh(updatebale, updatebale);\r\n      }\r\n    }\r\n  }\r\n\r\n  private checkBoundsOfElements() {\r\n    const changed = this._trackBox.checkBoundsOfElements();\r\n    if (changed) {\r\n      const readyForShow = this._readyForShow,\r\n        isScrolling = this._$scrollingTo.getValue();\r\n      this._trackBox.changes(true, readyForShow && !isScrolling);\r\n    }\r\n  }\r\n\r\n  private snappingHandler() {\r\n    const scroller = this._scrollerComponent;\r\n    if (!!scroller) {\r\n      const isVertical = this.isVertical,\r\n        maxScrollSize = Math.round(isVertical ? scroller.scrollHeight ?? 0 : scroller.scrollWidth ?? 0),\r\n        scrollSize = isVertical ? scroller.scrollTop ?? 0 : scroller.scrollLeft ?? 0,\r\n        actualScrollSize = Math.round(scrollSize);\r\n      if (this._readyForShow && !this._isLoading) {\r\n        const isScrollEnd = (actualScrollSize >= (maxScrollSize - MIN_PIXELS_FOR_PREVENT_SNAPPING)) || !scroller.scrollable || this._trackBox.isScrollEnd;\r\n        if (isScrollEnd) {\r\n          this._$isScrollStart.next(false);\r\n          this._$isScrollEnd.next(true);\r\n          this._trackBox.isScrollStart = false;\r\n          this._trackBox.isScrollEnd = true;\r\n        } else {\r\n          const isScrollStart = (actualScrollSize <= MIN_PIXELS_FOR_PREVENT_SNAPPING);\r\n          this._$isScrollStart.next(isScrollStart);\r\n          this._$isScrollEnd.next(false);\r\n          this._trackBox.isScrollStart = isScrollStart;\r\n          this._trackBox.isScrollEnd = false;\r\n        }\r\n      } else if (!this._readyForShow) {\r\n        const snapScrollToStart = this._$actualSnapScrollToStart.getValue(), snapScrollToEnd = this._$actualSnapScrollToEnd.getValue();\r\n        if (!snapScrollToStart && snapScrollToEnd) {\r\n          this._$isScrollStart.next(false);\r\n          this._$isScrollEnd.next(true);\r\n          this._trackBox.isScrollStart = false;\r\n          this._trackBox.isScrollEnd = true;\r\n        } else if (snapScrollToStart && snapScrollToEnd) {\r\n          this._$isScrollStart.next(true);\r\n          this._$isScrollEnd.next(false);\r\n          this._trackBox.isScrollStart = true;\r\n          this._trackBox.isScrollEnd = false;\r\n        } else {\r\n          this._$isScrollStart.next(false);\r\n          this._$isScrollEnd.next(false);\r\n          this._trackBox.isScrollStart = false;\r\n          this._trackBox.isScrollEnd = false;\r\n        }\r\n      }\r\n    }\r\n  };\r\n\r\n  private emitScrollEvent(isScrollEnd: boolean = false, update: boolean = true, userAction: boolean = false) {\r\n    if (!this._readyForShow) {\r\n      return;\r\n    }\r\n    const scrollerEl = this._$scroller.getValue()?.nativeElement, scrollerComponent = this._scrollerComponent;\r\n    if (scrollerEl && scrollerComponent) {\r\n      const isVertical = this._isVertical, scrollSize = (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),\r\n        maxScrollSize = (isVertical ? scrollerComponent.scrollHeight : scrollerComponent.scrollWidth),\r\n        bounds = this._$bounds.getValue() || { x: 0, y: 0, width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE };\r\n      const itemsRange = formatActualDisplayItems(this._service.displayItems, this._$actualScrollStartOffset.getValue(), this._$actualScrollEndOffset.getValue(),\r\n        scrollSize, isVertical, bounds),\r\n        event = new ScrollEvent({\r\n          direction: this._scrollerComponent?.scrollDirection ?? 0, container: scrollerEl,\r\n          list: this._$list.getValue()!.nativeElement, delta: this._trackBox.delta,\r\n          deltaOfNewItems: this._trackBox.deltaOfNewItems, isVertical,\r\n          scrollSize,\r\n          itemsRange,\r\n          isEnd: !scrollerComponent.scrollable || this._trackBox.isSnappedToEnd || (Math.round(scrollSize) === Math.round(maxScrollSize)),\r\n          userAction,\r\n        });\r\n      if (update) {\r\n        this._$scroll.next(event);\r\n      }\r\n\r\n      if (isScrollEnd) {\r\n        this.onScrollEnd.emit(event);\r\n      } else {\r\n        this.onScroll.emit(event);\r\n      }\r\n    }\r\n  }\r\n\r\n  private getIsSnappingMethodAdvanced(m?: SnappingMethod) {\r\n    const method = m || this.snappingMethod;\r\n    return isSnappingMethodAdvenced(method);\r\n  }\r\n\r\n  private getIsNoneSelection(m?: SelectingMode) {\r\n    const mode = m || this.selectingMode;\r\n    return isSelectMode(mode, SelectingModes.NONE);\r\n  }\r\n\r\n  private getIsSingleSelection(m?: SelectingMode) {\r\n    const mode = m || this.selectingMode;\r\n    return isSelectMode(mode, SelectingModes.SELECT);\r\n  }\r\n\r\n  private getIsMultiSelection(m?: SelectingMode) {\r\n    const mode = m || this.selectingMode;\r\n    return isSelectMode(mode, SelectingModes.MULTI_SELECT);\r\n  }\r\n\r\n  private getIsNoneCollapse(m?: CollapsingMode) {\r\n    const mode = m || this.collapsingMode;\r\n    return isCollapseMode(mode, CollapsingModes.NONE);\r\n  }\r\n\r\n  private getIsMultipleCollapse(m?: CollapsingMode) {\r\n    const mode = m || this.collapsingMode;\r\n    return isCollapseMode(mode, CollapsingModes.MULTI_COLLAPSE);\r\n  }\r\n\r\n  private getIsAccordionCollapse(m?: CollapsingMode) {\r\n    const mode = m || this.collapsingMode;\r\n    return isCollapseMode(mode, CollapsingModes.ACCORDION);\r\n  }\r\n\r\n  private getIsVertical(d?: Direction) {\r\n    const dir = d || this.direction;\r\n    return isDirection(dir, Directions.VERTICAL);\r\n  }\r\n\r\n  private getIsLazy(m?: CollectionMode) {\r\n    const mode = m || this.collectionMode;\r\n    return isCollectionMode(mode, CollectionModes.LAZY);\r\n  }\r\n\r\n  private createDisplayComponentsIfNeed(displayItems: IRenderVirtualListCollection | null) {\r\n    if (!displayItems || !this._listContainerRef) {\r\n      this._trackBox.setDisplayObjectIndexMapById({});\r\n      return;\r\n    }\r\n\r\n    if (this._isSnappingMethodAdvanced && this.stickyEnabled) {\r\n      if (this._snappedDisplayComponents.length < MAX_REGULAR_SNAPED_COMPONENTS && !!this._snapContainerRef) {\r\n        while (this._snappedDisplayComponents.length < MAX_REGULAR_SNAPED_COMPONENTS) {\r\n          const comp = this._snapContainerRef.createComponent(this._itemComponentClass);\r\n          comp.instance.renderer = this._$itemRenderer.getValue();\r\n          comp.instance.regular = true;\r\n          this._snappedDisplayComponents.push(comp);\r\n          this._trackBox.snappedDisplayComponents = this._snappedDisplayComponents;\r\n          this._resizeSnappedObserver = new ResizeObserver(this._resizeSnappedComponentHandler);\r\n          this._resizeSnappedObserver.observe(comp.instance.element);\r\n        }\r\n      }\r\n    }\r\n\r\n    this._trackBox.items = displayItems;\r\n\r\n    const listContainerRef = this._listContainerRef;\r\n\r\n    const maxLength = displayItems.length, components = this._displayComponents;\r\n\r\n    if (!!listContainerRef) {\r\n      const doMap: { [id: number]: number } = {};\r\n      let i = 0;\r\n      for (let l = components.length; i < l; i++) {\r\n        const item = components[i];\r\n        if (!!item) {\r\n          const id = item.instance.id;\r\n          item.instance.renderer = this._$itemRenderer.getValue();\r\n          doMap[id] = i;\r\n        }\r\n      }\r\n      while (components.length < maxLength) {\r\n        const comp = listContainerRef.createComponent(this._itemComponentClass);\r\n        const id = comp.instance.id;\r\n        comp.instance.renderer = this._$itemRenderer.getValue();\r\n        doMap[id] = i;\r\n        components.push(comp);\r\n        i++;\r\n      }\r\n      this._trackBox.setDisplayObjectIndexMapById(doMap);\r\n    }\r\n  }\r\n\r\n  private updateOffsetsByAllignment() {\r\n    const alignment = this._$actualAlignment.getValue(), items = this._$actualItems.getValue(), trackBy = this.trackBy,\r\n      isInfinity = this.isInfinity, isVertical = this._isVertical,\r\n      { width, height } = this._$bounds.getValue() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE },\r\n      viewportSize = isVertical ? height : width,\r\n      precalculatedScrollStartOffset = this._$precalculatedScrollStartOffset.getValue(),\r\n      precalculatedScrollEndOffset = this._$precalculatedScrollEndOffset.getValue();\r\n    switch (alignment) {\r\n      case Alignments.NONE: {\r\n        this._$actualScrollStartOffset.next(precalculatedScrollStartOffset);\r\n        this._$actualScrollEndOffset.next(precalculatedScrollEndOffset);\r\n        break;\r\n      }\r\n      case Alignments.CENTER: {\r\n        const firstItemId: Id | null = items.length > 0 ? (items[0]?.[trackBy] ?? null) : null,\r\n          endItemId: Id | null = items.length > 0 ? (items?.[items.length - 1]?.[trackBy] ?? null) : null,\r\n          alignmentStartOffset = viewportSize * .5 - (firstItemId !== null ? (isVertical ? (this._service.getItemBounds(firstItemId)?.height ?? 0) :\r\n            (this._service.getItemBounds(firstItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5),\r\n          alignmentEndOffset = viewportSize * .5 - (endItemId !== null ? (isVertical ? (this._service.getItemBounds(endItemId)?.height ?? 0) :\r\n            (this._service.getItemBounds(endItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5);\r\n\r\n        this._$alignmentScrollStartOffset.next(alignmentStartOffset);\r\n        this._$alignmentScrollEndOffset.next(alignmentEndOffset);\r\n        this._$actualScrollStartOffset.next(precalculatedScrollStartOffset + alignmentStartOffset);\r\n        this._$actualScrollEndOffset.next(precalculatedScrollEndOffset + alignmentEndOffset);\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private updateRegularRenderer() {\r\n    this._resizeSnappedComponentHandler();\r\n  }\r\n\r\n  /**\r\n   * Tracking by id\r\n   */\r\n  private tracking() {\r\n    this._trackBox.track();\r\n  }\r\n\r\n  private resetBoundsSize(isVertical: boolean, totalSize: number) {\r\n    const l = this._$list.getValue(), prop = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME,\r\n      size = totalSize;\r\n    if (!!l && parseInt(l.nativeElement.style[prop]) !== size) {\r\n      l.nativeElement.style[prop] = `${size}${PX}`;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Returns the bounds of an element with a given id\r\n   */\r\n  getItemBounds(id: Id): ISize | null {\r\n    return this._service.getItemBounds(id);\r\n  }\r\n\r\n  /**\r\n   * Focus an list item by a given id.\r\n   */\r\n  focus(id: Id, align: FocusAlignment = FocusAlignments.NONE) {\r\n    this._elementRef.nativeElement.focus();\r\n    this._service.focusById(id, align, this.scrollBehavior);\r\n  }\r\n\r\n  /**\r\n   * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.\r\n   */\r\n  scrollTo(id: Id, cb: (() => void) | null = null, options: IScrollOptions | null = null) {\r\n    const behavior = options?.behavior ?? BEHAVIOR_INSTANT,\r\n      blending = options?.blending ?? false,\r\n      focused = options?.focused ?? true,\r\n      delay = options?.delay ?? 0,\r\n      iteration = options?.iteration ?? 0;\r\n    validateId(id);\r\n    validateScrollBehavior(behavior);\r\n    validateIteration(iteration);\r\n    const actualIteration = validateScrollIteration(iteration);\r\n    this._elementRef.nativeElement.focus();\r\n    if (!this._scrollerComponent?.scrollable && !this.isInfinity) {\r\n      this.scrollToFinalize(id, focused, cb);\r\n      return;\r\n    }\r\n    this._$scrollTo.next({\r\n      id, behavior, blending, delay, iteration: actualIteration, isLastIteration: actualIteration === MAX_SCROLL_TO_ITERATIONS, cb: () => {\r\n        this.scrollToFinalize(id, focused, cb);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Scrolls the scroll area to the first item in the collection.\r\n   */\r\n  scrollToStart(cb: (() => void) | null = null, options: IScrollOptions | null = null) {\r\n    const scroller = this._scrollerComponent;\r\n    if (!!scroller) {\r\n      const scrollSize = this.isVertical ? scroller.scrollTop : scroller.scrollLeft;\r\n      if (scrollSize === 0) {\r\n        return;\r\n      }\r\n      scroller.stopScrolling();\r\n    }\r\n    const behavior = options?.behavior ?? BEHAVIOR_INSTANT,\r\n      blending = options?.blending ?? false,\r\n      focused = options?.focused ?? true,\r\n      delay = options?.delay ?? 0,\r\n      iteration = options?.iteration ?? 0;\r\n    validateScrollBehavior(behavior);\r\n    validateIteration(iteration);\r\n    const trackBy = this.trackBy, items = this._$actualItems.getValue(), firstItem = items.length > 0 ? items[0] ?? null : null, id = firstItem?.[trackBy] ?? null,\r\n      actualIteration = validateScrollIteration(iteration);\r\n    if (!!firstItem) {\r\n      this._elementRef.nativeElement.focus();\r\n      this._$scrollTo.next({\r\n        id, behavior, blending, delay, iteration: actualIteration, isLastIteration: actualIteration === MAX_SCROLL_TO_ITERATIONS, cb: () => {\r\n          this._$isScrollStart.next(true);\r\n          this._trackBox.isScrollStart = true;\r\n          this._trackBox.isScrollEnd = false;\r\n          this._$fireUpdate.next(true);\r\n          this.scrollToFinalize(id, focused, cb);\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @deprecated\r\n   * The scrollToEndItem method is deprecated. Use the scrollToEnd method.\r\n   */\r\n  scrollToEndItem(cb?: () => void, options?: IScrollOptions) {\r\n    throw Error('The scrollToEndItem method is deprecated. Use the scrollToEnd method.');\r\n  }\r\n\r\n  /**\r\n   * Scrolls the list to the end of the content size.\r\n   */\r\n  scrollToEnd(cb: (() => void) | null = null, options: IScrollOptions | null = null) {\r\n    const scroller = this._scrollerComponent;\r\n    if (!!scroller) {\r\n      const isVertical = this.isVertical,\r\n        scrollSize = isVertical ? scroller.scrollTop : scroller.scrollLeft,\r\n        maxScrollSize = isVertical ? scroller.scrollHeight : scroller.scrollTop;\r\n      if (scrollSize === maxScrollSize) {\r\n        return;\r\n      }\r\n      scroller.stopScrolling();\r\n    }\r\n    const behavior = options?.behavior ?? BEHAVIOR_INSTANT,\r\n      blending = options?.blending ?? false,\r\n      focused = options?.focused ?? true,\r\n      delay = options?.delay ?? 0,\r\n      iteration = options?.iteration ?? 0;\r\n    validateScrollBehavior(behavior);\r\n    validateIteration(iteration);\r\n    const trackBy = this.trackBy, items = this._$actualItems.getValue(), latItem = items[items.length > 0 ? items.length - 1 : 0], id = latItem?.[trackBy] ?? null,\r\n      actualIteration = validateScrollIteration(iteration);\r\n    if (latItem === null) {\r\n      return;\r\n    }\r\n    this._elementRef.nativeElement.focus();\r\n    if (!this._scrollerComponent?.scrollable) {\r\n      this.scrollToFinalize(id, focused, cb);\r\n      return;\r\n    }\r\n    this._$scrollTo.next({\r\n      id, behavior, blending, delay, iteration: actualIteration, isLastIteration: actualIteration === MAX_SCROLL_TO_ITERATIONS, cb: () => {\r\n        this._$isScrollEnd.next(true);\r\n        this._trackBox.isScrollStart = false;\r\n        this._trackBox.isScrollEnd = true;\r\n        this._$fireUpdate.next(true);\r\n        this.scrollToFinalize(id, focused, cb);\r\n      }\r\n    });\r\n  }\r\n\r\n  private scrollToFinalize(id: Id, focused: boolean, cb: (() => void) | null) {\r\n    if (focused) {\r\n      const el = this._service.getFocusedElementById(id);\r\n      if (!!el) {\r\n        this._service.focus(el, FocusAlignments.NONE);\r\n      }\r\n    }\r\n    if (typeof cb === 'function') {\r\n      cb?.();\r\n    }\r\n  }\r\n\r\n  protected cleanup() {\r\n    const displayItems: IRenderVirtualListCollection = [];\r\n    this._service.collection = displayItems;\r\n    this.createDisplayComponentsIfNeed(displayItems);\r\n    this.tracking();\r\n    this.emitScrollEvent(true, false, false);\r\n  }\r\n\r\n  /**\r\n   * Force clearing the cache.\r\n   */\r\n  protected cacheClean() {\r\n    this._cached = false;\r\n    if (this.dynamicSize) {\r\n      this._trackBox.cacheClean();\r\n    }\r\n    const prerenderContainer = this._prerender;\r\n    if (!!prerenderContainer) {\r\n      prerenderContainer.clear();\r\n      prerenderContainer.off();\r\n    }\r\n    this._$collapsedItemIds.next([]);\r\n    this._$isScrollStart.next(true);\r\n    this._$isScrollEnd.next(false);\r\n    this._$totalSize.next(0);\r\n    this._$scrollSize.next(0);\r\n    const scroller = this._scrollerComponent;\r\n    if (!!scroller) {\r\n      scroller.reset();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @deprecated\r\n   * The stopSnappingScrollToEnd method is deprecated. Use the preventSnapping method.\r\n   */\r\n  stopSnappingScrollToEnd() {\r\n    throw Error('The stopSnappingScrollToEnd method is deprecated. Use the preventSnapping method.');\r\n  }\r\n\r\n  /**\r\n   * Prevents the list from snapping to its start or end edge.\r\n   */\r\n  preventSnapping() {\r\n    if (!this._readyForShow) {\r\n      return;\r\n    }\r\n    const scroller = this._scrollerComponent;\r\n    this._$isScrollStart.next(false);\r\n    this._$isScrollEnd.next(false);\r\n    this._trackBox.preventScrollSnapping(true);\r\n    if (scroller) {\r\n      scroller.stopScrolling();\r\n    }\r\n  }\r\n\r\n  override ngOnDestroy(): void {\r\n    super.ngOnDestroy();\r\n    this.dispose();\r\n  }\r\n\r\n  private dispose() {\r\n    this._$destroy.next();\r\n\r\n    const updateId = this._updateId;\r\n    if (updateId !== undefined) {\r\n      cancelAnimationFrame(updateId);\r\n      this._updateId = undefined;\r\n    }\r\n\r\n    if (this._service) {\r\n      this._service.dispose();\r\n    }\r\n\r\n    if (!!this._trackBox) {\r\n      this._trackBox.dispose();\r\n    }\r\n\r\n    if (!!this._resizeSnappedObserver) {\r\n      this._resizeSnappedObserver.disconnect();\r\n    }\r\n\r\n    if (!!this._snappedDisplayComponents) {\r\n      while (this._snappedDisplayComponents.length > 0) {\r\n        const comp = this._snappedDisplayComponents.shift();\r\n        comp?.destroy();\r\n      }\r\n    }\r\n\r\n    if (this._displayComponents) {\r\n      while (this._displayComponents.length > 0) {\r\n        const comp = this._displayComponents.shift();\r\n        comp?.destroy();\r\n      }\r\n    }\r\n  }\r\n}\r\n","<div aria-live=\"polite\" aria-atomic=\"true\" class=\"ngvl__screen-reader\">\r\n  {{ $screenReaderFormattedMessage | async }}\r\n</div>\r\n\r\n<ng-prerender-container #prerender [bounds]=\"($bounds | async)!\" [direction]=\"($direction | async)!\"\r\n  [dynamic]=\"($dynamicSize | async)!\" [divides]=\"($divides | async)!\" [isVertical]=\"($isVertical | async)!\"\r\n  [itemSize]=\"($actualItemSize | async)!\" [trackBy]=\"($trackBy | async)!\" [itemRenderer]=\"($itemRenderer | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\"\r\n  [scrollbarEnabled]=\"(scroller.$scrollbarShow | async)!\"\r\n  [enabled]=\"($prerenderEnabled | async)!\"></ng-prerender-container>\r\n\r\n<ng-container *ngIf=\"($stickyEnabled | async)!\">\r\n  <div localeSensitive [langTextDir]=\"($langTextDir | async)!\" #snappedContainer class=\"ngvl__snapped-container\"\r\n    [ngClass]=\"($classes | async)\">\r\n    <div #snapped part=\"snapped-item\" class=\"ngvl__list-snapper\">\r\n      <ng-container #snapRendererContainer></ng-container>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n\r\n<ng-scroller #scroller class=\"ngvl__list-scroller\" [classes]=\"($classes | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\"\r\n  [alignmentStartOffset]=\"($alignmentScrollStartOffset | async)!\"\r\n  [alignmentEndOffset]=\"($alignmentScrollEndOffset | async)!\" [direction]=\"($direction | async)!\"\r\n  [scrollbarThumbRenderer]=\"($scrollbarThumbRenderer | async)!\" [isInfinity]=\"($isInfinity | async)!\"\r\n  [scrollbarThickness]=\"($scrollbarThickness | async)!\" [scrollbarThumbParams]=\"($scrollbarThumbParams | async)!\"\r\n  [animationParams]=\"($animationParams | async)!\" [focusedElement]=\"($focusedElement | async)!\"\r\n  [loading]=\"($loading | async)!\" [overscrollEnabled]=\"($overscrollEnabled | async)!\"\r\n  [snappingDistance]=\"($snappingDistance | async)!\" [overlappingScrollbar]=\"($overlappingScrollbar | async)!\"\r\n  [scrollbarEnabled]=\"($actualScrollbarEnabled | async)!\" [scrollbarInteractive]=\"($scrollbarInteractive | async)!\"\r\n  [snapToItem]=\"($snapToItem | async)!\" [snapToItemAlign]=\"($snapToItemAlign | async)!\"\r\n  [scrollbarMinSize]=\"($scrollbarMinSize | async)!\" [scrollBehavior]=\"($scrollBehavior | async)!\"\r\n  [scrollingSettings]=\"($scrollingSettings | async)!\" [scrollingOneByOne]=\"($scrollingOneByOne | async)!\"\r\n  [motionBlur]=\"($motionBlur | async)!\" [maxMotionBlur]=\"($maxMotionBlur | async)!\"\r\n  [motionBlurEnabled]=\"($motionBlurEnabled | async)!\">\r\n  <ng-container #renderersContainer></ng-container>\r\n</ng-scroller>"]}