{"version":3,"file":"2698.f9438b6f04a6607a.js","mappings":"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","names":["scrollBehaviorSupported","supportsScrollBehavior","BlockScrollStrategy","constructor","_viewportRuler","document","this","_previousHTMLStyles","top","left","_isEnabled","_document","attach","enable","_canBeEnabled","root","documentElement","_previousScrollPosition","getViewportScrollPosition","style","coerceCssPixelValue","classList","add","disable","html","htmlStyle","bodyStyle","body","previousHtmlScrollBehavior","scrollBehavior","previousBodyScrollBehavior","remove","window","scroll","contains","viewport","getViewportSize","scrollHeight","height","scrollWidth","width","CloseScrollStrategy","_scrollDispatcher","_ngZone","_config","_scrollSubscription","_detach","_overlayRef","hasAttached","run","detach","overlayRef","stream","scrolled","pipe","filter","scrollable","overlayElement","getElementRef","nativeElement","threshold","_initialScrollPosition","subscribe","scrollPosition","Math","abs","updatePosition","unsubscribe","NoopScrollStrategy","isElementScrolledOutsideView","element","scrollContainers","some","containerBounds","bottom","right","isElementClippedByScrolling","scrollContainerRect","RepositionScrollStrategy","scrollThrottle","autoClose","overlayRect","getBoundingClientRect","ScrollStrategyOptions","noop","close","config","block","reposition","static","ɵfac","t","i0","i1","DOCUMENT","ɵprov","token","factory","providedIn","OverlayConfig","scrollStrategy","panelClass","hasBackdrop","backdropClass","disposeOnNavigation","configKeys","Object","keys","key","undefined","ConnectedOverlayPositionChange","connectionPair","scrollableViewProperties","BaseOverlayDispatcher","_attachedOverlays","ngOnDestroy","push","index","indexOf","splice","length","OverlayKeyboardDispatcher","super","_keydownListener","event","overlays","i","_keydownEvents","observers","keydownEvents","next","_isAttached","runOutsideAngular","addEventListener","removeEventListener","OverlayOutsideClickDispatcher","_platform","_cursorStyleIsSet","_pointerDownListener","_pointerDownEventTarget","_getEventTarget","_clickListener","target","origin","type","slice","_outsidePointerEvents","outsidePointerEvents","_addEventListeners","IOS","_cursorOriginalValue","cursor","i1$1","OverlayContainer","_containerElement","getContainerElement","_createContainer","containerClass","isBrowser","_isTestEnvironment","oppositePlatformContainers","querySelectorAll","container","createElement","setAttribute","appendChild","OverlayRef","_portalOutlet","_host","_pane","_keyboardDispatcher","_location","_outsideClickDispatcher","_animationsDisabled","_backdropElement","_backdropClick","Subject","_attachments","_detachments","_locationChanges","Subscription","EMPTY","_backdropClickHandler","_backdropTransitionendHandler","_disposeBackdrop","_scrollStrategy","_positionStrategy","positionStrategy","backdropElement","hostElement","portal","parentElement","_previousHostParent","attachResult","_updateStackingOrder","_updateElementSize","_updateElementDirection","onStable","take","_togglePointerEvents","_attachBackdrop","_toggleClasses","dispose","onDestroy","Promise","resolve","then","detachBackdrop","detachmentResult","_detachContentWhenStable","isAttached","_disposeScrollStrategy","complete","backdropClick","attachments","detachments","getConfig","apply","updatePositionStrategy","strategy","updateSize","sizeConfig","setDirection","dir","direction","addPanelClass","classes","removePanelClass","getDirection","value","updateScrollStrategy","minWidth","minHeight","maxWidth","maxHeight","enablePointer","pointerEvents","showingClass","insertBefore","requestAnimationFrame","nextSibling","parentNode","backdropToDetach","_backdropTimeout","setTimeout","cssClasses","isAdd","coerceArray","c","subscription","takeUntil","merge","children","backdrop","clearTimeout","boundingBoxClass","cssUnitPattern","FlexibleConnectedPositionStrategy","positions","_preferredPositions","connectedTo","_overlayContainer","_lastBoundingBoxSize","_isPushed","_canPush","_growAfterOpen","_hasFlexibleDimensions","_positionLocked","_viewportMargin","_scrollables","_positionChanges","_resizeSubscription","_offsetX","_offsetY","_appliedPanelClasses","positionChanges","setOrigin","_validatePositions","_boundingBox","_isDisposed","_isInitialRender","_lastPosition","change","reapplyLastPosition","_clearPanelClasses","_resetOverlayElementStyles","_resetBoundingBoxStyles","_viewportRect","_getNarrowedViewportRect","_originRect","_getOriginRect","_overlayRect","_containerRect","originRect","viewportRect","containerRect","flexibleFits","fallback","pos","originPoint","_getOriginPoint","overlayPoint","_getOverlayPoint","overlayFit","_getOverlayFit","isCompletelyWithinViewport","_applyPosition","_canFitWithFlexibleDimensions","position","boundingBoxRect","_calculateBoundingBoxRect","visibleArea","bestFit","bestScore","fit","score","weight","_previousPushAmount","extendStyles","alignItems","justifyContent","lastPosition","withScrollableContainers","scrollables","withPositions","withViewportMargin","margin","withFlexibleDimensions","flexibleDimensions","withGrowAfterOpen","growAfterOpen","withPush","canPush","withLockedPosition","isLocked","_origin","withDefaultOffsetX","offset","withDefaultOffsetY","withTransformOriginOn","selector","_transformOriginSelector","x","y","originX","startX","_isRtl","endX","originY","overlayStartX","overlayStartY","overlayX","overlayY","point","rawOverlayRect","overlay","getRoundedBoundingClientRect","offsetX","_getOffset","offsetY","topOverflow","bottomOverflow","visibleWidth","_subtractOverflows","visibleHeight","fitsInViewportVertically","fitsInViewportHorizontally","availableHeight","availableWidth","getPixelValue","horizontalFit","_pushOverlayOnScreen","start","overflowRight","max","overflowBottom","overflowTop","overflowLeft","pushX","pushY","_setTransformOrigin","_setOverlayElementStyles","_setBoundingBoxStyles","_addPanelClasses","_getScrollVisibility","changeEvent","elements","xOrigin","yOrigin","transformOrigin","isRtl","smallestDistanceToViewportEdge","min","previousHeight","previousWidth","styles","_hasExactPosition","transform","hasExactPosition","hasFlexibleDimensions","_getExactOverlayY","_getExactOverlayX","transformString","trim","clientHeight","horizontalStyleProperty","clientWidth","originBounds","overlayBounds","scrollContainerBounds","map","isOriginClipped","isOriginOutsideView","isOverlayClipped","isOverlayOutsideView","overflows","reduce","currentValue","currentOverflow","axis","forEach","cssClass","ElementRef","Element","destination","source","hasOwnProperty","input","units","split","parseFloat","clientRect","floor","wrapperClass","GlobalPositionStrategy","_cssPosition","_topOffset","_bottomOffset","_alignItems","_xPosition","_xOffset","_width","_height","end","centerHorizontally","centerVertically","parentStyles","shouldBeFlushHorizontally","shouldBeFlushVertically","xPosition","xOffset","marginLeft","marginRight","marginTop","marginBottom","parent","OverlayPositionBuilder","global","flexibleConnectedTo","nextUniqueId","Overlay","scrollStrategies","_componentFactoryResolver","_positionBuilder","_injector","_directionality","_animationsModuleType","create","host","_createHostElement","pane","_createPaneElement","portalOutlet","_createPortalOutlet","overlayConfig","id","_appRef","get","ApplicationRef","DomPortalOutlet","i5","i6","ANIMATION_MODULE_TYPE","defaultPositionList","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY","InjectionToken","CdkOverlayOrigin","elementRef","ɵdir","selectors","exportAs","standalone","CdkConnectedOverlay","_position","_updatePositionStrategy","_hasBackdrop","coerceBooleanProperty","lockPosition","_lockPosition","_flexibleDimensions","_push","_overlay","templateRef","viewContainerRef","scrollStrategyFactory","_dir","_backdropSubscription","_attachSubscription","_detachSubscription","_positionSubscription","viewportMargin","open","disableClose","EventEmitter","positionChange","overlayKeydown","overlayOutsideClick","_templatePortal","TemplatePortal","_scrollStrategyFactory","ngOnChanges","changes","_attachOverlay","_detachOverlay","_createOverlay","_buildConfig","emit","keyCode","ESCAPE","hasModifierKey","preventDefault","_createPositionStrategy","currentPosition","_getFlexibleConnectedPositionStrategyOrigin","transformOriginSelector","takeWhile","inputs","outputs","features","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER","provide","deps","useFactory","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY","OverlayModule","ɵmod","ɵinj","providers","imports","BidiModule","PortalModule","ScrollingModule","Portal","_attachedHost","setAttachedHost","ComponentPortal","component","injector","componentFactoryResolver","projectableNodes","context","DomPortal","BasePortalOutlet","attachDomPortal","_attachedPortal","attachComponentPortal","attachTemplatePortal","_invokeDisposeFn","setDisposeFn","fn","_disposeFn","outletElement","_defaultInjector","anchorNode","createComment","replaceChild","componentFactory","resolveComponentFactory","componentRef","createComponent","destroy","Injector","NULL","attachView","hostView","viewCount","detachView","_getComponentRootNode","viewContainer","viewRef","createEmbeddedView","rootNodes","rootNode","detectChanges","CdkPortalOutlet","_viewContainerRef","_isInitialized","attached","_getRootNode","attachedRef","_attachedRef","ngOnInit","ref","clear","nodeType","ELEMENT_NODE","ScrollDispatcher","_scrolled","_globalSubscription","_scrolledCount","Map","register","has","set","elementScrolled","deregister","scrollableReference","delete","auditTimeInMs","Observable","observer","_addGlobalListener","auditTime","_removeGlobalListener","of","_","ancestorScrolled","elementOrElementRef","ancestors","getAncestorScrollContainers","scrollingContainers","_subscription","_scrollableContainsElement","_getWindow","defaultView","coerceElement","scrollableElement","fromEvent","CdkScrollable","scrollDispatcher","ngZone","_destroyed","_elementScrolled","scrollTo","options","el","getRtlScrollAxisType","_applyScrollToOptions","scrollTop","scrollLeft","measureScrollOffset","from","LEFT","RIGHT","i2","ViewportRuler","_change","_changeListener","_viewportSize","_updateViewportSize","output","getViewportRect","documentRect","scrollY","scrollX","throttleTime","innerWidth","innerHeight","CdkScrollableModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/cdk/fesm2022/overlay.mjs","./node_modules/@angular/cdk/fesm2022/portal.mjs","./node_modules/@angular/cdk/fesm2022/scrolling.mjs"],"sourcesContent":["import * as i1 from '@angular/cdk/scrolling';\nimport { ScrollingModule } from '@angular/cdk/scrolling';\nexport { CdkScrollable, ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';\nimport * as i6 from '@angular/common';\nimport { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { Injectable, Inject, Optional, ElementRef, ApplicationRef, ANIMATION_MODULE_TYPE, InjectionToken, Directive, EventEmitter, Input, Output, NgModule } from '@angular/core';\nimport { coerceCssPixelValue, coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i1$1 from '@angular/cdk/platform';\nimport { supportsScrollBehavior, _getEventTarget, _isTestEnvironment } from '@angular/cdk/platform';\nimport { filter, take, takeUntil, takeWhile } from 'rxjs/operators';\nimport * as i5 from '@angular/cdk/bidi';\nimport { BidiModule } from '@angular/cdk/bidi';\nimport { DomPortalOutlet, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport { Subject, Subscription, merge } from 'rxjs';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\n\nconst scrollBehaviorSupported = supportsScrollBehavior();\n/**\n * Strategy that will prevent the user from scrolling while the overlay is visible.\n */\nclass BlockScrollStrategy {\n    constructor(_viewportRuler, document) {\n        this._viewportRuler = _viewportRuler;\n        this._previousHTMLStyles = { top: '', left: '' };\n        this._isEnabled = false;\n        this._document = document;\n    }\n    /** Attaches this scroll strategy to an overlay. */\n    attach() { }\n    /** Blocks page-level scroll while the attached overlay is open. */\n    enable() {\n        if (this._canBeEnabled()) {\n            const root = this._document.documentElement;\n            this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();\n            // Cache the previous inline styles in case the user had set them.\n            this._previousHTMLStyles.left = root.style.left || '';\n            this._previousHTMLStyles.top = root.style.top || '';\n            // Note: we're using the `html` node, instead of the `body`, because the `body` may\n            // have the user agent margin, whereas the `html` is guaranteed not to have one.\n            root.style.left = coerceCssPixelValue(-this._previousScrollPosition.left);\n            root.style.top = coerceCssPixelValue(-this._previousScrollPosition.top);\n            root.classList.add('cdk-global-scrollblock');\n            this._isEnabled = true;\n        }\n    }\n    /** Unblocks page-level scroll while the attached overlay is open. */\n    disable() {\n        if (this._isEnabled) {\n            const html = this._document.documentElement;\n            const body = this._document.body;\n            const htmlStyle = html.style;\n            const bodyStyle = body.style;\n            const previousHtmlScrollBehavior = htmlStyle.scrollBehavior || '';\n            const previousBodyScrollBehavior = bodyStyle.scrollBehavior || '';\n            this._isEnabled = false;\n            htmlStyle.left = this._previousHTMLStyles.left;\n            htmlStyle.top = this._previousHTMLStyles.top;\n            html.classList.remove('cdk-global-scrollblock');\n            // Disable user-defined smooth scrolling temporarily while we restore the scroll position.\n            // See https://developer.mozilla.org/en-US/docs/Web/CSS/scroll-behavior\n            // Note that we don't mutate the property if the browser doesn't support `scroll-behavior`,\n            // because it can throw off feature detections in `supportsScrollBehavior` which\n            // checks for `'scrollBehavior' in documentElement.style`.\n            if (scrollBehaviorSupported) {\n                htmlStyle.scrollBehavior = bodyStyle.scrollBehavior = 'auto';\n            }\n            window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);\n            if (scrollBehaviorSupported) {\n                htmlStyle.scrollBehavior = previousHtmlScrollBehavior;\n                bodyStyle.scrollBehavior = previousBodyScrollBehavior;\n            }\n        }\n    }\n    _canBeEnabled() {\n        // Since the scroll strategies can't be singletons, we have to use a global CSS class\n        // (`cdk-global-scrollblock`) to make sure that we don't try to disable global\n        // scrolling multiple times.\n        const html = this._document.documentElement;\n        if (html.classList.contains('cdk-global-scrollblock') || this._isEnabled) {\n            return false;\n        }\n        const body = this._document.body;\n        const viewport = this._viewportRuler.getViewportSize();\n        return body.scrollHeight > viewport.height || body.scrollWidth > viewport.width;\n    }\n}\n\n/**\n * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.\n */\nfunction getMatScrollStrategyAlreadyAttachedError() {\n    return Error(`Scroll strategy has already been attached.`);\n}\n\n/**\n * Strategy that will close the overlay as soon as the user starts scrolling.\n */\nclass CloseScrollStrategy {\n    constructor(_scrollDispatcher, _ngZone, _viewportRuler, _config) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._ngZone = _ngZone;\n        this._viewportRuler = _viewportRuler;\n        this._config = _config;\n        this._scrollSubscription = null;\n        /** Detaches the overlay ref and disables the scroll strategy. */\n        this._detach = () => {\n            this.disable();\n            if (this._overlayRef.hasAttached()) {\n                this._ngZone.run(() => this._overlayRef.detach());\n            }\n        };\n    }\n    /** Attaches this scroll strategy to an overlay. */\n    attach(overlayRef) {\n        if (this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatScrollStrategyAlreadyAttachedError();\n        }\n        this._overlayRef = overlayRef;\n    }\n    /** Enables the closing of the attached overlay on scroll. */\n    enable() {\n        if (this._scrollSubscription) {\n            return;\n        }\n        const stream = this._scrollDispatcher.scrolled(0).pipe(filter(scrollable => {\n            return (!scrollable ||\n                !this._overlayRef.overlayElement.contains(scrollable.getElementRef().nativeElement));\n        }));\n        if (this._config && this._config.threshold && this._config.threshold > 1) {\n            this._initialScrollPosition = this._viewportRuler.getViewportScrollPosition().top;\n            this._scrollSubscription = stream.subscribe(() => {\n                const scrollPosition = this._viewportRuler.getViewportScrollPosition().top;\n                if (Math.abs(scrollPosition - this._initialScrollPosition) > this._config.threshold) {\n                    this._detach();\n                }\n                else {\n                    this._overlayRef.updatePosition();\n                }\n            });\n        }\n        else {\n            this._scrollSubscription = stream.subscribe(this._detach);\n        }\n    }\n    /** Disables the closing the attached overlay on scroll. */\n    disable() {\n        if (this._scrollSubscription) {\n            this._scrollSubscription.unsubscribe();\n            this._scrollSubscription = null;\n        }\n    }\n    detach() {\n        this.disable();\n        this._overlayRef = null;\n    }\n}\n\n/** Scroll strategy that doesn't do anything. */\nclass NoopScrollStrategy {\n    /** Does nothing, as this scroll strategy is a no-op. */\n    enable() { }\n    /** Does nothing, as this scroll strategy is a no-op. */\n    disable() { }\n    /** Does nothing, as this scroll strategy is a no-op. */\n    attach() { }\n}\n\n/**\n * Gets whether an element is scrolled outside of view by any of its parent scrolling containers.\n * @param element Dimensions of the element (from getBoundingClientRect)\n * @param scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)\n * @returns Whether the element is scrolled out of view\n * @docs-private\n */\nfunction isElementScrolledOutsideView(element, scrollContainers) {\n    return scrollContainers.some(containerBounds => {\n        const outsideAbove = element.bottom < containerBounds.top;\n        const outsideBelow = element.top > containerBounds.bottom;\n        const outsideLeft = element.right < containerBounds.left;\n        const outsideRight = element.left > containerBounds.right;\n        return outsideAbove || outsideBelow || outsideLeft || outsideRight;\n    });\n}\n/**\n * Gets whether an element is clipped by any of its scrolling containers.\n * @param element Dimensions of the element (from getBoundingClientRect)\n * @param scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)\n * @returns Whether the element is clipped\n * @docs-private\n */\nfunction isElementClippedByScrolling(element, scrollContainers) {\n    return scrollContainers.some(scrollContainerRect => {\n        const clippedAbove = element.top < scrollContainerRect.top;\n        const clippedBelow = element.bottom > scrollContainerRect.bottom;\n        const clippedLeft = element.left < scrollContainerRect.left;\n        const clippedRight = element.right > scrollContainerRect.right;\n        return clippedAbove || clippedBelow || clippedLeft || clippedRight;\n    });\n}\n\n/**\n * Strategy that will update the element position as the user is scrolling.\n */\nclass RepositionScrollStrategy {\n    constructor(_scrollDispatcher, _viewportRuler, _ngZone, _config) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewportRuler = _viewportRuler;\n        this._ngZone = _ngZone;\n        this._config = _config;\n        this._scrollSubscription = null;\n    }\n    /** Attaches this scroll strategy to an overlay. */\n    attach(overlayRef) {\n        if (this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatScrollStrategyAlreadyAttachedError();\n        }\n        this._overlayRef = overlayRef;\n    }\n    /** Enables repositioning of the attached overlay on scroll. */\n    enable() {\n        if (!this._scrollSubscription) {\n            const throttle = this._config ? this._config.scrollThrottle : 0;\n            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe(() => {\n                this._overlayRef.updatePosition();\n                // TODO(crisbeto): make `close` on by default once all components can handle it.\n                if (this._config && this._config.autoClose) {\n                    const overlayRect = this._overlayRef.overlayElement.getBoundingClientRect();\n                    const { width, height } = this._viewportRuler.getViewportSize();\n                    // TODO(crisbeto): include all ancestor scroll containers here once\n                    // we have a way of exposing the trigger element to the scroll strategy.\n                    const parentRects = [{ width, height, bottom: height, right: width, top: 0, left: 0 }];\n                    if (isElementScrolledOutsideView(overlayRect, parentRects)) {\n                        this.disable();\n                        this._ngZone.run(() => this._overlayRef.detach());\n                    }\n                }\n            });\n        }\n    }\n    /** Disables repositioning of the attached overlay on scroll. */\n    disable() {\n        if (this._scrollSubscription) {\n            this._scrollSubscription.unsubscribe();\n            this._scrollSubscription = null;\n        }\n    }\n    detach() {\n        this.disable();\n        this._overlayRef = null;\n    }\n}\n\n/**\n * Options for how an overlay will handle scrolling.\n *\n * Users can provide a custom value for `ScrollStrategyOptions` to replace the default\n * behaviors. This class primarily acts as a factory for ScrollStrategy instances.\n */\nclass ScrollStrategyOptions {\n    constructor(_scrollDispatcher, _viewportRuler, _ngZone, document) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewportRuler = _viewportRuler;\n        this._ngZone = _ngZone;\n        /** Do nothing on scroll. */\n        this.noop = () => new NoopScrollStrategy();\n        /**\n         * Close the overlay as soon as the user scrolls.\n         * @param config Configuration to be used inside the scroll strategy.\n         */\n        this.close = (config) => new CloseScrollStrategy(this._scrollDispatcher, this._ngZone, this._viewportRuler, config);\n        /** Block scrolling. */\n        this.block = () => new BlockScrollStrategy(this._viewportRuler, this._document);\n        /**\n         * Update the overlay's position on scroll.\n         * @param config Configuration to be used inside the scroll strategy.\n         * Allows debouncing the reposition calls.\n         */\n        this.reposition = (config) => new RepositionScrollStrategy(this._scrollDispatcher, this._viewportRuler, this._ngZone, config);\n        this._document = document;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollStrategyOptions, deps: [{ token: i1.ScrollDispatcher }, { token: i1.ViewportRuler }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollStrategyOptions, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollStrategyOptions, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.ScrollDispatcher }, { type: i1.ViewportRuler }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n\n/** Initial configuration used when creating an overlay. */\nclass OverlayConfig {\n    constructor(config) {\n        /** Strategy to be used when handling scroll events while the overlay is open. */\n        this.scrollStrategy = new NoopScrollStrategy();\n        /** Custom class to add to the overlay pane. */\n        this.panelClass = '';\n        /** Whether the overlay has a backdrop. */\n        this.hasBackdrop = false;\n        /** Custom class to add to the backdrop */\n        this.backdropClass = 'cdk-overlay-dark-backdrop';\n        /**\n         * Whether the overlay should be disposed of when the user goes backwards/forwards in history.\n         * Note that this usually doesn't include clicking on links (unless the user is using\n         * the `HashLocationStrategy`).\n         */\n        this.disposeOnNavigation = false;\n        if (config) {\n            // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,\n            // loses the array generic type in the `for of`. But we *also* have to use `Array` because\n            // typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`\n            const configKeys = Object.keys(config);\n            for (const key of configKeys) {\n                if (config[key] !== undefined) {\n                    // TypeScript, as of version 3.5, sees the left-hand-side of this expression\n                    // as \"I don't know *which* key this is, so the only valid value is the intersection\n                    // of all the possible values.\" In this case, that happens to be `undefined`. TypeScript\n                    // is not smart enough to see that the right-hand-side is actually an access of the same\n                    // exact type with the same exact key, meaning that the value type must be identical.\n                    // So we use `any` to work around this.\n                    this[key] = config[key];\n                }\n            }\n        }\n    }\n}\n\n/** The points of the origin element and the overlay element to connect. */\nclass ConnectionPositionPair {\n    constructor(origin, overlay, \n    /** Offset along the X axis. */\n    offsetX, \n    /** Offset along the Y axis. */\n    offsetY, \n    /** Class(es) to be applied to the panel while this position is active. */\n    panelClass) {\n        this.offsetX = offsetX;\n        this.offsetY = offsetY;\n        this.panelClass = panelClass;\n        this.originX = origin.originX;\n        this.originY = origin.originY;\n        this.overlayX = overlay.overlayX;\n        this.overlayY = overlay.overlayY;\n    }\n}\n/**\n * Set of properties regarding the position of the origin and overlay relative to the viewport\n * with respect to the containing Scrollable elements.\n *\n * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the\n * bounds of any one of the strategy's Scrollable's bounding client rectangle.\n *\n * The overlay and origin are outside view if there is no overlap between their bounding client\n * rectangle and any one of the strategy's Scrollable's bounding client rectangle.\n *\n *       -----------                    -----------\n *       | outside |                    | clipped |\n *       |  view   |              --------------------------\n *       |         |              |     |         |        |\n *       ----------               |     -----------        |\n *  --------------------------    |                        |\n *  |                        |    |      Scrollable        |\n *  |                        |    |                        |\n *  |                        |     --------------------------\n *  |      Scrollable        |\n *  |                        |\n *  --------------------------\n *\n *  @docs-private\n */\nclass ScrollingVisibility {\n}\n/** The change event emitted by the strategy when a fallback position is used. */\nclass ConnectedOverlayPositionChange {\n    constructor(\n    /** The position used as a result of this change. */\n    connectionPair, \n    /** @docs-private */\n    scrollableViewProperties) {\n        this.connectionPair = connectionPair;\n        this.scrollableViewProperties = scrollableViewProperties;\n    }\n}\n/**\n * Validates whether a vertical position property matches the expected values.\n * @param property Name of the property being validated.\n * @param value Value of the property being validated.\n * @docs-private\n */\nfunction validateVerticalPosition(property, value) {\n    if (value !== 'top' && value !== 'bottom' && value !== 'center') {\n        throw Error(`ConnectedPosition: Invalid ${property} \"${value}\". ` +\n            `Expected \"top\", \"bottom\" or \"center\".`);\n    }\n}\n/**\n * Validates whether a horizontal position property matches the expected values.\n * @param property Name of the property being validated.\n * @param value Value of the property being validated.\n * @docs-private\n */\nfunction validateHorizontalPosition(property, value) {\n    if (value !== 'start' && value !== 'end' && value !== 'center') {\n        throw Error(`ConnectedPosition: Invalid ${property} \"${value}\". ` +\n            `Expected \"start\", \"end\" or \"center\".`);\n    }\n}\n\n/**\n * Service for dispatching events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass BaseOverlayDispatcher {\n    constructor(document) {\n        /** Currently attached overlays in the order they were attached. */\n        this._attachedOverlays = [];\n        this._document = document;\n    }\n    ngOnDestroy() {\n        this.detach();\n    }\n    /** Add a new overlay to the list of attached overlay refs. */\n    add(overlayRef) {\n        // Ensure that we don't get the same overlay multiple times.\n        this.remove(overlayRef);\n        this._attachedOverlays.push(overlayRef);\n    }\n    /** Remove an overlay from the list of attached overlay refs. */\n    remove(overlayRef) {\n        const index = this._attachedOverlays.indexOf(overlayRef);\n        if (index > -1) {\n            this._attachedOverlays.splice(index, 1);\n        }\n        // Remove the global listener once there are no more overlays.\n        if (this._attachedOverlays.length === 0) {\n            this.detach();\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BaseOverlayDispatcher, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BaseOverlayDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: BaseOverlayDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n\n/**\n * Service for dispatching keyboard events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass OverlayKeyboardDispatcher extends BaseOverlayDispatcher {\n    constructor(document, \n    /** @breaking-change 14.0.0 _ngZone will be required. */\n    _ngZone) {\n        super(document);\n        this._ngZone = _ngZone;\n        /** Keyboard event listener that will be attached to the body. */\n        this._keydownListener = (event) => {\n            const overlays = this._attachedOverlays;\n            for (let i = overlays.length - 1; i > -1; i--) {\n                // Dispatch the keydown event to the top overlay which has subscribers to its keydown events.\n                // We want to target the most recent overlay, rather than trying to match where the event came\n                // from, because some components might open an overlay, but keep focus on a trigger element\n                // (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,\n                // because we don't want overlays that don't handle keyboard events to block the ones below\n                // them that do.\n                if (overlays[i]._keydownEvents.observers.length > 0) {\n                    const keydownEvents = overlays[i]._keydownEvents;\n                    /** @breaking-change 14.0.0 _ngZone will be required. */\n                    if (this._ngZone) {\n                        this._ngZone.run(() => keydownEvents.next(event));\n                    }\n                    else {\n                        keydownEvents.next(event);\n                    }\n                    break;\n                }\n            }\n        };\n    }\n    /** Add a new overlay to the list of attached overlay refs. */\n    add(overlayRef) {\n        super.add(overlayRef);\n        // Lazily start dispatcher once first overlay is added\n        if (!this._isAttached) {\n            /** @breaking-change 14.0.0 _ngZone will be required. */\n            if (this._ngZone) {\n                this._ngZone.runOutsideAngular(() => this._document.body.addEventListener('keydown', this._keydownListener));\n            }\n            else {\n                this._document.body.addEventListener('keydown', this._keydownListener);\n            }\n            this._isAttached = true;\n        }\n    }\n    /** Detaches the global keyboard event listener. */\n    detach() {\n        if (this._isAttached) {\n            this._document.body.removeEventListener('keydown', this._keydownListener);\n            this._isAttached = false;\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayKeyboardDispatcher, deps: [{ token: DOCUMENT }, { token: i0.NgZone, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayKeyboardDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayKeyboardDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i0.NgZone, decorators: [{\n                    type: Optional\n                }] }]; } });\n\n/**\n * Service for dispatching mouse click events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {\n    constructor(document, _platform, \n    /** @breaking-change 14.0.0 _ngZone will be required. */\n    _ngZone) {\n        super(document);\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        this._cursorStyleIsSet = false;\n        /** Store pointerdown event target to track origin of click. */\n        this._pointerDownListener = (event) => {\n            this._pointerDownEventTarget = _getEventTarget(event);\n        };\n        /** Click event listener that will be attached to the body propagate phase. */\n        this._clickListener = (event) => {\n            const target = _getEventTarget(event);\n            // In case of a click event, we want to check the origin of the click\n            // (e.g. in case where a user starts a click inside the overlay and\n            // releases the click outside of it).\n            // This is done by using the event target of the preceding pointerdown event.\n            // Every click event caused by a pointer device has a preceding pointerdown\n            // event, unless the click was programmatically triggered (e.g. in a unit test).\n            const origin = event.type === 'click' && this._pointerDownEventTarget\n                ? this._pointerDownEventTarget\n                : target;\n            // Reset the stored pointerdown event target, to avoid having it interfere\n            // in subsequent events.\n            this._pointerDownEventTarget = null;\n            // We copy the array because the original may be modified asynchronously if the\n            // outsidePointerEvents listener decides to detach overlays resulting in index errors inside\n            // the for loop.\n            const overlays = this._attachedOverlays.slice();\n            // Dispatch the mouse event to the top overlay which has subscribers to its mouse events.\n            // We want to target all overlays for which the click could be considered as outside click.\n            // As soon as we reach an overlay for which the click is not outside click we break off\n            // the loop.\n            for (let i = overlays.length - 1; i > -1; i--) {\n                const overlayRef = overlays[i];\n                if (overlayRef._outsidePointerEvents.observers.length < 1 || !overlayRef.hasAttached()) {\n                    continue;\n                }\n                // If it's a click inside the overlay, just break - we should do nothing\n                // If it's an outside click (both origin and target of the click) dispatch the mouse event,\n                // and proceed with the next overlay\n                if (overlayRef.overlayElement.contains(target) ||\n                    overlayRef.overlayElement.contains(origin)) {\n                    break;\n                }\n                const outsidePointerEvents = overlayRef._outsidePointerEvents;\n                /** @breaking-change 14.0.0 _ngZone will be required. */\n                if (this._ngZone) {\n                    this._ngZone.run(() => outsidePointerEvents.next(event));\n                }\n                else {\n                    outsidePointerEvents.next(event);\n                }\n            }\n        };\n    }\n    /** Add a new overlay to the list of attached overlay refs. */\n    add(overlayRef) {\n        super.add(overlayRef);\n        // Safari on iOS does not generate click events for non-interactive\n        // elements. However, we want to receive a click for any element outside\n        // the overlay. We can force a \"clickable\" state by setting\n        // `cursor: pointer` on the document body. See:\n        // https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event#Safari_Mobile\n        // https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html\n        if (!this._isAttached) {\n            const body = this._document.body;\n            /** @breaking-change 14.0.0 _ngZone will be required. */\n            if (this._ngZone) {\n                this._ngZone.runOutsideAngular(() => this._addEventListeners(body));\n            }\n            else {\n                this._addEventListeners(body);\n            }\n            // click event is not fired on iOS. To make element \"clickable\" we are\n            // setting the cursor to pointer\n            if (this._platform.IOS && !this._cursorStyleIsSet) {\n                this._cursorOriginalValue = body.style.cursor;\n                body.style.cursor = 'pointer';\n                this._cursorStyleIsSet = true;\n            }\n            this._isAttached = true;\n        }\n    }\n    /** Detaches the global keyboard event listener. */\n    detach() {\n        if (this._isAttached) {\n            const body = this._document.body;\n            body.removeEventListener('pointerdown', this._pointerDownListener, true);\n            body.removeEventListener('click', this._clickListener, true);\n            body.removeEventListener('auxclick', this._clickListener, true);\n            body.removeEventListener('contextmenu', this._clickListener, true);\n            if (this._platform.IOS && this._cursorStyleIsSet) {\n                body.style.cursor = this._cursorOriginalValue;\n                this._cursorStyleIsSet = false;\n            }\n            this._isAttached = false;\n        }\n    }\n    _addEventListeners(body) {\n        body.addEventListener('pointerdown', this._pointerDownListener, true);\n        body.addEventListener('click', this._clickListener, true);\n        body.addEventListener('auxclick', this._clickListener, true);\n        body.addEventListener('contextmenu', this._clickListener, true);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayOutsideClickDispatcher, deps: [{ token: DOCUMENT }, { token: i1$1.Platform }, { token: i0.NgZone, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayOutsideClickDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayOutsideClickDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i1$1.Platform }, { type: i0.NgZone, decorators: [{\n                    type: Optional\n                }] }]; } });\n\n/** Container inside which all overlays will render. */\nclass OverlayContainer {\n    constructor(document, _platform) {\n        this._platform = _platform;\n        this._document = document;\n    }\n    ngOnDestroy() {\n        this._containerElement?.remove();\n    }\n    /**\n     * This method returns the overlay container element. It will lazily\n     * create the element the first time it is called to facilitate using\n     * the container in non-browser environments.\n     * @returns the container element\n     */\n    getContainerElement() {\n        if (!this._containerElement) {\n            this._createContainer();\n        }\n        return this._containerElement;\n    }\n    /**\n     * Create the overlay container element, which is simply a div\n     * with the 'cdk-overlay-container' class on the document body.\n     */\n    _createContainer() {\n        const containerClass = 'cdk-overlay-container';\n        // TODO(crisbeto): remove the testing check once we have an overlay testing\n        // module or Angular starts tearing down the testing `NgModule`. See:\n        // https://github.com/angular/angular/issues/18831\n        if (this._platform.isBrowser || _isTestEnvironment()) {\n            const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform=\"server\"], ` + `.${containerClass}[platform=\"test\"]`);\n            // Remove any old containers from the opposite platform.\n            // This can happen when transitioning from the server to the client.\n            for (let i = 0; i < oppositePlatformContainers.length; i++) {\n                oppositePlatformContainers[i].remove();\n            }\n        }\n        const container = this._document.createElement('div');\n        container.classList.add(containerClass);\n        // A long time ago we kept adding new overlay containers whenever a new app was instantiated,\n        // but at some point we added logic which clears the duplicate ones in order to avoid leaks.\n        // The new logic was a little too aggressive since it was breaking some legitimate use cases.\n        // To mitigate the problem we made it so that only containers from a different platform are\n        // cleared, but the side-effect was that people started depending on the overly-aggressive\n        // logic to clean up their tests for them. Until we can introduce an overlay-specific testing\n        // module which does the cleanup, we try to detect that we're in a test environment and we\n        // always clear the container. See #17006.\n        // TODO(crisbeto): remove the test environment check once we have an overlay testing module.\n        if (_isTestEnvironment()) {\n            container.setAttribute('platform', 'test');\n        }\n        else if (!this._platform.isBrowser) {\n            container.setAttribute('platform', 'server');\n        }\n        this._document.body.appendChild(container);\n        this._containerElement = container;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayContainer, deps: [{ token: DOCUMENT }, { token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayContainer, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayContainer, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i1$1.Platform }]; } });\n\n/**\n * Reference to an overlay that has been created with the Overlay service.\n * Used to manipulate or dispose of said overlay.\n */\nclass OverlayRef {\n    constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location, _outsideClickDispatcher, _animationsDisabled = false) {\n        this._portalOutlet = _portalOutlet;\n        this._host = _host;\n        this._pane = _pane;\n        this._config = _config;\n        this._ngZone = _ngZone;\n        this._keyboardDispatcher = _keyboardDispatcher;\n        this._document = _document;\n        this._location = _location;\n        this._outsideClickDispatcher = _outsideClickDispatcher;\n        this._animationsDisabled = _animationsDisabled;\n        this._backdropElement = null;\n        this._backdropClick = new Subject();\n        this._attachments = new Subject();\n        this._detachments = new Subject();\n        this._locationChanges = Subscription.EMPTY;\n        this._backdropClickHandler = (event) => this._backdropClick.next(event);\n        this._backdropTransitionendHandler = (event) => {\n            this._disposeBackdrop(event.target);\n        };\n        /** Stream of keydown events dispatched to this overlay. */\n        this._keydownEvents = new Subject();\n        /** Stream of mouse outside events dispatched to this overlay. */\n        this._outsidePointerEvents = new Subject();\n        if (_config.scrollStrategy) {\n            this._scrollStrategy = _config.scrollStrategy;\n            this._scrollStrategy.attach(this);\n        }\n        this._positionStrategy = _config.positionStrategy;\n    }\n    /** The overlay's HTML element */\n    get overlayElement() {\n        return this._pane;\n    }\n    /** The overlay's backdrop HTML element. */\n    get backdropElement() {\n        return this._backdropElement;\n    }\n    /**\n     * Wrapper around the panel element. Can be used for advanced\n     * positioning where a wrapper with specific styling is\n     * required around the overlay pane.\n     */\n    get hostElement() {\n        return this._host;\n    }\n    /**\n     * Attaches content, given via a Portal, to the overlay.\n     * If the overlay is configured to have a backdrop, it will be created.\n     *\n     * @param portal Portal instance to which to attach the overlay.\n     * @returns The portal attachment result.\n     */\n    attach(portal) {\n        // Insert the host into the DOM before attaching the portal, otherwise\n        // the animations module will skip animations on repeat attachments.\n        if (!this._host.parentElement && this._previousHostParent) {\n            this._previousHostParent.appendChild(this._host);\n        }\n        const attachResult = this._portalOutlet.attach(portal);\n        if (this._positionStrategy) {\n            this._positionStrategy.attach(this);\n        }\n        this._updateStackingOrder();\n        this._updateElementSize();\n        this._updateElementDirection();\n        if (this._scrollStrategy) {\n            this._scrollStrategy.enable();\n        }\n        // Update the position once the zone is stable so that the overlay will be fully rendered\n        // before attempting to position it, as the position may depend on the size of the rendered\n        // content.\n        this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n            // The overlay could've been detached before the zone has stabilized.\n            if (this.hasAttached()) {\n                this.updatePosition();\n            }\n        });\n        // Enable pointer events for the overlay pane element.\n        this._togglePointerEvents(true);\n        if (this._config.hasBackdrop) {\n            this._attachBackdrop();\n        }\n        if (this._config.panelClass) {\n            this._toggleClasses(this._pane, this._config.panelClass, true);\n        }\n        // Only emit the `attachments` event once all other setup is done.\n        this._attachments.next();\n        // Track this overlay by the keyboard dispatcher\n        this._keyboardDispatcher.add(this);\n        if (this._config.disposeOnNavigation) {\n            this._locationChanges = this._location.subscribe(() => this.dispose());\n        }\n        this._outsideClickDispatcher.add(this);\n        // TODO(crisbeto): the null check is here, because the portal outlet returns `any`.\n        // We should be guaranteed for the result to be `ComponentRef | EmbeddedViewRef`, but\n        // `instanceof EmbeddedViewRef` doesn't appear to work at the moment.\n        if (typeof attachResult?.onDestroy === 'function') {\n            // In most cases we control the portal and we know when it is being detached so that\n            // we can finish the disposal process. The exception is if the user passes in a custom\n            // `ViewContainerRef` that isn't destroyed through the overlay API. Note that we use\n            // `detach` here instead of `dispose`, because we don't know if the user intends to\n            // reattach the overlay at a later point. It also has the advantage of waiting for animations.\n            attachResult.onDestroy(() => {\n                if (this.hasAttached()) {\n                    // We have to delay the `detach` call, because detaching immediately prevents\n                    // other destroy hooks from running. This is likely a framework bug similar to\n                    // https://github.com/angular/angular/issues/46119\n                    this._ngZone.runOutsideAngular(() => Promise.resolve().then(() => this.detach()));\n                }\n            });\n        }\n        return attachResult;\n    }\n    /**\n     * Detaches an overlay from a portal.\n     * @returns The portal detachment result.\n     */\n    detach() {\n        if (!this.hasAttached()) {\n            return;\n        }\n        this.detachBackdrop();\n        // When the overlay is detached, the pane element should disable pointer events.\n        // This is necessary because otherwise the pane element will cover the page and disable\n        // pointer events therefore. Depends on the position strategy and the applied pane boundaries.\n        this._togglePointerEvents(false);\n        if (this._positionStrategy && this._positionStrategy.detach) {\n            this._positionStrategy.detach();\n        }\n        if (this._scrollStrategy) {\n            this._scrollStrategy.disable();\n        }\n        const detachmentResult = this._portalOutlet.detach();\n        // Only emit after everything is detached.\n        this._detachments.next();\n        // Remove this overlay from keyboard dispatcher tracking.\n        this._keyboardDispatcher.remove(this);\n        // Keeping the host element in the DOM can cause scroll jank, because it still gets\n        // rendered, even though it's transparent and unclickable which is why we remove it.\n        this._detachContentWhenStable();\n        this._locationChanges.unsubscribe();\n        this._outsideClickDispatcher.remove(this);\n        return detachmentResult;\n    }\n    /** Cleans up the overlay from the DOM. */\n    dispose() {\n        const isAttached = this.hasAttached();\n        if (this._positionStrategy) {\n            this._positionStrategy.dispose();\n        }\n        this._disposeScrollStrategy();\n        this._disposeBackdrop(this._backdropElement);\n        this._locationChanges.unsubscribe();\n        this._keyboardDispatcher.remove(this);\n        this._portalOutlet.dispose();\n        this._attachments.complete();\n        this._backdropClick.complete();\n        this._keydownEvents.complete();\n        this._outsidePointerEvents.complete();\n        this._outsideClickDispatcher.remove(this);\n        this._host?.remove();\n        this._previousHostParent = this._pane = this._host = null;\n        if (isAttached) {\n            this._detachments.next();\n        }\n        this._detachments.complete();\n    }\n    /** Whether the overlay has attached content. */\n    hasAttached() {\n        return this._portalOutlet.hasAttached();\n    }\n    /** Gets an observable that emits when the backdrop has been clicked. */\n    backdropClick() {\n        return this._backdropClick;\n    }\n    /** Gets an observable that emits when the overlay has been attached. */\n    attachments() {\n        return this._attachments;\n    }\n    /** Gets an observable that emits when the overlay has been detached. */\n    detachments() {\n        return this._detachments;\n    }\n    /** Gets an observable of keydown events targeted to this overlay. */\n    keydownEvents() {\n        return this._keydownEvents;\n    }\n    /** Gets an observable of pointer events targeted outside this overlay. */\n    outsidePointerEvents() {\n        return this._outsidePointerEvents;\n    }\n    /** Gets the current overlay configuration, which is immutable. */\n    getConfig() {\n        return this._config;\n    }\n    /** Updates the position of the overlay based on the position strategy. */\n    updatePosition() {\n        if (this._positionStrategy) {\n            this._positionStrategy.apply();\n        }\n    }\n    /** Switches to a new position strategy and updates the overlay position. */\n    updatePositionStrategy(strategy) {\n        if (strategy === this._positionStrategy) {\n            return;\n        }\n        if (this._positionStrategy) {\n            this._positionStrategy.dispose();\n        }\n        this._positionStrategy = strategy;\n        if (this.hasAttached()) {\n            strategy.attach(this);\n            this.updatePosition();\n        }\n    }\n    /** Update the size properties of the overlay. */\n    updateSize(sizeConfig) {\n        this._config = { ...this._config, ...sizeConfig };\n        this._updateElementSize();\n    }\n    /** Sets the LTR/RTL direction for the overlay. */\n    setDirection(dir) {\n        this._config = { ...this._config, direction: dir };\n        this._updateElementDirection();\n    }\n    /** Add a CSS class or an array of classes to the overlay pane. */\n    addPanelClass(classes) {\n        if (this._pane) {\n            this._toggleClasses(this._pane, classes, true);\n        }\n    }\n    /** Remove a CSS class or an array of classes from the overlay pane. */\n    removePanelClass(classes) {\n        if (this._pane) {\n            this._toggleClasses(this._pane, classes, false);\n        }\n    }\n    /**\n     * Returns the layout direction of the overlay panel.\n     */\n    getDirection() {\n        const direction = this._config.direction;\n        if (!direction) {\n            return 'ltr';\n        }\n        return typeof direction === 'string' ? direction : direction.value;\n    }\n    /** Switches to a new scroll strategy. */\n    updateScrollStrategy(strategy) {\n        if (strategy === this._scrollStrategy) {\n            return;\n        }\n        this._disposeScrollStrategy();\n        this._scrollStrategy = strategy;\n        if (this.hasAttached()) {\n            strategy.attach(this);\n            strategy.enable();\n        }\n    }\n    /** Updates the text direction of the overlay panel. */\n    _updateElementDirection() {\n        this._host.setAttribute('dir', this.getDirection());\n    }\n    /** Updates the size of the overlay element based on the overlay config. */\n    _updateElementSize() {\n        if (!this._pane) {\n            return;\n        }\n        const style = this._pane.style;\n        style.width = coerceCssPixelValue(this._config.width);\n        style.height = coerceCssPixelValue(this._config.height);\n        style.minWidth = coerceCssPixelValue(this._config.minWidth);\n        style.minHeight = coerceCssPixelValue(this._config.minHeight);\n        style.maxWidth = coerceCssPixelValue(this._config.maxWidth);\n        style.maxHeight = coerceCssPixelValue(this._config.maxHeight);\n    }\n    /** Toggles the pointer events for the overlay pane element. */\n    _togglePointerEvents(enablePointer) {\n        this._pane.style.pointerEvents = enablePointer ? '' : 'none';\n    }\n    /** Attaches a backdrop for this overlay. */\n    _attachBackdrop() {\n        const showingClass = 'cdk-overlay-backdrop-showing';\n        this._backdropElement = this._document.createElement('div');\n        this._backdropElement.classList.add('cdk-overlay-backdrop');\n        if (this._animationsDisabled) {\n            this._backdropElement.classList.add('cdk-overlay-backdrop-noop-animation');\n        }\n        if (this._config.backdropClass) {\n            this._toggleClasses(this._backdropElement, this._config.backdropClass, true);\n        }\n        // Insert the backdrop before the pane in the DOM order,\n        // in order to handle stacked overlays properly.\n        this._host.parentElement.insertBefore(this._backdropElement, this._host);\n        // Forward backdrop clicks such that the consumer of the overlay can perform whatever\n        // action desired when such a click occurs (usually closing the overlay).\n        this._backdropElement.addEventListener('click', this._backdropClickHandler);\n        // Add class to fade-in the backdrop after one frame.\n        if (!this._animationsDisabled && typeof requestAnimationFrame !== 'undefined') {\n            this._ngZone.runOutsideAngular(() => {\n                requestAnimationFrame(() => {\n                    if (this._backdropElement) {\n                        this._backdropElement.classList.add(showingClass);\n                    }\n                });\n            });\n        }\n        else {\n            this._backdropElement.classList.add(showingClass);\n        }\n    }\n    /**\n     * Updates the stacking order of the element, moving it to the top if necessary.\n     * This is required in cases where one overlay was detached, while another one,\n     * that should be behind it, was destroyed. The next time both of them are opened,\n     * the stacking will be wrong, because the detached element's pane will still be\n     * in its original DOM position.\n     */\n    _updateStackingOrder() {\n        if (this._host.nextSibling) {\n            this._host.parentNode.appendChild(this._host);\n        }\n    }\n    /** Detaches the backdrop (if any) associated with the overlay. */\n    detachBackdrop() {\n        const backdropToDetach = this._backdropElement;\n        if (!backdropToDetach) {\n            return;\n        }\n        if (this._animationsDisabled) {\n            this._disposeBackdrop(backdropToDetach);\n            return;\n        }\n        backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');\n        this._ngZone.runOutsideAngular(() => {\n            backdropToDetach.addEventListener('transitionend', this._backdropTransitionendHandler);\n        });\n        // If the backdrop doesn't have a transition, the `transitionend` event won't fire.\n        // In this case we make it unclickable and we try to remove it after a delay.\n        backdropToDetach.style.pointerEvents = 'none';\n        // Run this outside the Angular zone because there's nothing that Angular cares about.\n        // If it were to run inside the Angular zone, every test that used Overlay would have to be\n        // either async or fakeAsync.\n        this._backdropTimeout = this._ngZone.runOutsideAngular(() => setTimeout(() => {\n            this._disposeBackdrop(backdropToDetach);\n        }, 500));\n    }\n    /** Toggles a single CSS class or an array of classes on an element. */\n    _toggleClasses(element, cssClasses, isAdd) {\n        const classes = coerceArray(cssClasses || []).filter(c => !!c);\n        if (classes.length) {\n            isAdd ? element.classList.add(...classes) : element.classList.remove(...classes);\n        }\n    }\n    /** Detaches the overlay content next time the zone stabilizes. */\n    _detachContentWhenStable() {\n        // Normally we wouldn't have to explicitly run this outside the `NgZone`, however\n        // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will\n        // be patched to run inside the zone, which will throw us into an infinite loop.\n        this._ngZone.runOutsideAngular(() => {\n            // We can't remove the host here immediately, because the overlay pane's content\n            // might still be animating. This stream helps us avoid interrupting the animation\n            // by waiting for the pane to become empty.\n            const subscription = this._ngZone.onStable\n                .pipe(takeUntil(merge(this._attachments, this._detachments)))\n                .subscribe(() => {\n                // Needs a couple of checks for the pane and host, because\n                // they may have been removed by the time the zone stabilizes.\n                if (!this._pane || !this._host || this._pane.children.length === 0) {\n                    if (this._pane && this._config.panelClass) {\n                        this._toggleClasses(this._pane, this._config.panelClass, false);\n                    }\n                    if (this._host && this._host.parentElement) {\n                        this._previousHostParent = this._host.parentElement;\n                        this._host.remove();\n                    }\n                    subscription.unsubscribe();\n                }\n            });\n        });\n    }\n    /** Disposes of a scroll strategy. */\n    _disposeScrollStrategy() {\n        const scrollStrategy = this._scrollStrategy;\n        if (scrollStrategy) {\n            scrollStrategy.disable();\n            if (scrollStrategy.detach) {\n                scrollStrategy.detach();\n            }\n        }\n    }\n    /** Removes a backdrop element from the DOM. */\n    _disposeBackdrop(backdrop) {\n        if (backdrop) {\n            backdrop.removeEventListener('click', this._backdropClickHandler);\n            backdrop.removeEventListener('transitionend', this._backdropTransitionendHandler);\n            backdrop.remove();\n            // It is possible that a new portal has been attached to this overlay since we started\n            // removing the backdrop. If that is the case, only clear the backdrop reference if it\n            // is still the same instance that we started to remove.\n            if (this._backdropElement === backdrop) {\n                this._backdropElement = null;\n            }\n        }\n        if (this._backdropTimeout) {\n            clearTimeout(this._backdropTimeout);\n            this._backdropTimeout = undefined;\n        }\n    }\n}\n\n// TODO: refactor clipping detection into a separate thing (part of scrolling module)\n// TODO: doesn't handle both flexible width and height when it has to scroll along both axis.\n/** Class to be added to the overlay bounding box. */\nconst boundingBoxClass = 'cdk-overlay-connected-position-bounding-box';\n/** Regex used to split a string on its CSS units. */\nconst cssUnitPattern = /([A-Za-z%]+)$/;\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * implicit position relative some origin element. The relative position is defined in terms of\n * a point on the origin element that is connected to a point on the overlay element. For example,\n * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner\n * of the overlay.\n */\nclass FlexibleConnectedPositionStrategy {\n    /** Ordered list of preferred positions, from most to least desirable. */\n    get positions() {\n        return this._preferredPositions;\n    }\n    constructor(connectedTo, _viewportRuler, _document, _platform, _overlayContainer) {\n        this._viewportRuler = _viewportRuler;\n        this._document = _document;\n        this._platform = _platform;\n        this._overlayContainer = _overlayContainer;\n        /** Last size used for the bounding box. Used to avoid resizing the overlay after open. */\n        this._lastBoundingBoxSize = { width: 0, height: 0 };\n        /** Whether the overlay was pushed in a previous positioning. */\n        this._isPushed = false;\n        /** Whether the overlay can be pushed on-screen on the initial open. */\n        this._canPush = true;\n        /** Whether the overlay can grow via flexible width/height after the initial open. */\n        this._growAfterOpen = false;\n        /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n        this._hasFlexibleDimensions = true;\n        /** Whether the overlay position is locked. */\n        this._positionLocked = false;\n        /** Amount of space that must be maintained between the overlay and the edge of the viewport. */\n        this._viewportMargin = 0;\n        /** The Scrollable containers used to check scrollable view properties on position change. */\n        this._scrollables = [];\n        /** Ordered list of preferred positions, from most to least desirable. */\n        this._preferredPositions = [];\n        /** Subject that emits whenever the position changes. */\n        this._positionChanges = new Subject();\n        /** Subscription to viewport size changes. */\n        this._resizeSubscription = Subscription.EMPTY;\n        /** Default offset for the overlay along the x axis. */\n        this._offsetX = 0;\n        /** Default offset for the overlay along the y axis. */\n        this._offsetY = 0;\n        /** Keeps track of the CSS classes that the position strategy has applied on the overlay panel. */\n        this._appliedPanelClasses = [];\n        /** Observable sequence of position changes. */\n        this.positionChanges = this._positionChanges;\n        this.setOrigin(connectedTo);\n    }\n    /** Attaches this position strategy to an overlay. */\n    attach(overlayRef) {\n        if (this._overlayRef &&\n            overlayRef !== this._overlayRef &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('This position strategy is already attached to an overlay');\n        }\n        this._validatePositions();\n        overlayRef.hostElement.classList.add(boundingBoxClass);\n        this._overlayRef = overlayRef;\n        this._boundingBox = overlayRef.hostElement;\n        this._pane = overlayRef.overlayElement;\n        this._isDisposed = false;\n        this._isInitialRender = true;\n        this._lastPosition = null;\n        this._resizeSubscription.unsubscribe();\n        this._resizeSubscription = this._viewportRuler.change().subscribe(() => {\n            // When the window is resized, we want to trigger the next reposition as if it\n            // was an initial render, in order for the strategy to pick a new optimal position,\n            // otherwise position locking will cause it to stay at the old one.\n            this._isInitialRender = true;\n            this.apply();\n        });\n    }\n    /**\n     * Updates the position of the overlay element, using whichever preferred position relative\n     * to the origin best fits on-screen.\n     *\n     * The selection of a position goes as follows:\n     *  - If any positions fit completely within the viewport as-is,\n     *      choose the first position that does so.\n     *  - If flexible dimensions are enabled and at least one satisfies the given minimum width/height,\n     *      choose the position with the greatest available size modified by the positions' weight.\n     *  - If pushing is enabled, take the position that went off-screen the least and push it\n     *      on-screen.\n     *  - If none of the previous criteria were met, use the position that goes off-screen the least.\n     * @docs-private\n     */\n    apply() {\n        // We shouldn't do anything if the strategy was disposed or we're on the server.\n        if (this._isDisposed || !this._platform.isBrowser) {\n            return;\n        }\n        // If the position has been applied already (e.g. when the overlay was opened) and the\n        // consumer opted into locking in the position, re-use the old position, in order to\n        // prevent the overlay from jumping around.\n        if (!this._isInitialRender && this._positionLocked && this._lastPosition) {\n            this.reapplyLastPosition();\n            return;\n        }\n        this._clearPanelClasses();\n        this._resetOverlayElementStyles();\n        this._resetBoundingBoxStyles();\n        // We need the bounding rects for the origin, the overlay and the container to determine how to position\n        // the overlay relative to the origin.\n        // We use the viewport rect to determine whether a position would go off-screen.\n        this._viewportRect = this._getNarrowedViewportRect();\n        this._originRect = this._getOriginRect();\n        this._overlayRect = this._pane.getBoundingClientRect();\n        this._containerRect = this._overlayContainer.getContainerElement().getBoundingClientRect();\n        const originRect = this._originRect;\n        const overlayRect = this._overlayRect;\n        const viewportRect = this._viewportRect;\n        const containerRect = this._containerRect;\n        // Positions where the overlay will fit with flexible dimensions.\n        const flexibleFits = [];\n        // Fallback if none of the preferred positions fit within the viewport.\n        let fallback;\n        // Go through each of the preferred positions looking for a good fit.\n        // If a good fit is found, it will be applied immediately.\n        for (let pos of this._preferredPositions) {\n            // Get the exact (x, y) coordinate for the point-of-origin on the origin element.\n            let originPoint = this._getOriginPoint(originRect, containerRect, pos);\n            // From that point-of-origin, get the exact (x, y) coordinate for the top-left corner of the\n            // overlay in this position. We use the top-left corner for calculations and later translate\n            // this into an appropriate (top, left, bottom, right) style.\n            let overlayPoint = this._getOverlayPoint(originPoint, overlayRect, pos);\n            // Calculate how well the overlay would fit into the viewport with this point.\n            let overlayFit = this._getOverlayFit(overlayPoint, overlayRect, viewportRect, pos);\n            // If the overlay, without any further work, fits into the viewport, use this position.\n            if (overlayFit.isCompletelyWithinViewport) {\n                this._isPushed = false;\n                this._applyPosition(pos, originPoint);\n                return;\n            }\n            // If the overlay has flexible dimensions, we can use this position\n            // so long as there's enough space for the minimum dimensions.\n            if (this._canFitWithFlexibleDimensions(overlayFit, overlayPoint, viewportRect)) {\n                // Save positions where the overlay will fit with flexible dimensions. We will use these\n                // if none of the positions fit *without* flexible dimensions.\n                flexibleFits.push({\n                    position: pos,\n                    origin: originPoint,\n                    overlayRect,\n                    boundingBoxRect: this._calculateBoundingBoxRect(originPoint, pos),\n                });\n                continue;\n            }\n            // If the current preferred position does not fit on the screen, remember the position\n            // if it has more visible area on-screen than we've seen and move onto the next preferred\n            // position.\n            if (!fallback || fallback.overlayFit.visibleArea < overlayFit.visibleArea) {\n                fallback = { overlayFit, overlayPoint, originPoint, position: pos, overlayRect };\n            }\n        }\n        // If there are any positions where the overlay would fit with flexible dimensions, choose the\n        // one that has the greatest area available modified by the position's weight\n        if (flexibleFits.length) {\n            let bestFit = null;\n            let bestScore = -1;\n            for (const fit of flexibleFits) {\n                const score = fit.boundingBoxRect.width * fit.boundingBoxRect.height * (fit.position.weight || 1);\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestFit = fit;\n                }\n            }\n            this._isPushed = false;\n            this._applyPosition(bestFit.position, bestFit.origin);\n            return;\n        }\n        // When none of the preferred positions fit within the viewport, take the position\n        // that went off-screen the least and attempt to push it on-screen.\n        if (this._canPush) {\n            // TODO(jelbourn): after pushing, the opening \"direction\" of the overlay might not make sense.\n            this._isPushed = true;\n            this._applyPosition(fallback.position, fallback.originPoint);\n            return;\n        }\n        // All options for getting the overlay within the viewport have been exhausted, so go with the\n        // position that went off-screen the least.\n        this._applyPosition(fallback.position, fallback.originPoint);\n    }\n    detach() {\n        this._clearPanelClasses();\n        this._lastPosition = null;\n        this._previousPushAmount = null;\n        this._resizeSubscription.unsubscribe();\n    }\n    /** Cleanup after the element gets destroyed. */\n    dispose() {\n        if (this._isDisposed) {\n            return;\n        }\n        // We can't use `_resetBoundingBoxStyles` here, because it resets\n        // some properties to zero, rather than removing them.\n        if (this._boundingBox) {\n            extendStyles(this._boundingBox.style, {\n                top: '',\n                left: '',\n                right: '',\n                bottom: '',\n                height: '',\n                width: '',\n                alignItems: '',\n                justifyContent: '',\n            });\n        }\n        if (this._pane) {\n            this._resetOverlayElementStyles();\n        }\n        if (this._overlayRef) {\n            this._overlayRef.hostElement.classList.remove(boundingBoxClass);\n        }\n        this.detach();\n        this._positionChanges.complete();\n        this._overlayRef = this._boundingBox = null;\n        this._isDisposed = true;\n    }\n    /**\n     * This re-aligns the overlay element with the trigger in its last calculated position,\n     * even if a position higher in the \"preferred positions\" list would now fit. This\n     * allows one to re-align the panel without changing the orientation of the panel.\n     */\n    reapplyLastPosition() {\n        if (this._isDisposed || !this._platform.isBrowser) {\n            return;\n        }\n        const lastPosition = this._lastPosition;\n        if (lastPosition) {\n            this._originRect = this._getOriginRect();\n            this._overlayRect = this._pane.getBoundingClientRect();\n            this._viewportRect = this._getNarrowedViewportRect();\n            this._containerRect = this._overlayContainer.getContainerElement().getBoundingClientRect();\n            const originPoint = this._getOriginPoint(this._originRect, this._containerRect, lastPosition);\n            this._applyPosition(lastPosition, originPoint);\n        }\n        else {\n            this.apply();\n        }\n    }\n    /**\n     * Sets the list of Scrollable containers that host the origin element so that\n     * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every\n     * Scrollable must be an ancestor element of the strategy's origin element.\n     */\n    withScrollableContainers(scrollables) {\n        this._scrollables = scrollables;\n        return this;\n    }\n    /**\n     * Adds new preferred positions.\n     * @param positions List of positions options for this overlay.\n     */\n    withPositions(positions) {\n        this._preferredPositions = positions;\n        // If the last calculated position object isn't part of the positions anymore, clear\n        // it in order to avoid it being picked up if the consumer tries to re-apply.\n        if (positions.indexOf(this._lastPosition) === -1) {\n            this._lastPosition = null;\n        }\n        this._validatePositions();\n        return this;\n    }\n    /**\n     * Sets a minimum distance the overlay may be positioned to the edge of the viewport.\n     * @param margin Required margin between the overlay and the viewport edge in pixels.\n     */\n    withViewportMargin(margin) {\n        this._viewportMargin = margin;\n        return this;\n    }\n    /** Sets whether the overlay's width and height can be constrained to fit within the viewport. */\n    withFlexibleDimensions(flexibleDimensions = true) {\n        this._hasFlexibleDimensions = flexibleDimensions;\n        return this;\n    }\n    /** Sets whether the overlay can grow after the initial open via flexible width/height. */\n    withGrowAfterOpen(growAfterOpen = true) {\n        this._growAfterOpen = growAfterOpen;\n        return this;\n    }\n    /** Sets whether the overlay can be pushed on-screen if none of the provided positions fit. */\n    withPush(canPush = true) {\n        this._canPush = canPush;\n        return this;\n    }\n    /**\n     * Sets whether the overlay's position should be locked in after it is positioned\n     * initially. When an overlay is locked in, it won't attempt to reposition itself\n     * when the position is re-applied (e.g. when the user scrolls away).\n     * @param isLocked Whether the overlay should locked in.\n     */\n    withLockedPosition(isLocked = true) {\n        this._positionLocked = isLocked;\n        return this;\n    }\n    /**\n     * Sets the origin, relative to which to position the overlay.\n     * Using an element origin is useful for building components that need to be positioned\n     * relatively to a trigger (e.g. dropdown menus or tooltips), whereas using a point can be\n     * used for cases like contextual menus which open relative to the user's pointer.\n     * @param origin Reference to the new origin.\n     */\n    setOrigin(origin) {\n        this._origin = origin;\n        return this;\n    }\n    /**\n     * Sets the default offset for the overlay's connection point on the x-axis.\n     * @param offset New offset in the X axis.\n     */\n    withDefaultOffsetX(offset) {\n        this._offsetX = offset;\n        return this;\n    }\n    /**\n     * Sets the default offset for the overlay's connection point on the y-axis.\n     * @param offset New offset in the Y axis.\n     */\n    withDefaultOffsetY(offset) {\n        this._offsetY = offset;\n        return this;\n    }\n    /**\n     * Configures that the position strategy should set a `transform-origin` on some elements\n     * inside the overlay, depending on the current position that is being applied. This is\n     * useful for the cases where the origin of an animation can change depending on the\n     * alignment of the overlay.\n     * @param selector CSS selector that will be used to find the target\n     *    elements onto which to set the transform origin.\n     */\n    withTransformOriginOn(selector) {\n        this._transformOriginSelector = selector;\n        return this;\n    }\n    /**\n     * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.\n     */\n    _getOriginPoint(originRect, containerRect, pos) {\n        let x;\n        if (pos.originX == 'center') {\n            // Note: when centering we should always use the `left`\n            // offset, otherwise the position will be wrong in RTL.\n            x = originRect.left + originRect.width / 2;\n        }\n        else {\n            const startX = this._isRtl() ? originRect.right : originRect.left;\n            const endX = this._isRtl() ? originRect.left : originRect.right;\n            x = pos.originX == 'start' ? startX : endX;\n        }\n        // When zooming in Safari the container rectangle contains negative values for the position\n        // and we need to re-add them to the calculated coordinates.\n        if (containerRect.left < 0) {\n            x -= containerRect.left;\n        }\n        let y;\n        if (pos.originY == 'center') {\n            y = originRect.top + originRect.height / 2;\n        }\n        else {\n            y = pos.originY == 'top' ? originRect.top : originRect.bottom;\n        }\n        // Normally the containerRect's top value would be zero, however when the overlay is attached to an input\n        // (e.g. in an autocomplete), mobile browsers will shift everything in order to put the input in the middle\n        // of the screen and to make space for the virtual keyboard. We need to account for this offset,\n        // otherwise our positioning will be thrown off.\n        // Additionally, when zooming in Safari this fixes the vertical position.\n        if (containerRect.top < 0) {\n            y -= containerRect.top;\n        }\n        return { x, y };\n    }\n    /**\n     * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and\n     * origin point to which the overlay should be connected.\n     */\n    _getOverlayPoint(originPoint, overlayRect, pos) {\n        // Calculate the (overlayStartX, overlayStartY), the start of the\n        // potential overlay position relative to the origin point.\n        let overlayStartX;\n        if (pos.overlayX == 'center') {\n            overlayStartX = -overlayRect.width / 2;\n        }\n        else if (pos.overlayX === 'start') {\n            overlayStartX = this._isRtl() ? -overlayRect.width : 0;\n        }\n        else {\n            overlayStartX = this._isRtl() ? 0 : -overlayRect.width;\n        }\n        let overlayStartY;\n        if (pos.overlayY == 'center') {\n            overlayStartY = -overlayRect.height / 2;\n        }\n        else {\n            overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;\n        }\n        // The (x, y) coordinates of the overlay.\n        return {\n            x: originPoint.x + overlayStartX,\n            y: originPoint.y + overlayStartY,\n        };\n    }\n    /** Gets how well an overlay at the given point will fit within the viewport. */\n    _getOverlayFit(point, rawOverlayRect, viewport, position) {\n        // Round the overlay rect when comparing against the\n        // viewport, because the viewport is always rounded.\n        const overlay = getRoundedBoundingClientRect(rawOverlayRect);\n        let { x, y } = point;\n        let offsetX = this._getOffset(position, 'x');\n        let offsetY = this._getOffset(position, 'y');\n        // Account for the offsets since they could push the overlay out of the viewport.\n        if (offsetX) {\n            x += offsetX;\n        }\n        if (offsetY) {\n            y += offsetY;\n        }\n        // How much the overlay would overflow at this position, on each side.\n        let leftOverflow = 0 - x;\n        let rightOverflow = x + overlay.width - viewport.width;\n        let topOverflow = 0 - y;\n        let bottomOverflow = y + overlay.height - viewport.height;\n        // Visible parts of the element on each axis.\n        let visibleWidth = this._subtractOverflows(overlay.width, leftOverflow, rightOverflow);\n        let visibleHeight = this._subtractOverflows(overlay.height, topOverflow, bottomOverflow);\n        let visibleArea = visibleWidth * visibleHeight;\n        return {\n            visibleArea,\n            isCompletelyWithinViewport: overlay.width * overlay.height === visibleArea,\n            fitsInViewportVertically: visibleHeight === overlay.height,\n            fitsInViewportHorizontally: visibleWidth == overlay.width,\n        };\n    }\n    /**\n     * Whether the overlay can fit within the viewport when it may resize either its width or height.\n     * @param fit How well the overlay fits in the viewport at some position.\n     * @param point The (x, y) coordinates of the overlay at some position.\n     * @param viewport The geometry of the viewport.\n     */\n    _canFitWithFlexibleDimensions(fit, point, viewport) {\n        if (this._hasFlexibleDimensions) {\n            const availableHeight = viewport.bottom - point.y;\n            const availableWidth = viewport.right - point.x;\n            const minHeight = getPixelValue(this._overlayRef.getConfig().minHeight);\n            const minWidth = getPixelValue(this._overlayRef.getConfig().minWidth);\n            const verticalFit = fit.fitsInViewportVertically || (minHeight != null && minHeight <= availableHeight);\n            const horizontalFit = fit.fitsInViewportHorizontally || (minWidth != null && minWidth <= availableWidth);\n            return verticalFit && horizontalFit;\n        }\n        return false;\n    }\n    /**\n     * Gets the point at which the overlay can be \"pushed\" on-screen. If the overlay is larger than\n     * the viewport, the top-left corner will be pushed on-screen (with overflow occurring on the\n     * right and bottom).\n     *\n     * @param start Starting point from which the overlay is pushed.\n     * @param rawOverlayRect Dimensions of the overlay.\n     * @param scrollPosition Current viewport scroll position.\n     * @returns The point at which to position the overlay after pushing. This is effectively a new\n     *     originPoint.\n     */\n    _pushOverlayOnScreen(start, rawOverlayRect, scrollPosition) {\n        // If the position is locked and we've pushed the overlay already, reuse the previous push\n        // amount, rather than pushing it again. If we were to continue pushing, the element would\n        // remain in the viewport, which goes against the expectations when position locking is enabled.\n        if (this._previousPushAmount && this._positionLocked) {\n            return {\n                x: start.x + this._previousPushAmount.x,\n                y: start.y + this._previousPushAmount.y,\n            };\n        }\n        // Round the overlay rect when comparing against the\n        // viewport, because the viewport is always rounded.\n        const overlay = getRoundedBoundingClientRect(rawOverlayRect);\n        const viewport = this._viewportRect;\n        // Determine how much the overlay goes outside the viewport on each\n        // side, which we'll use to decide which direction to push it.\n        const overflowRight = Math.max(start.x + overlay.width - viewport.width, 0);\n        const overflowBottom = Math.max(start.y + overlay.height - viewport.height, 0);\n        const overflowTop = Math.max(viewport.top - scrollPosition.top - start.y, 0);\n        const overflowLeft = Math.max(viewport.left - scrollPosition.left - start.x, 0);\n        // Amount by which to push the overlay in each axis such that it remains on-screen.\n        let pushX = 0;\n        let pushY = 0;\n        // If the overlay fits completely within the bounds of the viewport, push it from whichever\n        // direction is goes off-screen. Otherwise, push the top-left corner such that its in the\n        // viewport and allow for the trailing end of the overlay to go out of bounds.\n        if (overlay.width <= viewport.width) {\n            pushX = overflowLeft || -overflowRight;\n        }\n        else {\n            pushX = start.x < this._viewportMargin ? viewport.left - scrollPosition.left - start.x : 0;\n        }\n        if (overlay.height <= viewport.height) {\n            pushY = overflowTop || -overflowBottom;\n        }\n        else {\n            pushY = start.y < this._viewportMargin ? viewport.top - scrollPosition.top - start.y : 0;\n        }\n        this._previousPushAmount = { x: pushX, y: pushY };\n        return {\n            x: start.x + pushX,\n            y: start.y + pushY,\n        };\n    }\n    /**\n     * Applies a computed position to the overlay and emits a position change.\n     * @param position The position preference\n     * @param originPoint The point on the origin element where the overlay is connected.\n     */\n    _applyPosition(position, originPoint) {\n        this._setTransformOrigin(position);\n        this._setOverlayElementStyles(originPoint, position);\n        this._setBoundingBoxStyles(originPoint, position);\n        if (position.panelClass) {\n            this._addPanelClasses(position.panelClass);\n        }\n        // Save the last connected position in case the position needs to be re-calculated.\n        this._lastPosition = position;\n        // Notify that the position has been changed along with its change properties.\n        // We only emit if we've got any subscriptions, because the scroll visibility\n        // calculations can be somewhat expensive.\n        if (this._positionChanges.observers.length) {\n            const scrollableViewProperties = this._getScrollVisibility();\n            const changeEvent = new ConnectedOverlayPositionChange(position, scrollableViewProperties);\n            this._positionChanges.next(changeEvent);\n        }\n        this._isInitialRender = false;\n    }\n    /** Sets the transform origin based on the configured selector and the passed-in position.  */\n    _setTransformOrigin(position) {\n        if (!this._transformOriginSelector) {\n            return;\n        }\n        const elements = this._boundingBox.querySelectorAll(this._transformOriginSelector);\n        let xOrigin;\n        let yOrigin = position.overlayY;\n        if (position.overlayX === 'center') {\n            xOrigin = 'center';\n        }\n        else if (this._isRtl()) {\n            xOrigin = position.overlayX === 'start' ? 'right' : 'left';\n        }\n        else {\n            xOrigin = position.overlayX === 'start' ? 'left' : 'right';\n        }\n        for (let i = 0; i < elements.length; i++) {\n            elements[i].style.transformOrigin = `${xOrigin} ${yOrigin}`;\n        }\n    }\n    /**\n     * Gets the position and size of the overlay's sizing container.\n     *\n     * This method does no measuring and applies no styles so that we can cheaply compute the\n     * bounds for all positions and choose the best fit based on these results.\n     */\n    _calculateBoundingBoxRect(origin, position) {\n        const viewport = this._viewportRect;\n        const isRtl = this._isRtl();\n        let height, top, bottom;\n        if (position.overlayY === 'top') {\n            // Overlay is opening \"downward\" and thus is bound by the bottom viewport edge.\n            top = origin.y;\n            height = viewport.height - top + this._viewportMargin;\n        }\n        else if (position.overlayY === 'bottom') {\n            // Overlay is opening \"upward\" and thus is bound by the top viewport edge. We need to add\n            // the viewport margin back in, because the viewport rect is narrowed down to remove the\n            // margin, whereas the `origin` position is calculated based on its `ClientRect`.\n            bottom = viewport.height - origin.y + this._viewportMargin * 2;\n            height = viewport.height - bottom + this._viewportMargin;\n        }\n        else {\n            // If neither top nor bottom, it means that the overlay is vertically centered on the\n            // origin point. Note that we want the position relative to the viewport, rather than\n            // the page, which is why we don't use something like `viewport.bottom - origin.y` and\n            // `origin.y - viewport.top`.\n            const smallestDistanceToViewportEdge = Math.min(viewport.bottom - origin.y + viewport.top, origin.y);\n            const previousHeight = this._lastBoundingBoxSize.height;\n            height = smallestDistanceToViewportEdge * 2;\n            top = origin.y - smallestDistanceToViewportEdge;\n            if (height > previousHeight && !this._isInitialRender && !this._growAfterOpen) {\n                top = origin.y - previousHeight / 2;\n            }\n        }\n        // The overlay is opening 'right-ward' (the content flows to the right).\n        const isBoundedByRightViewportEdge = (position.overlayX === 'start' && !isRtl) || (position.overlayX === 'end' && isRtl);\n        // The overlay is opening 'left-ward' (the content flows to the left).\n        const isBoundedByLeftViewportEdge = (position.overlayX === 'end' && !isRtl) || (position.overlayX === 'start' && isRtl);\n        let width, left, right;\n        if (isBoundedByLeftViewportEdge) {\n            right = viewport.width - origin.x + this._viewportMargin;\n            width = origin.x - this._viewportMargin;\n        }\n        else if (isBoundedByRightViewportEdge) {\n            left = origin.x;\n            width = viewport.right - origin.x;\n        }\n        else {\n            // If neither start nor end, it means that the overlay is horizontally centered on the\n            // origin point. Note that we want the position relative to the viewport, rather than\n            // the page, which is why we don't use something like `viewport.right - origin.x` and\n            // `origin.x - viewport.left`.\n            const smallestDistanceToViewportEdge = Math.min(viewport.right - origin.x + viewport.left, origin.x);\n            const previousWidth = this._lastBoundingBoxSize.width;\n            width = smallestDistanceToViewportEdge * 2;\n            left = origin.x - smallestDistanceToViewportEdge;\n            if (width > previousWidth && !this._isInitialRender && !this._growAfterOpen) {\n                left = origin.x - previousWidth / 2;\n            }\n        }\n        return { top: top, left: left, bottom: bottom, right: right, width, height };\n    }\n    /**\n     * Sets the position and size of the overlay's sizing wrapper. The wrapper is positioned on the\n     * origin's connection point and stretches to the bounds of the viewport.\n     *\n     * @param origin The point on the origin element where the overlay is connected.\n     * @param position The position preference\n     */\n    _setBoundingBoxStyles(origin, position) {\n        const boundingBoxRect = this._calculateBoundingBoxRect(origin, position);\n        // It's weird if the overlay *grows* while scrolling, so we take the last size into account\n        // when applying a new size.\n        if (!this._isInitialRender && !this._growAfterOpen) {\n            boundingBoxRect.height = Math.min(boundingBoxRect.height, this._lastBoundingBoxSize.height);\n            boundingBoxRect.width = Math.min(boundingBoxRect.width, this._lastBoundingBoxSize.width);\n        }\n        const styles = {};\n        if (this._hasExactPosition()) {\n            styles.top = styles.left = '0';\n            styles.bottom = styles.right = styles.maxHeight = styles.maxWidth = '';\n            styles.width = styles.height = '100%';\n        }\n        else {\n            const maxHeight = this._overlayRef.getConfig().maxHeight;\n            const maxWidth = this._overlayRef.getConfig().maxWidth;\n            styles.height = coerceCssPixelValue(boundingBoxRect.height);\n            styles.top = coerceCssPixelValue(boundingBoxRect.top);\n            styles.bottom = coerceCssPixelValue(boundingBoxRect.bottom);\n            styles.width = coerceCssPixelValue(boundingBoxRect.width);\n            styles.left = coerceCssPixelValue(boundingBoxRect.left);\n            styles.right = coerceCssPixelValue(boundingBoxRect.right);\n            // Push the pane content towards the proper direction.\n            if (position.overlayX === 'center') {\n                styles.alignItems = 'center';\n            }\n            else {\n                styles.alignItems = position.overlayX === 'end' ? 'flex-end' : 'flex-start';\n            }\n            if (position.overlayY === 'center') {\n                styles.justifyContent = 'center';\n            }\n            else {\n                styles.justifyContent = position.overlayY === 'bottom' ? 'flex-end' : 'flex-start';\n            }\n            if (maxHeight) {\n                styles.maxHeight = coerceCssPixelValue(maxHeight);\n            }\n            if (maxWidth) {\n                styles.maxWidth = coerceCssPixelValue(maxWidth);\n            }\n        }\n        this._lastBoundingBoxSize = boundingBoxRect;\n        extendStyles(this._boundingBox.style, styles);\n    }\n    /** Resets the styles for the bounding box so that a new positioning can be computed. */\n    _resetBoundingBoxStyles() {\n        extendStyles(this._boundingBox.style, {\n            top: '0',\n            left: '0',\n            right: '0',\n            bottom: '0',\n            height: '',\n            width: '',\n            alignItems: '',\n            justifyContent: '',\n        });\n    }\n    /** Resets the styles for the overlay pane so that a new positioning can be computed. */\n    _resetOverlayElementStyles() {\n        extendStyles(this._pane.style, {\n            top: '',\n            left: '',\n            bottom: '',\n            right: '',\n            position: '',\n            transform: '',\n        });\n    }\n    /** Sets positioning styles to the overlay element. */\n    _setOverlayElementStyles(originPoint, position) {\n        const styles = {};\n        const hasExactPosition = this._hasExactPosition();\n        const hasFlexibleDimensions = this._hasFlexibleDimensions;\n        const config = this._overlayRef.getConfig();\n        if (hasExactPosition) {\n            const scrollPosition = this._viewportRuler.getViewportScrollPosition();\n            extendStyles(styles, this._getExactOverlayY(position, originPoint, scrollPosition));\n            extendStyles(styles, this._getExactOverlayX(position, originPoint, scrollPosition));\n        }\n        else {\n            styles.position = 'static';\n        }\n        // Use a transform to apply the offsets. We do this because the `center` positions rely on\n        // being in the normal flex flow and setting a `top` / `left` at all will completely throw\n        // off the position. We also can't use margins, because they won't have an effect in some\n        // cases where the element doesn't have anything to \"push off of\". Finally, this works\n        // better both with flexible and non-flexible positioning.\n        let transformString = '';\n        let offsetX = this._getOffset(position, 'x');\n        let offsetY = this._getOffset(position, 'y');\n        if (offsetX) {\n            transformString += `translateX(${offsetX}px) `;\n        }\n        if (offsetY) {\n            transformString += `translateY(${offsetY}px)`;\n        }\n        styles.transform = transformString.trim();\n        // If a maxWidth or maxHeight is specified on the overlay, we remove them. We do this because\n        // we need these values to both be set to \"100%\" for the automatic flexible sizing to work.\n        // The maxHeight and maxWidth are set on the boundingBox in order to enforce the constraint.\n        // Note that this doesn't apply when we have an exact position, in which case we do want to\n        // apply them because they'll be cleared from the bounding box.\n        if (config.maxHeight) {\n            if (hasExactPosition) {\n                styles.maxHeight = coerceCssPixelValue(config.maxHeight);\n            }\n            else if (hasFlexibleDimensions) {\n                styles.maxHeight = '';\n            }\n        }\n        if (config.maxWidth) {\n            if (hasExactPosition) {\n                styles.maxWidth = coerceCssPixelValue(config.maxWidth);\n            }\n            else if (hasFlexibleDimensions) {\n                styles.maxWidth = '';\n            }\n        }\n        extendStyles(this._pane.style, styles);\n    }\n    /** Gets the exact top/bottom for the overlay when not using flexible sizing or when pushing. */\n    _getExactOverlayY(position, originPoint, scrollPosition) {\n        // Reset any existing styles. This is necessary in case the\n        // preferred position has changed since the last `apply`.\n        let styles = { top: '', bottom: '' };\n        let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);\n        if (this._isPushed) {\n            overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);\n        }\n        // We want to set either `top` or `bottom` based on whether the overlay wants to appear\n        // above or below the origin and the direction in which the element will expand.\n        if (position.overlayY === 'bottom') {\n            // When using `bottom`, we adjust the y position such that it is the distance\n            // from the bottom of the viewport rather than the top.\n            const documentHeight = this._document.documentElement.clientHeight;\n            styles.bottom = `${documentHeight - (overlayPoint.y + this._overlayRect.height)}px`;\n        }\n        else {\n            styles.top = coerceCssPixelValue(overlayPoint.y);\n        }\n        return styles;\n    }\n    /** Gets the exact left/right for the overlay when not using flexible sizing or when pushing. */\n    _getExactOverlayX(position, originPoint, scrollPosition) {\n        // Reset any existing styles. This is necessary in case the preferred position has\n        // changed since the last `apply`.\n        let styles = { left: '', right: '' };\n        let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);\n        if (this._isPushed) {\n            overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);\n        }\n        // We want to set either `left` or `right` based on whether the overlay wants to appear \"before\"\n        // or \"after\" the origin, which determines the direction in which the element will expand.\n        // For the horizontal axis, the meaning of \"before\" and \"after\" change based on whether the\n        // page is in RTL or LTR.\n        let horizontalStyleProperty;\n        if (this._isRtl()) {\n            horizontalStyleProperty = position.overlayX === 'end' ? 'left' : 'right';\n        }\n        else {\n            horizontalStyleProperty = position.overlayX === 'end' ? 'right' : 'left';\n        }\n        // When we're setting `right`, we adjust the x position such that it is the distance\n        // from the right edge of the viewport rather than the left edge.\n        if (horizontalStyleProperty === 'right') {\n            const documentWidth = this._document.documentElement.clientWidth;\n            styles.right = `${documentWidth - (overlayPoint.x + this._overlayRect.width)}px`;\n        }\n        else {\n            styles.left = coerceCssPixelValue(overlayPoint.x);\n        }\n        return styles;\n    }\n    /**\n     * Gets the view properties of the trigger and overlay, including whether they are clipped\n     * or completely outside the view of any of the strategy's scrollables.\n     */\n    _getScrollVisibility() {\n        // Note: needs fresh rects since the position could've changed.\n        const originBounds = this._getOriginRect();\n        const overlayBounds = this._pane.getBoundingClientRect();\n        // TODO(jelbourn): instead of needing all of the client rects for these scrolling containers\n        // every time, we should be able to use the scrollTop of the containers if the size of those\n        // containers hasn't changed.\n        const scrollContainerBounds = this._scrollables.map(scrollable => {\n            return scrollable.getElementRef().nativeElement.getBoundingClientRect();\n        });\n        return {\n            isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),\n            isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),\n            isOverlayClipped: isElementClippedByScrolling(overlayBounds, scrollContainerBounds),\n            isOverlayOutsideView: isElementScrolledOutsideView(overlayBounds, scrollContainerBounds),\n        };\n    }\n    /** Subtracts the amount that an element is overflowing on an axis from its length. */\n    _subtractOverflows(length, ...overflows) {\n        return overflows.reduce((currentValue, currentOverflow) => {\n            return currentValue - Math.max(currentOverflow, 0);\n        }, length);\n    }\n    /** Narrows the given viewport rect by the current _viewportMargin. */\n    _getNarrowedViewportRect() {\n        // We recalculate the viewport rect here ourselves, rather than using the ViewportRuler,\n        // because we want to use the `clientWidth` and `clientHeight` as the base. The difference\n        // being that the client properties don't include the scrollbar, as opposed to `innerWidth`\n        // and `innerHeight` that do. This is necessary, because the overlay container uses\n        // 100% `width` and `height` which don't include the scrollbar either.\n        const width = this._document.documentElement.clientWidth;\n        const height = this._document.documentElement.clientHeight;\n        const scrollPosition = this._viewportRuler.getViewportScrollPosition();\n        return {\n            top: scrollPosition.top + this._viewportMargin,\n            left: scrollPosition.left + this._viewportMargin,\n            right: scrollPosition.left + width - this._viewportMargin,\n            bottom: scrollPosition.top + height - this._viewportMargin,\n            width: width - 2 * this._viewportMargin,\n            height: height - 2 * this._viewportMargin,\n        };\n    }\n    /** Whether the we're dealing with an RTL context */\n    _isRtl() {\n        return this._overlayRef.getDirection() === 'rtl';\n    }\n    /** Determines whether the overlay uses exact or flexible positioning. */\n    _hasExactPosition() {\n        return !this._hasFlexibleDimensions || this._isPushed;\n    }\n    /** Retrieves the offset of a position along the x or y axis. */\n    _getOffset(position, axis) {\n        if (axis === 'x') {\n            // We don't do something like `position['offset' + axis]` in\n            // order to avoid breaking minifiers that rename properties.\n            return position.offsetX == null ? this._offsetX : position.offsetX;\n        }\n        return position.offsetY == null ? this._offsetY : position.offsetY;\n    }\n    /** Validates that the current position match the expected values. */\n    _validatePositions() {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._preferredPositions.length) {\n                throw Error('FlexibleConnectedPositionStrategy: At least one position is required.');\n            }\n            // TODO(crisbeto): remove these once Angular's template type\n            // checking is advanced enough to catch these cases.\n            this._preferredPositions.forEach(pair => {\n                validateHorizontalPosition('originX', pair.originX);\n                validateVerticalPosition('originY', pair.originY);\n                validateHorizontalPosition('overlayX', pair.overlayX);\n                validateVerticalPosition('overlayY', pair.overlayY);\n            });\n        }\n    }\n    /** Adds a single CSS class or an array of classes on the overlay panel. */\n    _addPanelClasses(cssClasses) {\n        if (this._pane) {\n            coerceArray(cssClasses).forEach(cssClass => {\n                if (cssClass !== '' && this._appliedPanelClasses.indexOf(cssClass) === -1) {\n                    this._appliedPanelClasses.push(cssClass);\n                    this._pane.classList.add(cssClass);\n                }\n            });\n        }\n    }\n    /** Clears the classes that the position strategy has applied from the overlay panel. */\n    _clearPanelClasses() {\n        if (this._pane) {\n            this._appliedPanelClasses.forEach(cssClass => {\n                this._pane.classList.remove(cssClass);\n            });\n            this._appliedPanelClasses = [];\n        }\n    }\n    /** Returns the ClientRect of the current origin. */\n    _getOriginRect() {\n        const origin = this._origin;\n        if (origin instanceof ElementRef) {\n            return origin.nativeElement.getBoundingClientRect();\n        }\n        // Check for Element so SVG elements are also supported.\n        if (origin instanceof Element) {\n            return origin.getBoundingClientRect();\n        }\n        const width = origin.width || 0;\n        const height = origin.height || 0;\n        // If the origin is a point, return a client rect as if it was a 0x0 element at the point.\n        return {\n            top: origin.y,\n            bottom: origin.y + height,\n            left: origin.x,\n            right: origin.x + width,\n            height,\n            width,\n        };\n    }\n}\n/** Shallow-extends a stylesheet object with another stylesheet object. */\nfunction extendStyles(destination, source) {\n    for (let key in source) {\n        if (source.hasOwnProperty(key)) {\n            destination[key] = source[key];\n        }\n    }\n    return destination;\n}\n/**\n * Extracts the pixel value as a number from a value, if it's a number\n * or a CSS pixel string (e.g. `1337px`). Otherwise returns null.\n */\nfunction getPixelValue(input) {\n    if (typeof input !== 'number' && input != null) {\n        const [value, units] = input.split(cssUnitPattern);\n        return !units || units === 'px' ? parseFloat(value) : null;\n    }\n    return input || null;\n}\n/**\n * Gets a version of an element's bounding `ClientRect` where all the values are rounded down to\n * the nearest pixel. This allows us to account for the cases where there may be sub-pixel\n * deviations in the `ClientRect` returned by the browser (e.g. when zoomed in with a percentage\n * size, see #21350).\n */\nfunction getRoundedBoundingClientRect(clientRect) {\n    return {\n        top: Math.floor(clientRect.top),\n        right: Math.floor(clientRect.right),\n        bottom: Math.floor(clientRect.bottom),\n        left: Math.floor(clientRect.left),\n        width: Math.floor(clientRect.width),\n        height: Math.floor(clientRect.height),\n    };\n}\nconst STANDARD_DROPDOWN_BELOW_POSITIONS = [\n    { originX: 'start', originY: 'bottom', overlayX: 'start', overlayY: 'top' },\n    { originX: 'start', originY: 'top', overlayX: 'start', overlayY: 'bottom' },\n    { originX: 'end', originY: 'bottom', overlayX: 'end', overlayY: 'top' },\n    { originX: 'end', originY: 'top', overlayX: 'end', overlayY: 'bottom' },\n];\nconst STANDARD_DROPDOWN_ADJACENT_POSITIONS = [\n    { originX: 'end', originY: 'top', overlayX: 'start', overlayY: 'top' },\n    { originX: 'end', originY: 'bottom', overlayX: 'start', overlayY: 'bottom' },\n    { originX: 'start', originY: 'top', overlayX: 'end', overlayY: 'top' },\n    { originX: 'start', originY: 'bottom', overlayX: 'end', overlayY: 'bottom' },\n];\n\n/** Class to be added to the overlay pane wrapper. */\nconst wrapperClass = 'cdk-global-overlay-wrapper';\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * explicit position relative to the browser's viewport. We use flexbox, instead of\n * transforms, in order to avoid issues with subpixel rendering which can cause the\n * element to become blurry.\n */\nclass GlobalPositionStrategy {\n    constructor() {\n        this._cssPosition = 'static';\n        this._topOffset = '';\n        this._bottomOffset = '';\n        this._alignItems = '';\n        this._xPosition = '';\n        this._xOffset = '';\n        this._width = '';\n        this._height = '';\n        this._isDisposed = false;\n    }\n    attach(overlayRef) {\n        const config = overlayRef.getConfig();\n        this._overlayRef = overlayRef;\n        if (this._width && !config.width) {\n            overlayRef.updateSize({ width: this._width });\n        }\n        if (this._height && !config.height) {\n            overlayRef.updateSize({ height: this._height });\n        }\n        overlayRef.hostElement.classList.add(wrapperClass);\n        this._isDisposed = false;\n    }\n    /**\n     * Sets the top position of the overlay. Clears any previously set vertical position.\n     * @param value New top offset.\n     */\n    top(value = '') {\n        this._bottomOffset = '';\n        this._topOffset = value;\n        this._alignItems = 'flex-start';\n        return this;\n    }\n    /**\n     * Sets the left position of the overlay. Clears any previously set horizontal position.\n     * @param value New left offset.\n     */\n    left(value = '') {\n        this._xOffset = value;\n        this._xPosition = 'left';\n        return this;\n    }\n    /**\n     * Sets the bottom position of the overlay. Clears any previously set vertical position.\n     * @param value New bottom offset.\n     */\n    bottom(value = '') {\n        this._topOffset = '';\n        this._bottomOffset = value;\n        this._alignItems = 'flex-end';\n        return this;\n    }\n    /**\n     * Sets the right position of the overlay. Clears any previously set horizontal position.\n     * @param value New right offset.\n     */\n    right(value = '') {\n        this._xOffset = value;\n        this._xPosition = 'right';\n        return this;\n    }\n    /**\n     * Sets the overlay to the start of the viewport, depending on the overlay direction.\n     * This will be to the left in LTR layouts and to the right in RTL.\n     * @param offset Offset from the edge of the screen.\n     */\n    start(value = '') {\n        this._xOffset = value;\n        this._xPosition = 'start';\n        return this;\n    }\n    /**\n     * Sets the overlay to the end of the viewport, depending on the overlay direction.\n     * This will be to the right in LTR layouts and to the left in RTL.\n     * @param offset Offset from the edge of the screen.\n     */\n    end(value = '') {\n        this._xOffset = value;\n        this._xPosition = 'end';\n        return this;\n    }\n    /**\n     * Sets the overlay width and clears any previously set width.\n     * @param value New width for the overlay\n     * @deprecated Pass the `width` through the `OverlayConfig`.\n     * @breaking-change 8.0.0\n     */\n    width(value = '') {\n        if (this._overlayRef) {\n            this._overlayRef.updateSize({ width: value });\n        }\n        else {\n            this._width = value;\n        }\n        return this;\n    }\n    /**\n     * Sets the overlay height and clears any previously set height.\n     * @param value New height for the overlay\n     * @deprecated Pass the `height` through the `OverlayConfig`.\n     * @breaking-change 8.0.0\n     */\n    height(value = '') {\n        if (this._overlayRef) {\n            this._overlayRef.updateSize({ height: value });\n        }\n        else {\n            this._height = value;\n        }\n        return this;\n    }\n    /**\n     * Centers the overlay horizontally with an optional offset.\n     * Clears any previously set horizontal position.\n     *\n     * @param offset Overlay offset from the horizontal center.\n     */\n    centerHorizontally(offset = '') {\n        this.left(offset);\n        this._xPosition = 'center';\n        return this;\n    }\n    /**\n     * Centers the overlay vertically with an optional offset.\n     * Clears any previously set vertical position.\n     *\n     * @param offset Overlay offset from the vertical center.\n     */\n    centerVertically(offset = '') {\n        this.top(offset);\n        this._alignItems = 'center';\n        return this;\n    }\n    /**\n     * Apply the position to the element.\n     * @docs-private\n     */\n    apply() {\n        // Since the overlay ref applies the strategy asynchronously, it could\n        // have been disposed before it ends up being applied. If that is the\n        // case, we shouldn't do anything.\n        if (!this._overlayRef || !this._overlayRef.hasAttached()) {\n            return;\n        }\n        const styles = this._overlayRef.overlayElement.style;\n        const parentStyles = this._overlayRef.hostElement.style;\n        const config = this._overlayRef.getConfig();\n        const { width, height, maxWidth, maxHeight } = config;\n        const shouldBeFlushHorizontally = (width === '100%' || width === '100vw') &&\n            (!maxWidth || maxWidth === '100%' || maxWidth === '100vw');\n        const shouldBeFlushVertically = (height === '100%' || height === '100vh') &&\n            (!maxHeight || maxHeight === '100%' || maxHeight === '100vh');\n        const xPosition = this._xPosition;\n        const xOffset = this._xOffset;\n        const isRtl = this._overlayRef.getConfig().direction === 'rtl';\n        let marginLeft = '';\n        let marginRight = '';\n        let justifyContent = '';\n        if (shouldBeFlushHorizontally) {\n            justifyContent = 'flex-start';\n        }\n        else if (xPosition === 'center') {\n            justifyContent = 'center';\n            if (isRtl) {\n                marginRight = xOffset;\n            }\n            else {\n                marginLeft = xOffset;\n            }\n        }\n        else if (isRtl) {\n            if (xPosition === 'left' || xPosition === 'end') {\n                justifyContent = 'flex-end';\n                marginLeft = xOffset;\n            }\n            else if (xPosition === 'right' || xPosition === 'start') {\n                justifyContent = 'flex-start';\n                marginRight = xOffset;\n            }\n        }\n        else if (xPosition === 'left' || xPosition === 'start') {\n            justifyContent = 'flex-start';\n            marginLeft = xOffset;\n        }\n        else if (xPosition === 'right' || xPosition === 'end') {\n            justifyContent = 'flex-end';\n            marginRight = xOffset;\n        }\n        styles.position = this._cssPosition;\n        styles.marginLeft = shouldBeFlushHorizontally ? '0' : marginLeft;\n        styles.marginTop = shouldBeFlushVertically ? '0' : this._topOffset;\n        styles.marginBottom = this._bottomOffset;\n        styles.marginRight = shouldBeFlushHorizontally ? '0' : marginRight;\n        parentStyles.justifyContent = justifyContent;\n        parentStyles.alignItems = shouldBeFlushVertically ? 'flex-start' : this._alignItems;\n    }\n    /**\n     * Cleans up the DOM changes from the position strategy.\n     * @docs-private\n     */\n    dispose() {\n        if (this._isDisposed || !this._overlayRef) {\n            return;\n        }\n        const styles = this._overlayRef.overlayElement.style;\n        const parent = this._overlayRef.hostElement;\n        const parentStyles = parent.style;\n        parent.classList.remove(wrapperClass);\n        parentStyles.justifyContent =\n            parentStyles.alignItems =\n                styles.marginTop =\n                    styles.marginBottom =\n                        styles.marginLeft =\n                            styles.marginRight =\n                                styles.position =\n                                    '';\n        this._overlayRef = null;\n        this._isDisposed = true;\n    }\n}\n\n/** Builder for overlay position strategy. */\nclass OverlayPositionBuilder {\n    constructor(_viewportRuler, _document, _platform, _overlayContainer) {\n        this._viewportRuler = _viewportRuler;\n        this._document = _document;\n        this._platform = _platform;\n        this._overlayContainer = _overlayContainer;\n    }\n    /**\n     * Creates a global position strategy.\n     */\n    global() {\n        return new GlobalPositionStrategy();\n    }\n    /**\n     * Creates a flexible position strategy.\n     * @param origin Origin relative to which to position the overlay.\n     */\n    flexibleConnectedTo(origin) {\n        return new FlexibleConnectedPositionStrategy(origin, this._viewportRuler, this._document, this._platform, this._overlayContainer);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayPositionBuilder, deps: [{ token: i1.ViewportRuler }, { token: DOCUMENT }, { token: i1$1.Platform }, { token: OverlayContainer }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayPositionBuilder, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayPositionBuilder, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.ViewportRuler }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i1$1.Platform }, { type: OverlayContainer }]; } });\n\n/** Next overlay unique ID. */\nlet nextUniqueId = 0;\n// Note that Overlay is *not* scoped to the app root because of the ComponentFactoryResolver\n// which needs to be different depending on where OverlayModule is imported.\n/**\n * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be\n * used as a low-level building block for other components. Dialogs, tooltips, menus,\n * selects, etc. can all be built using overlays. The service should primarily be used by authors\n * of re-usable components rather than developers building end-user applications.\n *\n * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.\n */\nclass Overlay {\n    constructor(\n    /** Scrolling strategies that can be used when creating an overlay. */\n    scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _injector, _ngZone, _document, _directionality, _location, _outsideClickDispatcher, _animationsModuleType) {\n        this.scrollStrategies = scrollStrategies;\n        this._overlayContainer = _overlayContainer;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._positionBuilder = _positionBuilder;\n        this._keyboardDispatcher = _keyboardDispatcher;\n        this._injector = _injector;\n        this._ngZone = _ngZone;\n        this._document = _document;\n        this._directionality = _directionality;\n        this._location = _location;\n        this._outsideClickDispatcher = _outsideClickDispatcher;\n        this._animationsModuleType = _animationsModuleType;\n    }\n    /**\n     * Creates an overlay.\n     * @param config Configuration applied to the overlay.\n     * @returns Reference to the created overlay.\n     */\n    create(config) {\n        const host = this._createHostElement();\n        const pane = this._createPaneElement(host);\n        const portalOutlet = this._createPortalOutlet(pane);\n        const overlayConfig = new OverlayConfig(config);\n        overlayConfig.direction = overlayConfig.direction || this._directionality.value;\n        return new OverlayRef(portalOutlet, host, pane, overlayConfig, this._ngZone, this._keyboardDispatcher, this._document, this._location, this._outsideClickDispatcher, this._animationsModuleType === 'NoopAnimations');\n    }\n    /**\n     * Gets a position builder that can be used, via fluent API,\n     * to construct and configure a position strategy.\n     * @returns An overlay position builder.\n     */\n    position() {\n        return this._positionBuilder;\n    }\n    /**\n     * Creates the DOM element for an overlay and appends it to the overlay container.\n     * @returns Newly-created pane element\n     */\n    _createPaneElement(host) {\n        const pane = this._document.createElement('div');\n        pane.id = `cdk-overlay-${nextUniqueId++}`;\n        pane.classList.add('cdk-overlay-pane');\n        host.appendChild(pane);\n        return pane;\n    }\n    /**\n     * Creates the host element that wraps around an overlay\n     * and can be used for advanced positioning.\n     * @returns Newly-create host element.\n     */\n    _createHostElement() {\n        const host = this._document.createElement('div');\n        this._overlayContainer.getContainerElement().appendChild(host);\n        return host;\n    }\n    /**\n     * Create a DomPortalOutlet into which the overlay content can be loaded.\n     * @param pane The DOM element to turn into a portal outlet.\n     * @returns A portal outlet for the given DOM element.\n     */\n    _createPortalOutlet(pane) {\n        // We have to resolve the ApplicationRef later in order to allow people\n        // to use overlay-based providers during app initialization.\n        if (!this._appRef) {\n            this._appRef = this._injector.get(ApplicationRef);\n        }\n        return new DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector, this._document);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Overlay, deps: [{ token: ScrollStrategyOptions }, { token: OverlayContainer }, { token: i0.ComponentFactoryResolver }, { token: OverlayPositionBuilder }, { token: OverlayKeyboardDispatcher }, { token: i0.Injector }, { token: i0.NgZone }, { token: DOCUMENT }, { token: i5.Directionality }, { token: i6.Location }, { token: OverlayOutsideClickDispatcher }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Overlay, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: Overlay, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: ScrollStrategyOptions }, { type: OverlayContainer }, { type: i0.ComponentFactoryResolver }, { type: OverlayPositionBuilder }, { type: OverlayKeyboardDispatcher }, { type: i0.Injector }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i5.Directionality }, { type: i6.Location }, { type: OverlayOutsideClickDispatcher }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [ANIMATION_MODULE_TYPE]\n                }, {\n                    type: Optional\n                }] }]; } });\n\n/** Default set of positions for the overlay. Follows the behavior of a dropdown. */\nconst defaultPositionList = [\n    {\n        originX: 'start',\n        originY: 'bottom',\n        overlayX: 'start',\n        overlayY: 'top',\n    },\n    {\n        originX: 'start',\n        originY: 'top',\n        overlayX: 'start',\n        overlayY: 'bottom',\n    },\n    {\n        originX: 'end',\n        originY: 'top',\n        overlayX: 'end',\n        overlayY: 'bottom',\n    },\n    {\n        originX: 'end',\n        originY: 'bottom',\n        overlayX: 'end',\n        overlayY: 'top',\n    },\n];\n/** Injection token that determines the scroll handling while the connected overlay is open. */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = new InjectionToken('cdk-connected-overlay-scroll-strategy');\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\nclass CdkOverlayOrigin {\n    constructor(\n    /** Reference to the element on which the directive is applied. */\n    elementRef) {\n        this.elementRef = elementRef;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkOverlayOrigin, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkOverlayOrigin, isStandalone: true, selector: \"[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]\", exportAs: [\"cdkOverlayOrigin\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkOverlayOrigin, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',\n                    exportAs: 'cdkOverlayOrigin',\n                    standalone: true,\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\nclass CdkConnectedOverlay {\n    /** The offset in pixels for the overlay connection point on the x-axis */\n    get offsetX() {\n        return this._offsetX;\n    }\n    set offsetX(offsetX) {\n        this._offsetX = offsetX;\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n        }\n    }\n    /** The offset in pixels for the overlay connection point on the y-axis */\n    get offsetY() {\n        return this._offsetY;\n    }\n    set offsetY(offsetY) {\n        this._offsetY = offsetY;\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n        }\n    }\n    /** Whether or not the overlay should attach a backdrop. */\n    get hasBackdrop() {\n        return this._hasBackdrop;\n    }\n    set hasBackdrop(value) {\n        this._hasBackdrop = coerceBooleanProperty(value);\n    }\n    /** Whether or not the overlay should be locked when scrolling. */\n    get lockPosition() {\n        return this._lockPosition;\n    }\n    set lockPosition(value) {\n        this._lockPosition = coerceBooleanProperty(value);\n    }\n    /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n    get flexibleDimensions() {\n        return this._flexibleDimensions;\n    }\n    set flexibleDimensions(value) {\n        this._flexibleDimensions = coerceBooleanProperty(value);\n    }\n    /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n    get growAfterOpen() {\n        return this._growAfterOpen;\n    }\n    set growAfterOpen(value) {\n        this._growAfterOpen = coerceBooleanProperty(value);\n    }\n    /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n    get push() {\n        return this._push;\n    }\n    set push(value) {\n        this._push = coerceBooleanProperty(value);\n    }\n    // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.\n    constructor(_overlay, templateRef, viewContainerRef, scrollStrategyFactory, _dir) {\n        this._overlay = _overlay;\n        this._dir = _dir;\n        this._hasBackdrop = false;\n        this._lockPosition = false;\n        this._growAfterOpen = false;\n        this._flexibleDimensions = false;\n        this._push = false;\n        this._backdropSubscription = Subscription.EMPTY;\n        this._attachSubscription = Subscription.EMPTY;\n        this._detachSubscription = Subscription.EMPTY;\n        this._positionSubscription = Subscription.EMPTY;\n        /** Margin between the overlay and the viewport edges. */\n        this.viewportMargin = 0;\n        /** Whether the overlay is open. */\n        this.open = false;\n        /** Whether the overlay can be closed by user interaction. */\n        this.disableClose = false;\n        /** Event emitted when the backdrop is clicked. */\n        this.backdropClick = new EventEmitter();\n        /** Event emitted when the position has changed. */\n        this.positionChange = new EventEmitter();\n        /** Event emitted when the overlay has been attached. */\n        this.attach = new EventEmitter();\n        /** Event emitted when the overlay has been detached. */\n        this.detach = new EventEmitter();\n        /** Emits when there are keyboard events that are targeted at the overlay. */\n        this.overlayKeydown = new EventEmitter();\n        /** Emits when there are mouse outside click events that are targeted at the overlay. */\n        this.overlayOutsideClick = new EventEmitter();\n        this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\n        this._scrollStrategyFactory = scrollStrategyFactory;\n        this.scrollStrategy = this._scrollStrategyFactory();\n    }\n    /** The associated overlay reference. */\n    get overlayRef() {\n        return this._overlayRef;\n    }\n    /** The element's layout direction. */\n    get dir() {\n        return this._dir ? this._dir.value : 'ltr';\n    }\n    ngOnDestroy() {\n        this._attachSubscription.unsubscribe();\n        this._detachSubscription.unsubscribe();\n        this._backdropSubscription.unsubscribe();\n        this._positionSubscription.unsubscribe();\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n        }\n    }\n    ngOnChanges(changes) {\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n            this._overlayRef.updateSize({\n                width: this.width,\n                minWidth: this.minWidth,\n                height: this.height,\n                minHeight: this.minHeight,\n            });\n            if (changes['origin'] && this.open) {\n                this._position.apply();\n            }\n        }\n        if (changes['open']) {\n            this.open ? this._attachOverlay() : this._detachOverlay();\n        }\n    }\n    /** Creates an overlay */\n    _createOverlay() {\n        if (!this.positions || !this.positions.length) {\n            this.positions = defaultPositionList;\n        }\n        const overlayRef = (this._overlayRef = this._overlay.create(this._buildConfig()));\n        this._attachSubscription = overlayRef.attachments().subscribe(() => this.attach.emit());\n        this._detachSubscription = overlayRef.detachments().subscribe(() => this.detach.emit());\n        overlayRef.keydownEvents().subscribe((event) => {\n            this.overlayKeydown.next(event);\n            if (event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)) {\n                event.preventDefault();\n                this._detachOverlay();\n            }\n        });\n        this._overlayRef.outsidePointerEvents().subscribe((event) => {\n            this.overlayOutsideClick.next(event);\n        });\n    }\n    /** Builds the overlay config based on the directive's inputs */\n    _buildConfig() {\n        const positionStrategy = (this._position =\n            this.positionStrategy || this._createPositionStrategy());\n        const overlayConfig = new OverlayConfig({\n            direction: this._dir,\n            positionStrategy,\n            scrollStrategy: this.scrollStrategy,\n            hasBackdrop: this.hasBackdrop,\n        });\n        if (this.width || this.width === 0) {\n            overlayConfig.width = this.width;\n        }\n        if (this.height || this.height === 0) {\n            overlayConfig.height = this.height;\n        }\n        if (this.minWidth || this.minWidth === 0) {\n            overlayConfig.minWidth = this.minWidth;\n        }\n        if (this.minHeight || this.minHeight === 0) {\n            overlayConfig.minHeight = this.minHeight;\n        }\n        if (this.backdropClass) {\n            overlayConfig.backdropClass = this.backdropClass;\n        }\n        if (this.panelClass) {\n            overlayConfig.panelClass = this.panelClass;\n        }\n        return overlayConfig;\n    }\n    /** Updates the state of a position strategy, based on the values of the directive inputs. */\n    _updatePositionStrategy(positionStrategy) {\n        const positions = this.positions.map(currentPosition => ({\n            originX: currentPosition.originX,\n            originY: currentPosition.originY,\n            overlayX: currentPosition.overlayX,\n            overlayY: currentPosition.overlayY,\n            offsetX: currentPosition.offsetX || this.offsetX,\n            offsetY: currentPosition.offsetY || this.offsetY,\n            panelClass: currentPosition.panelClass || undefined,\n        }));\n        return positionStrategy\n            .setOrigin(this._getFlexibleConnectedPositionStrategyOrigin())\n            .withPositions(positions)\n            .withFlexibleDimensions(this.flexibleDimensions)\n            .withPush(this.push)\n            .withGrowAfterOpen(this.growAfterOpen)\n            .withViewportMargin(this.viewportMargin)\n            .withLockedPosition(this.lockPosition)\n            .withTransformOriginOn(this.transformOriginSelector);\n    }\n    /** Returns the position strategy of the overlay to be set on the overlay config */\n    _createPositionStrategy() {\n        const strategy = this._overlay\n            .position()\n            .flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());\n        this._updatePositionStrategy(strategy);\n        return strategy;\n    }\n    _getFlexibleConnectedPositionStrategyOrigin() {\n        if (this.origin instanceof CdkOverlayOrigin) {\n            return this.origin.elementRef;\n        }\n        else {\n            return this.origin;\n        }\n    }\n    /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */\n    _attachOverlay() {\n        if (!this._overlayRef) {\n            this._createOverlay();\n        }\n        else {\n            // Update the overlay size, in case the directive's inputs have changed\n            this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;\n        }\n        if (!this._overlayRef.hasAttached()) {\n            this._overlayRef.attach(this._templatePortal);\n        }\n        if (this.hasBackdrop) {\n            this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {\n                this.backdropClick.emit(event);\n            });\n        }\n        else {\n            this._backdropSubscription.unsubscribe();\n        }\n        this._positionSubscription.unsubscribe();\n        // Only subscribe to `positionChanges` if requested, because putting\n        // together all the information for it can be expensive.\n        if (this.positionChange.observers.length > 0) {\n            this._positionSubscription = this._position.positionChanges\n                .pipe(takeWhile(() => this.positionChange.observers.length > 0))\n                .subscribe(position => {\n                this.positionChange.emit(position);\n                if (this.positionChange.observers.length === 0) {\n                    this._positionSubscription.unsubscribe();\n                }\n            });\n        }\n    }\n    /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */\n    _detachOverlay() {\n        if (this._overlayRef) {\n            this._overlayRef.detach();\n        }\n        this._backdropSubscription.unsubscribe();\n        this._positionSubscription.unsubscribe();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkConnectedOverlay, deps: [{ token: Overlay }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY }, { token: i5.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkConnectedOverlay, isStandalone: true, selector: \"[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]\", inputs: { origin: [\"cdkConnectedOverlayOrigin\", \"origin\"], positions: [\"cdkConnectedOverlayPositions\", \"positions\"], positionStrategy: [\"cdkConnectedOverlayPositionStrategy\", \"positionStrategy\"], offsetX: [\"cdkConnectedOverlayOffsetX\", \"offsetX\"], offsetY: [\"cdkConnectedOverlayOffsetY\", \"offsetY\"], width: [\"cdkConnectedOverlayWidth\", \"width\"], height: [\"cdkConnectedOverlayHeight\", \"height\"], minWidth: [\"cdkConnectedOverlayMinWidth\", \"minWidth\"], minHeight: [\"cdkConnectedOverlayMinHeight\", \"minHeight\"], backdropClass: [\"cdkConnectedOverlayBackdropClass\", \"backdropClass\"], panelClass: [\"cdkConnectedOverlayPanelClass\", \"panelClass\"], viewportMargin: [\"cdkConnectedOverlayViewportMargin\", \"viewportMargin\"], scrollStrategy: [\"cdkConnectedOverlayScrollStrategy\", \"scrollStrategy\"], open: [\"cdkConnectedOverlayOpen\", \"open\"], disableClose: [\"cdkConnectedOverlayDisableClose\", \"disableClose\"], transformOriginSelector: [\"cdkConnectedOverlayTransformOriginOn\", \"transformOriginSelector\"], hasBackdrop: [\"cdkConnectedOverlayHasBackdrop\", \"hasBackdrop\"], lockPosition: [\"cdkConnectedOverlayLockPosition\", \"lockPosition\"], flexibleDimensions: [\"cdkConnectedOverlayFlexibleDimensions\", \"flexibleDimensions\"], growAfterOpen: [\"cdkConnectedOverlayGrowAfterOpen\", \"growAfterOpen\"], push: [\"cdkConnectedOverlayPush\", \"push\"] }, outputs: { backdropClick: \"backdropClick\", positionChange: \"positionChange\", attach: \"attach\", detach: \"detach\", overlayKeydown: \"overlayKeydown\", overlayOutsideClick: \"overlayOutsideClick\" }, exportAs: [\"cdkConnectedOverlay\"], usesOnChanges: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkConnectedOverlay, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',\n                    exportAs: 'cdkConnectedOverlay',\n                    standalone: true,\n                }]\n        }], ctorParameters: function () { return [{ type: Overlay }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY]\n                }] }, { type: i5.Directionality, decorators: [{\n                    type: Optional\n                }] }]; }, propDecorators: { origin: [{\n                type: Input,\n                args: ['cdkConnectedOverlayOrigin']\n            }], positions: [{\n                type: Input,\n                args: ['cdkConnectedOverlayPositions']\n            }], positionStrategy: [{\n                type: Input,\n                args: ['cdkConnectedOverlayPositionStrategy']\n            }], offsetX: [{\n                type: Input,\n                args: ['cdkConnectedOverlayOffsetX']\n            }], offsetY: [{\n                type: Input,\n                args: ['cdkConnectedOverlayOffsetY']\n            }], width: [{\n                type: Input,\n                args: ['cdkConnectedOverlayWidth']\n            }], height: [{\n                type: Input,\n                args: ['cdkConnectedOverlayHeight']\n            }], minWidth: [{\n                type: Input,\n                args: ['cdkConnectedOverlayMinWidth']\n            }], minHeight: [{\n                type: Input,\n                args: ['cdkConnectedOverlayMinHeight']\n            }], backdropClass: [{\n                type: Input,\n                args: ['cdkConnectedOverlayBackdropClass']\n            }], panelClass: [{\n                type: Input,\n                args: ['cdkConnectedOverlayPanelClass']\n            }], viewportMargin: [{\n                type: Input,\n                args: ['cdkConnectedOverlayViewportMargin']\n            }], scrollStrategy: [{\n                type: Input,\n                args: ['cdkConnectedOverlayScrollStrategy']\n            }], open: [{\n                type: Input,\n                args: ['cdkConnectedOverlayOpen']\n            }], disableClose: [{\n                type: Input,\n                args: ['cdkConnectedOverlayDisableClose']\n            }], transformOriginSelector: [{\n                type: Input,\n                args: ['cdkConnectedOverlayTransformOriginOn']\n            }], hasBackdrop: [{\n                type: Input,\n                args: ['cdkConnectedOverlayHasBackdrop']\n            }], lockPosition: [{\n                type: Input,\n                args: ['cdkConnectedOverlayLockPosition']\n            }], flexibleDimensions: [{\n                type: Input,\n                args: ['cdkConnectedOverlayFlexibleDimensions']\n            }], growAfterOpen: [{\n                type: Input,\n                args: ['cdkConnectedOverlayGrowAfterOpen']\n            }], push: [{\n                type: Input,\n                args: ['cdkConnectedOverlayPush']\n            }], backdropClick: [{\n                type: Output\n            }], positionChange: [{\n                type: Output\n            }], attach: [{\n                type: Output\n            }], detach: [{\n                type: Output\n            }], overlayKeydown: [{\n                type: Output\n            }], overlayOutsideClick: [{\n                type: Output\n            }] } });\n/** @docs-private */\nfunction CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** @docs-private */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {\n    provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n\nclass OverlayModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayModule, imports: [BidiModule, PortalModule, ScrollingModule, CdkConnectedOverlay, CdkOverlayOrigin], exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayModule, providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER], imports: [BidiModule, PortalModule, ScrollingModule, ScrollingModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: OverlayModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [BidiModule, PortalModule, ScrollingModule, CdkConnectedOverlay, CdkOverlayOrigin],\n                    exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule],\n                    providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER],\n                }]\n        }] });\n\n/**\n * Alternative to OverlayContainer that supports correct displaying of overlay elements in\n * Fullscreen mode\n * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen\n *\n * Should be provided in the root component.\n */\nclass FullscreenOverlayContainer extends OverlayContainer {\n    constructor(_document, platform) {\n        super(_document, platform);\n    }\n    ngOnDestroy() {\n        super.ngOnDestroy();\n        if (this._fullScreenEventName && this._fullScreenListener) {\n            this._document.removeEventListener(this._fullScreenEventName, this._fullScreenListener);\n        }\n    }\n    _createContainer() {\n        super._createContainer();\n        this._adjustParentForFullscreenChange();\n        this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());\n    }\n    _adjustParentForFullscreenChange() {\n        if (!this._containerElement) {\n            return;\n        }\n        const fullscreenElement = this.getFullscreenElement();\n        const parent = fullscreenElement || this._document.body;\n        parent.appendChild(this._containerElement);\n    }\n    _addFullscreenChangeListener(fn) {\n        const eventName = this._getEventName();\n        if (eventName) {\n            if (this._fullScreenListener) {\n                this._document.removeEventListener(eventName, this._fullScreenListener);\n            }\n            this._document.addEventListener(eventName, fn);\n            this._fullScreenListener = fn;\n        }\n    }\n    _getEventName() {\n        if (!this._fullScreenEventName) {\n            const _document = this._document;\n            if (_document.fullscreenEnabled) {\n                this._fullScreenEventName = 'fullscreenchange';\n            }\n            else if (_document.webkitFullscreenEnabled) {\n                this._fullScreenEventName = 'webkitfullscreenchange';\n            }\n            else if (_document.mozFullScreenEnabled) {\n                this._fullScreenEventName = 'mozfullscreenchange';\n            }\n            else if (_document.msFullscreenEnabled) {\n                this._fullScreenEventName = 'MSFullscreenChange';\n            }\n        }\n        return this._fullScreenEventName;\n    }\n    /**\n     * When the page is put into fullscreen mode, a specific element is specified.\n     * Only that element and its children are visible when in fullscreen mode.\n     */\n    getFullscreenElement() {\n        const _document = this._document;\n        return (_document.fullscreenElement ||\n            _document.webkitFullscreenElement ||\n            _document.mozFullScreenElement ||\n            _document.msFullscreenElement ||\n            null);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FullscreenOverlayContainer, deps: [{ token: DOCUMENT }, { token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FullscreenOverlayContainer, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: FullscreenOverlayContainer, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i1$1.Platform }]; } });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BlockScrollStrategy, CdkConnectedOverlay, CdkOverlayOrigin, CloseScrollStrategy, ConnectedOverlayPositionChange, ConnectionPositionPair, FlexibleConnectedPositionStrategy, FullscreenOverlayContainer, GlobalPositionStrategy, NoopScrollStrategy, Overlay, OverlayConfig, OverlayContainer, OverlayKeyboardDispatcher, OverlayModule, OverlayOutsideClickDispatcher, OverlayPositionBuilder, OverlayRef, RepositionScrollStrategy, STANDARD_DROPDOWN_ADJACENT_POSITIONS, STANDARD_DROPDOWN_BELOW_POSITIONS, ScrollStrategyOptions, ScrollingVisibility, validateHorizontalPosition, validateVerticalPosition };\n","import * as i0 from '@angular/core';\nimport { ElementRef, Injector, Directive, EventEmitter, Inject, Output, NgModule } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * Throws an exception when attempting to attach a null portal to a host.\n * @docs-private\n */\nfunction throwNullPortalError() {\n    throw Error('Must provide a portal to attach');\n}\n/**\n * Throws an exception when attempting to attach a portal to a host that is already attached.\n * @docs-private\n */\nfunction throwPortalAlreadyAttachedError() {\n    throw Error('Host already has a portal attached');\n}\n/**\n * Throws an exception when attempting to attach a portal to an already-disposed host.\n * @docs-private\n */\nfunction throwPortalOutletAlreadyDisposedError() {\n    throw Error('This PortalOutlet has already been disposed');\n}\n/**\n * Throws an exception when attempting to attach an unknown portal type.\n * @docs-private\n */\nfunction throwUnknownPortalTypeError() {\n    throw Error('Attempting to attach an unknown Portal type. BasePortalOutlet accepts either ' +\n        'a ComponentPortal or a TemplatePortal.');\n}\n/**\n * Throws an exception when attempting to attach a portal to a null host.\n * @docs-private\n */\nfunction throwNullPortalOutletError() {\n    throw Error('Attempting to attach a portal to a null PortalOutlet');\n}\n/**\n * Throws an exception when attempting to detach a portal that is not attached.\n * @docs-private\n */\nfunction throwNoPortalAttachedError() {\n    throw Error('Attempting to detach a portal that is not attached to a host');\n}\n\n/**\n * A `Portal` is something that you want to render somewhere else.\n * It can be attach to / detached from a `PortalOutlet`.\n */\nclass Portal {\n    /** Attach this portal to a host. */\n    attach(host) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (host == null) {\n                throwNullPortalOutletError();\n            }\n            if (host.hasAttached()) {\n                throwPortalAlreadyAttachedError();\n            }\n        }\n        this._attachedHost = host;\n        return host.attach(this);\n    }\n    /** Detach this portal from its host */\n    detach() {\n        let host = this._attachedHost;\n        if (host != null) {\n            this._attachedHost = null;\n            host.detach();\n        }\n        else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throwNoPortalAttachedError();\n        }\n    }\n    /** Whether this portal is attached to a host. */\n    get isAttached() {\n        return this._attachedHost != null;\n    }\n    /**\n     * Sets the PortalOutlet reference without performing `attach()`. This is used directly by\n     * the PortalOutlet when it is performing an `attach()` or `detach()`.\n     */\n    setAttachedHost(host) {\n        this._attachedHost = host;\n    }\n}\n/**\n * A `ComponentPortal` is a portal that instantiates some Component upon attachment.\n */\nclass ComponentPortal extends Portal {\n    constructor(component, viewContainerRef, injector, componentFactoryResolver, projectableNodes) {\n        super();\n        this.component = component;\n        this.viewContainerRef = viewContainerRef;\n        this.injector = injector;\n        this.componentFactoryResolver = componentFactoryResolver;\n        this.projectableNodes = projectableNodes;\n    }\n}\n/**\n * A `TemplatePortal` is a portal that represents some embedded template (TemplateRef).\n */\nclass TemplatePortal extends Portal {\n    constructor(\n    /** The embedded template that will be used to instantiate an embedded View in the host. */\n    templateRef, \n    /** Reference to the ViewContainer into which the template will be stamped out. */\n    viewContainerRef, \n    /** Contextual data to be passed in to the embedded view. */\n    context, \n    /** The injector to use for the embedded view. */\n    injector) {\n        super();\n        this.templateRef = templateRef;\n        this.viewContainerRef = viewContainerRef;\n        this.context = context;\n        this.injector = injector;\n    }\n    get origin() {\n        return this.templateRef.elementRef;\n    }\n    /**\n     * Attach the portal to the provided `PortalOutlet`.\n     * When a context is provided it will override the `context` property of the `TemplatePortal`\n     * instance.\n     */\n    attach(host, context = this.context) {\n        this.context = context;\n        return super.attach(host);\n    }\n    detach() {\n        this.context = undefined;\n        return super.detach();\n    }\n}\n/**\n * A `DomPortal` is a portal whose DOM element will be taken from its current position\n * in the DOM and moved into a portal outlet, when it is attached. On detach, the content\n * will be restored to its original position.\n */\nclass DomPortal extends Portal {\n    constructor(element) {\n        super();\n        this.element = element instanceof ElementRef ? element.nativeElement : element;\n    }\n}\n/**\n * Partial implementation of PortalOutlet that handles attaching\n * ComponentPortal and TemplatePortal.\n */\nclass BasePortalOutlet {\n    constructor() {\n        /** Whether this host has already been permanently disposed. */\n        this._isDisposed = false;\n        // @breaking-change 10.0.0 `attachDomPortal` to become a required abstract method.\n        this.attachDomPortal = null;\n    }\n    /** Whether this host has an attached portal. */\n    hasAttached() {\n        return !!this._attachedPortal;\n    }\n    /** Attaches a portal. */\n    attach(portal) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!portal) {\n                throwNullPortalError();\n            }\n            if (this.hasAttached()) {\n                throwPortalAlreadyAttachedError();\n            }\n            if (this._isDisposed) {\n                throwPortalOutletAlreadyDisposedError();\n            }\n        }\n        if (portal instanceof ComponentPortal) {\n            this._attachedPortal = portal;\n            return this.attachComponentPortal(portal);\n        }\n        else if (portal instanceof TemplatePortal) {\n            this._attachedPortal = portal;\n            return this.attachTemplatePortal(portal);\n            // @breaking-change 10.0.0 remove null check for `this.attachDomPortal`.\n        }\n        else if (this.attachDomPortal && portal instanceof DomPortal) {\n            this._attachedPortal = portal;\n            return this.attachDomPortal(portal);\n        }\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throwUnknownPortalTypeError();\n        }\n    }\n    /** Detaches a previously attached portal. */\n    detach() {\n        if (this._attachedPortal) {\n            this._attachedPortal.setAttachedHost(null);\n            this._attachedPortal = null;\n        }\n        this._invokeDisposeFn();\n    }\n    /** Permanently dispose of this portal host. */\n    dispose() {\n        if (this.hasAttached()) {\n            this.detach();\n        }\n        this._invokeDisposeFn();\n        this._isDisposed = true;\n    }\n    /** @docs-private */\n    setDisposeFn(fn) {\n        this._disposeFn = fn;\n    }\n    _invokeDisposeFn() {\n        if (this._disposeFn) {\n            this._disposeFn();\n            this._disposeFn = null;\n        }\n    }\n}\n/**\n * @deprecated Use `BasePortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nclass BasePortalHost extends BasePortalOutlet {\n}\n\n/**\n * A PortalOutlet for attaching portals to an arbitrary DOM element outside of the Angular\n * application context.\n */\nclass DomPortalOutlet extends BasePortalOutlet {\n    /**\n     * @param outletElement Element into which the content is projected.\n     * @param _componentFactoryResolver Used to resolve the component factory.\n     *   Only required when attaching component portals.\n     * @param _appRef Reference to the application. Only used in component portals when there\n     *   is no `ViewContainerRef` available.\n     * @param _defaultInjector Injector to use as a fallback when the portal being attached doesn't\n     *   have one. Only used for component portals.\n     * @param _document Reference to the document. Used when attaching a DOM portal. Will eventually\n     *   become a required parameter.\n     */\n    constructor(\n    /** Element into which the content is projected. */\n    outletElement, _componentFactoryResolver, _appRef, _defaultInjector, \n    /**\n     * @deprecated `_document` Parameter to be made required.\n     * @breaking-change 10.0.0\n     */\n    _document) {\n        super();\n        this.outletElement = outletElement;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._appRef = _appRef;\n        this._defaultInjector = _defaultInjector;\n        /**\n         * Attaches a DOM portal by transferring its content into the outlet.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * @breaking-change 10.0.0\n         */\n        this.attachDomPortal = (portal) => {\n            // @breaking-change 10.0.0 Remove check and error once the\n            // `_document` constructor parameter is required.\n            if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('Cannot attach DOM portal without _document constructor parameter');\n            }\n            const element = portal.element;\n            if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('DOM portal content must be attached to a parent node.');\n            }\n            // Anchor used to save the element's previous position so\n            // that we can restore it when the portal is detached.\n            const anchorNode = this._document.createComment('dom-portal');\n            element.parentNode.insertBefore(anchorNode, element);\n            this.outletElement.appendChild(element);\n            this._attachedPortal = portal;\n            super.setDisposeFn(() => {\n                // We can't use `replaceWith` here because IE doesn't support it.\n                if (anchorNode.parentNode) {\n                    anchorNode.parentNode.replaceChild(element, anchorNode);\n                }\n            });\n        };\n        this._document = _document;\n    }\n    /**\n     * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.\n     * @param portal Portal to be attached\n     * @returns Reference to the created component.\n     */\n    attachComponentPortal(portal) {\n        const resolver = (portal.componentFactoryResolver || this._componentFactoryResolver);\n        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !resolver) {\n            throw Error('Cannot attach component portal to outlet without a ComponentFactoryResolver.');\n        }\n        const componentFactory = resolver.resolveComponentFactory(portal.component);\n        let componentRef;\n        // If the portal specifies a ViewContainerRef, we will use that as the attachment point\n        // for the component (in terms of Angular's component tree, not rendering).\n        // When the ViewContainerRef is missing, we use the factory to create the component directly\n        // and then manually attach the view to the application.\n        if (portal.viewContainerRef) {\n            componentRef = portal.viewContainerRef.createComponent(componentFactory, portal.viewContainerRef.length, portal.injector || portal.viewContainerRef.injector, portal.projectableNodes || undefined);\n            this.setDisposeFn(() => componentRef.destroy());\n        }\n        else {\n            if ((typeof ngDevMode === 'undefined' || ngDevMode) && !this._appRef) {\n                throw Error('Cannot attach component portal to outlet without an ApplicationRef.');\n            }\n            componentRef = componentFactory.create(portal.injector || this._defaultInjector || Injector.NULL);\n            this._appRef.attachView(componentRef.hostView);\n            this.setDisposeFn(() => {\n                // Verify that the ApplicationRef has registered views before trying to detach a host view.\n                // This check also protects the `detachView` from being called on a destroyed ApplicationRef.\n                if (this._appRef.viewCount > 0) {\n                    this._appRef.detachView(componentRef.hostView);\n                }\n                componentRef.destroy();\n            });\n        }\n        // At this point the component has been instantiated, so we move it to the location in the DOM\n        // where we want it to be rendered.\n        this.outletElement.appendChild(this._getComponentRootNode(componentRef));\n        this._attachedPortal = portal;\n        return componentRef;\n    }\n    /**\n     * Attaches a template portal to the DOM as an embedded view.\n     * @param portal Portal to be attached.\n     * @returns Reference to the created embedded view.\n     */\n    attachTemplatePortal(portal) {\n        let viewContainer = portal.viewContainerRef;\n        let viewRef = viewContainer.createEmbeddedView(portal.templateRef, portal.context, {\n            injector: portal.injector,\n        });\n        // The method `createEmbeddedView` will add the view as a child of the viewContainer.\n        // But for the DomPortalOutlet the view can be added everywhere in the DOM\n        // (e.g Overlay Container) To move the view to the specified host element. We just\n        // re-append the existing root nodes.\n        viewRef.rootNodes.forEach(rootNode => this.outletElement.appendChild(rootNode));\n        // Note that we want to detect changes after the nodes have been moved so that\n        // any directives inside the portal that are looking at the DOM inside a lifecycle\n        // hook won't be invoked too early.\n        viewRef.detectChanges();\n        this.setDisposeFn(() => {\n            let index = viewContainer.indexOf(viewRef);\n            if (index !== -1) {\n                viewContainer.remove(index);\n            }\n        });\n        this._attachedPortal = portal;\n        // TODO(jelbourn): Return locals from view.\n        return viewRef;\n    }\n    /**\n     * Clears out a portal from the DOM.\n     */\n    dispose() {\n        super.dispose();\n        this.outletElement.remove();\n    }\n    /** Gets the root HTMLElement for an instantiated component. */\n    _getComponentRootNode(componentRef) {\n        return componentRef.hostView.rootNodes[0];\n    }\n}\n/**\n * @deprecated Use `DomPortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nclass DomPortalHost extends DomPortalOutlet {\n}\n\n/**\n * Directive version of a `TemplatePortal`. Because the directive *is* a TemplatePortal,\n * the directive instance itself can be attached to a host, enabling declarative use of portals.\n */\nclass CdkPortal extends TemplatePortal {\n    constructor(templateRef, viewContainerRef) {\n        super(templateRef, viewContainerRef);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkPortal, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkPortal, selector: \"[cdkPortal]\", exportAs: [\"cdkPortal\"], usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkPortal, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkPortal]',\n                    exportAs: 'cdkPortal',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; } });\n/**\n * @deprecated Use `CdkPortal` instead.\n * @breaking-change 9.0.0\n */\nclass TemplatePortalDirective extends CdkPortal {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: TemplatePortalDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: TemplatePortalDirective, selector: \"[cdk-portal], [portal]\", providers: [\n            {\n                provide: CdkPortal,\n                useExisting: TemplatePortalDirective,\n            },\n        ], exportAs: [\"cdkPortal\"], usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: TemplatePortalDirective, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdk-portal], [portal]',\n                    exportAs: 'cdkPortal',\n                    providers: [\n                        {\n                            provide: CdkPortal,\n                            useExisting: TemplatePortalDirective,\n                        },\n                    ],\n                }]\n        }] });\n/**\n * Directive version of a PortalOutlet. Because the directive *is* a PortalOutlet, portals can be\n * directly attached to it, enabling declarative use.\n *\n * Usage:\n * `<ng-template [cdkPortalOutlet]=\"greeting\"></ng-template>`\n */\nclass CdkPortalOutlet extends BasePortalOutlet {\n    constructor(_componentFactoryResolver, _viewContainerRef, \n    /**\n     * @deprecated `_document` parameter to be made required.\n     * @breaking-change 9.0.0\n     */\n    _document) {\n        super();\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._viewContainerRef = _viewContainerRef;\n        /** Whether the portal component is initialized. */\n        this._isInitialized = false;\n        /** Emits when a portal is attached to the outlet. */\n        this.attached = new EventEmitter();\n        /**\n         * Attaches the given DomPortal to this PortalHost by moving all of the portal content into it.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * @breaking-change 10.0.0\n         */\n        this.attachDomPortal = (portal) => {\n            // @breaking-change 9.0.0 Remove check and error once the\n            // `_document` constructor parameter is required.\n            if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('Cannot attach DOM portal without _document constructor parameter');\n            }\n            const element = portal.element;\n            if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('DOM portal content must be attached to a parent node.');\n            }\n            // Anchor used to save the element's previous position so\n            // that we can restore it when the portal is detached.\n            const anchorNode = this._document.createComment('dom-portal');\n            portal.setAttachedHost(this);\n            element.parentNode.insertBefore(anchorNode, element);\n            this._getRootNode().appendChild(element);\n            this._attachedPortal = portal;\n            super.setDisposeFn(() => {\n                if (anchorNode.parentNode) {\n                    anchorNode.parentNode.replaceChild(element, anchorNode);\n                }\n            });\n        };\n        this._document = _document;\n    }\n    /** Portal associated with the Portal outlet. */\n    get portal() {\n        return this._attachedPortal;\n    }\n    set portal(portal) {\n        // Ignore the cases where the `portal` is set to a falsy value before the lifecycle hooks have\n        // run. This handles the cases where the user might do something like `<div cdkPortalOutlet>`\n        // and attach a portal programmatically in the parent component. When Angular does the first CD\n        // round, it will fire the setter with empty string, causing the user's content to be cleared.\n        if (this.hasAttached() && !portal && !this._isInitialized) {\n            return;\n        }\n        if (this.hasAttached()) {\n            super.detach();\n        }\n        if (portal) {\n            super.attach(portal);\n        }\n        this._attachedPortal = portal || null;\n    }\n    /** Component or view reference that is attached to the portal. */\n    get attachedRef() {\n        return this._attachedRef;\n    }\n    ngOnInit() {\n        this._isInitialized = true;\n    }\n    ngOnDestroy() {\n        super.dispose();\n        this._attachedRef = this._attachedPortal = null;\n    }\n    /**\n     * Attach the given ComponentPortal to this PortalOutlet using the ComponentFactoryResolver.\n     *\n     * @param portal Portal to be attached to the portal outlet.\n     * @returns Reference to the created component.\n     */\n    attachComponentPortal(portal) {\n        portal.setAttachedHost(this);\n        // If the portal specifies an origin, use that as the logical location of the component\n        // in the application tree. Otherwise use the location of this PortalOutlet.\n        const viewContainerRef = portal.viewContainerRef != null ? portal.viewContainerRef : this._viewContainerRef;\n        const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;\n        const componentFactory = resolver.resolveComponentFactory(portal.component);\n        const ref = viewContainerRef.createComponent(componentFactory, viewContainerRef.length, portal.injector || viewContainerRef.injector, portal.projectableNodes || undefined);\n        // If we're using a view container that's different from the injected one (e.g. when the portal\n        // specifies its own) we need to move the component into the outlet, otherwise it'll be rendered\n        // inside of the alternate view container.\n        if (viewContainerRef !== this._viewContainerRef) {\n            this._getRootNode().appendChild(ref.hostView.rootNodes[0]);\n        }\n        super.setDisposeFn(() => ref.destroy());\n        this._attachedPortal = portal;\n        this._attachedRef = ref;\n        this.attached.emit(ref);\n        return ref;\n    }\n    /**\n     * Attach the given TemplatePortal to this PortalHost as an embedded View.\n     * @param portal Portal to be attached.\n     * @returns Reference to the created embedded view.\n     */\n    attachTemplatePortal(portal) {\n        portal.setAttachedHost(this);\n        const viewRef = this._viewContainerRef.createEmbeddedView(portal.templateRef, portal.context, {\n            injector: portal.injector,\n        });\n        super.setDisposeFn(() => this._viewContainerRef.clear());\n        this._attachedPortal = portal;\n        this._attachedRef = viewRef;\n        this.attached.emit(viewRef);\n        return viewRef;\n    }\n    /** Gets the root node of the portal outlet. */\n    _getRootNode() {\n        const nativeElement = this._viewContainerRef.element.nativeElement;\n        // The directive could be set on a template which will result in a comment\n        // node being the root. Use the comment's parent node if that is the case.\n        return (nativeElement.nodeType === nativeElement.ELEMENT_NODE\n            ? nativeElement\n            : nativeElement.parentNode);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkPortalOutlet, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.ViewContainerRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkPortalOutlet, selector: \"[cdkPortalOutlet]\", inputs: { portal: [\"cdkPortalOutlet\", \"portal\"] }, outputs: { attached: \"attached\" }, exportAs: [\"cdkPortalOutlet\"], usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkPortalOutlet, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkPortalOutlet]',\n                    exportAs: 'cdkPortalOutlet',\n                    inputs: ['portal: cdkPortalOutlet'],\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; }, propDecorators: { attached: [{\n                type: Output\n            }] } });\n/**\n * @deprecated Use `CdkPortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nclass PortalHostDirective extends CdkPortalOutlet {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PortalHostDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: PortalHostDirective, selector: \"[cdkPortalHost], [portalHost]\", inputs: { portal: [\"cdkPortalHost\", \"portal\"] }, providers: [\n            {\n                provide: CdkPortalOutlet,\n                useExisting: PortalHostDirective,\n            },\n        ], exportAs: [\"cdkPortalHost\"], usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PortalHostDirective, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkPortalHost], [portalHost]',\n                    exportAs: 'cdkPortalHost',\n                    inputs: ['portal: cdkPortalHost'],\n                    providers: [\n                        {\n                            provide: CdkPortalOutlet,\n                            useExisting: PortalHostDirective,\n                        },\n                    ],\n                }]\n        }] });\nclass PortalModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PortalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: PortalModule, declarations: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective], exports: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PortalModule }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: PortalModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective],\n                    declarations: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective],\n                }]\n        }] });\n\n/**\n * Custom injector to be used when providing custom\n * injection tokens to components inside a portal.\n * @docs-private\n * @deprecated Use `Injector.create` instead.\n * @breaking-change 11.0.0\n */\nclass PortalInjector {\n    constructor(_parentInjector, _customTokens) {\n        this._parentInjector = _parentInjector;\n        this._customTokens = _customTokens;\n    }\n    get(token, notFoundValue) {\n        const value = this._customTokens.get(token);\n        if (typeof value !== 'undefined') {\n            return value;\n        }\n        return this._parentInjector.get(token, notFoundValue);\n    }\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BasePortalHost, BasePortalOutlet, CdkPortal, CdkPortalOutlet, ComponentPortal, DomPortal, DomPortalHost, DomPortalOutlet, Portal, PortalHostDirective, PortalInjector, PortalModule, TemplatePortal, TemplatePortalDirective };\n","import { coerceNumberProperty, coerceElement, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, forwardRef, Directive, Input, Injectable, Optional, Inject, inject, Component, ViewEncapsulation, ChangeDetectionStrategy, Output, ViewChild, SkipSelf, ElementRef, NgModule } from '@angular/core';\nimport { Subject, of, Observable, fromEvent, animationFrameScheduler, asapScheduler, Subscription, isObservable } from 'rxjs';\nimport { distinctUntilChanged, auditTime, filter, takeUntil, startWith, pairwise, switchMap, shareReplay } from 'rxjs/operators';\nimport * as i1 from '@angular/cdk/platform';\nimport { getRtlScrollAxisType, supportsScrollBehavior, Platform } from '@angular/cdk/platform';\nimport { DOCUMENT } from '@angular/common';\nimport * as i2 from '@angular/cdk/bidi';\nimport { BidiModule } from '@angular/cdk/bidi';\nimport * as i2$1 from '@angular/cdk/collections';\nimport { isDataSource, ArrayDataSource, _VIEW_REPEATER_STRATEGY, _RecycleViewRepeaterStrategy } from '@angular/cdk/collections';\n\n/** The injection token used to specify the virtual scrolling strategy. */\nconst VIRTUAL_SCROLL_STRATEGY = new InjectionToken('VIRTUAL_SCROLL_STRATEGY');\n\n/** Virtual scrolling strategy for lists with items of known fixed size. */\nclass FixedSizeVirtualScrollStrategy {\n    /**\n     * @param itemSize The size of the items in the virtually scrolling list.\n     * @param minBufferPx The minimum amount of buffer (in pixels) before needing to render more\n     * @param maxBufferPx The amount of buffer (in pixels) to render when rendering more.\n     */\n    constructor(itemSize, minBufferPx, maxBufferPx) {\n        this._scrolledIndexChange = new Subject();\n        /** @docs-private Implemented as part of VirtualScrollStrategy. */\n        this.scrolledIndexChange = this._scrolledIndexChange.pipe(distinctUntilChanged());\n        /** The attached viewport. */\n        this._viewport = null;\n        this._itemSize = itemSize;\n        this._minBufferPx = minBufferPx;\n        this._maxBufferPx = maxBufferPx;\n    }\n    /**\n     * Attaches this scroll strategy to a viewport.\n     * @param viewport The viewport to attach this strategy to.\n     */\n    attach(viewport) {\n        this._viewport = viewport;\n        this._updateTotalContentSize();\n        this._updateRenderedRange();\n    }\n    /** Detaches this scroll strategy from the currently attached viewport. */\n    detach() {\n        this._scrolledIndexChange.complete();\n        this._viewport = null;\n    }\n    /**\n     * Update the item size and buffer size.\n     * @param itemSize The size of the items in the virtually scrolling list.\n     * @param minBufferPx The minimum amount of buffer (in pixels) before needing to render more\n     * @param maxBufferPx The amount of buffer (in pixels) to render when rendering more.\n     */\n    updateItemAndBufferSize(itemSize, minBufferPx, maxBufferPx) {\n        if (maxBufferPx < minBufferPx && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('CDK virtual scroll: maxBufferPx must be greater than or equal to minBufferPx');\n        }\n        this._itemSize = itemSize;\n        this._minBufferPx = minBufferPx;\n        this._maxBufferPx = maxBufferPx;\n        this._updateTotalContentSize();\n        this._updateRenderedRange();\n    }\n    /** @docs-private Implemented as part of VirtualScrollStrategy. */\n    onContentScrolled() {\n        this._updateRenderedRange();\n    }\n    /** @docs-private Implemented as part of VirtualScrollStrategy. */\n    onDataLengthChanged() {\n        this._updateTotalContentSize();\n        this._updateRenderedRange();\n    }\n    /** @docs-private Implemented as part of VirtualScrollStrategy. */\n    onContentRendered() {\n        /* no-op */\n    }\n    /** @docs-private Implemented as part of VirtualScrollStrategy. */\n    onRenderedOffsetChanged() {\n        /* no-op */\n    }\n    /**\n     * Scroll to the offset for the given index.\n     * @param index The index of the element to scroll to.\n     * @param behavior The ScrollBehavior to use when scrolling.\n     */\n    scrollToIndex(index, behavior) {\n        if (this._viewport) {\n            this._viewport.scrollToOffset(index * this._itemSize, behavior);\n        }\n    }\n    /** Update the viewport's total content size. */\n    _updateTotalContentSize() {\n        if (!this._viewport) {\n            return;\n        }\n        this._viewport.setTotalContentSize(this._viewport.getDataLength() * this._itemSize);\n    }\n    /** Update the viewport's rendered range. */\n    _updateRenderedRange() {\n        if (!this._viewport) {\n            return;\n        }\n        const renderedRange = this._viewport.getRenderedRange();\n        const newRange = { start: renderedRange.start, end: renderedRange.end };\n        const viewportSize = this._viewport.getViewportSize();\n        const dataLength = this._viewport.getDataLength();\n        let scrollOffset = this._viewport.measureScrollOffset();\n        // Prevent NaN as result when dividing by zero.\n        let firstVisibleIndex = this._itemSize > 0 ? scrollOffset / this._itemSize : 0;\n        // If user scrolls to the bottom of the list and data changes to a smaller list\n        if (newRange.end > dataLength) {\n            // We have to recalculate the first visible index based on new data length and viewport size.\n            const maxVisibleItems = Math.ceil(viewportSize / this._itemSize);\n            const newVisibleIndex = Math.max(0, Math.min(firstVisibleIndex, dataLength - maxVisibleItems));\n            // If first visible index changed we must update scroll offset to handle start/end buffers\n            // Current range must also be adjusted to cover the new position (bottom of new list).\n            if (firstVisibleIndex != newVisibleIndex) {\n                firstVisibleIndex = newVisibleIndex;\n                scrollOffset = newVisibleIndex * this._itemSize;\n                newRange.start = Math.floor(firstVisibleIndex);\n            }\n            newRange.end = Math.max(0, Math.min(dataLength, newRange.start + maxVisibleItems));\n        }\n        const startBuffer = scrollOffset - newRange.start * this._itemSize;\n        if (startBuffer < this._minBufferPx && newRange.start != 0) {\n            const expandStart = Math.ceil((this._maxBufferPx - startBuffer) / this._itemSize);\n            newRange.start = Math.max(0, newRange.start - expandStart);\n            newRange.end = Math.min(dataLength, Math.ceil(firstVisibleIndex + (viewportSize + this._minBufferPx) / this._itemSize));\n        }\n        else {\n            const endBuffer = newRange.end * this._itemSize - (scrollOffset + viewportSize);\n            if (endBuffer < this._minBufferPx && newRange.end != dataLength) {\n                const expandEnd = Math.ceil((this._maxBufferPx - endBuffer) / this._itemSize);\n                if (expandEnd > 0) {\n                    newRange.end = Math.min(dataLength, newRange.end + expandEnd);\n                    newRange.start = Math.max(0, Math.floor(firstVisibleIndex - this._minBufferPx / this._itemSize));\n                }\n            }\n        }\n        this._viewport.setRenderedRange(newRange);\n        this._viewport.setRenderedContentOffset(this._itemSize * newRange.start);\n        this._scrolledIndexChange.next(Math.floor(firstVisibleIndex));\n    }\n}\n/**\n * Provider factory for `FixedSizeVirtualScrollStrategy` that simply extracts the already created\n * `FixedSizeVirtualScrollStrategy` from the given directive.\n * @param fixedSizeDir The instance of `CdkFixedSizeVirtualScroll` to extract the\n *     `FixedSizeVirtualScrollStrategy` from.\n */\nfunction _fixedSizeVirtualScrollStrategyFactory(fixedSizeDir) {\n    return fixedSizeDir._scrollStrategy;\n}\n/** A virtual scroll strategy that supports fixed-size items. */\nclass CdkFixedSizeVirtualScroll {\n    constructor() {\n        this._itemSize = 20;\n        this._minBufferPx = 100;\n        this._maxBufferPx = 200;\n        /** The scroll strategy used by this directive. */\n        this._scrollStrategy = new FixedSizeVirtualScrollStrategy(this.itemSize, this.minBufferPx, this.maxBufferPx);\n    }\n    /** The size of the items in the list (in pixels). */\n    get itemSize() {\n        return this._itemSize;\n    }\n    set itemSize(value) {\n        this._itemSize = coerceNumberProperty(value);\n    }\n    /**\n     * The minimum amount of buffer rendered beyond the viewport (in pixels).\n     * If the amount of buffer dips below this number, more items will be rendered. Defaults to 100px.\n     */\n    get minBufferPx() {\n        return this._minBufferPx;\n    }\n    set minBufferPx(value) {\n        this._minBufferPx = coerceNumberProperty(value);\n    }\n    /**\n     * The number of pixels worth of buffer to render for when rendering new items. Defaults to 200px.\n     */\n    get maxBufferPx() {\n        return this._maxBufferPx;\n    }\n    set maxBufferPx(value) {\n        this._maxBufferPx = coerceNumberProperty(value);\n    }\n    ngOnChanges() {\n        this._scrollStrategy.updateItemAndBufferSize(this.itemSize, this.minBufferPx, this.maxBufferPx);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkFixedSizeVirtualScroll, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkFixedSizeVirtualScroll, isStandalone: true, selector: \"cdk-virtual-scroll-viewport[itemSize]\", inputs: { itemSize: \"itemSize\", minBufferPx: \"minBufferPx\", maxBufferPx: \"maxBufferPx\" }, providers: [\n            {\n                provide: VIRTUAL_SCROLL_STRATEGY,\n                useFactory: _fixedSizeVirtualScrollStrategyFactory,\n                deps: [forwardRef(() => CdkFixedSizeVirtualScroll)],\n            },\n        ], usesOnChanges: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkFixedSizeVirtualScroll, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-virtual-scroll-viewport[itemSize]',\n                    standalone: true,\n                    providers: [\n                        {\n                            provide: VIRTUAL_SCROLL_STRATEGY,\n                            useFactory: _fixedSizeVirtualScrollStrategyFactory,\n                            deps: [forwardRef(() => CdkFixedSizeVirtualScroll)],\n                        },\n                    ],\n                }]\n        }], propDecorators: { itemSize: [{\n                type: Input\n            }], minBufferPx: [{\n                type: Input\n            }], maxBufferPx: [{\n                type: Input\n            }] } });\n\n/** Time in ms to throttle the scrolling events by default. */\nconst DEFAULT_SCROLL_TIME = 20;\n/**\n * Service contained all registered Scrollable references and emits an event when any one of the\n * Scrollable references emit a scrolled event.\n */\nclass ScrollDispatcher {\n    constructor(_ngZone, _platform, document) {\n        this._ngZone = _ngZone;\n        this._platform = _platform;\n        /** Subject for notifying that a registered scrollable reference element has been scrolled. */\n        this._scrolled = new Subject();\n        /** Keeps track of the global `scroll` and `resize` subscriptions. */\n        this._globalSubscription = null;\n        /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */\n        this._scrolledCount = 0;\n        /**\n         * Map of all the scrollable references that are registered with the service and their\n         * scroll event subscriptions.\n         */\n        this.scrollContainers = new Map();\n        this._document = document;\n    }\n    /**\n     * Registers a scrollable instance with the service and listens for its scrolled events. When the\n     * scrollable is scrolled, the service emits the event to its scrolled observable.\n     * @param scrollable Scrollable instance to be registered.\n     */\n    register(scrollable) {\n        if (!this.scrollContainers.has(scrollable)) {\n            this.scrollContainers.set(scrollable, scrollable.elementScrolled().subscribe(() => this._scrolled.next(scrollable)));\n        }\n    }\n    /**\n     * De-registers a Scrollable reference and unsubscribes from its scroll event observable.\n     * @param scrollable Scrollable instance to be deregistered.\n     */\n    deregister(scrollable) {\n        const scrollableReference = this.scrollContainers.get(scrollable);\n        if (scrollableReference) {\n            scrollableReference.unsubscribe();\n            this.scrollContainers.delete(scrollable);\n        }\n    }\n    /**\n     * Returns an observable that emits an event whenever any of the registered Scrollable\n     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms\n     * to override the default \"throttle\" time.\n     *\n     * **Note:** in order to avoid hitting change detection for every scroll event,\n     * all of the events emitted from this stream will be run outside the Angular zone.\n     * If you need to update any data bindings as a result of a scroll event, you have\n     * to run the callback using `NgZone.run`.\n     */\n    scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME) {\n        if (!this._platform.isBrowser) {\n            return of();\n        }\n        return new Observable((observer) => {\n            if (!this._globalSubscription) {\n                this._addGlobalListener();\n            }\n            // In the case of a 0ms delay, use an observable without auditTime\n            // since it does add a perceptible delay in processing overhead.\n            const subscription = auditTimeInMs > 0\n                ? this._scrolled.pipe(auditTime(auditTimeInMs)).subscribe(observer)\n                : this._scrolled.subscribe(observer);\n            this._scrolledCount++;\n            return () => {\n                subscription.unsubscribe();\n                this._scrolledCount--;\n                if (!this._scrolledCount) {\n                    this._removeGlobalListener();\n                }\n            };\n        });\n    }\n    ngOnDestroy() {\n        this._removeGlobalListener();\n        this.scrollContainers.forEach((_, container) => this.deregister(container));\n        this._scrolled.complete();\n    }\n    /**\n     * Returns an observable that emits whenever any of the\n     * scrollable ancestors of an element are scrolled.\n     * @param elementOrElementRef Element whose ancestors to listen for.\n     * @param auditTimeInMs Time to throttle the scroll events.\n     */\n    ancestorScrolled(elementOrElementRef, auditTimeInMs) {\n        const ancestors = this.getAncestorScrollContainers(elementOrElementRef);\n        return this.scrolled(auditTimeInMs).pipe(filter(target => {\n            return !target || ancestors.indexOf(target) > -1;\n        }));\n    }\n    /** Returns all registered Scrollables that contain the provided element. */\n    getAncestorScrollContainers(elementOrElementRef) {\n        const scrollingContainers = [];\n        this.scrollContainers.forEach((_subscription, scrollable) => {\n            if (this._scrollableContainsElement(scrollable, elementOrElementRef)) {\n                scrollingContainers.push(scrollable);\n            }\n        });\n        return scrollingContainers;\n    }\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    _getWindow() {\n        return this._document.defaultView || window;\n    }\n    /** Returns true if the element is contained within the provided Scrollable. */\n    _scrollableContainsElement(scrollable, elementOrElementRef) {\n        let element = coerceElement(elementOrElementRef);\n        let scrollableElement = scrollable.getElementRef().nativeElement;\n        // Traverse through the element parents until we reach null, checking if any of the elements\n        // are the scrollable's element.\n        do {\n            if (element == scrollableElement) {\n                return true;\n            }\n        } while ((element = element.parentElement));\n        return false;\n    }\n    /** Sets up the global scroll listeners. */\n    _addGlobalListener() {\n        this._globalSubscription = this._ngZone.runOutsideAngular(() => {\n            const window = this._getWindow();\n            return fromEvent(window.document, 'scroll').subscribe(() => this._scrolled.next());\n        });\n    }\n    /** Cleans up the global scroll listener. */\n    _removeGlobalListener() {\n        if (this._globalSubscription) {\n            this._globalSubscription.unsubscribe();\n            this._globalSubscription = null;\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollDispatcher, deps: [{ token: i0.NgZone }, { token: i1.Platform }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.Platform }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n\n/**\n * Sends an event when the directive's element is scrolled. Registers itself with the\n * ScrollDispatcher service to include itself as part of its collection of scrolling events that it\n * can be listened to through the service.\n */\nclass CdkScrollable {\n    constructor(elementRef, scrollDispatcher, ngZone, dir) {\n        this.elementRef = elementRef;\n        this.scrollDispatcher = scrollDispatcher;\n        this.ngZone = ngZone;\n        this.dir = dir;\n        this._destroyed = new Subject();\n        this._elementScrolled = new Observable((observer) => this.ngZone.runOutsideAngular(() => fromEvent(this.elementRef.nativeElement, 'scroll')\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(observer)));\n    }\n    ngOnInit() {\n        this.scrollDispatcher.register(this);\n    }\n    ngOnDestroy() {\n        this.scrollDispatcher.deregister(this);\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /** Returns observable that emits when a scroll event is fired on the host element. */\n    elementScrolled() {\n        return this._elementScrolled;\n    }\n    /** Gets the ElementRef for the viewport. */\n    getElementRef() {\n        return this.elementRef;\n    }\n    /**\n     * Scrolls to the specified offsets. This is a normalized version of the browser's native scrollTo\n     * method, since browsers are not consistent about what scrollLeft means in RTL. For this method\n     * left and right always refer to the left and right side of the scrolling container irrespective\n     * of the layout direction. start and end refer to left and right in an LTR context and vice-versa\n     * in an RTL context.\n     * @param options specified the offsets to scroll to.\n     */\n    scrollTo(options) {\n        const el = this.elementRef.nativeElement;\n        const isRtl = this.dir && this.dir.value == 'rtl';\n        // Rewrite start & end offsets as right or left offsets.\n        if (options.left == null) {\n            options.left = isRtl ? options.end : options.start;\n        }\n        if (options.right == null) {\n            options.right = isRtl ? options.start : options.end;\n        }\n        // Rewrite the bottom offset as a top offset.\n        if (options.bottom != null) {\n            options.top =\n                el.scrollHeight - el.clientHeight - options.bottom;\n        }\n        // Rewrite the right offset as a left offset.\n        if (isRtl && getRtlScrollAxisType() != 0 /* RtlScrollAxisType.NORMAL */) {\n            if (options.left != null) {\n                options.right =\n                    el.scrollWidth - el.clientWidth - options.left;\n            }\n            if (getRtlScrollAxisType() == 2 /* RtlScrollAxisType.INVERTED */) {\n                options.left = options.right;\n            }\n            else if (getRtlScrollAxisType() == 1 /* RtlScrollAxisType.NEGATED */) {\n                options.left = options.right ? -options.right : options.right;\n            }\n        }\n        else {\n            if (options.right != null) {\n                options.left =\n                    el.scrollWidth - el.clientWidth - options.right;\n            }\n        }\n        this._applyScrollToOptions(options);\n    }\n    _applyScrollToOptions(options) {\n        const el = this.elementRef.nativeElement;\n        if (supportsScrollBehavior()) {\n            el.scrollTo(options);\n        }\n        else {\n            if (options.top != null) {\n                el.scrollTop = options.top;\n            }\n            if (options.left != null) {\n                el.scrollLeft = options.left;\n            }\n        }\n    }\n    /**\n     * Measures the scroll offset relative to the specified edge of the viewport. This method can be\n     * used instead of directly checking scrollLeft or scrollTop, since browsers are not consistent\n     * about what scrollLeft means in RTL. The values returned by this method are normalized such that\n     * left and right always refer to the left and right side of the scrolling container irrespective\n     * of the layout direction. start and end refer to left and right in an LTR context and vice-versa\n     * in an RTL context.\n     * @param from The edge to measure from.\n     */\n    measureScrollOffset(from) {\n        const LEFT = 'left';\n        const RIGHT = 'right';\n        const el = this.elementRef.nativeElement;\n        if (from == 'top') {\n            return el.scrollTop;\n        }\n        if (from == 'bottom') {\n            return el.scrollHeight - el.clientHeight - el.scrollTop;\n        }\n        // Rewrite start & end as left or right offsets.\n        const isRtl = this.dir && this.dir.value == 'rtl';\n        if (from == 'start') {\n            from = isRtl ? RIGHT : LEFT;\n        }\n        else if (from == 'end') {\n            from = isRtl ? LEFT : RIGHT;\n        }\n        if (isRtl && getRtlScrollAxisType() == 2 /* RtlScrollAxisType.INVERTED */) {\n            // For INVERTED, scrollLeft is (scrollWidth - clientWidth) when scrolled all the way left and\n            // 0 when scrolled all the way right.\n            if (from == LEFT) {\n                return el.scrollWidth - el.clientWidth - el.scrollLeft;\n            }\n            else {\n                return el.scrollLeft;\n            }\n        }\n        else if (isRtl && getRtlScrollAxisType() == 1 /* RtlScrollAxisType.NEGATED */) {\n            // For NEGATED, scrollLeft is -(scrollWidth - clientWidth) when scrolled all the way left and\n            // 0 when scrolled all the way right.\n            if (from == LEFT) {\n                return el.scrollLeft + el.scrollWidth - el.clientWidth;\n            }\n            else {\n                return -el.scrollLeft;\n            }\n        }\n        else {\n            // For NORMAL, as well as non-RTL contexts, scrollLeft is 0 when scrolled all the way left and\n            // (scrollWidth - clientWidth) when scrolled all the way right.\n            if (from == LEFT) {\n                return el.scrollLeft;\n            }\n            else {\n                return el.scrollWidth - el.clientWidth - el.scrollLeft;\n            }\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkScrollable, deps: [{ token: i0.ElementRef }, { token: ScrollDispatcher }, { token: i0.NgZone }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkScrollable, isStandalone: true, selector: \"[cdk-scrollable], [cdkScrollable]\", ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkScrollable, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdk-scrollable], [cdkScrollable]',\n                    standalone: true,\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: ScrollDispatcher }, { type: i0.NgZone }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }]; } });\n\n/** Time in ms to throttle the resize events by default. */\nconst DEFAULT_RESIZE_TIME = 20;\n/**\n * Simple utility for getting the bounds of the browser viewport.\n * @docs-private\n */\nclass ViewportRuler {\n    constructor(_platform, ngZone, document) {\n        this._platform = _platform;\n        /** Stream of viewport change events. */\n        this._change = new Subject();\n        /** Event listener that will be used to handle the viewport change events. */\n        this._changeListener = (event) => {\n            this._change.next(event);\n        };\n        this._document = document;\n        ngZone.runOutsideAngular(() => {\n            if (_platform.isBrowser) {\n                const window = this._getWindow();\n                // Note that bind the events ourselves, rather than going through something like RxJS's\n                // `fromEvent` so that we can ensure that they're bound outside of the NgZone.\n                window.addEventListener('resize', this._changeListener);\n                window.addEventListener('orientationchange', this._changeListener);\n            }\n            // Clear the cached position so that the viewport is re-measured next time it is required.\n            // We don't need to keep track of the subscription, because it is completed on destroy.\n            this.change().subscribe(() => (this._viewportSize = null));\n        });\n    }\n    ngOnDestroy() {\n        if (this._platform.isBrowser) {\n            const window = this._getWindow();\n            window.removeEventListener('resize', this._changeListener);\n            window.removeEventListener('orientationchange', this._changeListener);\n        }\n        this._change.complete();\n    }\n    /** Returns the viewport's width and height. */\n    getViewportSize() {\n        if (!this._viewportSize) {\n            this._updateViewportSize();\n        }\n        const output = { width: this._viewportSize.width, height: this._viewportSize.height };\n        // If we're not on a browser, don't cache the size since it'll be mocked out anyway.\n        if (!this._platform.isBrowser) {\n            this._viewportSize = null;\n        }\n        return output;\n    }\n    /** Gets a ClientRect for the viewport's bounds. */\n    getViewportRect() {\n        // Use the document element's bounding rect rather than the window scroll properties\n        // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll\n        // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different\n        // conceptual viewports. Under most circumstances these viewports are equivalent, but they\n        // can disagree when the page is pinch-zoomed (on devices that support touch).\n        // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4\n        // We use the documentElement instead of the body because, by default (without a css reset)\n        // browsers typically give the document body an 8px margin, which is not included in\n        // getBoundingClientRect().\n        const scrollPosition = this.getViewportScrollPosition();\n        const { width, height } = this.getViewportSize();\n        return {\n            top: scrollPosition.top,\n            left: scrollPosition.left,\n            bottom: scrollPosition.top + height,\n            right: scrollPosition.left + width,\n            height,\n            width,\n        };\n    }\n    /** Gets the (top, left) scroll position of the viewport. */\n    getViewportScrollPosition() {\n        // While we can get a reference to the fake document\n        // during SSR, it doesn't have getBoundingClientRect.\n        if (!this._platform.isBrowser) {\n            return { top: 0, left: 0 };\n        }\n        // The top-left-corner of the viewport is determined by the scroll position of the document\n        // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about\n        // whether `document.body` or `document.documentElement` is the scrolled element, so reading\n        // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of\n        // `document.documentElement` works consistently, where the `top` and `left` values will\n        // equal negative the scroll position.\n        const document = this._document;\n        const window = this._getWindow();\n        const documentElement = document.documentElement;\n        const documentRect = documentElement.getBoundingClientRect();\n        const top = -documentRect.top ||\n            document.body.scrollTop ||\n            window.scrollY ||\n            documentElement.scrollTop ||\n            0;\n        const left = -documentRect.left ||\n            document.body.scrollLeft ||\n            window.scrollX ||\n            documentElement.scrollLeft ||\n            0;\n        return { top, left };\n    }\n    /**\n     * Returns a stream that emits whenever the size of the viewport changes.\n     * This stream emits outside of the Angular zone.\n     * @param throttleTime Time in milliseconds to throttle the stream.\n     */\n    change(throttleTime = DEFAULT_RESIZE_TIME) {\n        return throttleTime > 0 ? this._change.pipe(auditTime(throttleTime)) : this._change;\n    }\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    _getWindow() {\n        return this._document.defaultView || window;\n    }\n    /** Updates the cached viewport size. */\n    _updateViewportSize() {\n        const window = this._getWindow();\n        this._viewportSize = this._platform.isBrowser\n            ? { width: window.innerWidth, height: window.innerHeight }\n            : { width: 0, height: 0 };\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ViewportRuler, deps: [{ token: i1.Platform }, { token: i0.NgZone }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ViewportRuler, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ViewportRuler, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; } });\n\nconst VIRTUAL_SCROLLABLE = new InjectionToken('VIRTUAL_SCROLLABLE');\n/**\n * Extending the {@link CdkScrollable} to be used as scrolling container for virtual scrolling.\n */\nclass CdkVirtualScrollable extends CdkScrollable {\n    constructor(elementRef, scrollDispatcher, ngZone, dir) {\n        super(elementRef, scrollDispatcher, ngZone, dir);\n    }\n    /**\n     * Measure the viewport size for the provided orientation.\n     *\n     * @param orientation The orientation to measure the size from.\n     */\n    measureViewportSize(orientation) {\n        const viewportEl = this.elementRef.nativeElement;\n        return orientation === 'horizontal' ? viewportEl.clientWidth : viewportEl.clientHeight;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollable, deps: [{ token: i0.ElementRef }, { token: ScrollDispatcher }, { token: i0.NgZone }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkVirtualScrollable, usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollable, decorators: [{\n            type: Directive\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: ScrollDispatcher }, { type: i0.NgZone }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }]; } });\n\n/** Checks if the given ranges are equal. */\nfunction rangesEqual(r1, r2) {\n    return r1.start == r2.start && r1.end == r2.end;\n}\n/**\n * Scheduler to be used for scroll events. Needs to fall back to\n * something that doesn't rely on requestAnimationFrame on environments\n * that don't support it (e.g. server-side rendering).\n */\nconst SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;\n/** A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`. */\nclass CdkVirtualScrollViewport extends CdkVirtualScrollable {\n    /** The direction the viewport scrolls. */\n    get orientation() {\n        return this._orientation;\n    }\n    set orientation(orientation) {\n        if (this._orientation !== orientation) {\n            this._orientation = orientation;\n            this._calculateSpacerSize();\n        }\n    }\n    /**\n     * Whether rendered items should persist in the DOM after scrolling out of view. By default, items\n     * will be removed.\n     */\n    get appendOnly() {\n        return this._appendOnly;\n    }\n    set appendOnly(value) {\n        this._appendOnly = coerceBooleanProperty(value);\n    }\n    constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, viewportRuler, scrollable) {\n        super(elementRef, scrollDispatcher, ngZone, dir);\n        this.elementRef = elementRef;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._scrollStrategy = _scrollStrategy;\n        this.scrollable = scrollable;\n        this._platform = inject(Platform);\n        /** Emits when the viewport is detached from a CdkVirtualForOf. */\n        this._detachedSubject = new Subject();\n        /** Emits when the rendered range changes. */\n        this._renderedRangeSubject = new Subject();\n        this._orientation = 'vertical';\n        this._appendOnly = false;\n        // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll\n        // strategy lazily (i.e. only if the user is actually listening to the events). We do this because\n        // depending on how the strategy calculates the scrolled index, it may come at a cost to\n        // performance.\n        /** Emits when the index of the first element visible in the viewport changes. */\n        this.scrolledIndexChange = new Observable((observer) => this._scrollStrategy.scrolledIndexChange.subscribe(index => Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));\n        /** A stream that emits whenever the rendered range changes. */\n        this.renderedRangeStream = this._renderedRangeSubject;\n        /**\n         * The total size of all content (in pixels), including content that is not currently rendered.\n         */\n        this._totalContentSize = 0;\n        /** A string representing the `style.width` property value to be used for the spacer element. */\n        this._totalContentWidth = '';\n        /** A string representing the `style.height` property value to be used for the spacer element. */\n        this._totalContentHeight = '';\n        /** The currently rendered range of indices. */\n        this._renderedRange = { start: 0, end: 0 };\n        /** The length of the data bound to this viewport (in number of items). */\n        this._dataLength = 0;\n        /** The size of the viewport (in pixels). */\n        this._viewportSize = 0;\n        /** The last rendered content offset that was set. */\n        this._renderedContentOffset = 0;\n        /**\n         * Whether the last rendered content offset was to the end of the content (and therefore needs to\n         * be rewritten as an offset to the start of the content).\n         */\n        this._renderedContentOffsetNeedsRewrite = false;\n        /** Whether there is a pending change detection cycle. */\n        this._isChangeDetectionPending = false;\n        /** A list of functions to run after the next change detection cycle. */\n        this._runAfterChangeDetection = [];\n        /** Subscription to changes in the viewport size. */\n        this._viewportChanges = Subscription.EMPTY;\n        if (!_scrollStrategy && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\n        }\n        this._viewportChanges = viewportRuler.change().subscribe(() => {\n            this.checkViewportSize();\n        });\n        if (!this.scrollable) {\n            // No scrollable is provided, so the virtual-scroll-viewport needs to become a scrollable\n            this.elementRef.nativeElement.classList.add('cdk-virtual-scrollable');\n            this.scrollable = this;\n        }\n    }\n    ngOnInit() {\n        // Scrolling depends on the element dimensions which we can't get during SSR.\n        if (!this._platform.isBrowser) {\n            return;\n        }\n        if (this.scrollable === this) {\n            super.ngOnInit();\n        }\n        // It's still too early to measure the viewport at this point. Deferring with a promise allows\n        // the Viewport to be rendered with the correct size before we measure. We run this outside the\n        // zone to avoid causing more change detection cycles. We handle the change detection loop\n        // ourselves instead.\n        this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {\n            this._measureViewportSize();\n            this._scrollStrategy.attach(this);\n            this.scrollable\n                .elementScrolled()\n                .pipe(\n            // Start off with a fake scroll event so we properly detect our initial position.\n            startWith(null), \n            // Collect multiple events into one until the next animation frame. This way if\n            // there are multiple scroll events in the same frame we only need to recheck\n            // our layout once.\n            auditTime(0, SCROLL_SCHEDULER))\n                .subscribe(() => this._scrollStrategy.onContentScrolled());\n            this._markChangeDetectionNeeded();\n        }));\n    }\n    ngOnDestroy() {\n        this.detach();\n        this._scrollStrategy.detach();\n        // Complete all subjects\n        this._renderedRangeSubject.complete();\n        this._detachedSubject.complete();\n        this._viewportChanges.unsubscribe();\n        super.ngOnDestroy();\n    }\n    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */\n    attach(forOf) {\n        if (this._forOf && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('CdkVirtualScrollViewport is already attached.');\n        }\n        // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length\n        // changes. Run outside the zone to avoid triggering change detection, since we're managing the\n        // change detection loop ourselves.\n        this.ngZone.runOutsideAngular(() => {\n            this._forOf = forOf;\n            this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe(data => {\n                const newLength = data.length;\n                if (newLength !== this._dataLength) {\n                    this._dataLength = newLength;\n                    this._scrollStrategy.onDataLengthChanged();\n                }\n                this._doChangeDetection();\n            });\n        });\n    }\n    /** Detaches the current `CdkVirtualForOf`. */\n    detach() {\n        this._forOf = null;\n        this._detachedSubject.next();\n    }\n    /** Gets the length of the data bound to this viewport (in number of items). */\n    getDataLength() {\n        return this._dataLength;\n    }\n    /** Gets the size of the viewport (in pixels). */\n    getViewportSize() {\n        return this._viewportSize;\n    }\n    // TODO(mmalerba): This is technically out of sync with what's really rendered until a render\n    // cycle happens. I'm being careful to only call it after the render cycle is complete and before\n    // setting it to something else, but its error prone and should probably be split into\n    // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.\n    /** Get the current rendered range of items. */\n    getRenderedRange() {\n        return this._renderedRange;\n    }\n    measureBoundingClientRectWithScrollOffset(from) {\n        return this.getElementRef().nativeElement.getBoundingClientRect()[from];\n    }\n    /**\n     * Sets the total size of all content (in pixels), including content that is not currently\n     * rendered.\n     */\n    setTotalContentSize(size) {\n        if (this._totalContentSize !== size) {\n            this._totalContentSize = size;\n            this._calculateSpacerSize();\n            this._markChangeDetectionNeeded();\n        }\n    }\n    /** Sets the currently rendered range of indices. */\n    setRenderedRange(range) {\n        if (!rangesEqual(this._renderedRange, range)) {\n            if (this.appendOnly) {\n                range = { start: 0, end: Math.max(this._renderedRange.end, range.end) };\n            }\n            this._renderedRangeSubject.next((this._renderedRange = range));\n            this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());\n        }\n    }\n    /**\n     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).\n     */\n    getOffsetToRenderedContentStart() {\n        return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;\n    }\n    /**\n     * Sets the offset from the start of the viewport to either the start or end of the rendered data\n     * (in pixels).\n     */\n    setRenderedContentOffset(offset, to = 'to-start') {\n        // In appendOnly, we always start from the top\n        offset = this.appendOnly && to === 'to-start' ? 0 : offset;\n        // For a horizontal viewport in a right-to-left language we need to translate along the x-axis\n        // in the negative direction.\n        const isRtl = this.dir && this.dir.value == 'rtl';\n        const isHorizontal = this.orientation == 'horizontal';\n        const axis = isHorizontal ? 'X' : 'Y';\n        const axisDirection = isHorizontal && isRtl ? -1 : 1;\n        let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;\n        this._renderedContentOffset = offset;\n        if (to === 'to-end') {\n            transform += ` translate${axis}(-100%)`;\n            // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise\n            // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would\n            // expand upward).\n            this._renderedContentOffsetNeedsRewrite = true;\n        }\n        if (this._renderedContentTransform != transform) {\n            // We know this value is safe because we parse `offset` with `Number()` before passing it\n            // into the string.\n            this._renderedContentTransform = transform;\n            this._markChangeDetectionNeeded(() => {\n                if (this._renderedContentOffsetNeedsRewrite) {\n                    this._renderedContentOffset -= this.measureRenderedContentSize();\n                    this._renderedContentOffsetNeedsRewrite = false;\n                    this.setRenderedContentOffset(this._renderedContentOffset);\n                }\n                else {\n                    this._scrollStrategy.onRenderedOffsetChanged();\n                }\n            });\n        }\n    }\n    /**\n     * Scrolls to the given offset from the start of the viewport. Please note that this is not always\n     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left\n     * direction, this would be the equivalent of setting a fictional `scrollRight` property.\n     * @param offset The offset to scroll to.\n     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n     */\n    scrollToOffset(offset, behavior = 'auto') {\n        const options = { behavior };\n        if (this.orientation === 'horizontal') {\n            options.start = offset;\n        }\n        else {\n            options.top = offset;\n        }\n        this.scrollable.scrollTo(options);\n    }\n    /**\n     * Scrolls to the offset for the given index.\n     * @param index The index of the element to scroll to.\n     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n     */\n    scrollToIndex(index, behavior = 'auto') {\n        this._scrollStrategy.scrollToIndex(index, behavior);\n    }\n    /**\n     * Gets the current scroll offset from the start of the scrollable (in pixels).\n     * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'\n     *     in horizontal mode.\n     */\n    measureScrollOffset(from) {\n        // This is to break the call cycle\n        let measureScrollOffset;\n        if (this.scrollable == this) {\n            measureScrollOffset = (_from) => super.measureScrollOffset(_from);\n        }\n        else {\n            measureScrollOffset = (_from) => this.scrollable.measureScrollOffset(_from);\n        }\n        return Math.max(0, measureScrollOffset(from ?? (this.orientation === 'horizontal' ? 'start' : 'top')) -\n            this.measureViewportOffset());\n    }\n    /**\n     * Measures the offset of the viewport from the scrolling container\n     * @param from The edge to measure from.\n     */\n    measureViewportOffset(from) {\n        let fromRect;\n        const LEFT = 'left';\n        const RIGHT = 'right';\n        const isRtl = this.dir?.value == 'rtl';\n        if (from == 'start') {\n            fromRect = isRtl ? RIGHT : LEFT;\n        }\n        else if (from == 'end') {\n            fromRect = isRtl ? LEFT : RIGHT;\n        }\n        else if (from) {\n            fromRect = from;\n        }\n        else {\n            fromRect = this.orientation === 'horizontal' ? 'left' : 'top';\n        }\n        const scrollerClientRect = this.scrollable.measureBoundingClientRectWithScrollOffset(fromRect);\n        const viewportClientRect = this.elementRef.nativeElement.getBoundingClientRect()[fromRect];\n        return viewportClientRect - scrollerClientRect;\n    }\n    /** Measure the combined size of all of the rendered items. */\n    measureRenderedContentSize() {\n        const contentEl = this._contentWrapper.nativeElement;\n        return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;\n    }\n    /**\n     * Measure the total combined size of the given range. Throws if the range includes items that are\n     * not rendered.\n     */\n    measureRangeSize(range) {\n        if (!this._forOf) {\n            return 0;\n        }\n        return this._forOf.measureRangeSize(range, this.orientation);\n    }\n    /** Update the viewport dimensions and re-render. */\n    checkViewportSize() {\n        // TODO: Cleanup later when add logic for handling content resize\n        this._measureViewportSize();\n        this._scrollStrategy.onDataLengthChanged();\n    }\n    /** Measure the viewport size. */\n    _measureViewportSize() {\n        this._viewportSize = this.scrollable.measureViewportSize(this.orientation);\n    }\n    /** Queue up change detection to run. */\n    _markChangeDetectionNeeded(runAfter) {\n        if (runAfter) {\n            this._runAfterChangeDetection.push(runAfter);\n        }\n        // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of\n        // properties sequentially we only have to run `_doChangeDetection` once at the end.\n        if (!this._isChangeDetectionPending) {\n            this._isChangeDetectionPending = true;\n            this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {\n                this._doChangeDetection();\n            }));\n        }\n    }\n    /** Run change detection. */\n    _doChangeDetection() {\n        this._isChangeDetectionPending = false;\n        // Apply the content transform. The transform can't be set via an Angular binding because\n        // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of\n        // string literals, a variable that can only be 'X' or 'Y', and user input that is run through\n        // the `Number` function first to coerce it to a numeric value.\n        this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform;\n        // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection\n        // from the root, since the repeated items are content projected in. Calling `detectChanges`\n        // instead does not properly check the projected content.\n        this.ngZone.run(() => this._changeDetectorRef.markForCheck());\n        const runAfterChangeDetection = this._runAfterChangeDetection;\n        this._runAfterChangeDetection = [];\n        for (const fn of runAfterChangeDetection) {\n            fn();\n        }\n    }\n    /** Calculates the `style.width` and `style.height` for the spacer element. */\n    _calculateSpacerSize() {\n        this._totalContentHeight =\n            this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;\n        this._totalContentWidth =\n            this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollViewport, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: VIRTUAL_SCROLL_STRATEGY, optional: true }, { token: i2.Directionality, optional: true }, { token: ScrollDispatcher }, { token: ViewportRuler }, { token: VIRTUAL_SCROLLABLE, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }\n    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkVirtualScrollViewport, isStandalone: true, selector: \"cdk-virtual-scroll-viewport\", inputs: { orientation: \"orientation\", appendOnly: \"appendOnly\" }, outputs: { scrolledIndexChange: \"scrolledIndexChange\" }, host: { properties: { \"class.cdk-virtual-scroll-orientation-horizontal\": \"orientation === \\\"horizontal\\\"\", \"class.cdk-virtual-scroll-orientation-vertical\": \"orientation !== \\\"horizontal\\\"\" }, classAttribute: \"cdk-virtual-scroll-viewport\" }, providers: [\n            {\n                provide: CdkScrollable,\n                useFactory: (virtualScrollable, viewport) => virtualScrollable || viewport,\n                deps: [[new Optional(), new Inject(VIRTUAL_SCROLLABLE)], CdkVirtualScrollViewport],\n            },\n        ], viewQueries: [{ propertyName: \"_contentWrapper\", first: true, predicate: [\"contentWrapper\"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: \"<!--\\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\\n  position.\\n-->\\n<div #contentWrapper class=\\\"cdk-virtual-scroll-content-wrapper\\\">\\n  <ng-content></ng-content>\\n</div>\\n<!--\\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\\n  so that the scrollbar captures the size of the entire data set.\\n-->\\n<div class=\\\"cdk-virtual-scroll-spacer\\\"\\n     [style.width]=\\\"_totalContentWidth\\\" [style.height]=\\\"_totalContentHeight\\\"></div>\\n\", styles: [\"cdk-virtual-scroll-viewport{display:block;position:relative;transform:translateZ(0)}.cdk-virtual-scrollable{overflow:auto;will-change:scroll-position;contain:strict;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{height:1px;transform-origin:0 0;flex:0 0 auto}[dir=rtl] .cdk-virtual-scroll-spacer{transform-origin:100% 0}\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollViewport, decorators: [{\n            type: Component,\n            args: [{ selector: 'cdk-virtual-scroll-viewport', host: {\n                        'class': 'cdk-virtual-scroll-viewport',\n                        '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === \"horizontal\"',\n                        '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== \"horizontal\"',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, providers: [\n                        {\n                            provide: CdkScrollable,\n                            useFactory: (virtualScrollable, viewport) => virtualScrollable || viewport,\n                            deps: [[new Optional(), new Inject(VIRTUAL_SCROLLABLE)], CdkVirtualScrollViewport],\n                        },\n                    ], template: \"<!--\\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\\n  position.\\n-->\\n<div #contentWrapper class=\\\"cdk-virtual-scroll-content-wrapper\\\">\\n  <ng-content></ng-content>\\n</div>\\n<!--\\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\\n  so that the scrollbar captures the size of the entire data set.\\n-->\\n<div class=\\\"cdk-virtual-scroll-spacer\\\"\\n     [style.width]=\\\"_totalContentWidth\\\" [style.height]=\\\"_totalContentHeight\\\"></div>\\n\", styles: [\"cdk-virtual-scroll-viewport{display:block;position:relative;transform:translateZ(0)}.cdk-virtual-scrollable{overflow:auto;will-change:scroll-position;contain:strict;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{height:1px;transform-origin:0 0;flex:0 0 auto}[dir=rtl] .cdk-virtual-scroll-spacer{transform-origin:100% 0}\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [VIRTUAL_SCROLL_STRATEGY]\n                }] }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }, { type: ScrollDispatcher }, { type: ViewportRuler }, { type: CdkVirtualScrollable, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [VIRTUAL_SCROLLABLE]\n                }] }]; }, propDecorators: { orientation: [{\n                type: Input\n            }], appendOnly: [{\n                type: Input\n            }], scrolledIndexChange: [{\n                type: Output\n            }], _contentWrapper: [{\n                type: ViewChild,\n                args: ['contentWrapper', { static: true }]\n            }] } });\n\n/** Helper to extract the offset of a DOM Node in a certain direction. */\nfunction getOffset(orientation, direction, node) {\n    const el = node;\n    if (!el.getBoundingClientRect) {\n        return 0;\n    }\n    const rect = el.getBoundingClientRect();\n    if (orientation === 'horizontal') {\n        return direction === 'start' ? rect.left : rect.right;\n    }\n    return direction === 'start' ? rect.top : rect.bottom;\n}\n/**\n * A directive similar to `ngForOf` to be used for rendering data inside a virtual scrolling\n * container.\n */\nclass CdkVirtualForOf {\n    /** The DataSource to display. */\n    get cdkVirtualForOf() {\n        return this._cdkVirtualForOf;\n    }\n    set cdkVirtualForOf(value) {\n        this._cdkVirtualForOf = value;\n        if (isDataSource(value)) {\n            this._dataSourceChanges.next(value);\n        }\n        else {\n            // If value is an an NgIterable, convert it to an array.\n            this._dataSourceChanges.next(new ArrayDataSource(isObservable(value) ? value : Array.from(value || [])));\n        }\n    }\n    /**\n     * The `TrackByFunction` to use for tracking changes. The `TrackByFunction` takes the index and\n     * the item and produces a value to be used as the item's identity when tracking changes.\n     */\n    get cdkVirtualForTrackBy() {\n        return this._cdkVirtualForTrackBy;\n    }\n    set cdkVirtualForTrackBy(fn) {\n        this._needsUpdate = true;\n        this._cdkVirtualForTrackBy = fn\n            ? (index, item) => fn(index + (this._renderedRange ? this._renderedRange.start : 0), item)\n            : undefined;\n    }\n    /** The template used to stamp out new elements. */\n    set cdkVirtualForTemplate(value) {\n        if (value) {\n            this._needsUpdate = true;\n            this._template = value;\n        }\n    }\n    /**\n     * The size of the cache used to store templates that are not being used for re-use later.\n     * Setting the cache size to `0` will disable caching. Defaults to 20 templates.\n     */\n    get cdkVirtualForTemplateCacheSize() {\n        return this._viewRepeater.viewCacheSize;\n    }\n    set cdkVirtualForTemplateCacheSize(size) {\n        this._viewRepeater.viewCacheSize = coerceNumberProperty(size);\n    }\n    constructor(\n    /** The view container to add items to. */\n    _viewContainerRef, \n    /** The template to use when stamping out new items. */\n    _template, \n    /** The set of available differs. */\n    _differs, \n    /** The strategy used to render items in the virtual scroll viewport. */\n    _viewRepeater, \n    /** The virtual scrolling viewport that these items are being rendered in. */\n    _viewport, ngZone) {\n        this._viewContainerRef = _viewContainerRef;\n        this._template = _template;\n        this._differs = _differs;\n        this._viewRepeater = _viewRepeater;\n        this._viewport = _viewport;\n        /** Emits when the rendered view of the data changes. */\n        this.viewChange = new Subject();\n        /** Subject that emits when a new DataSource instance is given. */\n        this._dataSourceChanges = new Subject();\n        /** Emits whenever the data in the current DataSource changes. */\n        this.dataStream = this._dataSourceChanges.pipe(\n        // Start off with null `DataSource`.\n        startWith(null), \n        // Bundle up the previous and current data sources so we can work with both.\n        pairwise(), \n        // Use `_changeDataSource` to disconnect from the previous data source and connect to the\n        // new one, passing back a stream of data changes which we run through `switchMap` to give\n        // us a data stream that emits the latest data from whatever the current `DataSource` is.\n        switchMap(([prev, cur]) => this._changeDataSource(prev, cur)), \n        // Replay the last emitted data when someone subscribes.\n        shareReplay(1));\n        /** The differ used to calculate changes to the data. */\n        this._differ = null;\n        /** Whether the rendered data should be updated during the next ngDoCheck cycle. */\n        this._needsUpdate = false;\n        this._destroyed = new Subject();\n        this.dataStream.subscribe(data => {\n            this._data = data;\n            this._onRenderedDataChange();\n        });\n        this._viewport.renderedRangeStream.pipe(takeUntil(this._destroyed)).subscribe(range => {\n            this._renderedRange = range;\n            if (this.viewChange.observers.length) {\n                ngZone.run(() => this.viewChange.next(this._renderedRange));\n            }\n            this._onRenderedDataChange();\n        });\n        this._viewport.attach(this);\n    }\n    /**\n     * Measures the combined size (width for horizontal orientation, height for vertical) of all items\n     * in the specified range. Throws an error if the range includes items that are not currently\n     * rendered.\n     */\n    measureRangeSize(range, orientation) {\n        if (range.start >= range.end) {\n            return 0;\n        }\n        if ((range.start < this._renderedRange.start || range.end > this._renderedRange.end) &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error(`Error: attempted to measure an item that isn't rendered.`);\n        }\n        // The index into the list of rendered views for the first item in the range.\n        const renderedStartIndex = range.start - this._renderedRange.start;\n        // The length of the range we're measuring.\n        const rangeLen = range.end - range.start;\n        // Loop over all the views, find the first and land node and compute the size by subtracting\n        // the top of the first node from the bottom of the last one.\n        let firstNode;\n        let lastNode;\n        // Find the first node by starting from the beginning and going forwards.\n        for (let i = 0; i < rangeLen; i++) {\n            const view = this._viewContainerRef.get(i + renderedStartIndex);\n            if (view && view.rootNodes.length) {\n                firstNode = lastNode = view.rootNodes[0];\n                break;\n            }\n        }\n        // Find the last node by starting from the end and going backwards.\n        for (let i = rangeLen - 1; i > -1; i--) {\n            const view = this._viewContainerRef.get(i + renderedStartIndex);\n            if (view && view.rootNodes.length) {\n                lastNode = view.rootNodes[view.rootNodes.length - 1];\n                break;\n            }\n        }\n        return firstNode && lastNode\n            ? getOffset(orientation, 'end', lastNode) - getOffset(orientation, 'start', firstNode)\n            : 0;\n    }\n    ngDoCheck() {\n        if (this._differ && this._needsUpdate) {\n            // TODO(mmalerba): We should differentiate needs update due to scrolling and a new portion of\n            // this list being rendered (can use simpler algorithm) vs needs update due to data actually\n            // changing (need to do this diff).\n            const changes = this._differ.diff(this._renderedItems);\n            if (!changes) {\n                this._updateContext();\n            }\n            else {\n                this._applyChanges(changes);\n            }\n            this._needsUpdate = false;\n        }\n    }\n    ngOnDestroy() {\n        this._viewport.detach();\n        this._dataSourceChanges.next(undefined);\n        this._dataSourceChanges.complete();\n        this.viewChange.complete();\n        this._destroyed.next();\n        this._destroyed.complete();\n        this._viewRepeater.detach();\n    }\n    /** React to scroll state changes in the viewport. */\n    _onRenderedDataChange() {\n        if (!this._renderedRange) {\n            return;\n        }\n        this._renderedItems = this._data.slice(this._renderedRange.start, this._renderedRange.end);\n        if (!this._differ) {\n            // Use a wrapper function for the `trackBy` so any new values are\n            // picked up automatically without having to recreate the differ.\n            this._differ = this._differs.find(this._renderedItems).create((index, item) => {\n                return this.cdkVirtualForTrackBy ? this.cdkVirtualForTrackBy(index, item) : item;\n            });\n        }\n        this._needsUpdate = true;\n    }\n    /** Swap out one `DataSource` for another. */\n    _changeDataSource(oldDs, newDs) {\n        if (oldDs) {\n            oldDs.disconnect(this);\n        }\n        this._needsUpdate = true;\n        return newDs ? newDs.connect(this) : of();\n    }\n    /** Update the `CdkVirtualForOfContext` for all views. */\n    _updateContext() {\n        const count = this._data.length;\n        let i = this._viewContainerRef.length;\n        while (i--) {\n            const view = this._viewContainerRef.get(i);\n            view.context.index = this._renderedRange.start + i;\n            view.context.count = count;\n            this._updateComputedContextProperties(view.context);\n            view.detectChanges();\n        }\n    }\n    /** Apply changes to the DOM. */\n    _applyChanges(changes) {\n        this._viewRepeater.applyChanges(changes, this._viewContainerRef, (record, _adjustedPreviousIndex, currentIndex) => this._getEmbeddedViewArgs(record, currentIndex), record => record.item);\n        // Update $implicit for any items that had an identity change.\n        changes.forEachIdentityChange((record) => {\n            const view = this._viewContainerRef.get(record.currentIndex);\n            view.context.$implicit = record.item;\n        });\n        // Update the context variables on all items.\n        const count = this._data.length;\n        let i = this._viewContainerRef.length;\n        while (i--) {\n            const view = this._viewContainerRef.get(i);\n            view.context.index = this._renderedRange.start + i;\n            view.context.count = count;\n            this._updateComputedContextProperties(view.context);\n        }\n    }\n    /** Update the computed properties on the `CdkVirtualForOfContext`. */\n    _updateComputedContextProperties(context) {\n        context.first = context.index === 0;\n        context.last = context.index === context.count - 1;\n        context.even = context.index % 2 === 0;\n        context.odd = !context.even;\n    }\n    _getEmbeddedViewArgs(record, index) {\n        // Note that it's important that we insert the item directly at the proper index,\n        // rather than inserting it and the moving it in place, because if there's a directive\n        // on the same node that injects the `ViewContainerRef`, Angular will insert another\n        // comment node which can throw off the move when it's being repeated for all items.\n        return {\n            templateRef: this._template,\n            context: {\n                $implicit: record.item,\n                // It's guaranteed that the iterable is not \"undefined\" or \"null\" because we only\n                // generate views for elements if the \"cdkVirtualForOf\" iterable has elements.\n                cdkVirtualForOf: this._cdkVirtualForOf,\n                index: -1,\n                count: -1,\n                first: false,\n                last: false,\n                odd: false,\n                even: false,\n            },\n            index,\n        };\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualForOf, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: _VIEW_REPEATER_STRATEGY }, { token: CdkVirtualScrollViewport, skipSelf: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkVirtualForOf, isStandalone: true, selector: \"[cdkVirtualFor][cdkVirtualForOf]\", inputs: { cdkVirtualForOf: \"cdkVirtualForOf\", cdkVirtualForTrackBy: \"cdkVirtualForTrackBy\", cdkVirtualForTemplate: \"cdkVirtualForTemplate\", cdkVirtualForTemplateCacheSize: \"cdkVirtualForTemplateCacheSize\" }, providers: [{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy }], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualForOf, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkVirtualFor][cdkVirtualForOf]',\n                    providers: [{ provide: _VIEW_REPEATER_STRATEGY, useClass: _RecycleViewRepeaterStrategy }],\n                    standalone: true,\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: i2$1._RecycleViewRepeaterStrategy, decorators: [{\n                    type: Inject,\n                    args: [_VIEW_REPEATER_STRATEGY]\n                }] }, { type: CdkVirtualScrollViewport, decorators: [{\n                    type: SkipSelf\n                }] }, { type: i0.NgZone }]; }, propDecorators: { cdkVirtualForOf: [{\n                type: Input\n            }], cdkVirtualForTrackBy: [{\n                type: Input\n            }], cdkVirtualForTemplate: [{\n                type: Input\n            }], cdkVirtualForTemplateCacheSize: [{\n                type: Input\n            }] } });\n\n/**\n * Provides a virtual scrollable for the element it is attached to.\n */\nclass CdkVirtualScrollableElement extends CdkVirtualScrollable {\n    constructor(elementRef, scrollDispatcher, ngZone, dir) {\n        super(elementRef, scrollDispatcher, ngZone, dir);\n    }\n    measureBoundingClientRectWithScrollOffset(from) {\n        return (this.getElementRef().nativeElement.getBoundingClientRect()[from] -\n            this.measureScrollOffset(from));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollableElement, deps: [{ token: i0.ElementRef }, { token: ScrollDispatcher }, { token: i0.NgZone }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkVirtualScrollableElement, isStandalone: true, selector: \"[cdkVirtualScrollingElement]\", host: { classAttribute: \"cdk-virtual-scrollable\" }, providers: [{ provide: VIRTUAL_SCROLLABLE, useExisting: CdkVirtualScrollableElement }], usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollableElement, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkVirtualScrollingElement]',\n                    providers: [{ provide: VIRTUAL_SCROLLABLE, useExisting: CdkVirtualScrollableElement }],\n                    standalone: true,\n                    host: {\n                        'class': 'cdk-virtual-scrollable',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: ScrollDispatcher }, { type: i0.NgZone }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }]; } });\n\n/**\n * Provides as virtual scrollable for the global / window scrollbar.\n */\nclass CdkVirtualScrollableWindow extends CdkVirtualScrollable {\n    constructor(scrollDispatcher, ngZone, dir) {\n        super(new ElementRef(document.documentElement), scrollDispatcher, ngZone, dir);\n        this._elementScrolled = new Observable((observer) => this.ngZone.runOutsideAngular(() => fromEvent(document, 'scroll').pipe(takeUntil(this._destroyed)).subscribe(observer)));\n    }\n    measureBoundingClientRectWithScrollOffset(from) {\n        return this.getElementRef().nativeElement.getBoundingClientRect()[from];\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollableWindow, deps: [{ token: ScrollDispatcher }, { token: i0.NgZone }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"16.1.1\", type: CdkVirtualScrollableWindow, isStandalone: true, selector: \"cdk-virtual-scroll-viewport[scrollWindow]\", providers: [{ provide: VIRTUAL_SCROLLABLE, useExisting: CdkVirtualScrollableWindow }], usesInheritance: true, ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkVirtualScrollableWindow, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'cdk-virtual-scroll-viewport[scrollWindow]',\n                    providers: [{ provide: VIRTUAL_SCROLLABLE, useExisting: CdkVirtualScrollableWindow }],\n                    standalone: true,\n                }]\n        }], ctorParameters: function () { return [{ type: ScrollDispatcher }, { type: i0.NgZone }, { type: i2.Directionality, decorators: [{\n                    type: Optional\n                }] }]; } });\n\nclass CdkScrollableModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkScrollableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkScrollableModule, imports: [CdkScrollable], exports: [CdkScrollable] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkScrollableModule }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: CdkScrollableModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    exports: [CdkScrollable],\n                    imports: [CdkScrollable],\n                }]\n        }] });\n/**\n * @docs-primary-export\n */\nclass ScrollingModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollingModule, imports: [BidiModule, CdkScrollableModule, CdkVirtualScrollViewport,\n            CdkFixedSizeVirtualScroll,\n            CdkVirtualForOf,\n            CdkVirtualScrollableWindow,\n            CdkVirtualScrollableElement], exports: [BidiModule, CdkScrollableModule, CdkFixedSizeVirtualScroll,\n            CdkVirtualForOf,\n            CdkVirtualScrollViewport,\n            CdkVirtualScrollableWindow,\n            CdkVirtualScrollableElement] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollingModule, imports: [BidiModule,\n            CdkScrollableModule, BidiModule, CdkScrollableModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: ScrollingModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [\n                        BidiModule,\n                        CdkScrollableModule,\n                        CdkVirtualScrollViewport,\n                        CdkFixedSizeVirtualScroll,\n                        CdkVirtualForOf,\n                        CdkVirtualScrollableWindow,\n                        CdkVirtualScrollableElement,\n                    ],\n                    exports: [\n                        BidiModule,\n                        CdkScrollableModule,\n                        CdkFixedSizeVirtualScroll,\n                        CdkVirtualForOf,\n                        CdkVirtualScrollViewport,\n                        CdkVirtualScrollableWindow,\n                        CdkVirtualScrollableElement,\n                    ],\n                }]\n        }] });\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { CdkFixedSizeVirtualScroll, CdkScrollable, CdkScrollableModule, CdkVirtualForOf, CdkVirtualScrollViewport, CdkVirtualScrollable, CdkVirtualScrollableElement, CdkVirtualScrollableWindow, DEFAULT_RESIZE_TIME, DEFAULT_SCROLL_TIME, FixedSizeVirtualScrollStrategy, ScrollDispatcher, ScrollingModule, VIRTUAL_SCROLLABLE, VIRTUAL_SCROLL_STRATEGY, ViewportRuler, _fixedSizeVirtualScrollStrategyFactory };\n"],"x_google_ignoreList":[0,1,2]}