default-node_modules_angular_cdk_fesm2022_overlay_mjs.31d23577918ea337.js.map

{"version":3,"file":"default-node_modules_angular_cdk_fesm2022_overlay_mjs.31d23577918ea337.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","_ScrollStrategyOptions","noop","close","config","block","reposition","ɵfac","t","i0","i1","DOCUMENT","ɵprov","token","factory","providedIn","OverlayConfig","scrollStrategy","panelClass","hasBackdrop","backdropClass","disposeOnNavigation","configKeys","Object","keys","key","undefined","ConnectedOverlayPositionChange","connectionPair","scrollableViewProperties","BaseOverlayDispatcher","_BaseOverlayDispatcher","_attachedOverlays","ngOnDestroy","push","index","indexOf","splice","length","OverlayKeyboardDispatcher","_OverlayKeyboardDispatcher","super","_keydownListener","event","overlays","i","_keydownEvents","observers","keydownEvents","next","_isAttached","runOutsideAngular","addEventListener","removeEventListener","OverlayOutsideClickDispatcher","_OverlayOutsideClickDispatcher","_platform","_cursorStyleIsSet","_pointerDownListener","_pointerDownEventTarget","_getEventTarget","_clickListener","target","origin","type","slice","_outsidePointerEvents","outsidePointerEvents","_addEventListeners","IOS","_cursorOriginalValue","cursor","i1$1","OverlayContainer","_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","_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","_OverlayPositionBuilder","global","flexibleConnectedTo","nextUniqueId","Overlay","_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","inject","CdkOverlayOrigin","_CdkOverlayOrigin","elementRef","ɵdir","selectors","exportAs","standalone","CdkConnectedOverlay","_CdkConnectedOverlay","_position","_updatePositionStrategy","_disposeOnNavigation","_overlay","templateRef","viewContainerRef","scrollStrategyFactory","_dir","_backdropSubscription","_attachSubscription","_detachSubscription","_positionSubscription","viewportMargin","open","disableClose","lockPosition","EventEmitter","positionChange","overlayKeydown","overlayOutsideClick","_templatePortal","TemplatePortal","_scrollStrategyFactory","ngOnChanges","changes","_attachOverlay","_detachOverlay","_createOverlay","_buildConfig","emit","keyCode","ESCAPE","hasModifierKey","preventDefault","_createPositionStrategy","currentPosition","_getFlexibleConnectedPositionStrategyOrigin","transformOriginSelector","takeWhile","predicate","inclusive","operate","subscriber","createOperatorSubscriber","result","inputs","None","HasDecoratorInputTransform","booleanAttribute","outputs","features","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER","provide","deps","useFactory","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY","OverlayModule","_OverlayModule","ɵmod","ɵinj","providers","imports","BidiModule","PortalModule","ScrollingModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/cdk/fesm2022/overlay.mjs","./node_modules/rxjs/dist/esm/internal/operators/takeWhile.js"],"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, inject, Directive, EventEmitter, booleanAttribute, Input, Output, NgModule } from '@angular/core';\nimport { coerceCssPixelValue, coerceArray } 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: ScrollStrategyOptions, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: ScrollStrategyOptions, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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: \"17.2.0\", ngImport: i0, type: BaseOverlayDispatcher, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: BaseOverlayDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: BaseOverlayDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: OverlayKeyboardDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: OverlayKeyboardDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: OverlayOutsideClickDispatcher, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: OverlayOutsideClickDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: OverlayContainer, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: OverlayContainer, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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 `DOMRect`.\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 DOMRect 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 `DOMRect` 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 `DOMRect` 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: OverlayPositionBuilder, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: OverlayPositionBuilder, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: Overlay, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: Overlay, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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    providedIn: 'root',\n    factory: () => {\n        const overlay = inject(Overlay);\n        return () => overlay.scrollStrategies.reposition();\n    },\n});\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: \"17.2.0\", ngImport: i0, type: CdkOverlayOrigin, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }\n    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"17.2.0\", type: CdkOverlayOrigin, isStandalone: true, selector: \"[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]\", exportAs: [\"cdkOverlayOrigin\"], ngImport: i0 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", 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: () => [{ 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 the overlay should be disposed of when the user goes backwards/forwards in history. */\n    get disposeOnNavigation() {\n        return this._disposeOnNavigation;\n    }\n    set disposeOnNavigation(value) {\n        this._disposeOnNavigation = 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._backdropSubscription = Subscription.EMPTY;\n        this._attachSubscription = Subscription.EMPTY;\n        this._detachSubscription = Subscription.EMPTY;\n        this._positionSubscription = Subscription.EMPTY;\n        this._disposeOnNavigation = false;\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        /** Whether or not the overlay should attach a backdrop. */\n        this.hasBackdrop = false;\n        /** Whether or not the overlay should be locked when scrolling. */\n        this.lockPosition = false;\n        /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n        this.flexibleDimensions = false;\n        /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n        this.growAfterOpen = false;\n        /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n        this.push = 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            disposeOnNavigation: this.disposeOnNavigation,\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: \"17.2.0\", 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: \"16.1.0\", version: \"17.2.0\", 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\", booleanAttribute], lockPosition: [\"cdkConnectedOverlayLockPosition\", \"lockPosition\", booleanAttribute], flexibleDimensions: [\"cdkConnectedOverlayFlexibleDimensions\", \"flexibleDimensions\", booleanAttribute], growAfterOpen: [\"cdkConnectedOverlayGrowAfterOpen\", \"growAfterOpen\", booleanAttribute], push: [\"cdkConnectedOverlayPush\", \"push\", booleanAttribute], disposeOnNavigation: [\"cdkConnectedOverlayDisposeOnNavigation\", \"disposeOnNavigation\", booleanAttribute] }, 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: \"17.2.0\", 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: () => [{ 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: [{ alias: 'cdkConnectedOverlayHasBackdrop', transform: booleanAttribute }]\n            }], lockPosition: [{\n                type: Input,\n                args: [{ alias: 'cdkConnectedOverlayLockPosition', transform: booleanAttribute }]\n            }], flexibleDimensions: [{\n                type: Input,\n                args: [{ alias: 'cdkConnectedOverlayFlexibleDimensions', transform: booleanAttribute }]\n            }], growAfterOpen: [{\n                type: Input,\n                args: [{ alias: 'cdkConnectedOverlayGrowAfterOpen', transform: booleanAttribute }]\n            }], push: [{\n                type: Input,\n                args: [{ alias: 'cdkConnectedOverlayPush', transform: booleanAttribute }]\n            }], disposeOnNavigation: [{\n                type: Input,\n                args: [{ alias: 'cdkConnectedOverlayDisposeOnNavigation', transform: booleanAttribute }]\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: \"17.2.0\", ngImport: i0, type: OverlayModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"17.2.0\", 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: \"17.2.0\", 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: \"17.2.0\", 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: \"17.2.0\", 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: \"17.2.0\", ngImport: i0, type: FullscreenOverlayContainer, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"17.2.0\", ngImport: i0, type: FullscreenOverlayContainer, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ 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 { operate } from '../util/lift';\nimport { createOperatorSubscriber } from './OperatorSubscriber';\nexport function takeWhile(predicate, inclusive = false) {\n    return operate((source, subscriber) => {\n        let index = 0;\n        source.subscribe(createOperatorSubscriber(subscriber, (value) => {\n            const result = predicate(value, index++);\n            (result || inclusive) && subscriber.next(value);\n            !result && subscriber.complete();\n        }));\n    });\n}\n"],"x_google_ignoreList":[0,1]}