angular-multiselect3 10.0.0

package/esm2022/lib/virtual-scroll/virtual-scroll.mjs

@@ -0,0 +1,1162 @@
+import { Component, ContentChild, ElementRef, EventEmitter, Inject, Optional, Input, NgModule, Output, ViewChild, } from '@angular/core';
+import { PLATFORM_ID } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as tween from '@tweenjs/tween.js';
+import * as i0 from "@angular/core";
+export function VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY() {
+    return {
+        scrollThrottlingTime: 0,
+        scrollDebounceTime: 0,
+        scrollAnimationTime: 750,
+        checkResizeInterval: 1000,
+        resizeBypassRefreshThreshold: 5,
+        modifyOverflowStyleOfParentScroll: true,
+        stripedTable: false,
+    };
+}
+export class VirtualScrollerComponent {
+    element;
+    renderer;
+    zone;
+    changeDetectorRef;
+    viewPortItems;
+    window = window;
+    get viewPortInfo() {
+        let pageInfo = this.previousViewPort || {};
+        return {
+            startIndex: pageInfo.startIndex || 0,
+            endIndex: pageInfo.endIndex || 0,
+            scrollStartPosition: pageInfo.scrollStartPosition || 0,
+            scrollEndPosition: pageInfo.scrollEndPosition || 0,
+            maxScrollPosition: pageInfo.maxScrollPosition || 0,
+            startIndexWithBuffer: pageInfo.startIndexWithBuffer || 0,
+            endIndexWithBuffer: pageInfo.endIndexWithBuffer || 0,
+        };
+    }
+    executeRefreshOutsideAngularZone = false;
+    _enableUnequalChildrenSizes = false;
+    get enableUnequalChildrenSizes() {
+        return this._enableUnequalChildrenSizes;
+    }
+    set enableUnequalChildrenSizes(value) {
+        if (this._enableUnequalChildrenSizes === value) {
+            return;
+        }
+        this._enableUnequalChildrenSizes = value;
+        this.minMeasuredChildWidth = undefined;
+        this.minMeasuredChildHeight = undefined;
+    }
+    useMarginInsteadOfTranslate = false;
+    modifyOverflowStyleOfParentScroll;
+    stripedTable;
+    scrollbarWidth;
+    scrollbarHeight;
+    childWidth;
+    childHeight;
+    ssrChildWidth;
+    ssrChildHeight;
+    ssrViewportWidth = 1920;
+    ssrViewportHeight = 1080;
+    _bufferAmount = 0;
+    get bufferAmount() {
+        if (typeof this._bufferAmount === 'number' && this._bufferAmount >= 0) {
+            return this._bufferAmount;
+        }
+        else {
+            return this.enableUnequalChildrenSizes ? 5 : 0;
+        }
+    }
+    set bufferAmount(value) {
+        this._bufferAmount = value;
+    }
+    scrollAnimationTime;
+    resizeBypassRefreshThreshold;
+    _scrollThrottlingTime;
+    get scrollThrottlingTime() {
+        return this._scrollThrottlingTime;
+    }
+    set scrollThrottlingTime(value) {
+        this._scrollThrottlingTime = value;
+        this.updateOnScrollFunction();
+    }
+    _scrollDebounceTime;
+    get scrollDebounceTime() {
+        return this._scrollDebounceTime;
+    }
+    set scrollDebounceTime(value) {
+        this._scrollDebounceTime = value;
+        this.updateOnScrollFunction();
+    }
+    onScroll;
+    updateOnScrollFunction() {
+        if (this.scrollDebounceTime) {
+            this.onScroll = this.debounce(() => {
+                this.refresh_internal(false);
+            }, this.scrollDebounceTime);
+        }
+        else if (this.scrollThrottlingTime) {
+            this.onScroll = this.throttleTrailing(() => {
+                this.refresh_internal(false);
+            }, this.scrollThrottlingTime);
+        }
+        else {
+            this.onScroll = () => {
+                this.refresh_internal(false);
+            };
+        }
+    }
+    checkScrollElementResizedTimer;
+    _checkResizeInterval;
+    get checkResizeInterval() {
+        return this._checkResizeInterval;
+    }
+    set checkResizeInterval(value) {
+        if (this._checkResizeInterval === value) {
+            return;
+        }
+        this._checkResizeInterval = value;
+        this.addScrollEventHandlers();
+    }
+    _items = [];
+    get items() {
+        return this._items;
+    }
+    set items(value) {
+        if (value === this._items) {
+            return;
+        }
+        this._items = value || [];
+        this.refresh_internal(true);
+    }
+    compareItems = (item1, item2) => item1 === item2;
+    _horizontal;
+    get horizontal() {
+        return this._horizontal;
+    }
+    set horizontal(value) {
+        this._horizontal = value;
+        this.updateDirection();
+    }
+    revertParentOverscroll() {
+        const scrollElement = this.getScrollElement();
+        if (scrollElement && this.oldParentScrollOverflow) {
+            scrollElement.style['overflow-y'] = this.oldParentScrollOverflow.y;
+            scrollElement.style['overflow-x'] = this.oldParentScrollOverflow.x;
+        }
+        this.oldParentScrollOverflow = undefined;
+    }
+    oldParentScrollOverflow;
+    _parentScroll;
+    get parentScroll() {
+        return this._parentScroll;
+    }
+    set parentScroll(value) {
+        if (this._parentScroll === value) {
+            return;
+        }
+        this.revertParentOverscroll();
+        this._parentScroll = value;
+        this.addScrollEventHandlers();
+        const scrollElement = this.getScrollElement();
+        if (this.modifyOverflowStyleOfParentScroll &&
+            scrollElement !== this.element.nativeElement) {
+            this.oldParentScrollOverflow = {
+                x: scrollElement.style['overflow-x'],
+                y: scrollElement.style['overflow-y'],
+            };
+            scrollElement.style['overflow-y'] = this.horizontal ? 'visible' : 'auto';
+            scrollElement.style['overflow-x'] = this.horizontal ? 'auto' : 'visible';
+        }
+    }
+    vsUpdate = new EventEmitter();
+    vsChange = new EventEmitter();
+    vsStart = new EventEmitter();
+    vsEnd = new EventEmitter();
+    contentElementRef;
+    invisiblePaddingElementRef;
+    headerElementRef;
+    containerElementRef;
+    ngOnInit() {
+        this.addScrollEventHandlers();
+    }
+    ngOnDestroy() {
+        this.removeScrollEventHandlers();
+        this.revertParentOverscroll();
+    }
+    ngOnChanges(changes) {
+        let indexLengthChanged = this.cachedItemsLength !== this.items.length;
+        this.cachedItemsLength = this.items.length;
+        const firstRun = !changes.items ||
+            !changes.items.previousValue ||
+            changes.items.previousValue.length === 0;
+        this.refresh_internal(indexLengthChanged || firstRun);
+    }
+    ngDoCheck() {
+        if (this.cachedItemsLength !== this.items.length) {
+            this.cachedItemsLength = this.items.length;
+            this.refresh_internal(true);
+            return;
+        }
+        if (this.previousViewPort &&
+            this.viewPortItems &&
+            this.viewPortItems.length > 0) {
+            let itemsArrayChanged = false;
+            for (let i = 0; i < this.viewPortItems.length; ++i) {
+                if (!this.compareItems(this.items[this.previousViewPort.startIndexWithBuffer + i], this.viewPortItems[i])) {
+                    itemsArrayChanged = true;
+                    break;
+                }
+            }
+            if (itemsArrayChanged) {
+                this.refresh_internal(true);
+            }
+        }
+    }
+    refresh() {
+        this.refresh_internal(true);
+    }
+    invalidateAllCachedMeasurements() {
+        this.wrapGroupDimensions = {
+            maxChildSizePerWrapGroup: [],
+            numberOfKnownWrapGroupChildSizes: 0,
+            sumOfKnownWrapGroupChildWidths: 0,
+            sumOfKnownWrapGroupChildHeights: 0,
+        };
+        this.minMeasuredChildWidth = undefined;
+        this.minMeasuredChildHeight = undefined;
+        this.refresh_internal(false);
+    }
+    invalidateCachedMeasurementForItem(item) {
+        if (this.enableUnequalChildrenSizes) {
+            let index = this.items && this.items.indexOf(item);
+            if (index >= 0) {
+                this.invalidateCachedMeasurementAtIndex(index);
+            }
+        }
+        else {
+            this.minMeasuredChildWidth = undefined;
+            this.minMeasuredChildHeight = undefined;
+        }
+        this.refresh_internal(false);
+    }
+    invalidateCachedMeasurementAtIndex(index) {
+        if (this.enableUnequalChildrenSizes) {
+            let cachedMeasurement = this.wrapGroupDimensions.maxChildSizePerWrapGroup[index];
+            if (cachedMeasurement) {
+                this.wrapGroupDimensions.maxChildSizePerWrapGroup[index] = undefined;
+                --this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -=
+                    cachedMeasurement.childWidth || 0;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -=
+                    cachedMeasurement.childHeight || 0;
+            }
+        }
+        else {
+            this.minMeasuredChildWidth = undefined;
+            this.minMeasuredChildHeight = undefined;
+        }
+        this.refresh_internal(false);
+    }
+    scrollInto(item, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        let index = this.items.indexOf(item);
+        if (index === -1) {
+            return;
+        }
+        this.scrollToIndex(index, alignToBeginning, additionalOffset, animationMilliseconds, animationCompletedCallback);
+    }
+    scrollToIndex(index, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        let maxRetries = 5;
+        let retryIfNeeded = () => {
+            --maxRetries;
+            if (maxRetries <= 0) {
+                if (animationCompletedCallback) {
+                    animationCompletedCallback();
+                }
+                return;
+            }
+            let dimensions = this.calculateDimensions();
+            let desiredStartIndex = Math.min(Math.max(index, 0), dimensions.itemCount - 1);
+            if (this.previousViewPort.startIndex === desiredStartIndex) {
+                if (animationCompletedCallback) {
+                    animationCompletedCallback();
+                }
+                return;
+            }
+            this.scrollToIndex_internal(index, alignToBeginning, additionalOffset, 0, retryIfNeeded);
+        };
+        this.scrollToIndex_internal(index, alignToBeginning, additionalOffset, animationMilliseconds, retryIfNeeded);
+    }
+    scrollToIndex_internal(index, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        animationMilliseconds =
+            animationMilliseconds === undefined
+                ? this.scrollAnimationTime
+                : animationMilliseconds;
+        let dimensions = this.calculateDimensions();
+        let scroll = this.calculatePadding(index, dimensions) + additionalOffset;
+        if (!alignToBeginning) {
+            scroll -= dimensions.wrapGroupsPerPage * dimensions[this._childScrollDim];
+        }
+        this.scrollToPosition(scroll, animationMilliseconds, animationCompletedCallback);
+    }
+    scrollToPosition(scrollPosition, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        scrollPosition += this.getElementsOffset();
+        animationMilliseconds =
+            animationMilliseconds === undefined
+                ? this.scrollAnimationTime
+                : animationMilliseconds;
+        let scrollElement = this.getScrollElement();
+        let animationRequest;
+        if (this.currentTween) {
+            this.currentTween.stop();
+            this.currentTween = undefined;
+        }
+        if (!animationMilliseconds) {
+            this.renderer.setProperty(scrollElement, this._scrollType, scrollPosition);
+            this.refresh_internal(false, animationCompletedCallback);
+            return;
+        }
+        const tweenConfigObj = { scrollPosition: scrollElement[this._scrollType] };
+        let newTween = new tween.Tween(tweenConfigObj)
+            .to({ scrollPosition }, animationMilliseconds)
+            .easing(tween.Easing.Quadratic.Out)
+            .onUpdate((data) => {
+            if (isNaN(data.scrollPosition)) {
+                return;
+            }
+            this.renderer.setProperty(scrollElement, this._scrollType, data.scrollPosition);
+            this.refresh_internal(false);
+        })
+            .onStop(() => {
+            cancelAnimationFrame(animationRequest);
+        })
+            .start();
+        const animate = (time) => {
+            if (!newTween['isPlaying']()) {
+                return;
+            }
+            newTween.update(time);
+            if (tweenConfigObj.scrollPosition === scrollPosition) {
+                this.refresh_internal(false, animationCompletedCallback);
+                return;
+            }
+            this.zone.runOutsideAngular(() => {
+                animationRequest = requestAnimationFrame(animate);
+            });
+        };
+        animate();
+        this.currentTween = newTween;
+    }
+    isAngularUniversalSSR;
+    constructor(element, renderer, zone, changeDetectorRef, platformId, options) {
+        this.element = element;
+        this.renderer = renderer;
+        this.zone = zone;
+        this.changeDetectorRef = changeDetectorRef;
+        this.isAngularUniversalSSR = isPlatformServer(platformId);
+        this.scrollThrottlingTime = options.scrollThrottlingTime;
+        this.scrollDebounceTime = options.scrollDebounceTime;
+        this.scrollAnimationTime = options.scrollAnimationTime;
+        this.scrollbarWidth = options.scrollbarWidth;
+        this.scrollbarHeight = options.scrollbarHeight;
+        this.checkResizeInterval = options.checkResizeInterval;
+        this.resizeBypassRefreshThreshold = options.resizeBypassRefreshThreshold;
+        this.modifyOverflowStyleOfParentScroll =
+            options.modifyOverflowStyleOfParentScroll;
+        this.stripedTable = options.stripedTable;
+        this.horizontal = false;
+        this.resetWrapGroupDimensions();
+    }
+    getElementSize(element) {
+        let result = element.getBoundingClientRect();
+        let styles = getComputedStyle(element);
+        let marginTop = parseInt(styles['margin-top'], 10) || 0;
+        let marginBottom = parseInt(styles['margin-bottom'], 10) || 0;
+        let marginLeft = parseInt(styles['margin-left'], 10) || 0;
+        let marginRight = parseInt(styles['margin-right'], 10) || 0;
+        return {
+            top: result.top + marginTop,
+            bottom: result.bottom + marginBottom,
+            left: result.left + marginLeft,
+            right: result.right + marginRight,
+            width: result.width + marginLeft + marginRight,
+            height: result.height + marginTop + marginBottom,
+            y: result.top + marginTop,
+            x: result.left + marginLeft,
+            toJSON() {
+                result.toJSON();
+            },
+        };
+    }
+    previousScrollBoundingRect;
+    checkScrollElementResized() {
+        let boundingRect = this.getElementSize(this.getScrollElement());
+        let sizeChanged;
+        if (!this.previousScrollBoundingRect) {
+            sizeChanged = true;
+        }
+        else {
+            let widthChange = Math.abs(boundingRect.width - this.previousScrollBoundingRect.width);
+            let heightChange = Math.abs(boundingRect.height - this.previousScrollBoundingRect.height);
+            sizeChanged =
+                widthChange > this.resizeBypassRefreshThreshold ||
+                    heightChange > this.resizeBypassRefreshThreshold;
+        }
+        if (sizeChanged) {
+            this.previousScrollBoundingRect = boundingRect;
+            if (boundingRect.width > 0 && boundingRect.height > 0) {
+                this.refresh_internal(false);
+            }
+        }
+    }
+    _invisiblePaddingProperty;
+    _offsetType;
+    _scrollType;
+    _pageOffsetType;
+    _childScrollDim;
+    _translateDir;
+    _marginDir;
+    updateDirection() {
+        if (this.horizontal) {
+            this._invisiblePaddingProperty = 'width';
+            this._offsetType = 'offsetLeft';
+            this._pageOffsetType = 'pageXOffset';
+            this._childScrollDim = 'childWidth';
+            this._marginDir = 'margin-left';
+            this._translateDir = 'translateX';
+            this._scrollType = 'scrollLeft';
+        }
+        else {
+            this._invisiblePaddingProperty = 'height';
+            this._offsetType = 'offsetTop';
+            this._pageOffsetType = 'pageYOffset';
+            this._childScrollDim = 'childHeight';
+            this._marginDir = 'margin-top';
+            this._translateDir = 'translateY';
+            this._scrollType = 'scrollTop';
+        }
+    }
+    debounce(func, wait) {
+        const throttled = this.throttleTrailing(func, wait);
+        const result = function () {
+            throttled['cancel']();
+            throttled.apply(this, arguments);
+        };
+        result['cancel'] = function () {
+            throttled['cancel']();
+        };
+        return result;
+    }
+    throttleTrailing(func, wait) {
+        let timeout = undefined;
+        let _arguments = arguments;
+        const result = function () {
+            const _this = this;
+            _arguments = arguments;
+            if (timeout) {
+                return;
+            }
+            if (wait <= 0) {
+                func.apply(_this, _arguments);
+            }
+            else {
+                timeout = setTimeout(function () {
+                    timeout = undefined;
+                    func.apply(_this, _arguments);
+                }, wait);
+            }
+        };
+        result['cancel'] = function () {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+        };
+        return result;
+    }
+    calculatedScrollbarWidth = 0;
+    calculatedScrollbarHeight = 0;
+    padding = 0;
+    previousViewPort = {};
+    currentTween;
+    cachedItemsLength;
+    disposeScrollHandler;
+    disposeResizeHandler;
+    refresh_internal(itemsArrayModified, refreshCompletedCallback = undefined, maxRunTimes = 2) {
+        //note: maxRunTimes is to force it to keep recalculating if the previous iteration caused a re-render (different sliced items in viewport or scrollPosition changed).
+        //The default of 2x max will probably be accurate enough without causing too large a performance bottleneck
+        //The code would typically quit out on the 2nd iteration anyways. The main time it'd think more than 2 runs would be necessary would be for vastly different sized child items or if this is the 1st time the items array was initialized.
+        //Without maxRunTimes, If the user is actively scrolling this code would become an infinite loop until they stopped scrolling. This would be okay, except each scroll event would start an additional infinte loop. We want to short-circuit it to prevent this.
+        if (itemsArrayModified &&
+            this.previousViewPort &&
+            this.previousViewPort.scrollStartPosition > 0) {
+            //if items were prepended, scroll forward to keep same items visible
+            let oldViewPort = this.previousViewPort;
+            let oldViewPortItems = this.viewPortItems;
+            let oldRefreshCompletedCallback = refreshCompletedCallback;
+            refreshCompletedCallback = () => {
+                let scrollLengthDelta = this.previousViewPort.scrollLength - oldViewPort.scrollLength;
+                if (scrollLengthDelta > 0 && this.viewPortItems) {
+                    let oldStartItem = oldViewPortItems[0];
+                    let oldStartItemIndex = this.items.findIndex((x) => this.compareItems(oldStartItem, x));
+                    if (oldStartItemIndex > this.previousViewPort.startIndexWithBuffer) {
+                        let itemOrderChanged = false;
+                        for (let i = 1; i < this.viewPortItems.length; ++i) {
+                            if (!this.compareItems(this.items[oldStartItemIndex + i], oldViewPortItems[i])) {
+                                itemOrderChanged = true;
+                                break;
+                            }
+                        }
+                        if (!itemOrderChanged) {
+                            this.scrollToPosition(this.previousViewPort.scrollStartPosition + scrollLengthDelta, 0, oldRefreshCompletedCallback);
+                            return;
+                        }
+                    }
+                }
+                if (oldRefreshCompletedCallback) {
+                    oldRefreshCompletedCallback();
+                }
+            };
+        }
+        this.zone.runOutsideAngular(() => {
+            requestAnimationFrame(() => {
+                if (itemsArrayModified) {
+                    this.resetWrapGroupDimensions();
+                }
+                let viewport = this.calculateViewport();
+                let startChanged = itemsArrayModified ||
+                    viewport.startIndex !== this.previousViewPort.startIndex;
+                let endChanged = itemsArrayModified ||
+                    viewport.endIndex !== this.previousViewPort.endIndex;
+                let scrollLengthChanged = viewport.scrollLength !== this.previousViewPort.scrollLength;
+                let paddingChanged = viewport.padding !== this.previousViewPort.padding;
+                let scrollPositionChanged = viewport.scrollStartPosition !==
+                    this.previousViewPort.scrollStartPosition ||
+                    viewport.scrollEndPosition !==
+                        this.previousViewPort.scrollEndPosition ||
+                    viewport.maxScrollPosition !==
+                        this.previousViewPort.maxScrollPosition;
+                this.previousViewPort = viewport;
+                if (scrollLengthChanged) {
+                    this.renderer.setStyle(this.invisiblePaddingElementRef.nativeElement, this._invisiblePaddingProperty, `${viewport.scrollLength}px`);
+                }
+                if (paddingChanged) {
+                    if (this.useMarginInsteadOfTranslate) {
+                        this.renderer.setStyle(this.contentElementRef.nativeElement, this._marginDir, `${viewport.padding}px`);
+                    }
+                    else {
+                        this.renderer.setStyle(this.contentElementRef.nativeElement, 'transform', `${this._translateDir}(${viewport.padding}px)`);
+                        this.renderer.setStyle(this.contentElementRef.nativeElement, 'webkitTransform', `${this._translateDir}(${viewport.padding}px)`);
+                    }
+                }
+                if (this.headerElementRef) {
+                    let scrollPosition = this.getScrollElement()[this._scrollType];
+                    let containerOffset = this.getElementsOffset();
+                    let offset = Math.max(scrollPosition -
+                        viewport.padding -
+                        containerOffset +
+                        this.headerElementRef.nativeElement.clientHeight, 0);
+                    this.renderer.setStyle(this.headerElementRef.nativeElement, 'transform', `${this._translateDir}(${offset}px)`);
+                    this.renderer.setStyle(this.headerElementRef.nativeElement, 'webkitTransform', `${this._translateDir}(${offset}px)`);
+                }
+                const changeEventArg = startChanged || endChanged
+                    ? {
+                        startIndex: viewport.startIndex,
+                        endIndex: viewport.endIndex,
+                        scrollStartPosition: viewport.scrollStartPosition,
+                        scrollEndPosition: viewport.scrollEndPosition,
+                        startIndexWithBuffer: viewport.startIndexWithBuffer,
+                        endIndexWithBuffer: viewport.endIndexWithBuffer,
+                        maxScrollPosition: viewport.maxScrollPosition,
+                    }
+                    : undefined;
+                if (startChanged || endChanged || scrollPositionChanged) {
+                    const handleChanged = () => {
+                        // update the scroll list to trigger re-render of components in viewport
+                        this.viewPortItems =
+                            viewport.startIndexWithBuffer >= 0 &&
+                                viewport.endIndexWithBuffer >= 0
+                                ? this.items.slice(viewport.startIndexWithBuffer, viewport.endIndexWithBuffer + 1)
+                                : [];
+                        this.vsUpdate.emit(this.viewPortItems);
+                        if (startChanged) {
+                            this.vsStart.emit(changeEventArg);
+                        }
+                        if (endChanged) {
+                            this.vsEnd.emit(changeEventArg);
+                        }
+                        if (startChanged || endChanged) {
+                            this.changeDetectorRef.markForCheck();
+                            this.vsChange.emit(changeEventArg);
+                        }
+                        if (maxRunTimes > 0) {
+                            this.refresh_internal(false, refreshCompletedCallback, maxRunTimes - 1);
+                            return;
+                        }
+                        if (refreshCompletedCallback) {
+                            refreshCompletedCallback();
+                        }
+                    };
+                    if (this.executeRefreshOutsideAngularZone) {
+                        handleChanged();
+                    }
+                    else {
+                        this.zone.run(handleChanged);
+                    }
+                }
+                else {
+                    if (maxRunTimes > 0 && (scrollLengthChanged || paddingChanged)) {
+                        this.refresh_internal(false, refreshCompletedCallback, maxRunTimes - 1);
+                        return;
+                    }
+                    if (refreshCompletedCallback) {
+                        refreshCompletedCallback();
+                    }
+                }
+            });
+        });
+    }
+    getScrollElement() {
+        return this.parentScroll instanceof Window
+            ? document.scrollingElement || document.documentElement || document.body
+            : this.parentScroll || this.element.nativeElement;
+    }
+    addScrollEventHandlers() {
+        if (this.isAngularUniversalSSR) {
+            return;
+        }
+        let scrollElement = this.getScrollElement();
+        this.removeScrollEventHandlers();
+        this.zone.runOutsideAngular(() => {
+            if (this.parentScroll instanceof Window) {
+                this.disposeScrollHandler = this.renderer.listen('window', 'scroll', this.onScroll);
+                this.disposeResizeHandler = this.renderer.listen('window', 'resize', this.onScroll);
+            }
+            else {
+                this.disposeScrollHandler = this.renderer.listen(scrollElement, 'scroll', this.onScroll);
+                if (this._checkResizeInterval > 0) {
+                    this.checkScrollElementResizedTimer = setInterval(() => {
+                        this.checkScrollElementResized();
+                    }, this._checkResizeInterval);
+                }
+            }
+        });
+    }
+    removeScrollEventHandlers() {
+        if (this.checkScrollElementResizedTimer) {
+            clearInterval(this.checkScrollElementResizedTimer);
+        }
+        if (this.disposeScrollHandler) {
+            this.disposeScrollHandler();
+            this.disposeScrollHandler = undefined;
+        }
+        if (this.disposeResizeHandler) {
+            this.disposeResizeHandler();
+            this.disposeResizeHandler = undefined;
+        }
+    }
+    getElementsOffset() {
+        if (this.isAngularUniversalSSR) {
+            return 0;
+        }
+        let offset = 0;
+        if (this.containerElementRef && this.containerElementRef.nativeElement) {
+            offset += this.containerElementRef.nativeElement[this._offsetType];
+        }
+        if (this.parentScroll) {
+            let scrollElement = this.getScrollElement();
+            let elementClientRect = this.getElementSize(this.element.nativeElement);
+            let scrollClientRect = this.getElementSize(scrollElement);
+            if (this.horizontal) {
+                offset += elementClientRect.left - scrollClientRect.left;
+            }
+            else {
+                offset += elementClientRect.top - scrollClientRect.top;
+            }
+            if (!(this.parentScroll instanceof Window)) {
+                offset += scrollElement[this._scrollType];
+            }
+        }
+        return offset;
+    }
+    countItemsPerWrapGroup() {
+        if (this.isAngularUniversalSSR) {
+            return Math.round(this.horizontal
+                ? this.ssrViewportHeight / this.ssrChildHeight
+                : this.ssrViewportWidth / this.ssrChildWidth);
+        }
+        let propertyName = this.horizontal ? 'offsetLeft' : 'offsetTop';
+        let children = ((this.containerElementRef && this.containerElementRef.nativeElement) ||
+            this.contentElementRef.nativeElement).children;
+        let childrenLength = children ? children.length : 0;
+        if (childrenLength === 0) {
+            return 1;
+        }
+        let firstOffset = children[0][propertyName];
+        let result = 1;
+        while (result < childrenLength &&
+            firstOffset === children[result][propertyName]) {
+            ++result;
+        }
+        return result;
+    }
+    getScrollStartPosition() {
+        let windowScrollValue = undefined;
+        if (this.parentScroll instanceof Window) {
+            windowScrollValue = window[this._pageOffsetType];
+        }
+        return windowScrollValue || this.getScrollElement()[this._scrollType] || 0;
+    }
+    minMeasuredChildWidth;
+    minMeasuredChildHeight;
+    wrapGroupDimensions;
+    resetWrapGroupDimensions() {
+        const oldWrapGroupDimensions = this.wrapGroupDimensions;
+        this.invalidateAllCachedMeasurements();
+        if (!this.enableUnequalChildrenSizes ||
+            !oldWrapGroupDimensions ||
+            oldWrapGroupDimensions.numberOfKnownWrapGroupChildSizes === 0) {
+            return;
+        }
+        const itemsPerWrapGroup = this.countItemsPerWrapGroup();
+        for (let wrapGroupIndex = 0; wrapGroupIndex < oldWrapGroupDimensions.maxChildSizePerWrapGroup.length; ++wrapGroupIndex) {
+            const oldWrapGroupDimension = oldWrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];
+            if (!oldWrapGroupDimension ||
+                !oldWrapGroupDimension.items ||
+                !oldWrapGroupDimension.items.length) {
+                continue;
+            }
+            if (oldWrapGroupDimension.items.length !== itemsPerWrapGroup) {
+                return;
+            }
+            let itemsChanged = false;
+            let arrayStartIndex = itemsPerWrapGroup * wrapGroupIndex;
+            for (let i = 0; i < itemsPerWrapGroup; ++i) {
+                if (!this.compareItems(oldWrapGroupDimension.items[i], this.items[arrayStartIndex + i])) {
+                    itemsChanged = true;
+                    break;
+                }
+            }
+            if (!itemsChanged) {
+                ++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths +=
+                    oldWrapGroupDimension.childWidth || 0;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights +=
+                    oldWrapGroupDimension.childHeight || 0;
+                this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] =
+                    oldWrapGroupDimension;
+            }
+        }
+    }
+    calculateDimensions() {
+        let scrollElement = this.getScrollElement();
+        const maxCalculatedScrollBarSize = 25; // Note: Formula to auto-calculate doesn't work for ParentScroll, so we default to this if not set by consuming application
+        this.calculatedScrollbarHeight = Math.max(Math.min(scrollElement.offsetHeight - scrollElement.clientHeight, maxCalculatedScrollBarSize), this.calculatedScrollbarHeight);
+        this.calculatedScrollbarWidth = Math.max(Math.min(scrollElement.offsetWidth - scrollElement.clientWidth, maxCalculatedScrollBarSize), this.calculatedScrollbarWidth);
+        let viewportWidth = scrollElement.offsetWidth -
+            (this.scrollbarWidth ||
+                this.calculatedScrollbarWidth ||
+                (this.horizontal ? 0 : maxCalculatedScrollBarSize));
+        let viewportHeight = scrollElement.offsetHeight -
+            (this.scrollbarHeight ||
+                this.calculatedScrollbarHeight ||
+                (this.horizontal ? maxCalculatedScrollBarSize : 0));
+        let content = (this.containerElementRef && this.containerElementRef.nativeElement) ||
+            this.contentElementRef.nativeElement;
+        let itemsPerWrapGroup = this.countItemsPerWrapGroup();
+        let wrapGroupsPerPage;
+        let defaultChildWidth;
+        let defaultChildHeight;
+        if (this.isAngularUniversalSSR) {
+            viewportWidth = this.ssrViewportWidth;
+            viewportHeight = this.ssrViewportHeight;
+            defaultChildWidth = this.ssrChildWidth;
+            defaultChildHeight = this.ssrChildHeight;
+            let itemsPerRow = Math.max(Math.ceil(viewportWidth / defaultChildWidth), 1);
+            let itemsPerCol = Math.max(Math.ceil(viewportHeight / defaultChildHeight), 1);
+            wrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;
+        }
+        else if (!this.enableUnequalChildrenSizes) {
+            if (content.children.length > 0) {
+                if (!this.childWidth || !this.childHeight) {
+                    if (!this.minMeasuredChildWidth && viewportWidth > 0) {
+                        this.minMeasuredChildWidth = viewportWidth;
+                    }
+                    if (!this.minMeasuredChildHeight && viewportHeight > 0) {
+                        this.minMeasuredChildHeight = viewportHeight;
+                    }
+                }
+                let child = content.children[0];
+                let clientRect = this.getElementSize(child);
+                this.minMeasuredChildWidth = Math.min(this.minMeasuredChildWidth, clientRect.width);
+                this.minMeasuredChildHeight = Math.min(this.minMeasuredChildHeight, clientRect.height);
+            }
+            defaultChildWidth =
+                this.childWidth || this.minMeasuredChildWidth || viewportWidth;
+            defaultChildHeight =
+                this.childHeight || this.minMeasuredChildHeight || viewportHeight;
+            let itemsPerRow = Math.max(Math.ceil(viewportWidth / defaultChildWidth), 1);
+            let itemsPerCol = Math.max(Math.ceil(viewportHeight / defaultChildHeight), 1);
+            wrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;
+        }
+        else {
+            let scrollOffset = scrollElement[this._scrollType] -
+                (this.previousViewPort ? this.previousViewPort.padding : 0);
+            let arrayStartIndex = this.previousViewPort.startIndexWithBuffer || 0;
+            let wrapGroupIndex = Math.ceil(arrayStartIndex / itemsPerWrapGroup);
+            let maxWidthForWrapGroup = 0;
+            let maxHeightForWrapGroup = 0;
+            let sumOfVisibleMaxWidths = 0;
+            let sumOfVisibleMaxHeights = 0;
+            wrapGroupsPerPage = 0;
+            for (let i = 0; i < content.children.length; ++i) {
+                ++arrayStartIndex;
+                let child = content.children[i];
+                let clientRect = this.getElementSize(child);
+                maxWidthForWrapGroup = Math.max(maxWidthForWrapGroup, clientRect.width);
+                maxHeightForWrapGroup = Math.max(maxHeightForWrapGroup, clientRect.height);
+                if (arrayStartIndex % itemsPerWrapGroup === 0) {
+                    let oldValue = this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];
+                    if (oldValue) {
+                        --this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                        this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -=
+                            oldValue.childWidth || 0;
+                        this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -=
+                            oldValue.childHeight || 0;
+                    }
+                    ++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                    const items = this.items.slice(arrayStartIndex - itemsPerWrapGroup, arrayStartIndex);
+                    this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] = {
+                        childWidth: maxWidthForWrapGroup,
+                        childHeight: maxHeightForWrapGroup,
+                        items: items,
+                    };
+                    this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths +=
+                        maxWidthForWrapGroup;
+                    this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights +=
+                        maxHeightForWrapGroup;
+                    if (this.horizontal) {
+                        let maxVisibleWidthForWrapGroup = Math.min(maxWidthForWrapGroup, Math.max(viewportWidth - sumOfVisibleMaxWidths, 0));
+                        if (scrollOffset > 0) {
+                            let scrollOffsetToRemove = Math.min(scrollOffset, maxVisibleWidthForWrapGroup);
+                            maxVisibleWidthForWrapGroup -= scrollOffsetToRemove;
+                            scrollOffset -= scrollOffsetToRemove;
+                        }
+                        sumOfVisibleMaxWidths += maxVisibleWidthForWrapGroup;
+                        if (maxVisibleWidthForWrapGroup > 0 &&
+                            viewportWidth >= sumOfVisibleMaxWidths) {
+                            ++wrapGroupsPerPage;
+                        }
+                    }
+                    else {
+                        let maxVisibleHeightForWrapGroup = Math.min(maxHeightForWrapGroup, Math.max(viewportHeight - sumOfVisibleMaxHeights, 0));
+                        if (scrollOffset > 0) {
+                            let scrollOffsetToRemove = Math.min(scrollOffset, maxVisibleHeightForWrapGroup);
+                            maxVisibleHeightForWrapGroup -= scrollOffsetToRemove;
+                            scrollOffset -= scrollOffsetToRemove;
+                        }
+                        sumOfVisibleMaxHeights += maxVisibleHeightForWrapGroup;
+                        if (maxVisibleHeightForWrapGroup > 0 &&
+                            viewportHeight >= sumOfVisibleMaxHeights) {
+                            ++wrapGroupsPerPage;
+                        }
+                    }
+                    ++wrapGroupIndex;
+                    maxWidthForWrapGroup = 0;
+                    maxHeightForWrapGroup = 0;
+                }
+            }
+            let averageChildWidth = this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths /
+                this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+            let averageChildHeight = this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights /
+                this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+            defaultChildWidth = this.childWidth || averageChildWidth || viewportWidth;
+            defaultChildHeight =
+                this.childHeight || averageChildHeight || viewportHeight;
+            if (this.horizontal) {
+                if (viewportWidth > sumOfVisibleMaxWidths) {
+                    wrapGroupsPerPage += Math.ceil((viewportWidth - sumOfVisibleMaxWidths) / defaultChildWidth);
+                }
+            }
+            else {
+                if (viewportHeight > sumOfVisibleMaxHeights) {
+                    wrapGroupsPerPage += Math.ceil((viewportHeight - sumOfVisibleMaxHeights) / defaultChildHeight);
+                }
+            }
+        }
+        let itemCount = this.items.length;
+        let itemsPerPage = itemsPerWrapGroup * wrapGroupsPerPage;
+        let pageCount_fractional = itemCount / itemsPerPage;
+        let numberOfWrapGroups = Math.ceil(itemCount / itemsPerWrapGroup);
+        let scrollLength = 0;
+        let defaultScrollLengthPerWrapGroup = this.horizontal
+            ? defaultChildWidth
+            : defaultChildHeight;
+        if (this.enableUnequalChildrenSizes) {
+            let numUnknownChildSizes = 0;
+            for (let i = 0; i < numberOfWrapGroups; ++i) {
+                let childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] &&
+                    this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];
+                if (childSize) {
+                    scrollLength += childSize;
+                }
+                else {
+                    ++numUnknownChildSizes;
+                }
+            }
+            scrollLength += Math.round(numUnknownChildSizes * defaultScrollLengthPerWrapGroup);
+        }
+        else {
+            scrollLength = numberOfWrapGroups * defaultScrollLengthPerWrapGroup;
+        }
+        if (this.headerElementRef) {
+            scrollLength += this.headerElementRef.nativeElement.clientHeight;
+        }
+        let viewportLength = this.horizontal ? viewportWidth : viewportHeight;
+        let maxScrollPosition = Math.max(scrollLength - viewportLength, 0);
+        return {
+            itemCount: itemCount,
+            itemsPerWrapGroup: itemsPerWrapGroup,
+            wrapGroupsPerPage: wrapGroupsPerPage,
+            itemsPerPage: itemsPerPage,
+            pageCount_fractional: pageCount_fractional,
+            childWidth: defaultChildWidth,
+            childHeight: defaultChildHeight,
+            scrollLength: scrollLength,
+            viewportLength: viewportLength,
+            maxScrollPosition: maxScrollPosition,
+        };
+    }
+    cachedPageSize = 0;
+    previousScrollNumberElements = 0;
+    calculatePadding(arrayStartIndexWithBuffer, dimensions) {
+        if (dimensions.itemCount === 0) {
+            return 0;
+        }
+        let defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];
+        let startingWrapGroupIndex = Math.floor(arrayStartIndexWithBuffer / dimensions.itemsPerWrapGroup) || 0;
+        if (!this.enableUnequalChildrenSizes) {
+            return defaultScrollLengthPerWrapGroup * startingWrapGroupIndex;
+        }
+        let numUnknownChildSizes = 0;
+        let result = 0;
+        for (let i = 0; i < startingWrapGroupIndex; ++i) {
+            let childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] &&
+                this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];
+            if (childSize) {
+                result += childSize;
+            }
+            else {
+                ++numUnknownChildSizes;
+            }
+        }
+        result += Math.round(numUnknownChildSizes * defaultScrollLengthPerWrapGroup);
+        return result;
+    }
+    calculatePageInfo(scrollPosition, dimensions) {
+        let scrollPercentage = 0;
+        if (this.enableUnequalChildrenSizes) {
+            const numberOfWrapGroups = Math.ceil(dimensions.itemCount / dimensions.itemsPerWrapGroup);
+            let totalScrolledLength = 0;
+            let defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];
+            for (let i = 0; i < numberOfWrapGroups; ++i) {
+                let childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] &&
+                    this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];
+                if (childSize) {
+                    totalScrolledLength += childSize;
+                }
+                else {
+                    totalScrolledLength += defaultScrollLengthPerWrapGroup;
+                }
+                if (scrollPosition < totalScrolledLength) {
+                    scrollPercentage = i / numberOfWrapGroups;
+                    break;
+                }
+            }
+        }
+        else {
+            scrollPercentage = scrollPosition / dimensions.scrollLength;
+        }
+        let startingArrayIndex_fractional = Math.min(Math.max(scrollPercentage * dimensions.pageCount_fractional, 0), dimensions.pageCount_fractional) * dimensions.itemsPerPage;
+        let maxStart = dimensions.itemCount - dimensions.itemsPerPage - 1;
+        let arrayStartIndex = Math.min(Math.floor(startingArrayIndex_fractional), maxStart);
+        arrayStartIndex -= arrayStartIndex % dimensions.itemsPerWrapGroup; // round down to start of wrapGroup
+        if (this.stripedTable) {
+            let bufferBoundary = 2 * dimensions.itemsPerWrapGroup;
+            if (arrayStartIndex % bufferBoundary !== 0) {
+                arrayStartIndex = Math.max(arrayStartIndex - (arrayStartIndex % bufferBoundary), 0);
+            }
+        }
+        let arrayEndIndex = Math.ceil(startingArrayIndex_fractional) + dimensions.itemsPerPage - 1;
+        let endIndexWithinWrapGroup = (arrayEndIndex + 1) % dimensions.itemsPerWrapGroup;
+        if (endIndexWithinWrapGroup > 0) {
+            arrayEndIndex += dimensions.itemsPerWrapGroup - endIndexWithinWrapGroup; // round up to end of wrapGroup
+        }
+        if (isNaN(arrayStartIndex)) {
+            arrayStartIndex = 0;
+        }
+        if (isNaN(arrayEndIndex)) {
+            arrayEndIndex = 0;
+        }
+        arrayStartIndex = Math.min(Math.max(arrayStartIndex, 0), dimensions.itemCount - 1);
+        arrayEndIndex = Math.min(Math.max(arrayEndIndex, 0), dimensions.itemCount - 1);
+        let bufferSize = this.bufferAmount * dimensions.itemsPerWrapGroup;
+        let startIndexWithBuffer = Math.min(Math.max(arrayStartIndex - bufferSize, 0), dimensions.itemCount - 1);
+        let endIndexWithBuffer = Math.min(Math.max(arrayEndIndex + bufferSize, 0), dimensions.itemCount - 1);
+        return {
+            startIndex: arrayStartIndex,
+            endIndex: arrayEndIndex,
+            startIndexWithBuffer: startIndexWithBuffer,
+            endIndexWithBuffer: endIndexWithBuffer,
+            scrollStartPosition: scrollPosition,
+            scrollEndPosition: scrollPosition + dimensions.viewportLength,
+            maxScrollPosition: dimensions.maxScrollPosition,
+        };
+    }
+    calculateViewport() {
+        let dimensions = this.calculateDimensions();
+        let offset = this.getElementsOffset();
+        let scrollStartPosition = this.getScrollStartPosition();
+        if (scrollStartPosition > dimensions.scrollLength + offset &&
+            !(this.parentScroll instanceof Window)) {
+            scrollStartPosition = dimensions.scrollLength;
+        }
+        else {
+            scrollStartPosition -= offset;
+        }
+        scrollStartPosition = Math.max(0, scrollStartPosition);
+        let pageInfo = this.calculatePageInfo(scrollStartPosition, dimensions);
+        let newPadding = this.calculatePadding(pageInfo.startIndexWithBuffer, dimensions);
+        let newScrollLength = dimensions.scrollLength;
+        return {
+            startIndex: pageInfo.startIndex,
+            endIndex: pageInfo.endIndex,
+            startIndexWithBuffer: pageInfo.startIndexWithBuffer,
+            endIndexWithBuffer: pageInfo.endIndexWithBuffer,
+            padding: Math.round(newPadding),
+            scrollLength: Math.round(newScrollLength),
+            scrollStartPosition: pageInfo.scrollStartPosition,
+            scrollEndPosition: pageInfo.scrollEndPosition,
+            maxScrollPosition: pageInfo.maxScrollPosition,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualScrollerComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: PLATFORM_ID }, { token: 'virtual-scroller-default-options', optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: VirtualScrollerComponent, selector: "virtual-scroller,[virtualScroller]", inputs: { executeRefreshOutsideAngularZone: "executeRefreshOutsideAngularZone", enableUnequalChildrenSizes: "enableUnequalChildrenSizes", useMarginInsteadOfTranslate: "useMarginInsteadOfTranslate", modifyOverflowStyleOfParentScroll: "modifyOverflowStyleOfParentScroll", stripedTable: "stripedTable", scrollbarWidth: "scrollbarWidth", scrollbarHeight: "scrollbarHeight", childWidth: "childWidth", childHeight: "childHeight", ssrChildWidth: "ssrChildWidth", ssrChildHeight: "ssrChildHeight", ssrViewportWidth: "ssrViewportWidth", ssrViewportHeight: "ssrViewportHeight", bufferAmount: "bufferAmount", scrollAnimationTime: "scrollAnimationTime", resizeBypassRefreshThreshold: "resizeBypassRefreshThreshold", scrollThrottlingTime: "scrollThrottlingTime", scrollDebounceTime: "scrollDebounceTime", checkResizeInterval: "checkResizeInterval", items: "items", compareItems: "compareItems", horizontal: "horizontal", parentScroll: "parentScroll" }, outputs: { vsUpdate: "vsUpdate", vsChange: "vsChange", vsStart: "vsStart", vsEnd: "vsEnd" }, host: { properties: { "class.horizontal": "horizontal", "class.vertical": "!horizontal", "class.selfScroll": "!parentScroll" } }, queries: [{ propertyName: "headerElementRef", first: true, predicate: ["header"], descendants: true, read: ElementRef }, { propertyName: "containerElementRef", first: true, predicate: ["container"], descendants: true, read: ElementRef }], viewQueries: [{ propertyName: "contentElementRef", first: true, predicate: ["content"], descendants: true, read: ElementRef }, { propertyName: "invisiblePaddingElementRef", first: true, predicate: ["invisiblePadding"], descendants: true, read: ElementRef }], exportAs: ["virtualScroller"], usesOnChanges: true, ngImport: i0, template: `
+    <div class="total-padding" #invisiblePadding></div>
+    <div class="scrollable-content" #content>
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{position:relative;display:block;-webkit-overflow-scrolling:touch}:host.horizontal.selfScroll{overflow-y:visible;overflow-x:auto}:host.vertical.selfScroll{overflow-y:auto;overflow-x:visible}.scrollable-content{top:0;left:0;width:100%;height:100%;max-width:100vw;max-height:100vh;position:absolute}.scrollable-content ::ng-deep>*{box-sizing:border-box}:host.horizontal{white-space:nowrap}:host.horizontal .scrollable-content{display:flex}:host.horizontal .scrollable-content ::ng-deep>*{flex-shrink:0;flex-grow:0;white-space:initial}.total-padding{width:1px;opacity:0}:host.horizontal .total-padding{height:100%}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualScrollerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'virtual-scroller,[virtualScroller]', exportAs: 'virtualScroller', template: `
+    <div class="total-padding" #invisiblePadding></div>
+    <div class="scrollable-content" #content>
+      <ng-content></ng-content>
+    </div>
+  `, host: {
+                        '[class.horizontal]': 'horizontal',
+                        '[class.vertical]': '!horizontal',
+                        '[class.selfScroll]': '!parentScroll',
+                    }, styles: [":host{position:relative;display:block;-webkit-overflow-scrolling:touch}:host.horizontal.selfScroll{overflow-y:visible;overflow-x:auto}:host.vertical.selfScroll{overflow-y:auto;overflow-x:visible}.scrollable-content{top:0;left:0;width:100%;height:100%;max-width:100vw;max-height:100vh;position:absolute}.scrollable-content ::ng-deep>*{box-sizing:border-box}:host.horizontal{white-space:nowrap}:host.horizontal .scrollable-content{display:flex}:host.horizontal .scrollable-content ::ng-deep>*{flex-shrink:0;flex-grow:0;white-space:initial}.total-padding{width:1px;opacity:0}:host.horizontal .total-padding{height:100%}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['virtual-scroller-default-options']
+                }] }], propDecorators: { executeRefreshOutsideAngularZone: [{
+                type: Input
+            }], enableUnequalChildrenSizes: [{
+                type: Input
+            }], useMarginInsteadOfTranslate: [{
+                type: Input
+            }], modifyOverflowStyleOfParentScroll: [{
+                type: Input
+            }], stripedTable: [{
+                type: Input
+            }], scrollbarWidth: [{
+                type: Input
+            }], scrollbarHeight: [{
+                type: Input
+            }], childWidth: [{
+                type: Input
+            }], childHeight: [{
+                type: Input
+            }], ssrChildWidth: [{
+                type: Input
+            }], ssrChildHeight: [{
+                type: Input
+            }], ssrViewportWidth: [{
+                type: Input
+            }], ssrViewportHeight: [{
+                type: Input
+            }], bufferAmount: [{
+                type: Input
+            }], scrollAnimationTime: [{
+                type: Input
+            }], resizeBypassRefreshThreshold: [{
+                type: Input
+            }], scrollThrottlingTime: [{
+                type: Input
+            }], scrollDebounceTime: [{
+                type: Input
+            }], checkResizeInterval: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], compareItems: [{
+                type: Input
+            }], horizontal: [{
+                type: Input
+            }], parentScroll: [{
+                type: Input
+            }], vsUpdate: [{
+                type: Output
+            }], vsChange: [{
+                type: Output
+            }], vsStart: [{
+                type: Output
+            }], vsEnd: [{
+                type: Output
+            }], contentElementRef: [{
+                type: ViewChild,
+                args: ['content', { read: ElementRef, static: false }]
+            }], invisiblePaddingElementRef: [{
+                type: ViewChild,
+                args: ['invisiblePadding', { read: ElementRef, static: false }]
+            }], headerElementRef: [{
+                type: ContentChild,
+                args: ['header', { read: ElementRef, static: false }]
+            }], containerElementRef: [{
+                type: ContentChild,
+                args: ['container', { read: ElementRef, static: false }]
+            }] } });
+export class VirtualScrollerModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualScrollerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: VirtualScrollerModule, declarations: [VirtualScrollerComponent], imports: [CommonModule], exports: [VirtualScrollerComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualScrollerModule, providers: [
+            {
+                provide: 'virtual-scroller-default-options',
+                useFactory: VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY,
+            },
+        ], imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualScrollerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [VirtualScrollerComponent],
+                    declarations: [VirtualScrollerComponent],
+                    imports: [CommonModule],
+                    providers: [
+                        {
+                            provide: 'virtual-scroller-default-options',
+                            useFactory: VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-scroll.js","sourceRoot":"","sources":["../../../../projects/angular2-multiselect-dropdown-lib/src/lib/virtual-scroll/virtual-scroll.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,KAAK,EACL,QAAQ,EAKR,MAAM,EAEN,SAAS,GAEV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;;AAU3C,MAAM,UAAU,wCAAwC;IACtD,OAAO;QACL,oBAAoB,EAAE,CAAC;QACvB,kBAAkB,EAAE,CAAC;QACrB,mBAAmB,EAAE,GAAG;QACxB,mBAAmB,EAAE,IAAI;QACzB,4BAA4B,EAAE,CAAC;QAC/B,iCAAiC,EAAE,IAAI;QACvC,YAAY,EAAE,KAAK;KACpB,CAAC;AACJ,CAAC;AAwED,MAAM,OAAO,wBAAwB;IAufd;IACA;IACA;IACT;IAzfL,aAAa,CAAQ;IACrB,MAAM,GAAG,MAAM,CAAC;IAEvB,IAAW,YAAY;QACrB,IAAI,QAAQ,GAAc,IAAI,CAAC,gBAAgB,IAAS,EAAE,CAAC;QAC3D,OAAO;YACL,UAAU,EAAE,QAAQ,CAAC,UAAU,IAAI,CAAC;YACpC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,CAAC;YAChC,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB,IAAI,CAAC;YACtD,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB,IAAI,CAAC;YAClD,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB,IAAI,CAAC;YAClD,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB,IAAI,CAAC;YACxD,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB,IAAI,CAAC;SACrD,CAAC;IACJ,CAAC;IAGM,gCAAgC,GAAY,KAAK,CAAC;IAE/C,2BAA2B,GAAY,KAAK,CAAC;IACvD,IACW,0BAA0B;QACnC,OAAO,IAAI,CAAC,2BAA2B,CAAC;IAC1C,CAAC;IACD,IAAW,0BAA0B,CAAC,KAAc;QAClD,IAAI,IAAI,CAAC,2BAA2B,KAAK,KAAK,EAAE,CAAC;YAC/C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,2BAA2B,GAAG,KAAK,CAAC;QACzC,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;QACvC,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAC1C,CAAC;IAGM,2BAA2B,GAAY,KAAK,CAAC;IAG7C,iCAAiC,CAAU;IAG3C,YAAY,CAAU;IAGtB,cAAc,CAAS;IAGvB,eAAe,CAAS;IAGxB,UAAU,CAAS;IAGnB,WAAW,CAAS;IAGpB,aAAa,CAAS;IAGtB,cAAc,CAAS;IAGvB,gBAAgB,GAAW,IAAI,CAAC;IAGhC,iBAAiB,GAAW,IAAI,CAAC;IAE9B,aAAa,GAAW,CAAC,CAAC;IACpC,IACW,YAAY;QACrB,IAAI,OAAO,IAAI,CAAC,aAAa,KAAK,QAAQ,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,EAAE,CAAC;YACtE,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IACD,IAAW,YAAY,CAAC,KAAa;QACnC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IAGM,mBAAmB,CAAS;IAG5B,4BAA4B,CAAS;IAElC,qBAAqB,CAAS;IACxC,IACW,oBAAoB;QAC7B,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IACD,IAAW,oBAAoB,CAAC,KAAa;QAC3C,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAES,mBAAmB,CAAS;IACtC,IACW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAW,kBAAkB,CAAC,KAAa;QACzC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAES,QAAQ,CAAa;IACrB,sBAAsB;QAC9B,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,IAAI,CAAC,QAAQ,GAAQ,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE;gBACtC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC9B,CAAC;aAAM,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACrC,IAAI,CAAC,QAAQ,GAAQ,IAAI,CAAC,gBAAgB,CAAC,GAAG,EAAE;gBAC9C,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAChC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,QAAQ,GAAG,GAAG,EAAE;gBACnB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC,CAAC;QACJ,CAAC;IACH,CAAC;IAES,8BAA8B,CAAS;IACvC,oBAAoB,CAAS;IACvC,IACW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IACD,IAAW,mBAAmB,CAAC,KAAa;QAC1C,IAAI,IAAI,CAAC,oBAAoB,KAAK,KAAK,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;QAClC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAES,MAAM,GAAU,EAAE,CAAC;IAC7B,IACW,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAW,KAAK,CAAC,KAAY;QAC3B,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,KAAK,IAAI,EAAE,CAAC;QAC1B,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAGM,YAAY,GAAwC,CACzD,KAAU,EACV,KAAU,EACV,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC;IAEX,WAAW,CAAU;IAC/B,IACW,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAW,UAAU,CAAC,KAAc;QAClC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAES,sBAAsB;QAC9B,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9C,IAAI,aAAa,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAClD,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,CAAC,CAAC;YACnE,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,CAAC,uBAAuB,GAAG,SAAS,CAAC;IAC3C,CAAC;IAES,uBAAuB,CAA2B;IAClD,aAAa,CAAmB;IAC1C,IACW,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAW,YAAY,CAAC,KAAuB;QAC7C,IAAI,IAAI,CAAC,aAAa,KAAK,KAAK,EAAE,CAAC;YACjC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9C,IACE,IAAI,CAAC,iCAAiC;YACtC,aAAa,KAAK,IAAI,CAAC,OAAO,CAAC,aAAa,EAC5C,CAAC;YACD,IAAI,CAAC,uBAAuB,GAAG;gBAC7B,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC;gBACpC,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC;aACrC,CAAC;YACF,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;YACzE,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;QAC3E,CAAC;IACH,CAAC;IAGM,QAAQ,GAAwB,IAAI,YAAY,EAAS,CAAC;IAG1D,QAAQ,GAA4B,IAAI,YAAY,EAAa,CAAC;IAGlE,OAAO,GAA4B,IAAI,YAAY,EAAa,CAAC;IAGjE,KAAK,GAA4B,IAAI,YAAY,EAAa,CAAC;IAG5D,iBAAiB,CAAa;IAG9B,0BAA0B,CAAa;IAGvC,gBAAgB,CAAa;IAG7B,mBAAmB,CAAa;IAEnC,QAAQ;QACb,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEM,WAAW,CAAC,OAAY;QAC7B,IAAI,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QACtE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAE3C,MAAM,QAAQ,GACZ,CAAC,OAAO,CAAC,KAAK;YACd,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa;YAC5B,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,IAAI,QAAQ,CAAC,CAAC;IACxD,CAAC;IAEM,SAAS;QACd,IAAI,IAAI,CAAC,iBAAiB,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACjD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;YAC3C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAC5B,OAAO;QACT,CAAC;QAED,IACE,IAAI,CAAC,gBAAgB;YACrB,IAAI,CAAC,aAAa;YAClB,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAC7B,CAAC;YACD,IAAI,iBAAiB,GAAG,KAAK,CAAC;YAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;gBACnD,IACE,CAAC,IAAI,CAAC,YAAY,CAChB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,GAAG,CAAC,CAAC,EAC1D,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CACtB,EACD,CAAC;oBACD,iBAAiB,GAAG,IAAI,CAAC;oBACzB,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,iBAAiB,EAAE,CAAC;gBACtB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;IACH,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAEM,+BAA+B;QACpC,IAAI,CAAC,mBAAmB,GAAG;YACzB,wBAAwB,EAAE,EAAE;YAC5B,gCAAgC,EAAE,CAAC;YACnC,8BAA8B,EAAE,CAAC;YACjC,+BAA+B,EAAE,CAAC;SACnC,CAAC;QAEF,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;QACvC,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;QAExC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEM,kCAAkC,CAAC,IAAS;QACjD,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACnD,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;gBACf,IAAI,CAAC,kCAAkC,CAAC,KAAK,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;YACvC,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;QAC1C,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEM,kCAAkC,CAAC,KAAa;QACrD,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,IAAI,iBAAiB,GACnB,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;YAC3D,IAAI,iBAAiB,EAAE,CAAC;gBACtB,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;gBACrE,EAAE,IAAI,CAAC,mBAAmB,CAAC,gCAAgC,CAAC;gBAC5D,IAAI,CAAC,mBAAmB,CAAC,8BAA8B;oBACrD,iBAAiB,CAAC,UAAU,IAAI,CAAC,CAAC;gBACpC,IAAI,CAAC,mBAAmB,CAAC,+BAA+B;oBACtD,iBAAiB,CAAC,WAAW,IAAI,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;YACvC,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;QAC1C,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEM,UAAU,CACf,IAAS,EACT,mBAA4B,IAAI,EAChC,mBAA2B,CAAC,EAC5B,wBAAgC,SAAS,EACzC,6BAAyC,SAAS;QAElD,IAAI,KAAK,GAAW,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,aAAa,CAChB,KAAK,EACL,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,0BAA0B,CAC3B,CAAC;IACJ,CAAC;IAEM,aAAa,CAClB,KAAa,EACb,mBAA4B,IAAI,EAChC,mBAA2B,CAAC,EAC5B,wBAAgC,SAAS,EACzC,6BAAyC,SAAS;QAElD,IAAI,UAAU,GAAW,CAAC,CAAC;QAE3B,IAAI,aAAa,GAAG,GAAG,EAAE;YACvB,EAAE,UAAU,CAAC;YACb,IAAI,UAAU,IAAI,CAAC,EAAE,CAAC;gBACpB,IAAI,0BAA0B,EAAE,CAAC;oBAC/B,0BAA0B,EAAE,CAAC;gBAC/B,CAAC;gBACD,OAAO;YACT,CAAC;YAED,IAAI,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC5C,IAAI,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAC9B,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAClB,UAAU,CAAC,SAAS,GAAG,CAAC,CACzB,CAAC;YACF,IAAI,IAAI,CAAC,gBAAgB,CAAC,UAAU,KAAK,iBAAiB,EAAE,CAAC;gBAC3D,IAAI,0BAA0B,EAAE,CAAC;oBAC/B,0BAA0B,EAAE,CAAC;gBAC/B,CAAC;gBACD,OAAO;YACT,CAAC;YAED,IAAI,CAAC,sBAAsB,CACzB,KAAK,EACL,gBAAgB,EAChB,gBAAgB,EAChB,CAAC,EACD,aAAa,CACd,CAAC;QACJ,CAAC,CAAC;QAEF,IAAI,CAAC,sBAAsB,CACzB,KAAK,EACL,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,CACd,CAAC;IACJ,CAAC;IAES,sBAAsB,CAC9B,KAAa,EACb,mBAA4B,IAAI,EAChC,mBAA2B,CAAC,EAC5B,wBAAgC,SAAS,EACzC,6BAAyC,SAAS;QAElD,qBAAqB;YACnB,qBAAqB,KAAK,SAAS;gBACjC,CAAC,CAAC,IAAI,CAAC,mBAAmB;gBAC1B,CAAC,CAAC,qBAAqB,CAAC;QAE5B,IAAI,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC5C,IAAI,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,UAAU,CAAC,GAAG,gBAAgB,CAAC;QACzE,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,MAAM,IAAI,UAAU,CAAC,iBAAiB,GAAG,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,CAAC,gBAAgB,CACnB,MAAM,EACN,qBAAqB,EACrB,0BAA0B,CAC3B,CAAC;IACJ,CAAC;IAEM,gBAAgB,CACrB,cAAsB,EACtB,wBAAgC,SAAS,EACzC,6BAAyC,SAAS;QAElD,cAAc,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE3C,qBAAqB;YACnB,qBAAqB,KAAK,SAAS;gBACjC,CAAC,CAAC,IAAI,CAAC,mBAAmB;gBAC1B,CAAC,CAAC,qBAAqB,CAAC;QAE5B,IAAI,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE5C,IAAI,gBAAwB,CAAC;QAE7B,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC3B,IAAI,CAAC,QAAQ,CAAC,WAAW,CACvB,aAAa,EACb,IAAI,CAAC,WAAW,EAChB,cAAc,CACf,CAAC;YACF,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,0BAA0B,CAAC,CAAC;YACzD,OAAO;QACT,CAAC;QAED,MAAM,cAAc,GAAG,EAAE,cAAc,EAAE,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;QAE3E,IAAI,QAAQ,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC;aAC3C,EAAE,CAAC,EAAE,cAAc,EAAE,EAAE,qBAAqB,CAAC;aAC7C,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC;aAClC,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE;YACjB,IAAI,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;gBAC/B,OAAO;YACT,CAAC;YACD,IAAI,CAAC,QAAQ,CAAC,WAAW,CACvB,aAAa,EACb,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,cAAc,CACpB,CAAC;YACF,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC,CAAC;aACD,MAAM,CAAC,GAAG,EAAE;YACX,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;QACzC,CAAC,CAAC;aACD,KAAK,EAAE,CAAC;QAEX,MAAM,OAAO,GAAG,CAAC,IAAa,EAAE,EAAE;YAChC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC;gBAC7B,OAAO;YACT,CAAC;YAED,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,cAAc,CAAC,cAAc,KAAK,cAAc,EAAE,CAAC;gBACrD,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,0BAA0B,CAAC,CAAC;gBACzD,OAAO;YACT,CAAC;YAED,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;gBAC/B,gBAAgB,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;YACpD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,OAAO,EAAE,CAAC;QACV,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC;IAC/B,CAAC;IAES,qBAAqB,CAAU;IAEzC,YACqB,OAAmB,EACnB,QAAmB,EACnB,IAAY,EACrB,iBAAoC,EACzB,UAAkB,EAGvC,OAAsC;QAPnB,YAAO,GAAP,OAAO,CAAY;QACnB,aAAQ,GAAR,QAAQ,CAAW;QACnB,SAAI,GAAJ,IAAI,CAAQ;QACrB,sBAAiB,GAAjB,iBAAiB,CAAmB;QAM9C,IAAI,CAAC,qBAAqB,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAE1D,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;QACzD,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC;QACrD,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;QACvD,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAC/C,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;QACvD,IAAI,CAAC,4BAA4B,GAAG,OAAO,CAAC,4BAA4B,CAAC;QACzE,IAAI,CAAC,iCAAiC;YACpC,OAAO,CAAC,iCAAiC,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QAEzC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAClC,CAAC;IAES,cAAc,CAAC,OAAoB;QAC3C,IAAI,MAAM,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;QAC7C,IAAI,MAAM,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACvC,IAAI,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QAC9D,IAAI,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QAC1D,IAAI,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QAE5D,OAAO;YACL,GAAG,EAAE,MAAM,CAAC,GAAG,GAAG,SAAS;YAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,YAAY;YACpC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,UAAU;YAC9B,KAAK,EAAE,MAAM,CAAC,KAAK,GAAG,WAAW;YACjC,KAAK,EAAE,MAAM,CAAC,KAAK,GAAG,UAAU,GAAG,WAAW;YAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,SAAS,GAAG,YAAY;YAChD,CAAC,EAAE,MAAM,CAAC,GAAG,GAAG,SAAS;YACzB,CAAC,EAAE,MAAM,CAAC,IAAI,GAAG,UAAU;YAC3B,MAAM;gBACJ,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,CAAC;SACF,CAAC;IACJ,CAAC;IAES,0BAA0B,CAAa;IACvC,yBAAyB;QACjC,IAAI,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAEhE,IAAI,WAAoB,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACrC,WAAW,GAAG,IAAI,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,IAAI,WAAW,GAAG,IAAI,CAAC,GAAG,CACxB,YAAY,CAAC,KAAK,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAC3D,CAAC;YACF,IAAI,YAAY,GAAG,IAAI,CAAC,GAAG,CACzB,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC,0BAA0B,CAAC,MAAM,CAC7D,CAAC;YACF,WAAW;gBACT,WAAW,GAAG,IAAI,CAAC,4BAA4B;oBAC/C,YAAY,GAAG,IAAI,CAAC,4BAA4B,CAAC;QACrD,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,CAAC,0BAA0B,GAAG,YAAY,CAAC;YAC/C,IAAI,YAAY,CAAC,KAAK,GAAG,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtD,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IAES,yBAAyB,CAAC;IAC1B,WAAW,CAAC;IACZ,WAAW,CAAC;IACZ,eAAe,CAAC;IAChB,eAAe,CAAC;IAChB,aAAa,CAAC;IACd,UAAU,CAAC;IACX,eAAe;QACvB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,yBAAyB,GAAG,OAAO,CAAC;YACzC,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC;YAChC,IAAI,CAAC,eAAe,GAAG,aAAa,CAAC;YACrC,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC;YACpC,IAAI,CAAC,UAAU,GAAG,aAAa,CAAC;YAChC,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;YAClC,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC;QAClC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,yBAAyB,GAAG,QAAQ,CAAC;YAC1C,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;YAC/B,IAAI,CAAC,eAAe,GAAG,aAAa,CAAC;YACrC,IAAI,CAAC,eAAe,GAAG,aAAa,CAAC;YACrC,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC;YAC/B,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;YAClC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QACjC,CAAC;IACH,CAAC;IAES,QAAQ,CAAC,IAAc,EAAE,IAAY;QAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACpD,MAAM,MAAM,GAAG;YACb,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtB,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACnC,CAAC,CAAC;QACF,MAAM,CAAC,QAAQ,CAAC,GAAG;YACjB,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxB,CAAC,CAAC;QAEF,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,gBAAgB,CAAC,IAAc,EAAE,IAAY;QACrD,IAAI,OAAO,GAAG,SAAS,CAAC;QACxB,IAAI,UAAU,GAAG,SAAS,CAAC;QAC3B,MAAM,MAAM,GAAG;YACb,MAAM,KAAK,GAAG,IAAI,CAAC;YACnB,UAAU,GAAG,SAAS,CAAC;YAEvB,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO;YACT,CAAC;YAED,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;gBACd,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;YAChC,CAAC;iBAAM,CAAC;gBACN,OAAO,GAAG,UAAU,CAAC;oBACnB,OAAO,GAAG,SAAS,CAAC;oBACpB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;gBAChC,CAAC,EAAE,IAAI,CAAC,CAAC;YACX,CAAC;QACH,CAAC,CAAC;QACF,MAAM,CAAC,QAAQ,CAAC,GAAG;YACjB,IAAI,OAAO,EAAE,CAAC;gBACZ,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,OAAO,GAAG,SAAS,CAAC;YACtB,CAAC;QACH,CAAC,CAAC;QAEF,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,wBAAwB,GAAW,CAAC,CAAC;IACrC,yBAAyB,GAAW,CAAC,CAAC;IAEtC,OAAO,GAAW,CAAC,CAAC;IACpB,gBAAgB,GAAmB,EAAE,CAAC;IACtC,YAAY,CAAM;IAClB,iBAAiB,CAAS;IAE1B,oBAAoB,CAAyB;IAC7C,oBAAoB,CAAyB;IAE7C,gBAAgB,CACxB,kBAA2B,EAC3B,2BAAuC,SAAS,EAChD,cAAsB,CAAC;QAEvB,qKAAqK;QACrK,2GAA2G;QAC3G,0OAA0O;QAC1O,gQAAgQ;QAEhQ,IACE,kBAAkB;YAClB,IAAI,CAAC,gBAAgB;YACrB,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,GAAG,CAAC,EAC7C,CAAC;YACD,oEAAoE;YACpE,IAAI,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC;YACxC,IAAI,gBAAgB,GAAG,IAAI,CAAC,aAAa,CAAC;YAE1C,IAAI,2BAA2B,GAAG,wBAAwB,CAAC;YAC3D,wBAAwB,GAAG,GAAG,EAAE;gBAC9B,IAAI,iBAAiB,GACnB,IAAI,CAAC,gBAAgB,CAAC,YAAY,GAAG,WAAW,CAAC,YAAY,CAAC;gBAChE,IAAI,iBAAiB,GAAG,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBAChD,IAAI,YAAY,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;oBACvC,IAAI,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CACjD,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC,CACnC,CAAC;oBACF,IAAI,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,EAAE,CAAC;wBACnE,IAAI,gBAAgB,GAAG,KAAK,CAAC;wBAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;4BACnD,IACE,CAAC,IAAI,CAAC,YAAY,CAChB,IAAI,CAAC,KAAK,CAAC,iBAAiB,GAAG,CAAC,CAAC,EACjC,gBAAgB,CAAC,CAAC,CAAC,CACpB,EACD,CAAC;gCACD,gBAAgB,GAAG,IAAI,CAAC;gCACxB,MAAM;4BACR,CAAC;wBACH,CAAC;wBAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;4BACtB,IAAI,CAAC,gBAAgB,CACnB,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,GAAG,iBAAiB,EAC7D,CAAC,EACD,2BAA2B,CAC5B,CAAC;4BACF,OAAO;wBACT,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,IAAI,2BAA2B,EAAE,CAAC;oBAChC,2BAA2B,EAAE,CAAC;gBAChC,CAAC;YACH,CAAC,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC/B,qBAAqB,CAAC,GAAG,EAAE;gBACzB,IAAI,kBAAkB,EAAE,CAAC;oBACvB,IAAI,CAAC,wBAAwB,EAAE,CAAC;gBAClC,CAAC;gBACD,IAAI,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAExC,IAAI,YAAY,GACd,kBAAkB;oBAClB,QAAQ,CAAC,UAAU,KAAK,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC;gBAC3D,IAAI,UAAU,GACZ,kBAAkB;oBAClB,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC;gBACvD,IAAI,mBAAmB,GACrB,QAAQ,CAAC,YAAY,KAAK,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC;gBAC/D,IAAI,cAAc,GAAG,QAAQ,CAAC,OAAO,KAAK,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;gBACxE,IAAI,qBAAqB,GACvB,QAAQ,CAAC,mBAAmB;oBAC1B,IAAI,CAAC,gBAAgB,CAAC,mBAAmB;oBAC3C,QAAQ,CAAC,iBAAiB;wBACxB,IAAI,CAAC,gBAAgB,CAAC,iBAAiB;oBACzC,QAAQ,CAAC,iBAAiB;wBACxB,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC;gBAE5C,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;gBAEjC,IAAI,mBAAmB,EAAE,CAAC;oBACxB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,0BAA0B,CAAC,aAAa,EAC7C,IAAI,CAAC,yBAAyB,EAC9B,GAAG,QAAQ,CAAC,YAAY,IAAI,CAC7B,CAAC;gBACJ,CAAC;gBAED,IAAI,cAAc,EAAE,CAAC;oBACnB,IAAI,IAAI,CAAC,2BAA2B,EAAE,CAAC;wBACrC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,iBAAiB,CAAC,aAAa,EACpC,IAAI,CAAC,UAAU,EACf,GAAG,QAAQ,CAAC,OAAO,IAAI,CACxB,CAAC;oBACJ,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,iBAAiB,CAAC,aAAa,EACpC,WAAW,EACX,GAAG,IAAI,CAAC,aAAa,IAAI,QAAQ,CAAC,OAAO,KAAK,CAC/C,CAAC;wBACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,iBAAiB,CAAC,aAAa,EACpC,iBAAiB,EACjB,GAAG,IAAI,CAAC,aAAa,IAAI,QAAQ,CAAC,OAAO,KAAK,CAC/C,CAAC;oBACJ,CAAC;gBACH,CAAC;gBAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBAC1B,IAAI,cAAc,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBAC/D,IAAI,eAAe,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBAC/C,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,CACnB,cAAc;wBACZ,QAAQ,CAAC,OAAO;wBAChB,eAAe;wBACf,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,YAAY,EAClD,CAAC,CACF,CAAC;oBACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,gBAAgB,CAAC,aAAa,EACnC,WAAW,EACX,GAAG,IAAI,CAAC,aAAa,IAAI,MAAM,KAAK,CACrC,CAAC;oBACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,gBAAgB,CAAC,aAAa,EACnC,iBAAiB,EACjB,GAAG,IAAI,CAAC,aAAa,IAAI,MAAM,KAAK,CACrC,CAAC;gBACJ,CAAC;gBAED,MAAM,cAAc,GAClB,YAAY,IAAI,UAAU;oBACxB,CAAC,CAAC;wBACE,UAAU,EAAE,QAAQ,CAAC,UAAU;wBAC/B,QAAQ,EAAE,QAAQ,CAAC,QAAQ;wBAC3B,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB;wBACjD,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;wBAC7C,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;wBACnD,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB;wBAC/C,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;qBAC9C;oBACH,CAAC,CAAC,SAAS,CAAC;gBAEhB,IAAI,YAAY,IAAI,UAAU,IAAI,qBAAqB,EAAE,CAAC;oBACxD,MAAM,aAAa,GAAG,GAAG,EAAE;wBACzB,wEAAwE;wBACxE,IAAI,CAAC,aAAa;4BAChB,QAAQ,CAAC,oBAAoB,IAAI,CAAC;gCAClC,QAAQ,CAAC,kBAAkB,IAAI,CAAC;gCAC9B,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CACd,QAAQ,CAAC,oBAAoB,EAC7B,QAAQ,CAAC,kBAAkB,GAAG,CAAC,CAChC;gCACH,CAAC,CAAC,EAAE,CAAC;wBACT,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;wBAEvC,IAAI,YAAY,EAAE,CAAC;4BACjB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;wBACpC,CAAC;wBAED,IAAI,UAAU,EAAE,CAAC;4BACf,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;wBAClC,CAAC;wBAED,IAAI,YAAY,IAAI,UAAU,EAAE,CAAC;4BAC/B,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;4BACtC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;wBACrC,CAAC;wBAED,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;4BACpB,IAAI,CAAC,gBAAgB,CACnB,KAAK,EACL,wBAAwB,EACxB,WAAW,GAAG,CAAC,CAChB,CAAC;4BACF,OAAO;wBACT,CAAC;wBAED,IAAI,wBAAwB,EAAE,CAAC;4BAC7B,wBAAwB,EAAE,CAAC;wBAC7B,CAAC;oBACH,CAAC,CAAC;oBAEF,IAAI,IAAI,CAAC,gCAAgC,EAAE,CAAC;wBAC1C,aAAa,EAAE,CAAC;oBAClB,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;oBAC/B,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,WAAW,GAAG,CAAC,IAAI,CAAC,mBAAmB,IAAI,cAAc,CAAC,EAAE,CAAC;wBAC/D,IAAI,CAAC,gBAAgB,CACnB,KAAK,EACL,wBAAwB,EACxB,WAAW,GAAG,CAAC,CAChB,CAAC;wBACF,OAAO;oBACT,CAAC;oBAED,IAAI,wBAAwB,EAAE,CAAC;wBAC7B,wBAAwB,EAAE,CAAC;oBAC7B,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAES,gBAAgB;QACxB,OAAO,IAAI,CAAC,YAAY,YAAY,MAAM;YACxC,CAAC,CAAC,QAAQ,CAAC,gBAAgB,IAAI,QAAQ,CAAC,eAAe,IAAI,QAAQ,CAAC,IAAI;YACxE,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;IACtD,CAAC;IAES,sBAAsB;QAC9B,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,OAAO;QACT,CAAC;QAED,IAAI,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE5C,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAEjC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC/B,IAAI,IAAI,CAAC,YAAY,YAAY,MAAM,EAAE,CAAC;gBACxC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAC9C,QAAQ,EACR,QAAQ,EACR,IAAI,CAAC,QAAQ,CACd,CAAC;gBACF,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAC9C,QAAQ,EACR,QAAQ,EACR,IAAI,CAAC,QAAQ,CACd,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAC9C,aAAa,EACb,QAAQ,EACR,IAAI,CAAC,QAAQ,CACd,CAAC;gBACF,IAAI,IAAI,CAAC,oBAAoB,GAAG,CAAC,EAAE,CAAC;oBAClC,IAAI,CAAC,8BAA8B,GAAQ,WAAW,CAAC,GAAG,EAAE;wBAC1D,IAAI,CAAC,yBAAyB,EAAE,CAAC;oBACnC,CAAC,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAChC,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAES,yBAAyB;QACjC,IAAI,IAAI,CAAC,8BAA8B,EAAE,CAAC;YACxC,aAAa,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;QACxC,CAAC;QAED,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;QACxC,CAAC;IACH,CAAC;IAES,iBAAiB;QACzB,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,OAAO,CAAC,CAAC;QACX,CAAC;QAED,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,IAAI,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,mBAAmB,CAAC,aAAa,EAAE,CAAC;YACvE,MAAM,IAAI,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC5C,IAAI,iBAAiB,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;YACxE,IAAI,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;YAC1D,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpB,MAAM,IAAI,iBAAiB,CAAC,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC;YAC3D,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,iBAAiB,CAAC,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC;YACzD,CAAC;YAED,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,YAAY,MAAM,CAAC,EAAE,CAAC;gBAC3C,MAAM,IAAI,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,sBAAsB;QAC9B,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,KAAK,CACf,IAAI,CAAC,UAAU;gBACb,CAAC,CAAC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,cAAc;gBAC9C,CAAC,CAAC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,aAAa,CAC/C,CAAC;QACJ,CAAC;QAED,IAAI,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC;QAChE,IAAI,QAAQ,GAAG,CACb,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC;YACpE,IAAI,CAAC,iBAAiB,CAAC,aAAa,CACrC,CAAC,QAAQ,CAAC;QAEX,IAAI,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,IAAI,cAAc,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,CAAC,CAAC;QACX,CAAC;QAED,IAAI,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;QAC5C,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,OACE,MAAM,GAAG,cAAc;YACvB,WAAW,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,EAC9C,CAAC;YACD,EAAE,MAAM,CAAC;QACX,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,sBAAsB;QAC9B,IAAI,iBAAiB,GAAG,SAAS,CAAC;QAClC,IAAI,IAAI,CAAC,YAAY,YAAY,MAAM,EAAE,CAAC;YACxC,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACnD,CAAC;QAED,OAAO,iBAAiB,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC7E,CAAC;IAES,qBAAqB,CAAS;IAC9B,sBAAsB,CAAS;IAE/B,mBAAmB,CAAsB;IAEzC,wBAAwB;QAChC,MAAM,sBAAsB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACxD,IAAI,CAAC,+BAA+B,EAAE,CAAC;QAEvC,IACE,CAAC,IAAI,CAAC,0BAA0B;YAChC,CAAC,sBAAsB;YACvB,sBAAsB,CAAC,gCAAgC,KAAK,CAAC,EAC7D,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,iBAAiB,GAAW,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAChE,KACE,IAAI,cAAc,GAAG,CAAC,EACtB,cAAc,GAAG,sBAAsB,CAAC,wBAAwB,CAAC,MAAM,EACvE,EAAE,cAAc,EAChB,CAAC;YACD,MAAM,qBAAqB,GACzB,sBAAsB,CAAC,wBAAwB,CAAC,cAAc,CAAC,CAAC;YAClE,IACE,CAAC,qBAAqB;gBACtB,CAAC,qBAAqB,CAAC,KAAK;gBAC5B,CAAC,qBAAqB,CAAC,KAAK,CAAC,MAAM,EACnC,CAAC;gBACD,SAAS;YACX,CAAC;YAED,IAAI,qBAAqB,CAAC,KAAK,CAAC,MAAM,KAAK,iBAAiB,EAAE,CAAC;gBAC7D,OAAO;YACT,CAAC;YAED,IAAI,YAAY,GAAG,KAAK,CAAC;YACzB,IAAI,eAAe,GAAG,iBAAiB,GAAG,cAAc,CAAC;YACzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,iBAAiB,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC3C,IACE,CAAC,IAAI,CAAC,YAAY,CAChB,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,EAC9B,IAAI,CAAC,KAAK,CAAC,eAAe,GAAG,CAAC,CAAC,CAChC,EACD,CAAC;oBACD,YAAY,GAAG,IAAI,CAAC;oBACpB,MAAM;gBACR,CAAC;YACH,CAAC;YAED,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,EAAE,IAAI,CAAC,mBAAmB,CAAC,gCAAgC,CAAC;gBAC5D,IAAI,CAAC,mBAAmB,CAAC,8BAA8B;oBACrD,qBAAqB,CAAC,UAAU,IAAI,CAAC,CAAC;gBACxC,IAAI,CAAC,mBAAmB,CAAC,+BAA+B;oBACtD,qBAAqB,CAAC,WAAW,IAAI,CAAC,CAAC;gBACzC,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,cAAc,CAAC;oBAC/D,qBAAqB,CAAC;YAC1B,CAAC;QACH,CAAC;IACH,CAAC;IAES,mBAAmB;QAC3B,IAAI,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE5C,MAAM,0BAA0B,GAAW,EAAE,CAAC,CAAC,2HAA2H;QAC1K,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,GAAG,CACvC,IAAI,CAAC,GAAG,CACN,aAAa,CAAC,YAAY,GAAG,aAAa,CAAC,YAAY,EACvD,0BAA0B,CAC3B,EACD,IAAI,CAAC,yBAAyB,CAC/B,CAAC;QACF,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,GAAG,CACtC,IAAI,CAAC,GAAG,CACN,aAAa,CAAC,WAAW,GAAG,aAAa,CAAC,WAAW,EACrD,0BAA0B,CAC3B,EACD,IAAI,CAAC,wBAAwB,CAC9B,CAAC;QAEF,IAAI,aAAa,GACf,aAAa,CAAC,WAAW;YACzB,CAAC,IAAI,CAAC,cAAc;gBAClB,IAAI,CAAC,wBAAwB;gBAC7B,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC;QACxD,IAAI,cAAc,GAChB,aAAa,CAAC,YAAY;YAC1B,CAAC,IAAI,CAAC,eAAe;gBACnB,IAAI,CAAC,yBAAyB;gBAC9B,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAExD,IAAI,OAAO,GACT,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC;YACpE,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC;QAEvC,IAAI,iBAAiB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACtD,IAAI,iBAAiB,CAAC;QAEtB,IAAI,iBAAiB,CAAC;QACtB,IAAI,kBAAkB,CAAC;QAEvB,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC;YACtC,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC;YACxC,iBAAiB,GAAG,IAAI,CAAC,aAAa,CAAC;YACvC,kBAAkB,GAAG,IAAI,CAAC,cAAc,CAAC;YACzC,IAAI,WAAW,GAAG,IAAI,CAAC,GAAG,CACxB,IAAI,CAAC,IAAI,CAAC,aAAa,GAAG,iBAAiB,CAAC,EAC5C,CAAC,CACF,CAAC;YACF,IAAI,WAAW,GAAG,IAAI,CAAC,GAAG,CACxB,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,EAC9C,CAAC,CACF,CAAC;YACF,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC;QAClE,CAAC;aAAM,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;YAC5C,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChC,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;oBAC1C,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;wBACrD,IAAI,CAAC,qBAAqB,GAAG,aAAa,CAAC;oBAC7C,CAAC;oBACD,IAAI,CAAC,IAAI,CAAC,sBAAsB,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;wBACvD,IAAI,CAAC,sBAAsB,GAAG,cAAc,CAAC;oBAC/C,CAAC;gBACH,CAAC;gBAED,IAAI,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAChC,IAAI,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gBAC5C,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,CACnC,IAAI,CAAC,qBAAqB,EAC1B,UAAU,CAAC,KAAK,CACjB,CAAC;gBACF,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,GAAG,CACpC,IAAI,CAAC,sBAAsB,EAC3B,UAAU,CAAC,MAAM,CAClB,CAAC;YACJ,CAAC;YAED,iBAAiB;gBACf,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,qBAAqB,IAAI,aAAa,CAAC;YACjE,kBAAkB;gBAChB,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,sBAAsB,IAAI,cAAc,CAAC;YACpE,IAAI,WAAW,GAAG,IAAI,CAAC,GAAG,CACxB,IAAI,CAAC,IAAI,CAAC,aAAa,GAAG,iBAAiB,CAAC,EAC5C,CAAC,CACF,CAAC;YACF,IAAI,WAAW,GAAG,IAAI,CAAC,GAAG,CACxB,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,kBAAkB,CAAC,EAC9C,CAAC,CACF,CAAC;YACF,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC;QAClE,CAAC;aAAM,CAAC;YACN,IAAI,YAAY,GACd,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC;gBAC/B,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE9D,IAAI,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,IAAI,CAAC,CAAC;YACtE,IAAI,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,iBAAiB,CAAC,CAAC;YAEpE,IAAI,oBAAoB,GAAG,CAAC,CAAC;YAC7B,IAAI,qBAAqB,GAAG,CAAC,CAAC;YAC9B,IAAI,qBAAqB,GAAG,CAAC,CAAC;YAC9B,IAAI,sBAAsB,GAAG,CAAC,CAAC;YAC/B,iBAAiB,GAAG,CAAC,CAAC;YAEtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;gBACjD,EAAE,eAAe,CAAC;gBAClB,IAAI,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAChC,IAAI,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gBAE5C,oBAAoB,GAAG,IAAI,CAAC,GAAG,CAAC,oBAAoB,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;gBACxE,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAC9B,qBAAqB,EACrB,UAAU,CAAC,MAAM,CAClB,CAAC;gBAEF,IAAI,eAAe,GAAG,iBAAiB,KAAK,CAAC,EAAE,CAAC;oBAC9C,IAAI,QAAQ,GACV,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,cAAc,CAAC,CAAC;oBACpE,IAAI,QAAQ,EAAE,CAAC;wBACb,EAAE,IAAI,CAAC,mBAAmB,CAAC,gCAAgC,CAAC;wBAC5D,IAAI,CAAC,mBAAmB,CAAC,8BAA8B;4BACrD,QAAQ,CAAC,UAAU,IAAI,CAAC,CAAC;wBAC3B,IAAI,CAAC,mBAAmB,CAAC,+BAA+B;4BACtD,QAAQ,CAAC,WAAW,IAAI,CAAC,CAAC;oBAC9B,CAAC;oBAED,EAAE,IAAI,CAAC,mBAAmB,CAAC,gCAAgC,CAAC;oBAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAC5B,eAAe,GAAG,iBAAiB,EACnC,eAAe,CAChB,CAAC;oBACF,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,cAAc,CAAC,GAAG;wBAClE,UAAU,EAAE,oBAAoB;wBAChC,WAAW,EAAE,qBAAqB;wBAClC,KAAK,EAAE,KAAK;qBACb,CAAC;oBACF,IAAI,CAAC,mBAAmB,CAAC,8BAA8B;wBACrD,oBAAoB,CAAC;oBACvB,IAAI,CAAC,mBAAmB,CAAC,+BAA+B;wBACtD,qBAAqB,CAAC;oBAExB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;wBACpB,IAAI,2BAA2B,GAAG,IAAI,CAAC,GAAG,CACxC,oBAAoB,EACpB,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,qBAAqB,EAAE,CAAC,CAAC,CACnD,CAAC;wBACF,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;4BACrB,IAAI,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACjC,YAAY,EACZ,2BAA2B,CAC5B,CAAC;4BACF,2BAA2B,IAAI,oBAAoB,CAAC;4BACpD,YAAY,IAAI,oBAAoB,CAAC;wBACvC,CAAC;wBAED,qBAAqB,IAAI,2BAA2B,CAAC;wBACrD,IACE,2BAA2B,GAAG,CAAC;4BAC/B,aAAa,IAAI,qBAAqB,EACtC,CAAC;4BACD,EAAE,iBAAiB,CAAC;wBACtB,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,IAAI,4BAA4B,GAAG,IAAI,CAAC,GAAG,CACzC,qBAAqB,EACrB,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,sBAAsB,EAAE,CAAC,CAAC,CACrD,CAAC;wBACF,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;4BACrB,IAAI,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACjC,YAAY,EACZ,4BAA4B,CAC7B,CAAC;4BACF,4BAA4B,IAAI,oBAAoB,CAAC;4BACrD,YAAY,IAAI,oBAAoB,CAAC;wBACvC,CAAC;wBAED,sBAAsB,IAAI,4BAA4B,CAAC;wBACvD,IACE,4BAA4B,GAAG,CAAC;4BAChC,cAAc,IAAI,sBAAsB,EACxC,CAAC;4BACD,EAAE,iBAAiB,CAAC;wBACtB,CAAC;oBACH,CAAC;oBAED,EAAE,cAAc,CAAC;oBAEjB,oBAAoB,GAAG,CAAC,CAAC;oBACzB,qBAAqB,GAAG,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;YAED,IAAI,iBAAiB,GACnB,IAAI,CAAC,mBAAmB,CAAC,8BAA8B;gBACvD,IAAI,CAAC,mBAAmB,CAAC,gCAAgC,CAAC;YAC5D,IAAI,kBAAkB,GACpB,IAAI,CAAC,mBAAmB,CAAC,+BAA+B;gBACxD,IAAI,CAAC,mBAAmB,CAAC,gCAAgC,CAAC;YAC5D,iBAAiB,GAAG,IAAI,CAAC,UAAU,IAAI,iBAAiB,IAAI,aAAa,CAAC;YAC1E,kBAAkB;gBAChB,IAAI,CAAC,WAAW,IAAI,kBAAkB,IAAI,cAAc,CAAC;YAE3D,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpB,IAAI,aAAa,GAAG,qBAAqB,EAAE,CAAC;oBAC1C,iBAAiB,IAAI,IAAI,CAAC,IAAI,CAC5B,CAAC,aAAa,GAAG,qBAAqB,CAAC,GAAG,iBAAiB,CAC5D,CAAC;gBACJ,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,cAAc,GAAG,sBAAsB,EAAE,CAAC;oBAC5C,iBAAiB,IAAI,IAAI,CAAC,IAAI,CAC5B,CAAC,cAAc,GAAG,sBAAsB,CAAC,GAAG,kBAAkB,CAC/D,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAClC,IAAI,YAAY,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;QACzD,IAAI,oBAAoB,GAAG,SAAS,GAAG,YAAY,CAAC;QACpD,IAAI,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,iBAAiB,CAAC,CAAC;QAElE,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,IAAI,+BAA+B,GAAG,IAAI,CAAC,UAAU;YACnD,CAAC,CAAC,iBAAiB;YACnB,CAAC,CAAC,kBAAkB,CAAC;QACvB,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,IAAI,oBAAoB,GAAG,CAAC,CAAC;YAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC5C,IAAI,SAAS,GACX,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC;oBACpD,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAClD,IAAI,CAAC,eAAe,CACrB,CAAC;gBACJ,IAAI,SAAS,EAAE,CAAC;oBACd,YAAY,IAAI,SAAS,CAAC;gBAC5B,CAAC;qBAAM,CAAC;oBACN,EAAE,oBAAoB,CAAC;gBACzB,CAAC;YACH,CAAC;YAED,YAAY,IAAI,IAAI,CAAC,KAAK,CACxB,oBAAoB,GAAG,+BAA+B,CACvD,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,YAAY,GAAG,kBAAkB,GAAG,+BAA+B,CAAC;QACtE,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,YAAY,IAAI,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,YAAY,CAAC;QACnE,CAAC;QAED,IAAI,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,cAAc,CAAC;QACtE,IAAI,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,cAAc,EAAE,CAAC,CAAC,CAAC;QAEnE,OAAO;YACL,SAAS,EAAE,SAAS;YACpB,iBAAiB,EAAE,iBAAiB;YACpC,iBAAiB,EAAE,iBAAiB;YACpC,YAAY,EAAE,YAAY;YAC1B,oBAAoB,EAAE,oBAAoB;YAC1C,UAAU,EAAE,iBAAiB;YAC7B,WAAW,EAAE,kBAAkB;YAC/B,YAAY,EAAE,YAAY;YAC1B,cAAc,EAAE,cAAc;YAC9B,iBAAiB,EAAE,iBAAiB;SACrC,CAAC;IACJ,CAAC;IAES,cAAc,GAAW,CAAC,CAAC;IAC3B,4BAA4B,GAAW,CAAC,CAAC;IAEzC,gBAAgB,CACxB,yBAAiC,EACjC,UAAuB;QAEvB,IAAI,UAAU,CAAC,SAAS,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,CAAC,CAAC;QACX,CAAC;QAED,IAAI,+BAA+B,GAAG,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACvE,IAAI,sBAAsB,GACxB,IAAI,CAAC,KAAK,CAAC,yBAAyB,GAAG,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAE5E,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACrC,OAAO,+BAA+B,GAAG,sBAAsB,CAAC;QAClE,CAAC;QAED,IAAI,oBAAoB,GAAG,CAAC,CAAC;QAC7B,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,sBAAsB,EAAE,EAAE,CAAC,EAAE,CAAC;YAChD,IAAI,SAAS,GACX,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC;gBACpD,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAClD,IAAI,CAAC,eAAe,CACrB,CAAC;YACJ,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,IAAI,SAAS,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,EAAE,oBAAoB,CAAC;YACzB,CAAC;QACH,CAAC;QACD,MAAM,IAAI,IAAI,CAAC,KAAK,CAClB,oBAAoB,GAAG,+BAA+B,CACvD,CAAC;QAEF,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,iBAAiB,CACzB,cAAsB,EACtB,UAAuB;QAEvB,IAAI,gBAAgB,GAAG,CAAC,CAAC;QACzB,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAClC,UAAU,CAAC,SAAS,GAAG,UAAU,CAAC,iBAAiB,CACpD,CAAC;YACF,IAAI,mBAAmB,GAAG,CAAC,CAAC;YAC5B,IAAI,+BAA+B,GAAG,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC5C,IAAI,SAAS,GACX,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC;oBACpD,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAClD,IAAI,CAAC,eAAe,CACrB,CAAC;gBACJ,IAAI,SAAS,EAAE,CAAC;oBACd,mBAAmB,IAAI,SAAS,CAAC;gBACnC,CAAC;qBAAM,CAAC;oBACN,mBAAmB,IAAI,+BAA+B,CAAC;gBACzD,CAAC;gBAED,IAAI,cAAc,GAAG,mBAAmB,EAAE,CAAC;oBACzC,gBAAgB,GAAG,CAAC,GAAG,kBAAkB,CAAC;oBAC1C,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,gBAAgB,GAAG,cAAc,GAAG,UAAU,CAAC,YAAY,CAAC;QAC9D,CAAC;QAED,IAAI,6BAA6B,GAC/B,IAAI,CAAC,GAAG,CACN,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,UAAU,CAAC,oBAAoB,EAAE,CAAC,CAAC,EAC/D,UAAU,CAAC,oBAAoB,CAChC,GAAG,UAAU,CAAC,YAAY,CAAC;QAE9B,IAAI,QAAQ,GAAG,UAAU,CAAC,SAAS,GAAG,UAAU,CAAC,YAAY,GAAG,CAAC,CAAC;QAClE,IAAI,eAAe,GAAG,IAAI,CAAC,GAAG,CAC5B,IAAI,CAAC,KAAK,CAAC,6BAA6B,CAAC,EACzC,QAAQ,CACT,CAAC;QACF,eAAe,IAAI,eAAe,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,mCAAmC;QAEtG,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,cAAc,GAAG,CAAC,GAAG,UAAU,CAAC,iBAAiB,CAAC;YACtD,IAAI,eAAe,GAAG,cAAc,KAAK,CAAC,EAAE,CAAC;gBAC3C,eAAe,GAAG,IAAI,CAAC,GAAG,CACxB,eAAe,GAAG,CAAC,eAAe,GAAG,cAAc,CAAC,EACpD,CAAC,CACF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IAAI,aAAa,GACf,IAAI,CAAC,IAAI,CAAC,6BAA6B,CAAC,GAAG,UAAU,CAAC,YAAY,GAAG,CAAC,CAAC;QACzE,IAAI,uBAAuB,GACzB,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,iBAAiB,CAAC;QACrD,IAAI,uBAAuB,GAAG,CAAC,EAAE,CAAC;YAChC,aAAa,IAAI,UAAU,CAAC,iBAAiB,GAAG,uBAAuB,CAAC,CAAC,+BAA+B;QAC1G,CAAC;QAED,IAAI,KAAK,CAAC,eAAe,CAAC,EAAE,CAAC;YAC3B,eAAe,GAAG,CAAC,CAAC;QACtB,CAAC;QACD,IAAI,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;YACzB,aAAa,GAAG,CAAC,CAAC;QACpB,CAAC;QAED,eAAe,GAAG,IAAI,CAAC,GAAG,CACxB,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,CAAC,EAC5B,UAAU,CAAC,SAAS,GAAG,CAAC,CACzB,CAAC;QACF,aAAa,GAAG,IAAI,CAAC,GAAG,CACtB,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC,CAAC,EAC1B,UAAU,CAAC,SAAS,GAAG,CAAC,CACzB,CAAC;QAEF,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,iBAAiB,CAAC;QAClE,IAAI,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACjC,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,UAAU,EAAE,CAAC,CAAC,EACzC,UAAU,CAAC,SAAS,GAAG,CAAC,CACzB,CAAC;QACF,IAAI,kBAAkB,GAAG,IAAI,CAAC,GAAG,CAC/B,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,UAAU,EAAE,CAAC,CAAC,EACvC,UAAU,CAAC,SAAS,GAAG,CAAC,CACzB,CAAC;QAEF,OAAO;YACL,UAAU,EAAE,eAAe;YAC3B,QAAQ,EAAE,aAAa;YACvB,oBAAoB,EAAE,oBAAoB;YAC1C,kBAAkB,EAAE,kBAAkB;YACtC,mBAAmB,EAAE,cAAc;YACnC,iBAAiB,EAAE,cAAc,GAAG,UAAU,CAAC,cAAc;YAC7D,iBAAiB,EAAE,UAAU,CAAC,iBAAiB;SAChD,CAAC;IACJ,CAAC;IAES,iBAAiB;QACzB,IAAI,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC5C,IAAI,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEtC,IAAI,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACxD,IACE,mBAAmB,GAAG,UAAU,CAAC,YAAY,GAAG,MAAM;YACtD,CAAC,CAAC,IAAI,CAAC,YAAY,YAAY,MAAM,CAAC,EACtC,CAAC;YACD,mBAAmB,GAAG,UAAU,CAAC,YAAY,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,mBAAmB,IAAI,MAAM,CAAC;QAChC,CAAC;QACD,mBAAmB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC;QAEvD,IAAI,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,UAAU,CAAC,CAAC;QACvE,IAAI,UAAU,GAAG,IAAI,CAAC,gBAAgB,CACpC,QAAQ,CAAC,oBAAoB,EAC7B,UAAU,CACX,CAAC;QACF,IAAI,eAAe,GAAG,UAAU,CAAC,YAAY,CAAC;QAE9C,OAAO;YACL,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;YACnD,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB;YAC/C,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC;YAC/B,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;YACzC,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB;YACjD,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;YAC7C,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;SAC9C,CAAC;IACJ,CAAC;wGAl+CU,wBAAwB,4HA2fzB,WAAW,aAEX,kCAAkC;4FA7fjC,wBAAwB,wyCAkOH,UAAU,2GAGP,UAAU,sHATf,UAAU,yHAGD,UAAU,iFAlSvC;;;;;GAKT;;4FA8DU,wBAAwB;kBAtEpC,SAAS;+BACE,oCAAoC,YACpC,iBAAiB,YACjB;;;;;GAKT,QACK;wBACJ,oBAAoB,EAAE,YAAY;wBAClC,kBAAkB,EAAE,aAAa;wBACjC,oBAAoB,EAAE,eAAe;qBACtC;;0BAojBE,MAAM;2BAAC,WAAW;;0BAClB,QAAQ;;0BACR,MAAM;2BAAC,kCAAkC;yCA3erC,gCAAgC;sBADtC,KAAK;gBAKK,0BAA0B;sBADpC,KAAK;gBAeC,2BAA2B;sBADjC,KAAK;gBAIC,iCAAiC;sBADvC,KAAK;gBAIC,YAAY;sBADlB,KAAK;gBAIC,cAAc;sBADpB,KAAK;gBAIC,eAAe;sBADrB,KAAK;gBAIC,UAAU;sBADhB,KAAK;gBAIC,WAAW;sBADjB,KAAK;gBAIC,aAAa;sBADnB,KAAK;gBAIC,cAAc;sBADpB,KAAK;gBAIC,gBAAgB;sBADtB,KAAK;gBAIC,iBAAiB;sBADvB,KAAK;gBAKK,YAAY;sBADtB,KAAK;gBAaC,mBAAmB;sBADzB,KAAK;gBAIC,4BAA4B;sBADlC,KAAK;gBAKK,oBAAoB;sBAD9B,KAAK;gBAWK,kBAAkB;sBAD5B,KAAK;gBA6BK,mBAAmB;sBAD7B,KAAK;gBAeK,KAAK;sBADf,KAAK;gBAcC,YAAY;sBADlB,KAAK;gBAQK,UAAU;sBADpB,KAAK;gBAsBK,YAAY;sBADtB,KAAK;gBA4BC,QAAQ;sBADd,MAAM;gBAIA,QAAQ;sBADd,MAAM;gBAIA,OAAO;sBADb,MAAM;gBAIA,KAAK;sBADX,MAAM;gBAIG,iBAAiB;sBAD1B,SAAS;uBAAC,SAAS,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE;gBAI/C,0BAA0B;sBADnC,SAAS;uBAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE;gBAIxD,gBAAgB;sBADzB,YAAY;uBAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE;gBAIjD,mBAAmB;sBAD5B,YAAY;uBAAC,WAAW,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE;;AA2wChE,MAAM,OAAO,qBAAqB;wGAArB,qBAAqB;yGAArB,qBAAqB,iBAh/CrB,wBAAwB,aAw+CzB,YAAY,aAx+CX,wBAAwB;yGAg/CxB,qBAAqB,aAPrB;YACT;gBACE,OAAO,EAAE,kCAAkC;gBAC3C,UAAU,EAAE,wCAAwC;aACrD;SACF,YANS,YAAY;;4FAQX,qBAAqB;kBAXjC,QAAQ;mBAAC;oBACR,OAAO,EAAE,CAAC,wBAAwB,CAAC;oBACnC,YAAY,EAAE,CAAC,wBAAwB,CAAC;oBACxC,OAAO,EAAE,CAAC,YAAY,CAAC;oBACvB,SAAS,EAAE;wBACT;4BACE,OAAO,EAAE,kCAAkC;4BAC3C,UAAU,EAAE,wCAAwC;yBACrD;qBACF;iBACF","sourcesContent":["import {\n  Component,\n  ContentChild,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Optional,\n  Input,\n  NgModule,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  ViewChild,\n  ChangeDetectorRef,\n} from '@angular/core';\n\nimport { PLATFORM_ID } from '@angular/core';\nimport { isPlatformServer } from '@angular/common';\n\nimport { CommonModule } from '@angular/common';\n\nimport * as tween from '@tweenjs/tween.js';\nimport { VirtualScrollerDefaultOptions } from './defaultoptions';\nimport { IPageInfo } from './ipageinfo';\nimport { IViewport } from './iviewport';\n\nimport { WrapGroupDimensions } from './wrapgroupdimensions';\nimport { WrapGroupDimension } from './wrapgroupdimension';\n\nimport { IDimensions } from './idimension';\n\nexport function VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY(): VirtualScrollerDefaultOptions {\n  return {\n    scrollThrottlingTime: 0,\n    scrollDebounceTime: 0,\n    scrollAnimationTime: 750,\n    checkResizeInterval: 1000,\n    resizeBypassRefreshThreshold: 5,\n    modifyOverflowStyleOfParentScroll: true,\n    stripedTable: false,\n  };\n}\n\n@Component({\n  selector: 'virtual-scroller,[virtualScroller]',\n  exportAs: 'virtualScroller',\n  template: `\n    <div class=\"total-padding\" #invisiblePadding></div>\n    <div class=\"scrollable-content\" #content>\n      <ng-content></ng-content>\n    </div>\n  `,\n  host: {\n    '[class.horizontal]': 'horizontal',\n    '[class.vertical]': '!horizontal',\n    '[class.selfScroll]': '!parentScroll',\n  },\n  styles: [\n    `\n      :host {\n        position: relative;\n        display: block;\n        -webkit-overflow-scrolling: touch;\n      }\n\n      :host.horizontal.selfScroll {\n        overflow-y: visible;\n        overflow-x: auto;\n      }\n      :host.vertical.selfScroll {\n        overflow-y: auto;\n        overflow-x: visible;\n      }\n\n      .scrollable-content {\n        top: 0;\n        left: 0;\n        width: 100%;\n        height: 100%;\n        max-width: 100vw;\n        max-height: 100vh;\n        position: absolute;\n      }\n\n      .scrollable-content ::ng-deep > * {\n        box-sizing: border-box;\n      }\n\n      :host.horizontal {\n        white-space: nowrap;\n      }\n\n      :host.horizontal .scrollable-content {\n        display: flex;\n      }\n\n      :host.horizontal .scrollable-content ::ng-deep > * {\n        flex-shrink: 0;\n        flex-grow: 0;\n        white-space: initial;\n      }\n\n      .total-padding {\n        width: 1px;\n        opacity: 0;\n      }\n\n      :host.horizontal .total-padding {\n        height: 100%;\n      }\n    `,\n  ],\n})\nexport class VirtualScrollerComponent implements OnInit, OnChanges, OnDestroy {\n  public viewPortItems: any[];\n  public window = window;\n\n  public get viewPortInfo(): IPageInfo {\n    let pageInfo: IViewport = this.previousViewPort || <any>{};\n    return {\n      startIndex: pageInfo.startIndex || 0,\n      endIndex: pageInfo.endIndex || 0,\n      scrollStartPosition: pageInfo.scrollStartPosition || 0,\n      scrollEndPosition: pageInfo.scrollEndPosition || 0,\n      maxScrollPosition: pageInfo.maxScrollPosition || 0,\n      startIndexWithBuffer: pageInfo.startIndexWithBuffer || 0,\n      endIndexWithBuffer: pageInfo.endIndexWithBuffer || 0,\n    };\n  }\n\n  @Input()\n  public executeRefreshOutsideAngularZone: boolean = false;\n\n  protected _enableUnequalChildrenSizes: boolean = false;\n  @Input()\n  public get enableUnequalChildrenSizes(): boolean {\n    return this._enableUnequalChildrenSizes;\n  }\n  public set enableUnequalChildrenSizes(value: boolean) {\n    if (this._enableUnequalChildrenSizes === value) {\n      return;\n    }\n\n    this._enableUnequalChildrenSizes = value;\n    this.minMeasuredChildWidth = undefined;\n    this.minMeasuredChildHeight = undefined;\n  }\n\n  @Input()\n  public useMarginInsteadOfTranslate: boolean = false;\n\n  @Input()\n  public modifyOverflowStyleOfParentScroll: boolean;\n\n  @Input()\n  public stripedTable: boolean;\n\n  @Input()\n  public scrollbarWidth: number;\n\n  @Input()\n  public scrollbarHeight: number;\n\n  @Input()\n  public childWidth: number;\n\n  @Input()\n  public childHeight: number;\n\n  @Input()\n  public ssrChildWidth: number;\n\n  @Input()\n  public ssrChildHeight: number;\n\n  @Input()\n  public ssrViewportWidth: number = 1920;\n\n  @Input()\n  public ssrViewportHeight: number = 1080;\n\n  protected _bufferAmount: number = 0;\n  @Input()\n  public get bufferAmount(): number {\n    if (typeof this._bufferAmount === 'number' && this._bufferAmount >= 0) {\n      return this._bufferAmount;\n    } else {\n      return this.enableUnequalChildrenSizes ? 5 : 0;\n    }\n  }\n  public set bufferAmount(value: number) {\n    this._bufferAmount = value;\n  }\n\n  @Input()\n  public scrollAnimationTime: number;\n\n  @Input()\n  public resizeBypassRefreshThreshold: number;\n\n  protected _scrollThrottlingTime: number;\n  @Input()\n  public get scrollThrottlingTime(): number {\n    return this._scrollThrottlingTime;\n  }\n  public set scrollThrottlingTime(value: number) {\n    this._scrollThrottlingTime = value;\n    this.updateOnScrollFunction();\n  }\n\n  protected _scrollDebounceTime: number;\n  @Input()\n  public get scrollDebounceTime(): number {\n    return this._scrollDebounceTime;\n  }\n  public set scrollDebounceTime(value: number) {\n    this._scrollDebounceTime = value;\n    this.updateOnScrollFunction();\n  }\n\n  protected onScroll: () => void;\n  protected updateOnScrollFunction(): void {\n    if (this.scrollDebounceTime) {\n      this.onScroll = <any>this.debounce(() => {\n        this.refresh_internal(false);\n      }, this.scrollDebounceTime);\n    } else if (this.scrollThrottlingTime) {\n      this.onScroll = <any>this.throttleTrailing(() => {\n        this.refresh_internal(false);\n      }, this.scrollThrottlingTime);\n    } else {\n      this.onScroll = () => {\n        this.refresh_internal(false);\n      };\n    }\n  }\n\n  protected checkScrollElementResizedTimer: number;\n  protected _checkResizeInterval: number;\n  @Input()\n  public get checkResizeInterval(): number {\n    return this._checkResizeInterval;\n  }\n  public set checkResizeInterval(value: number) {\n    if (this._checkResizeInterval === value) {\n      return;\n    }\n\n    this._checkResizeInterval = value;\n    this.addScrollEventHandlers();\n  }\n\n  protected _items: any[] = [];\n  @Input()\n  public get items(): any[] {\n    return this._items;\n  }\n  public set items(value: any[]) {\n    if (value === this._items) {\n      return;\n    }\n\n    this._items = value || [];\n    this.refresh_internal(true);\n  }\n\n  @Input()\n  public compareItems: (item1: any, item2: any) => boolean = (\n    item1: any,\n    item2: any,\n  ) => item1 === item2;\n\n  protected _horizontal: boolean;\n  @Input()\n  public get horizontal(): boolean {\n    return this._horizontal;\n  }\n  public set horizontal(value: boolean) {\n    this._horizontal = value;\n    this.updateDirection();\n  }\n\n  protected revertParentOverscroll(): void {\n    const scrollElement = this.getScrollElement();\n    if (scrollElement && this.oldParentScrollOverflow) {\n      scrollElement.style['overflow-y'] = this.oldParentScrollOverflow.y;\n      scrollElement.style['overflow-x'] = this.oldParentScrollOverflow.x;\n    }\n\n    this.oldParentScrollOverflow = undefined;\n  }\n\n  protected oldParentScrollOverflow: { x: string; y: string };\n  protected _parentScroll: Element | Window;\n  @Input()\n  public get parentScroll(): Element | Window {\n    return this._parentScroll;\n  }\n  public set parentScroll(value: Element | Window) {\n    if (this._parentScroll === value) {\n      return;\n    }\n\n    this.revertParentOverscroll();\n    this._parentScroll = value;\n    this.addScrollEventHandlers();\n\n    const scrollElement = this.getScrollElement();\n    if (\n      this.modifyOverflowStyleOfParentScroll &&\n      scrollElement !== this.element.nativeElement\n    ) {\n      this.oldParentScrollOverflow = {\n        x: scrollElement.style['overflow-x'],\n        y: scrollElement.style['overflow-y'],\n      };\n      scrollElement.style['overflow-y'] = this.horizontal ? 'visible' : 'auto';\n      scrollElement.style['overflow-x'] = this.horizontal ? 'auto' : 'visible';\n    }\n  }\n\n  @Output()\n  public vsUpdate: EventEmitter<any[]> = new EventEmitter<any[]>();\n\n  @Output()\n  public vsChange: EventEmitter<IPageInfo> = new EventEmitter<IPageInfo>();\n\n  @Output()\n  public vsStart: EventEmitter<IPageInfo> = new EventEmitter<IPageInfo>();\n\n  @Output()\n  public vsEnd: EventEmitter<IPageInfo> = new EventEmitter<IPageInfo>();\n\n  @ViewChild('content', { read: ElementRef, static: false })\n  protected contentElementRef: ElementRef;\n\n  @ViewChild('invisiblePadding', { read: ElementRef, static: false })\n  protected invisiblePaddingElementRef: ElementRef;\n\n  @ContentChild('header', { read: ElementRef, static: false })\n  protected headerElementRef: ElementRef;\n\n  @ContentChild('container', { read: ElementRef, static: false })\n  protected containerElementRef: ElementRef;\n\n  public ngOnInit(): void {\n    this.addScrollEventHandlers();\n  }\n\n  public ngOnDestroy(): void {\n    this.removeScrollEventHandlers();\n    this.revertParentOverscroll();\n  }\n\n  public ngOnChanges(changes: any): void {\n    let indexLengthChanged = this.cachedItemsLength !== this.items.length;\n    this.cachedItemsLength = this.items.length;\n\n    const firstRun: boolean =\n      !changes.items ||\n      !changes.items.previousValue ||\n      changes.items.previousValue.length === 0;\n    this.refresh_internal(indexLengthChanged || firstRun);\n  }\n\n  public ngDoCheck(): void {\n    if (this.cachedItemsLength !== this.items.length) {\n      this.cachedItemsLength = this.items.length;\n      this.refresh_internal(true);\n      return;\n    }\n\n    if (\n      this.previousViewPort &&\n      this.viewPortItems &&\n      this.viewPortItems.length > 0\n    ) {\n      let itemsArrayChanged = false;\n      for (let i = 0; i < this.viewPortItems.length; ++i) {\n        if (\n          !this.compareItems(\n            this.items[this.previousViewPort.startIndexWithBuffer + i],\n            this.viewPortItems[i],\n          )\n        ) {\n          itemsArrayChanged = true;\n          break;\n        }\n      }\n      if (itemsArrayChanged) {\n        this.refresh_internal(true);\n      }\n    }\n  }\n\n  public refresh(): void {\n    this.refresh_internal(true);\n  }\n\n  public invalidateAllCachedMeasurements(): void {\n    this.wrapGroupDimensions = {\n      maxChildSizePerWrapGroup: [],\n      numberOfKnownWrapGroupChildSizes: 0,\n      sumOfKnownWrapGroupChildWidths: 0,\n      sumOfKnownWrapGroupChildHeights: 0,\n    };\n\n    this.minMeasuredChildWidth = undefined;\n    this.minMeasuredChildHeight = undefined;\n\n    this.refresh_internal(false);\n  }\n\n  public invalidateCachedMeasurementForItem(item: any): void {\n    if (this.enableUnequalChildrenSizes) {\n      let index = this.items && this.items.indexOf(item);\n      if (index >= 0) {\n        this.invalidateCachedMeasurementAtIndex(index);\n      }\n    } else {\n      this.minMeasuredChildWidth = undefined;\n      this.minMeasuredChildHeight = undefined;\n    }\n\n    this.refresh_internal(false);\n  }\n\n  public invalidateCachedMeasurementAtIndex(index: number): void {\n    if (this.enableUnequalChildrenSizes) {\n      let cachedMeasurement =\n        this.wrapGroupDimensions.maxChildSizePerWrapGroup[index];\n      if (cachedMeasurement) {\n        this.wrapGroupDimensions.maxChildSizePerWrapGroup[index] = undefined;\n        --this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\n        this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -=\n          cachedMeasurement.childWidth || 0;\n        this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -=\n          cachedMeasurement.childHeight || 0;\n      }\n    } else {\n      this.minMeasuredChildWidth = undefined;\n      this.minMeasuredChildHeight = undefined;\n    }\n\n    this.refresh_internal(false);\n  }\n\n  public scrollInto(\n    item: any,\n    alignToBeginning: boolean = true,\n    additionalOffset: number = 0,\n    animationMilliseconds: number = undefined,\n    animationCompletedCallback: () => void = undefined,\n  ): void {\n    let index: number = this.items.indexOf(item);\n    if (index === -1) {\n      return;\n    }\n\n    this.scrollToIndex(\n      index,\n      alignToBeginning,\n      additionalOffset,\n      animationMilliseconds,\n      animationCompletedCallback,\n    );\n  }\n\n  public scrollToIndex(\n    index: number,\n    alignToBeginning: boolean = true,\n    additionalOffset: number = 0,\n    animationMilliseconds: number = undefined,\n    animationCompletedCallback: () => void = undefined,\n  ): void {\n    let maxRetries: number = 5;\n\n    let retryIfNeeded = () => {\n      --maxRetries;\n      if (maxRetries <= 0) {\n        if (animationCompletedCallback) {\n          animationCompletedCallback();\n        }\n        return;\n      }\n\n      let dimensions = this.calculateDimensions();\n      let desiredStartIndex = Math.min(\n        Math.max(index, 0),\n        dimensions.itemCount - 1,\n      );\n      if (this.previousViewPort.startIndex === desiredStartIndex) {\n        if (animationCompletedCallback) {\n          animationCompletedCallback();\n        }\n        return;\n      }\n\n      this.scrollToIndex_internal(\n        index,\n        alignToBeginning,\n        additionalOffset,\n        0,\n        retryIfNeeded,\n      );\n    };\n\n    this.scrollToIndex_internal(\n      index,\n      alignToBeginning,\n      additionalOffset,\n      animationMilliseconds,\n      retryIfNeeded,\n    );\n  }\n\n  protected scrollToIndex_internal(\n    index: number,\n    alignToBeginning: boolean = true,\n    additionalOffset: number = 0,\n    animationMilliseconds: number = undefined,\n    animationCompletedCallback: () => void = undefined,\n  ): void {\n    animationMilliseconds =\n      animationMilliseconds === undefined\n        ? this.scrollAnimationTime\n        : animationMilliseconds;\n\n    let dimensions = this.calculateDimensions();\n    let scroll = this.calculatePadding(index, dimensions) + additionalOffset;\n    if (!alignToBeginning) {\n      scroll -= dimensions.wrapGroupsPerPage * dimensions[this._childScrollDim];\n    }\n\n    this.scrollToPosition(\n      scroll,\n      animationMilliseconds,\n      animationCompletedCallback,\n    );\n  }\n\n  public scrollToPosition(\n    scrollPosition: number,\n    animationMilliseconds: number = undefined,\n    animationCompletedCallback: () => void = undefined,\n  ): void {\n    scrollPosition += this.getElementsOffset();\n\n    animationMilliseconds =\n      animationMilliseconds === undefined\n        ? this.scrollAnimationTime\n        : animationMilliseconds;\n\n    let scrollElement = this.getScrollElement();\n\n    let animationRequest: number;\n\n    if (this.currentTween) {\n      this.currentTween.stop();\n      this.currentTween = undefined;\n    }\n\n    if (!animationMilliseconds) {\n      this.renderer.setProperty(\n        scrollElement,\n        this._scrollType,\n        scrollPosition,\n      );\n      this.refresh_internal(false, animationCompletedCallback);\n      return;\n    }\n\n    const tweenConfigObj = { scrollPosition: scrollElement[this._scrollType] };\n\n    let newTween = new tween.Tween(tweenConfigObj)\n      .to({ scrollPosition }, animationMilliseconds)\n      .easing(tween.Easing.Quadratic.Out)\n      .onUpdate((data) => {\n        if (isNaN(data.scrollPosition)) {\n          return;\n        }\n        this.renderer.setProperty(\n          scrollElement,\n          this._scrollType,\n          data.scrollPosition,\n        );\n        this.refresh_internal(false);\n      })\n      .onStop(() => {\n        cancelAnimationFrame(animationRequest);\n      })\n      .start();\n\n    const animate = (time?: number) => {\n      if (!newTween['isPlaying']()) {\n        return;\n      }\n\n      newTween.update(time);\n      if (tweenConfigObj.scrollPosition === scrollPosition) {\n        this.refresh_internal(false, animationCompletedCallback);\n        return;\n      }\n\n      this.zone.runOutsideAngular(() => {\n        animationRequest = requestAnimationFrame(animate);\n      });\n    };\n\n    animate();\n    this.currentTween = newTween;\n  }\n\n  protected isAngularUniversalSSR: boolean;\n\n  constructor(\n    protected readonly element: ElementRef,\n    protected readonly renderer: Renderer2,\n    protected readonly zone: NgZone,\n    protected changeDetectorRef: ChangeDetectorRef,\n    @Inject(PLATFORM_ID) platformId: Object,\n    @Optional()\n    @Inject('virtual-scroller-default-options')\n    options: VirtualScrollerDefaultOptions,\n  ) {\n    this.isAngularUniversalSSR = isPlatformServer(platformId);\n\n    this.scrollThrottlingTime = options.scrollThrottlingTime;\n    this.scrollDebounceTime = options.scrollDebounceTime;\n    this.scrollAnimationTime = options.scrollAnimationTime;\n    this.scrollbarWidth = options.scrollbarWidth;\n    this.scrollbarHeight = options.scrollbarHeight;\n    this.checkResizeInterval = options.checkResizeInterval;\n    this.resizeBypassRefreshThreshold = options.resizeBypassRefreshThreshold;\n    this.modifyOverflowStyleOfParentScroll =\n      options.modifyOverflowStyleOfParentScroll;\n    this.stripedTable = options.stripedTable;\n\n    this.horizontal = false;\n    this.resetWrapGroupDimensions();\n  }\n\n  protected getElementSize(element: HTMLElement): ClientRect {\n    let result = element.getBoundingClientRect();\n    let styles = getComputedStyle(element);\n    let marginTop = parseInt(styles['margin-top'], 10) || 0;\n    let marginBottom = parseInt(styles['margin-bottom'], 10) || 0;\n    let marginLeft = parseInt(styles['margin-left'], 10) || 0;\n    let marginRight = parseInt(styles['margin-right'], 10) || 0;\n\n    return {\n      top: result.top + marginTop,\n      bottom: result.bottom + marginBottom,\n      left: result.left + marginLeft,\n      right: result.right + marginRight,\n      width: result.width + marginLeft + marginRight,\n      height: result.height + marginTop + marginBottom,\n      y: result.top + marginTop,\n      x: result.left + marginLeft,\n      toJSON(): any {\n        result.toJSON();\n      },\n    };\n  }\n\n  protected previousScrollBoundingRect: ClientRect;\n  protected checkScrollElementResized(): void {\n    let boundingRect = this.getElementSize(this.getScrollElement());\n\n    let sizeChanged: boolean;\n    if (!this.previousScrollBoundingRect) {\n      sizeChanged = true;\n    } else {\n      let widthChange = Math.abs(\n        boundingRect.width - this.previousScrollBoundingRect.width,\n      );\n      let heightChange = Math.abs(\n        boundingRect.height - this.previousScrollBoundingRect.height,\n      );\n      sizeChanged =\n        widthChange > this.resizeBypassRefreshThreshold ||\n        heightChange > this.resizeBypassRefreshThreshold;\n    }\n\n    if (sizeChanged) {\n      this.previousScrollBoundingRect = boundingRect;\n      if (boundingRect.width > 0 && boundingRect.height > 0) {\n        this.refresh_internal(false);\n      }\n    }\n  }\n\n  protected _invisiblePaddingProperty;\n  protected _offsetType;\n  protected _scrollType;\n  protected _pageOffsetType;\n  protected _childScrollDim;\n  protected _translateDir;\n  protected _marginDir;\n  protected updateDirection(): void {\n    if (this.horizontal) {\n      this._invisiblePaddingProperty = 'width';\n      this._offsetType = 'offsetLeft';\n      this._pageOffsetType = 'pageXOffset';\n      this._childScrollDim = 'childWidth';\n      this._marginDir = 'margin-left';\n      this._translateDir = 'translateX';\n      this._scrollType = 'scrollLeft';\n    } else {\n      this._invisiblePaddingProperty = 'height';\n      this._offsetType = 'offsetTop';\n      this._pageOffsetType = 'pageYOffset';\n      this._childScrollDim = 'childHeight';\n      this._marginDir = 'margin-top';\n      this._translateDir = 'translateY';\n      this._scrollType = 'scrollTop';\n    }\n  }\n\n  protected debounce(func: Function, wait: number): Function {\n    const throttled = this.throttleTrailing(func, wait);\n    const result = function () {\n      throttled['cancel']();\n      throttled.apply(this, arguments);\n    };\n    result['cancel'] = function () {\n      throttled['cancel']();\n    };\n\n    return result;\n  }\n\n  protected throttleTrailing(func: Function, wait: number): Function {\n    let timeout = undefined;\n    let _arguments = arguments;\n    const result = function () {\n      const _this = this;\n      _arguments = arguments;\n\n      if (timeout) {\n        return;\n      }\n\n      if (wait <= 0) {\n        func.apply(_this, _arguments);\n      } else {\n        timeout = setTimeout(function () {\n          timeout = undefined;\n          func.apply(_this, _arguments);\n        }, wait);\n      }\n    };\n    result['cancel'] = function () {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = undefined;\n      }\n    };\n\n    return result;\n  }\n\n  protected calculatedScrollbarWidth: number = 0;\n  protected calculatedScrollbarHeight: number = 0;\n\n  protected padding: number = 0;\n  protected previousViewPort: IViewport = <any>{};\n  protected currentTween: any;\n  protected cachedItemsLength: number;\n\n  protected disposeScrollHandler: () => void | undefined;\n  protected disposeResizeHandler: () => void | undefined;\n\n  protected refresh_internal(\n    itemsArrayModified: boolean,\n    refreshCompletedCallback: () => void = undefined,\n    maxRunTimes: number = 2,\n  ): void {\n    //note: maxRunTimes is to force it to keep recalculating if the previous iteration caused a re-render (different sliced items in viewport or scrollPosition changed).\n    //The default of 2x max will probably be accurate enough without causing too large a performance bottleneck\n    //The code would typically quit out on the 2nd iteration anyways. The main time it'd think more than 2 runs would be necessary would be for vastly different sized child items or if this is the 1st time the items array was initialized.\n    //Without maxRunTimes, If the user is actively scrolling this code would become an infinite loop until they stopped scrolling. This would be okay, except each scroll event would start an additional infinte loop. We want to short-circuit it to prevent this.\n\n    if (\n      itemsArrayModified &&\n      this.previousViewPort &&\n      this.previousViewPort.scrollStartPosition > 0\n    ) {\n      //if items were prepended, scroll forward to keep same items visible\n      let oldViewPort = this.previousViewPort;\n      let oldViewPortItems = this.viewPortItems;\n\n      let oldRefreshCompletedCallback = refreshCompletedCallback;\n      refreshCompletedCallback = () => {\n        let scrollLengthDelta =\n          this.previousViewPort.scrollLength - oldViewPort.scrollLength;\n        if (scrollLengthDelta > 0 && this.viewPortItems) {\n          let oldStartItem = oldViewPortItems[0];\n          let oldStartItemIndex = this.items.findIndex((x) =>\n            this.compareItems(oldStartItem, x),\n          );\n          if (oldStartItemIndex > this.previousViewPort.startIndexWithBuffer) {\n            let itemOrderChanged = false;\n            for (let i = 1; i < this.viewPortItems.length; ++i) {\n              if (\n                !this.compareItems(\n                  this.items[oldStartItemIndex + i],\n                  oldViewPortItems[i],\n                )\n              ) {\n                itemOrderChanged = true;\n                break;\n              }\n            }\n\n            if (!itemOrderChanged) {\n              this.scrollToPosition(\n                this.previousViewPort.scrollStartPosition + scrollLengthDelta,\n                0,\n                oldRefreshCompletedCallback,\n              );\n              return;\n            }\n          }\n        }\n\n        if (oldRefreshCompletedCallback) {\n          oldRefreshCompletedCallback();\n        }\n      };\n    }\n\n    this.zone.runOutsideAngular(() => {\n      requestAnimationFrame(() => {\n        if (itemsArrayModified) {\n          this.resetWrapGroupDimensions();\n        }\n        let viewport = this.calculateViewport();\n\n        let startChanged =\n          itemsArrayModified ||\n          viewport.startIndex !== this.previousViewPort.startIndex;\n        let endChanged =\n          itemsArrayModified ||\n          viewport.endIndex !== this.previousViewPort.endIndex;\n        let scrollLengthChanged =\n          viewport.scrollLength !== this.previousViewPort.scrollLength;\n        let paddingChanged = viewport.padding !== this.previousViewPort.padding;\n        let scrollPositionChanged =\n          viewport.scrollStartPosition !==\n            this.previousViewPort.scrollStartPosition ||\n          viewport.scrollEndPosition !==\n            this.previousViewPort.scrollEndPosition ||\n          viewport.maxScrollPosition !==\n            this.previousViewPort.maxScrollPosition;\n\n        this.previousViewPort = viewport;\n\n        if (scrollLengthChanged) {\n          this.renderer.setStyle(\n            this.invisiblePaddingElementRef.nativeElement,\n            this._invisiblePaddingProperty,\n            `${viewport.scrollLength}px`,\n          );\n        }\n\n        if (paddingChanged) {\n          if (this.useMarginInsteadOfTranslate) {\n            this.renderer.setStyle(\n              this.contentElementRef.nativeElement,\n              this._marginDir,\n              `${viewport.padding}px`,\n            );\n          } else {\n            this.renderer.setStyle(\n              this.contentElementRef.nativeElement,\n              'transform',\n              `${this._translateDir}(${viewport.padding}px)`,\n            );\n            this.renderer.setStyle(\n              this.contentElementRef.nativeElement,\n              'webkitTransform',\n              `${this._translateDir}(${viewport.padding}px)`,\n            );\n          }\n        }\n\n        if (this.headerElementRef) {\n          let scrollPosition = this.getScrollElement()[this._scrollType];\n          let containerOffset = this.getElementsOffset();\n          let offset = Math.max(\n            scrollPosition -\n              viewport.padding -\n              containerOffset +\n              this.headerElementRef.nativeElement.clientHeight,\n            0,\n          );\n          this.renderer.setStyle(\n            this.headerElementRef.nativeElement,\n            'transform',\n            `${this._translateDir}(${offset}px)`,\n          );\n          this.renderer.setStyle(\n            this.headerElementRef.nativeElement,\n            'webkitTransform',\n            `${this._translateDir}(${offset}px)`,\n          );\n        }\n\n        const changeEventArg: IPageInfo =\n          startChanged || endChanged\n            ? {\n                startIndex: viewport.startIndex,\n                endIndex: viewport.endIndex,\n                scrollStartPosition: viewport.scrollStartPosition,\n                scrollEndPosition: viewport.scrollEndPosition,\n                startIndexWithBuffer: viewport.startIndexWithBuffer,\n                endIndexWithBuffer: viewport.endIndexWithBuffer,\n                maxScrollPosition: viewport.maxScrollPosition,\n              }\n            : undefined;\n\n        if (startChanged || endChanged || scrollPositionChanged) {\n          const handleChanged = () => {\n            // update the scroll list to trigger re-render of components in viewport\n            this.viewPortItems =\n              viewport.startIndexWithBuffer >= 0 &&\n              viewport.endIndexWithBuffer >= 0\n                ? this.items.slice(\n                    viewport.startIndexWithBuffer,\n                    viewport.endIndexWithBuffer + 1,\n                  )\n                : [];\n            this.vsUpdate.emit(this.viewPortItems);\n\n            if (startChanged) {\n              this.vsStart.emit(changeEventArg);\n            }\n\n            if (endChanged) {\n              this.vsEnd.emit(changeEventArg);\n            }\n\n            if (startChanged || endChanged) {\n              this.changeDetectorRef.markForCheck();\n              this.vsChange.emit(changeEventArg);\n            }\n\n            if (maxRunTimes > 0) {\n              this.refresh_internal(\n                false,\n                refreshCompletedCallback,\n                maxRunTimes - 1,\n              );\n              return;\n            }\n\n            if (refreshCompletedCallback) {\n              refreshCompletedCallback();\n            }\n          };\n\n          if (this.executeRefreshOutsideAngularZone) {\n            handleChanged();\n          } else {\n            this.zone.run(handleChanged);\n          }\n        } else {\n          if (maxRunTimes > 0 && (scrollLengthChanged || paddingChanged)) {\n            this.refresh_internal(\n              false,\n              refreshCompletedCallback,\n              maxRunTimes - 1,\n            );\n            return;\n          }\n\n          if (refreshCompletedCallback) {\n            refreshCompletedCallback();\n          }\n        }\n      });\n    });\n  }\n\n  protected getScrollElement(): HTMLElement {\n    return this.parentScroll instanceof Window\n      ? document.scrollingElement || document.documentElement || document.body\n      : this.parentScroll || this.element.nativeElement;\n  }\n\n  protected addScrollEventHandlers(): void {\n    if (this.isAngularUniversalSSR) {\n      return;\n    }\n\n    let scrollElement = this.getScrollElement();\n\n    this.removeScrollEventHandlers();\n\n    this.zone.runOutsideAngular(() => {\n      if (this.parentScroll instanceof Window) {\n        this.disposeScrollHandler = this.renderer.listen(\n          'window',\n          'scroll',\n          this.onScroll,\n        );\n        this.disposeResizeHandler = this.renderer.listen(\n          'window',\n          'resize',\n          this.onScroll,\n        );\n      } else {\n        this.disposeScrollHandler = this.renderer.listen(\n          scrollElement,\n          'scroll',\n          this.onScroll,\n        );\n        if (this._checkResizeInterval > 0) {\n          this.checkScrollElementResizedTimer = <any>setInterval(() => {\n            this.checkScrollElementResized();\n          }, this._checkResizeInterval);\n        }\n      }\n    });\n  }\n\n  protected removeScrollEventHandlers(): void {\n    if (this.checkScrollElementResizedTimer) {\n      clearInterval(this.checkScrollElementResizedTimer);\n    }\n\n    if (this.disposeScrollHandler) {\n      this.disposeScrollHandler();\n      this.disposeScrollHandler = undefined;\n    }\n\n    if (this.disposeResizeHandler) {\n      this.disposeResizeHandler();\n      this.disposeResizeHandler = undefined;\n    }\n  }\n\n  protected getElementsOffset(): number {\n    if (this.isAngularUniversalSSR) {\n      return 0;\n    }\n\n    let offset = 0;\n\n    if (this.containerElementRef && this.containerElementRef.nativeElement) {\n      offset += this.containerElementRef.nativeElement[this._offsetType];\n    }\n\n    if (this.parentScroll) {\n      let scrollElement = this.getScrollElement();\n      let elementClientRect = this.getElementSize(this.element.nativeElement);\n      let scrollClientRect = this.getElementSize(scrollElement);\n      if (this.horizontal) {\n        offset += elementClientRect.left - scrollClientRect.left;\n      } else {\n        offset += elementClientRect.top - scrollClientRect.top;\n      }\n\n      if (!(this.parentScroll instanceof Window)) {\n        offset += scrollElement[this._scrollType];\n      }\n    }\n\n    return offset;\n  }\n\n  protected countItemsPerWrapGroup(): number {\n    if (this.isAngularUniversalSSR) {\n      return Math.round(\n        this.horizontal\n          ? this.ssrViewportHeight / this.ssrChildHeight\n          : this.ssrViewportWidth / this.ssrChildWidth,\n      );\n    }\n\n    let propertyName = this.horizontal ? 'offsetLeft' : 'offsetTop';\n    let children = (\n      (this.containerElementRef && this.containerElementRef.nativeElement) ||\n      this.contentElementRef.nativeElement\n    ).children;\n\n    let childrenLength = children ? children.length : 0;\n    if (childrenLength === 0) {\n      return 1;\n    }\n\n    let firstOffset = children[0][propertyName];\n    let result = 1;\n    while (\n      result < childrenLength &&\n      firstOffset === children[result][propertyName]\n    ) {\n      ++result;\n    }\n\n    return result;\n  }\n\n  protected getScrollStartPosition(): number {\n    let windowScrollValue = undefined;\n    if (this.parentScroll instanceof Window) {\n      windowScrollValue = window[this._pageOffsetType];\n    }\n\n    return windowScrollValue || this.getScrollElement()[this._scrollType] || 0;\n  }\n\n  protected minMeasuredChildWidth: number;\n  protected minMeasuredChildHeight: number;\n\n  protected wrapGroupDimensions: WrapGroupDimensions;\n\n  protected resetWrapGroupDimensions(): void {\n    const oldWrapGroupDimensions = this.wrapGroupDimensions;\n    this.invalidateAllCachedMeasurements();\n\n    if (\n      !this.enableUnequalChildrenSizes ||\n      !oldWrapGroupDimensions ||\n      oldWrapGroupDimensions.numberOfKnownWrapGroupChildSizes === 0\n    ) {\n      return;\n    }\n\n    const itemsPerWrapGroup: number = this.countItemsPerWrapGroup();\n    for (\n      let wrapGroupIndex = 0;\n      wrapGroupIndex < oldWrapGroupDimensions.maxChildSizePerWrapGroup.length;\n      ++wrapGroupIndex\n    ) {\n      const oldWrapGroupDimension: WrapGroupDimension =\n        oldWrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];\n      if (\n        !oldWrapGroupDimension ||\n        !oldWrapGroupDimension.items ||\n        !oldWrapGroupDimension.items.length\n      ) {\n        continue;\n      }\n\n      if (oldWrapGroupDimension.items.length !== itemsPerWrapGroup) {\n        return;\n      }\n\n      let itemsChanged = false;\n      let arrayStartIndex = itemsPerWrapGroup * wrapGroupIndex;\n      for (let i = 0; i < itemsPerWrapGroup; ++i) {\n        if (\n          !this.compareItems(\n            oldWrapGroupDimension.items[i],\n            this.items[arrayStartIndex + i],\n          )\n        ) {\n          itemsChanged = true;\n          break;\n        }\n      }\n\n      if (!itemsChanged) {\n        ++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\n        this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths +=\n          oldWrapGroupDimension.childWidth || 0;\n        this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights +=\n          oldWrapGroupDimension.childHeight || 0;\n        this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] =\n          oldWrapGroupDimension;\n      }\n    }\n  }\n\n  protected calculateDimensions(): IDimensions {\n    let scrollElement = this.getScrollElement();\n\n    const maxCalculatedScrollBarSize: number = 25; // Note: Formula to auto-calculate doesn't work for ParentScroll, so we default to this if not set by consuming application\n    this.calculatedScrollbarHeight = Math.max(\n      Math.min(\n        scrollElement.offsetHeight - scrollElement.clientHeight,\n        maxCalculatedScrollBarSize,\n      ),\n      this.calculatedScrollbarHeight,\n    );\n    this.calculatedScrollbarWidth = Math.max(\n      Math.min(\n        scrollElement.offsetWidth - scrollElement.clientWidth,\n        maxCalculatedScrollBarSize,\n      ),\n      this.calculatedScrollbarWidth,\n    );\n\n    let viewportWidth =\n      scrollElement.offsetWidth -\n      (this.scrollbarWidth ||\n        this.calculatedScrollbarWidth ||\n        (this.horizontal ? 0 : maxCalculatedScrollBarSize));\n    let viewportHeight =\n      scrollElement.offsetHeight -\n      (this.scrollbarHeight ||\n        this.calculatedScrollbarHeight ||\n        (this.horizontal ? maxCalculatedScrollBarSize : 0));\n\n    let content =\n      (this.containerElementRef && this.containerElementRef.nativeElement) ||\n      this.contentElementRef.nativeElement;\n\n    let itemsPerWrapGroup = this.countItemsPerWrapGroup();\n    let wrapGroupsPerPage;\n\n    let defaultChildWidth;\n    let defaultChildHeight;\n\n    if (this.isAngularUniversalSSR) {\n      viewportWidth = this.ssrViewportWidth;\n      viewportHeight = this.ssrViewportHeight;\n      defaultChildWidth = this.ssrChildWidth;\n      defaultChildHeight = this.ssrChildHeight;\n      let itemsPerRow = Math.max(\n        Math.ceil(viewportWidth / defaultChildWidth),\n        1,\n      );\n      let itemsPerCol = Math.max(\n        Math.ceil(viewportHeight / defaultChildHeight),\n        1,\n      );\n      wrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;\n    } else if (!this.enableUnequalChildrenSizes) {\n      if (content.children.length > 0) {\n        if (!this.childWidth || !this.childHeight) {\n          if (!this.minMeasuredChildWidth && viewportWidth > 0) {\n            this.minMeasuredChildWidth = viewportWidth;\n          }\n          if (!this.minMeasuredChildHeight && viewportHeight > 0) {\n            this.minMeasuredChildHeight = viewportHeight;\n          }\n        }\n\n        let child = content.children[0];\n        let clientRect = this.getElementSize(child);\n        this.minMeasuredChildWidth = Math.min(\n          this.minMeasuredChildWidth,\n          clientRect.width,\n        );\n        this.minMeasuredChildHeight = Math.min(\n          this.minMeasuredChildHeight,\n          clientRect.height,\n        );\n      }\n\n      defaultChildWidth =\n        this.childWidth || this.minMeasuredChildWidth || viewportWidth;\n      defaultChildHeight =\n        this.childHeight || this.minMeasuredChildHeight || viewportHeight;\n      let itemsPerRow = Math.max(\n        Math.ceil(viewportWidth / defaultChildWidth),\n        1,\n      );\n      let itemsPerCol = Math.max(\n        Math.ceil(viewportHeight / defaultChildHeight),\n        1,\n      );\n      wrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;\n    } else {\n      let scrollOffset =\n        scrollElement[this._scrollType] -\n        (this.previousViewPort ? this.previousViewPort.padding : 0);\n\n      let arrayStartIndex = this.previousViewPort.startIndexWithBuffer || 0;\n      let wrapGroupIndex = Math.ceil(arrayStartIndex / itemsPerWrapGroup);\n\n      let maxWidthForWrapGroup = 0;\n      let maxHeightForWrapGroup = 0;\n      let sumOfVisibleMaxWidths = 0;\n      let sumOfVisibleMaxHeights = 0;\n      wrapGroupsPerPage = 0;\n\n      for (let i = 0; i < content.children.length; ++i) {\n        ++arrayStartIndex;\n        let child = content.children[i];\n        let clientRect = this.getElementSize(child);\n\n        maxWidthForWrapGroup = Math.max(maxWidthForWrapGroup, clientRect.width);\n        maxHeightForWrapGroup = Math.max(\n          maxHeightForWrapGroup,\n          clientRect.height,\n        );\n\n        if (arrayStartIndex % itemsPerWrapGroup === 0) {\n          let oldValue =\n            this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];\n          if (oldValue) {\n            --this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\n            this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -=\n              oldValue.childWidth || 0;\n            this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -=\n              oldValue.childHeight || 0;\n          }\n\n          ++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\n          const items = this.items.slice(\n            arrayStartIndex - itemsPerWrapGroup,\n            arrayStartIndex,\n          );\n          this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] = {\n            childWidth: maxWidthForWrapGroup,\n            childHeight: maxHeightForWrapGroup,\n            items: items,\n          };\n          this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths +=\n            maxWidthForWrapGroup;\n          this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights +=\n            maxHeightForWrapGroup;\n\n          if (this.horizontal) {\n            let maxVisibleWidthForWrapGroup = Math.min(\n              maxWidthForWrapGroup,\n              Math.max(viewportWidth - sumOfVisibleMaxWidths, 0),\n            );\n            if (scrollOffset > 0) {\n              let scrollOffsetToRemove = Math.min(\n                scrollOffset,\n                maxVisibleWidthForWrapGroup,\n              );\n              maxVisibleWidthForWrapGroup -= scrollOffsetToRemove;\n              scrollOffset -= scrollOffsetToRemove;\n            }\n\n            sumOfVisibleMaxWidths += maxVisibleWidthForWrapGroup;\n            if (\n              maxVisibleWidthForWrapGroup > 0 &&\n              viewportWidth >= sumOfVisibleMaxWidths\n            ) {\n              ++wrapGroupsPerPage;\n            }\n          } else {\n            let maxVisibleHeightForWrapGroup = Math.min(\n              maxHeightForWrapGroup,\n              Math.max(viewportHeight - sumOfVisibleMaxHeights, 0),\n            );\n            if (scrollOffset > 0) {\n              let scrollOffsetToRemove = Math.min(\n                scrollOffset,\n                maxVisibleHeightForWrapGroup,\n              );\n              maxVisibleHeightForWrapGroup -= scrollOffsetToRemove;\n              scrollOffset -= scrollOffsetToRemove;\n            }\n\n            sumOfVisibleMaxHeights += maxVisibleHeightForWrapGroup;\n            if (\n              maxVisibleHeightForWrapGroup > 0 &&\n              viewportHeight >= sumOfVisibleMaxHeights\n            ) {\n              ++wrapGroupsPerPage;\n            }\n          }\n\n          ++wrapGroupIndex;\n\n          maxWidthForWrapGroup = 0;\n          maxHeightForWrapGroup = 0;\n        }\n      }\n\n      let averageChildWidth =\n        this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths /\n        this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\n      let averageChildHeight =\n        this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights /\n        this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\n      defaultChildWidth = this.childWidth || averageChildWidth || viewportWidth;\n      defaultChildHeight =\n        this.childHeight || averageChildHeight || viewportHeight;\n\n      if (this.horizontal) {\n        if (viewportWidth > sumOfVisibleMaxWidths) {\n          wrapGroupsPerPage += Math.ceil(\n            (viewportWidth - sumOfVisibleMaxWidths) / defaultChildWidth,\n          );\n        }\n      } else {\n        if (viewportHeight > sumOfVisibleMaxHeights) {\n          wrapGroupsPerPage += Math.ceil(\n            (viewportHeight - sumOfVisibleMaxHeights) / defaultChildHeight,\n          );\n        }\n      }\n    }\n\n    let itemCount = this.items.length;\n    let itemsPerPage = itemsPerWrapGroup * wrapGroupsPerPage;\n    let pageCount_fractional = itemCount / itemsPerPage;\n    let numberOfWrapGroups = Math.ceil(itemCount / itemsPerWrapGroup);\n\n    let scrollLength = 0;\n\n    let defaultScrollLengthPerWrapGroup = this.horizontal\n      ? defaultChildWidth\n      : defaultChildHeight;\n    if (this.enableUnequalChildrenSizes) {\n      let numUnknownChildSizes = 0;\n      for (let i = 0; i < numberOfWrapGroups; ++i) {\n        let childSize =\n          this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] &&\n          this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][\n            this._childScrollDim\n          ];\n        if (childSize) {\n          scrollLength += childSize;\n        } else {\n          ++numUnknownChildSizes;\n        }\n      }\n\n      scrollLength += Math.round(\n        numUnknownChildSizes * defaultScrollLengthPerWrapGroup,\n      );\n    } else {\n      scrollLength = numberOfWrapGroups * defaultScrollLengthPerWrapGroup;\n    }\n\n    if (this.headerElementRef) {\n      scrollLength += this.headerElementRef.nativeElement.clientHeight;\n    }\n\n    let viewportLength = this.horizontal ? viewportWidth : viewportHeight;\n    let maxScrollPosition = Math.max(scrollLength - viewportLength, 0);\n\n    return {\n      itemCount: itemCount,\n      itemsPerWrapGroup: itemsPerWrapGroup,\n      wrapGroupsPerPage: wrapGroupsPerPage,\n      itemsPerPage: itemsPerPage,\n      pageCount_fractional: pageCount_fractional,\n      childWidth: defaultChildWidth,\n      childHeight: defaultChildHeight,\n      scrollLength: scrollLength,\n      viewportLength: viewportLength,\n      maxScrollPosition: maxScrollPosition,\n    };\n  }\n\n  protected cachedPageSize: number = 0;\n  protected previousScrollNumberElements: number = 0;\n\n  protected calculatePadding(\n    arrayStartIndexWithBuffer: number,\n    dimensions: IDimensions,\n  ): number {\n    if (dimensions.itemCount === 0) {\n      return 0;\n    }\n\n    let defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];\n    let startingWrapGroupIndex =\n      Math.floor(arrayStartIndexWithBuffer / dimensions.itemsPerWrapGroup) || 0;\n\n    if (!this.enableUnequalChildrenSizes) {\n      return defaultScrollLengthPerWrapGroup * startingWrapGroupIndex;\n    }\n\n    let numUnknownChildSizes = 0;\n    let result = 0;\n    for (let i = 0; i < startingWrapGroupIndex; ++i) {\n      let childSize =\n        this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] &&\n        this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][\n          this._childScrollDim\n        ];\n      if (childSize) {\n        result += childSize;\n      } else {\n        ++numUnknownChildSizes;\n      }\n    }\n    result += Math.round(\n      numUnknownChildSizes * defaultScrollLengthPerWrapGroup,\n    );\n\n    return result;\n  }\n\n  protected calculatePageInfo(\n    scrollPosition: number,\n    dimensions: IDimensions,\n  ): IPageInfo {\n    let scrollPercentage = 0;\n    if (this.enableUnequalChildrenSizes) {\n      const numberOfWrapGroups = Math.ceil(\n        dimensions.itemCount / dimensions.itemsPerWrapGroup,\n      );\n      let totalScrolledLength = 0;\n      let defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];\n      for (let i = 0; i < numberOfWrapGroups; ++i) {\n        let childSize =\n          this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] &&\n          this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][\n            this._childScrollDim\n          ];\n        if (childSize) {\n          totalScrolledLength += childSize;\n        } else {\n          totalScrolledLength += defaultScrollLengthPerWrapGroup;\n        }\n\n        if (scrollPosition < totalScrolledLength) {\n          scrollPercentage = i / numberOfWrapGroups;\n          break;\n        }\n      }\n    } else {\n      scrollPercentage = scrollPosition / dimensions.scrollLength;\n    }\n\n    let startingArrayIndex_fractional =\n      Math.min(\n        Math.max(scrollPercentage * dimensions.pageCount_fractional, 0),\n        dimensions.pageCount_fractional,\n      ) * dimensions.itemsPerPage;\n\n    let maxStart = dimensions.itemCount - dimensions.itemsPerPage - 1;\n    let arrayStartIndex = Math.min(\n      Math.floor(startingArrayIndex_fractional),\n      maxStart,\n    );\n    arrayStartIndex -= arrayStartIndex % dimensions.itemsPerWrapGroup; // round down to start of wrapGroup\n\n    if (this.stripedTable) {\n      let bufferBoundary = 2 * dimensions.itemsPerWrapGroup;\n      if (arrayStartIndex % bufferBoundary !== 0) {\n        arrayStartIndex = Math.max(\n          arrayStartIndex - (arrayStartIndex % bufferBoundary),\n          0,\n        );\n      }\n    }\n\n    let arrayEndIndex =\n      Math.ceil(startingArrayIndex_fractional) + dimensions.itemsPerPage - 1;\n    let endIndexWithinWrapGroup =\n      (arrayEndIndex + 1) % dimensions.itemsPerWrapGroup;\n    if (endIndexWithinWrapGroup > 0) {\n      arrayEndIndex += dimensions.itemsPerWrapGroup - endIndexWithinWrapGroup; // round up to end of wrapGroup\n    }\n\n    if (isNaN(arrayStartIndex)) {\n      arrayStartIndex = 0;\n    }\n    if (isNaN(arrayEndIndex)) {\n      arrayEndIndex = 0;\n    }\n\n    arrayStartIndex = Math.min(\n      Math.max(arrayStartIndex, 0),\n      dimensions.itemCount - 1,\n    );\n    arrayEndIndex = Math.min(\n      Math.max(arrayEndIndex, 0),\n      dimensions.itemCount - 1,\n    );\n\n    let bufferSize = this.bufferAmount * dimensions.itemsPerWrapGroup;\n    let startIndexWithBuffer = Math.min(\n      Math.max(arrayStartIndex - bufferSize, 0),\n      dimensions.itemCount - 1,\n    );\n    let endIndexWithBuffer = Math.min(\n      Math.max(arrayEndIndex + bufferSize, 0),\n      dimensions.itemCount - 1,\n    );\n\n    return {\n      startIndex: arrayStartIndex,\n      endIndex: arrayEndIndex,\n      startIndexWithBuffer: startIndexWithBuffer,\n      endIndexWithBuffer: endIndexWithBuffer,\n      scrollStartPosition: scrollPosition,\n      scrollEndPosition: scrollPosition + dimensions.viewportLength,\n      maxScrollPosition: dimensions.maxScrollPosition,\n    };\n  }\n\n  protected calculateViewport(): IViewport {\n    let dimensions = this.calculateDimensions();\n    let offset = this.getElementsOffset();\n\n    let scrollStartPosition = this.getScrollStartPosition();\n    if (\n      scrollStartPosition > dimensions.scrollLength + offset &&\n      !(this.parentScroll instanceof Window)\n    ) {\n      scrollStartPosition = dimensions.scrollLength;\n    } else {\n      scrollStartPosition -= offset;\n    }\n    scrollStartPosition = Math.max(0, scrollStartPosition);\n\n    let pageInfo = this.calculatePageInfo(scrollStartPosition, dimensions);\n    let newPadding = this.calculatePadding(\n      pageInfo.startIndexWithBuffer,\n      dimensions,\n    );\n    let newScrollLength = dimensions.scrollLength;\n\n    return {\n      startIndex: pageInfo.startIndex,\n      endIndex: pageInfo.endIndex,\n      startIndexWithBuffer: pageInfo.startIndexWithBuffer,\n      endIndexWithBuffer: pageInfo.endIndexWithBuffer,\n      padding: Math.round(newPadding),\n      scrollLength: Math.round(newScrollLength),\n      scrollStartPosition: pageInfo.scrollStartPosition,\n      scrollEndPosition: pageInfo.scrollEndPosition,\n      maxScrollPosition: pageInfo.maxScrollPosition,\n    };\n  }\n}\n\n@NgModule({\n  exports: [VirtualScrollerComponent],\n  declarations: [VirtualScrollerComponent],\n  imports: [CommonModule],\n  providers: [\n    {\n      provide: 'virtual-scroller-default-options',\n      useFactory: VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY,\n    },\n  ],\n})\nexport class VirtualScrollerModule {}\n"]}