{"version":3,"sources":["node_modules/@angular/cdk/fesm2022/overlay.mjs"],"sourcesContent":["import { ScrollDispatcher, ViewportRuler, ScrollingModule } from '@angular/cdk/scrolling';\nexport { CdkScrollable, ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';\nimport { DOCUMENT, Location } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { inject, NgZone, Injectable, RendererFactory2, Component, ChangeDetectionStrategy, ViewEncapsulation, untracked, afterRender, afterNextRender, ElementRef, Injector, ANIMATION_MODULE_TYPE, EnvironmentInjector, ApplicationRef, InjectionToken, Directive, EventEmitter, TemplateRef, ViewContainerRef, booleanAttribute, Input, Output, NgModule } from '@angular/core';\nimport { coerceCssPixelValue, coerceArray } from '@angular/cdk/coercion';\nimport { supportsScrollBehavior, Platform, _getEventTarget, _isTestEnvironment } from '@angular/cdk/platform';\nimport { filter, takeUntil, takeWhile } from 'rxjs/operators';\nimport { Directionality, BidiModule } from '@angular/cdk/bidi';\nimport { DomPortalOutlet, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport { _IdGenerator } from '@angular/cdk/a11y';\nimport { _CdkPrivateStyleLoader } from '@angular/cdk/private';\nimport { Subject, Subscription, merge } from 'rxjs';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nconst scrollBehaviorSupported = /*#__PURE__*/supportsScrollBehavior();\n/**\n * Strategy that will prevent the user from scrolling while the overlay is visible.\n */\nclass BlockScrollStrategy {\n _viewportRuler;\n _previousHTMLStyles = {\n top: '',\n left: ''\n };\n _previousScrollPosition;\n _isEnabled = false;\n _document;\n constructor(_viewportRuler, document) {\n this._viewportRuler = _viewportRuler;\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 _scrollDispatcher;\n _ngZone;\n _viewportRuler;\n _config;\n _scrollSubscription = null;\n _overlayRef;\n _initialScrollPosition;\n constructor(_scrollDispatcher, _ngZone, _viewportRuler, _config) {\n this._scrollDispatcher = _scrollDispatcher;\n this._ngZone = _ngZone;\n this._viewportRuler = _viewportRuler;\n this._config = _config;\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 || !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 } else {\n this._overlayRef.updatePosition();\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 /** Detaches the overlay ref and disables the scroll strategy. */\n _detach = () => {\n this.disable();\n if (this._overlayRef.hasAttached()) {\n this._ngZone.run(() => this._overlayRef.detach());\n }\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 _scrollDispatcher;\n _viewportRuler;\n _ngZone;\n _config;\n _scrollSubscription = null;\n _overlayRef;\n constructor(_scrollDispatcher, _viewportRuler, _ngZone, _config) {\n this._scrollDispatcher = _scrollDispatcher;\n this._viewportRuler = _viewportRuler;\n this._ngZone = _ngZone;\n this._config = _config;\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 {\n width,\n height\n } = 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 = [{\n width,\n height,\n bottom: height,\n right: width,\n top: 0,\n left: 0\n }];\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 */\nlet ScrollStrategyOptions = /*#__PURE__*/(() => {\n class ScrollStrategyOptions {\n _scrollDispatcher = inject(ScrollDispatcher);\n _viewportRuler = inject(ViewportRuler);\n _ngZone = inject(NgZone);\n _document = inject(DOCUMENT);\n constructor() {}\n /** Do nothing on scroll. */\n 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 close = config => new CloseScrollStrategy(this._scrollDispatcher, this._ngZone, this._viewportRuler, config);\n /** Block scrolling. */\n 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 reposition = config => new RepositionScrollStrategy(this._scrollDispatcher, this._viewportRuler, this._ngZone, config);\n static 傻fac = function ScrollStrategyOptions_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || ScrollStrategyOptions)();\n };\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: ScrollStrategyOptions,\n factory: ScrollStrategyOptions.傻fac,\n providedIn: 'root'\n });\n }\n return ScrollStrategyOptions;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/** Initial configuration used when creating an overlay. */\nclass OverlayConfig {\n /** Strategy with which to position the overlay. */\n positionStrategy;\n /** Strategy to be used when handling scroll events while the overlay is open. */\n scrollStrategy = /*#__PURE__*/new NoopScrollStrategy();\n /** Custom class to add to the overlay pane. */\n panelClass = '';\n /** Whether the overlay has a backdrop. */\n hasBackdrop = false;\n /** Custom class to add to the backdrop */\n backdropClass = 'cdk-overlay-dark-backdrop';\n /** The width of the overlay panel. If a number is provided, pixel units are assumed. */\n width;\n /** The height of the overlay panel. If a number is provided, pixel units are assumed. */\n height;\n /** The min-width of the overlay panel. If a number is provided, pixel units are assumed. */\n minWidth;\n /** The min-height of the overlay panel. If a number is provided, pixel units are assumed. */\n minHeight;\n /** The max-width of the overlay panel. If a number is provided, pixel units are assumed. */\n maxWidth;\n /** The max-height of the overlay panel. If a number is provided, pixel units are assumed. */\n maxHeight;\n /**\n * Direction of the text in the overlay panel. If a `Directionality` instance\n * is passed in, the overlay will handle changes to its value automatically.\n */\n direction;\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 disposeOnNavigation = false;\n constructor(config) {\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 offsetX;\n offsetY;\n panelClass;\n /** X-axis attachment point for connected overlay origin. Can be 'start', 'end', or 'center'. */\n originX;\n /** Y-axis attachment point for connected overlay origin. Can be 'top', 'bottom', or 'center'. */\n originY;\n /** X-axis attachment point for connected overlay. Can be 'start', 'end', or 'center'. */\n overlayX;\n /** Y-axis attachment point for connected overlay. Can be 'top', 'bottom', or 'center'. */\n overlayY;\n constructor(origin, overlay, /** Offset along the X axis. */\n offsetX, /** Offset along the Y axis. */\n offsetY, /** 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 isOriginClipped;\n isOriginOutsideView;\n isOverlayClipped;\n isOverlayOutsideView;\n}\n/** The change event emitted by the strategy when a fallback position is used. */\nclass ConnectedOverlayPositionChange {\n connectionPair;\n scrollableViewProperties;\n constructor(/** The position used as a result of this change. */\n connectionPair, /** @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}\". ` + `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}\". ` + `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 */\nlet BaseOverlayDispatcher = /*#__PURE__*/(() => {\n class BaseOverlayDispatcher {\n /** Currently attached overlays in the order they were attached. */\n _attachedOverlays = [];\n _document = inject(DOCUMENT);\n _isAttached;\n constructor() {}\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 傻fac = function BaseOverlayDispatcher_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || BaseOverlayDispatcher)();\n };\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: BaseOverlayDispatcher,\n factory: BaseOverlayDispatcher.傻fac,\n providedIn: 'root'\n });\n }\n return BaseOverlayDispatcher;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\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 */\nlet OverlayKeyboardDispatcher = /*#__PURE__*/(() => {\n class OverlayKeyboardDispatcher extends BaseOverlayDispatcher {\n _ngZone = inject(NgZone);\n _renderer = inject(RendererFactory2).createRenderer(null, null);\n _cleanupKeydown;\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 this._ngZone.runOutsideAngular(() => {\n this._cleanupKeydown = this._renderer.listen('body', '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._cleanupKeydown?.();\n this._isAttached = false;\n }\n }\n /** Keyboard event listener that will be attached to the body. */\n _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 this._ngZone.run(() => overlays[i]._keydownEvents.next(event));\n break;\n }\n }\n };\n static 傻fac = /* @__PURE__ */(() => {\n let 傻OverlayKeyboardDispatcher_BaseFactory;\n return function OverlayKeyboardDispatcher_Factory(__ngFactoryType__) {\n return (傻OverlayKeyboardDispatcher_BaseFactory || (傻OverlayKeyboardDispatcher_BaseFactory = i0.傻傻getInheritedFactory(OverlayKeyboardDispatcher)))(__ngFactoryType__ || OverlayKeyboardDispatcher);\n };\n })();\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: OverlayKeyboardDispatcher,\n factory: OverlayKeyboardDispatcher.傻fac,\n providedIn: 'root'\n });\n }\n return OverlayKeyboardDispatcher;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\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 */\nlet OverlayOutsideClickDispatcher = /*#__PURE__*/(() => {\n class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {\n _platform = inject(Platform);\n _ngZone = inject(NgZone, {\n optional: true\n });\n _cursorOriginalValue;\n _cursorStyleIsSet = false;\n _pointerDownEventTarget;\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 } 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 /** Store pointerdown event target to track origin of click. */\n _pointerDownListener = event => {\n this._pointerDownEventTarget = _getEventTarget(event);\n };\n /** Click event listener that will be attached to the body propagate phase. */\n _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 ? this._pointerDownEventTarget : 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 (containsPierceShadowDom(overlayRef.overlayElement, target) || containsPierceShadowDom(overlayRef.overlayElement, 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 } else {\n outsidePointerEvents.next(event);\n }\n }\n };\n static 傻fac = /* @__PURE__ */(() => {\n let 傻OverlayOutsideClickDispatcher_BaseFactory;\n return function OverlayOutsideClickDispatcher_Factory(__ngFactoryType__) {\n return (傻OverlayOutsideClickDispatcher_BaseFactory || (傻OverlayOutsideClickDispatcher_BaseFactory = i0.傻傻getInheritedFactory(OverlayOutsideClickDispatcher)))(__ngFactoryType__ || OverlayOutsideClickDispatcher);\n };\n })();\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: OverlayOutsideClickDispatcher,\n factory: OverlayOutsideClickDispatcher.傻fac,\n providedIn: 'root'\n });\n }\n return OverlayOutsideClickDispatcher;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/** Version of `Element.contains` that transcends shadow DOM boundaries. */\nfunction containsPierceShadowDom(parent, child) {\n const supportsShadowRoot = typeof ShadowRoot !== 'undefined' && ShadowRoot;\n let current = child;\n while (current) {\n if (current === parent) {\n return true;\n }\n current = supportsShadowRoot && current instanceof ShadowRoot ? current.host : current.parentNode;\n }\n return false;\n}\nlet _CdkOverlayStyleLoader = /*#__PURE__*/(() => {\n class _CdkOverlayStyleLoader {\n static 傻fac = function _CdkOverlayStyleLoader_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || _CdkOverlayStyleLoader)();\n };\n static 傻cmp = /* @__PURE__ */i0.傻傻defineComponent({\n type: _CdkOverlayStyleLoader,\n selectors: [[\"ng-component\"]],\n hostAttrs: [\"cdk-overlay-style-loader\", \"\"],\n decls: 0,\n vars: 0,\n template: function _CdkOverlayStyleLoader_Template(rf, ctx) {},\n styles: [\".cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed}@layer cdk-overlay{.cdk-overlay-container{z-index:1000}}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute}@layer cdk-overlay{.cdk-global-overlay-wrapper{z-index:1000}}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;display:flex;max-width:100%;max-height:100%}@layer cdk-overlay{.cdk-overlay-pane{z-index:1000}}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);opacity:0}@layer cdk-overlay{.cdk-overlay-backdrop{z-index:1000;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}}.cdk-overlay-backdrop-showing{opacity:1}@media(forced-colors: active){.cdk-overlay-backdrop-showing{opacity:.6}}@layer cdk-overlay{.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing,.cdk-high-contrast-active .cdk-overlay-transparent-backdrop{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;display:flex;flex-direction:column;min-width:1px;min-height:1px}@layer cdk-overlay{.cdk-overlay-connected-position-bounding-box{z-index:1000}}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}\"],\n encapsulation: 2,\n changeDetection: 0\n });\n }\n return _CdkOverlayStyleLoader;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/** Container inside which all overlays will render. */\nlet OverlayContainer = /*#__PURE__*/(() => {\n class OverlayContainer {\n _platform = inject(Platform);\n _containerElement;\n _document = inject(DOCUMENT);\n _styleLoader = inject(_CdkPrivateStyleLoader);\n constructor() {}\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 this._loadStyles();\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 } else if (!this._platform.isBrowser) {\n container.setAttribute('platform', 'server');\n }\n this._document.body.appendChild(container);\n this._containerElement = container;\n }\n /** Loads the structural styles necessary for the overlay to work. */\n _loadStyles() {\n this._styleLoader.load(_CdkOverlayStyleLoader);\n }\n static 傻fac = function OverlayContainer_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || OverlayContainer)();\n };\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: OverlayContainer,\n factory: OverlayContainer.傻fac,\n providedIn: 'root'\n });\n }\n return OverlayContainer;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\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 _portalOutlet;\n _host;\n _pane;\n _config;\n _ngZone;\n _keyboardDispatcher;\n _document;\n _location;\n _outsideClickDispatcher;\n _animationsDisabled;\n _injector;\n _renderer;\n _backdropElement = null;\n _backdropTimeout;\n _backdropClick = /*#__PURE__*/new Subject();\n _attachments = /*#__PURE__*/new Subject();\n _detachments = /*#__PURE__*/new Subject();\n _positionStrategy;\n _scrollStrategy;\n _locationChanges = Subscription.EMPTY;\n _cleanupBackdropClick;\n _cleanupBackdropTransitionEnd;\n /**\n * Reference to the parent of the `_host` at the time it was detached. Used to restore\n * the `_host` to its original position in the DOM when it gets re-attached.\n */\n _previousHostParent;\n /** Stream of keydown events dispatched to this overlay. */\n _keydownEvents = /*#__PURE__*/new Subject();\n /** Stream of mouse outside events dispatched to this overlay. */\n _outsidePointerEvents = /*#__PURE__*/new Subject();\n _renders = /*#__PURE__*/new Subject();\n _afterRenderRef;\n /** Reference to the currently-running `afterNextRender` call. */\n _afterNextRenderRef;\n constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location, _outsideClickDispatcher, _animationsDisabled = false, _injector, _renderer) {\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._injector = _injector;\n this._renderer = _renderer;\n if (_config.scrollStrategy) {\n this._scrollStrategy = _config.scrollStrategy;\n this._scrollStrategy.attach(this);\n }\n this._positionStrategy = _config.positionStrategy;\n // Users could open the overlay from an `effect`, in which case we need to\n // run the `afterRender` as `untracked`. We don't recommend that users do\n // this, but we also don't want to break users who are doing it.\n this._afterRenderRef = untracked(() => afterRender(() => {\n this._renders.next();\n }, {\n injector: this._injector\n }));\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 // We need to clean this up ourselves, because we're passing in an\n // `EnvironmentInjector` below which won't ever be destroyed.\n // Otherwise it causes some callbacks to be retained (see #29696).\n this._afterNextRenderRef?.destroy();\n // Update the position once the overlay is fully rendered before attempting to position it,\n // as the position may depend on the size of the rendered content.\n this._afterNextRenderRef = afterNextRender(() => {\n // The overlay could've been detached before the callback executed.\n if (this.hasAttached()) {\n this.updatePosition();\n }\n }, {\n injector: this._injector\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._detachContentWhenEmpty();\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._afterNextRenderRef?.destroy();\n this._previousHostParent = this._pane = this._host = null;\n if (isAttached) {\n this._detachments.next();\n }\n this._detachments.complete();\n this._afterRenderRef.destroy();\n this._renders.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 = {\n ...this._config,\n ...sizeConfig\n };\n this._updateElementSize();\n }\n /** Sets the LTR/RTL direction for the overlay. */\n setDirection(dir) {\n this._config = {\n ...this._config,\n direction: dir\n };\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._cleanupBackdropClick?.();\n this._cleanupBackdropClick = this._renderer.listen(this._backdropElement, 'click', event => this._backdropClick.next(event));\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 } 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 this._cleanupBackdropTransitionEnd?.();\n this._cleanupBackdropTransitionEnd = this._renderer.listen(backdropToDetach, 'transitionend', event => {\n this._disposeBackdrop(event.target);\n });\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 _detachContentWhenEmpty() {\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._renders.pipe(takeUntil(merge(this._attachments, this._detachments))).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 this._cleanupBackdropClick?.();\n this._cleanupBackdropTransitionEnd?.();\n if (backdrop) {\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 _viewportRuler;\n _document;\n _platform;\n _overlayContainer;\n /** The overlay to which this strategy is attached. */\n _overlayRef;\n /** Whether we're performing the very first positioning of the overlay. */\n _isInitialRender;\n /** Last size used for the bounding box. Used to avoid resizing the overlay after open. */\n _lastBoundingBoxSize = {\n width: 0,\n height: 0\n };\n /** Whether the overlay was pushed in a previous positioning. */\n _isPushed = false;\n /** Whether the overlay can be pushed on-screen on the initial open. */\n _canPush = true;\n /** Whether the overlay can grow via flexible width/height after the initial open. */\n _growAfterOpen = false;\n /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n _hasFlexibleDimensions = true;\n /** Whether the overlay position is locked. */\n _positionLocked = false;\n /** Cached origin dimensions */\n _originRect;\n /** Cached overlay dimensions */\n _overlayRect;\n /** Cached viewport dimensions */\n _viewportRect;\n /** Cached container dimensions */\n _containerRect;\n /** Amount of space that must be maintained between the overlay and the edge of the viewport. */\n _viewportMargin = 0;\n /** The Scrollable containers used to check scrollable view properties on position change. */\n _scrollables = [];\n /** Ordered list of preferred positions, from most to least desirable. */\n _preferredPositions = [];\n /** The origin element against which the overlay will be positioned. */\n _origin;\n /** The overlay pane element. */\n _pane;\n /** Whether the strategy has been disposed of already. */\n _isDisposed;\n /**\n * Parent element for the overlay panel used to constrain the overlay panel's size to fit\n * within the viewport.\n */\n _boundingBox;\n /** The last position to have been calculated as the best fit position. */\n _lastPosition;\n /** The last calculated scroll visibility. Only tracked */\n _lastScrollVisibility;\n /** Subject that emits whenever the position changes. */\n _positionChanges = /*#__PURE__*/new Subject();\n /** Subscription to viewport size changes. */\n _resizeSubscription = Subscription.EMPTY;\n /** Default offset for the overlay along the x axis. */\n _offsetX = 0;\n /** Default offset for the overlay along the y axis. */\n _offsetY = 0;\n /** Selector to be used when finding the elements on which to set the transform origin. */\n _transformOriginSelector;\n /** Keeps track of the CSS classes that the position strategy has applied on the overlay panel. */\n _appliedPanelClasses = [];\n /** Amount by which the overlay was pushed in each axis during the last time it was positioned. */\n _previousPushAmount;\n /** Observable sequence of position changes. */\n positionChanges = this._positionChanges;\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 this.setOrigin(connectedTo);\n }\n /** Attaches this position strategy to an overlay. */\n attach(overlayRef) {\n if (this._overlayRef && overlayRef !== this._overlayRef && (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 = {\n overlayFit,\n overlayPoint,\n originPoint,\n position: pos,\n overlayRect\n };\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 } 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 } 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 } 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 {\n x,\n y\n };\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 } else if (pos.overlayX === 'start') {\n overlayStartX = this._isRtl() ? -overlayRect.width : 0;\n } else {\n overlayStartX = this._isRtl() ? 0 : -overlayRect.width;\n }\n let overlayStartY;\n if (pos.overlayY == 'center') {\n overlayStartY = -overlayRect.height / 2;\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 {\n x,\n y\n } = 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 } 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 } else {\n pushY = start.y < this._viewportMargin ? viewport.top - scrollPosition.top - start.y : 0;\n }\n this._previousPushAmount = {\n x: pushX,\n y: pushY\n };\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 // 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 scrollVisibility = this._getScrollVisibility();\n // We're recalculating on scroll, but we only want to emit if anything\n // changed since downstream code might be hitting the `NgZone`.\n if (position !== this._lastPosition || !this._lastScrollVisibility || !compareScrollVisibility(this._lastScrollVisibility, scrollVisibility)) {\n const changeEvent = new ConnectedOverlayPositionChange(position, scrollVisibility);\n this._positionChanges.next(changeEvent);\n }\n this._lastScrollVisibility = scrollVisibility;\n }\n // Save the last connected position in case the position needs to be re-calculated.\n this._lastPosition = position;\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 } else if (this._isRtl()) {\n xOrigin = position.overlayX === 'start' ? 'right' : 'left';\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 } 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 } 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 * 2;\n width = origin.x - this._viewportMargin;\n } else if (isBoundedByRightViewportEdge) {\n left = origin.x;\n width = viewport.right - origin.x;\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 {\n top: top,\n left: left,\n bottom: bottom,\n right: right,\n width,\n height\n };\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 } 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 } else {\n styles.alignItems = position.overlayX === 'end' ? 'flex-end' : 'flex-start';\n }\n if (position.overlayY === 'center') {\n styles.justifyContent = 'center';\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 } 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 } else if (hasFlexibleDimensions) {\n styles.maxHeight = '';\n }\n }\n if (config.maxWidth) {\n if (hasExactPosition) {\n styles.maxWidth = coerceCssPixelValue(config.maxWidth);\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 = {\n top: '',\n bottom: ''\n };\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 } 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 = {\n left: '',\n right: ''\n };\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 } 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 } 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}\n/** Returns whether two `ScrollingVisibility` objects are identical. */\nfunction compareScrollVisibility(a, b) {\n if (a === b) {\n return true;\n }\n return a.isOriginClipped === b.isOriginClipped && a.isOriginOutsideView === b.isOriginOutsideView && a.isOverlayClipped === b.isOverlayClipped && a.isOverlayOutsideView === b.isOverlayOutsideView;\n}\nconst STANDARD_DROPDOWN_BELOW_POSITIONS = [{\n originX: 'start',\n originY: 'bottom',\n overlayX: 'start',\n overlayY: 'top'\n}, {\n originX: 'start',\n originY: 'top',\n overlayX: 'start',\n overlayY: 'bottom'\n}, {\n originX: 'end',\n originY: 'bottom',\n overlayX: 'end',\n overlayY: 'top'\n}, {\n originX: 'end',\n originY: 'top',\n overlayX: 'end',\n overlayY: 'bottom'\n}];\nconst STANDARD_DROPDOWN_ADJACENT_POSITIONS = [{\n originX: 'end',\n originY: 'top',\n overlayX: 'start',\n overlayY: 'top'\n}, {\n originX: 'end',\n originY: 'bottom',\n overlayX: 'start',\n overlayY: 'bottom'\n}, {\n originX: 'start',\n originY: 'top',\n overlayX: 'end',\n overlayY: 'top'\n}, {\n originX: 'start',\n originY: 'bottom',\n overlayX: 'end',\n 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 /** The overlay to which this strategy is attached. */\n _overlayRef;\n _cssPosition = 'static';\n _topOffset = '';\n _bottomOffset = '';\n _alignItems = '';\n _xPosition = '';\n _xOffset = '';\n _width = '';\n _height = '';\n _isDisposed = false;\n attach(overlayRef) {\n const config = overlayRef.getConfig();\n this._overlayRef = overlayRef;\n if (this._width && !config.width) {\n overlayRef.updateSize({\n width: this._width\n });\n }\n if (this._height && !config.height) {\n overlayRef.updateSize({\n height: this._height\n });\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({\n 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({\n 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 {\n width,\n height,\n maxWidth,\n maxHeight\n } = config;\n const shouldBeFlushHorizontally = (width === '100%' || width === '100vw') && (!maxWidth || maxWidth === '100%' || maxWidth === '100vw');\n const shouldBeFlushVertically = (height === '100%' || height === '100vh') && (!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 } else if (xPosition === 'center') {\n justifyContent = 'center';\n if (isRtl) {\n marginRight = xOffset;\n } else {\n marginLeft = xOffset;\n }\n } else if (isRtl) {\n if (xPosition === 'left' || xPosition === 'end') {\n justifyContent = 'flex-end';\n marginLeft = xOffset;\n } else if (xPosition === 'right' || xPosition === 'start') {\n justifyContent = 'flex-start';\n marginRight = xOffset;\n }\n } else if (xPosition === 'left' || xPosition === 'start') {\n justifyContent = 'flex-start';\n marginLeft = xOffset;\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 = parentStyles.alignItems = styles.marginTop = styles.marginBottom = styles.marginLeft = styles.marginRight = styles.position = '';\n this._overlayRef = null;\n this._isDisposed = true;\n }\n}\n\n/** Builder for overlay position strategy. */\nlet OverlayPositionBuilder = /*#__PURE__*/(() => {\n class OverlayPositionBuilder {\n _viewportRuler = inject(ViewportRuler);\n _document = inject(DOCUMENT);\n _platform = inject(Platform);\n _overlayContainer = inject(OverlayContainer);\n constructor() {}\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 傻fac = function OverlayPositionBuilder_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || OverlayPositionBuilder)();\n };\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: OverlayPositionBuilder,\n factory: OverlayPositionBuilder.傻fac,\n providedIn: 'root'\n });\n }\n return OverlayPositionBuilder;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\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 */\nlet Overlay = /*#__PURE__*/(() => {\n class Overlay {\n scrollStrategies = inject(ScrollStrategyOptions);\n _overlayContainer = inject(OverlayContainer);\n _positionBuilder = inject(OverlayPositionBuilder);\n _keyboardDispatcher = inject(OverlayKeyboardDispatcher);\n _injector = inject(Injector);\n _ngZone = inject(NgZone);\n _document = inject(DOCUMENT);\n _directionality = inject(Directionality);\n _location = inject(Location);\n _outsideClickDispatcher = inject(OverlayOutsideClickDispatcher);\n _animationsModuleType = inject(ANIMATION_MODULE_TYPE, {\n optional: true\n });\n _idGenerator = inject(_IdGenerator);\n _renderer = inject(RendererFactory2).createRenderer(null, null);\n _appRef;\n _styleLoader = inject(_CdkPrivateStyleLoader);\n constructor() {}\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 // This is done in the overlay container as well, but we have it here\n // since it's common to mock out the overlay container in tests.\n this._styleLoader.load(_CdkOverlayStyleLoader);\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', this._injector.get(EnvironmentInjector), this._renderer);\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 = this._idGenerator.getId('cdk-overlay-');\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, null, this._appRef, this._injector, this._document);\n }\n static 傻fac = function Overlay_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || Overlay)();\n };\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: Overlay,\n factory: Overlay.傻fac,\n providedIn: 'root'\n });\n }\n return Overlay;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/** Default set of positions for the overlay. Follows the behavior of a dropdown. */\nconst defaultPositionList = [{\n originX: 'start',\n originY: 'bottom',\n overlayX: 'start',\n overlayY: 'top'\n}, {\n originX: 'start',\n originY: 'top',\n overlayX: 'start',\n overlayY: 'bottom'\n}, {\n originX: 'end',\n originY: 'top',\n overlayX: 'end',\n overlayY: 'bottom'\n}, {\n originX: 'end',\n originY: 'bottom',\n overlayX: 'end',\n overlayY: 'top'\n}];\n/** Injection token that determines the scroll handling while the connected overlay is open. */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = /*#__PURE__*/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 */\nlet CdkOverlayOrigin = /*#__PURE__*/(() => {\n class CdkOverlayOrigin {\n elementRef = inject(ElementRef);\n constructor() {}\n static 傻fac = function CdkOverlayOrigin_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || CdkOverlayOrigin)();\n };\n static 傻dir = /* @__PURE__ */i0.傻傻defineDirective({\n type: CdkOverlayOrigin,\n selectors: [[\"\", \"cdk-overlay-origin\", \"\"], [\"\", \"overlay-origin\", \"\"], [\"\", \"cdkOverlayOrigin\", \"\"]],\n exportAs: [\"cdkOverlayOrigin\"]\n });\n }\n return CdkOverlayOrigin;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\nlet CdkConnectedOverlay = /*#__PURE__*/(() => {\n class CdkConnectedOverlay {\n _overlay = inject(Overlay);\n _dir = inject(Directionality, {\n optional: true\n });\n _overlayRef;\n _templatePortal;\n _backdropSubscription = Subscription.EMPTY;\n _attachSubscription = Subscription.EMPTY;\n _detachSubscription = Subscription.EMPTY;\n _positionSubscription = Subscription.EMPTY;\n _offsetX;\n _offsetY;\n _position;\n _scrollStrategyFactory = inject(CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY);\n _disposeOnNavigation = false;\n _ngZone = inject(NgZone);\n /** Origin for the connected overlay. */\n origin;\n /** Registered connected position pairs. */\n positions;\n /**\n * This input overrides the positions input if specified. It lets users pass\n * in arbitrary positioning strategies.\n */\n positionStrategy;\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 /** The width of the overlay panel. */\n width;\n /** The height of the overlay panel. */\n height;\n /** The min width of the overlay panel. */\n minWidth;\n /** The min height of the overlay panel. */\n minHeight;\n /** The custom class to be set on the backdrop element. */\n backdropClass;\n /** The custom class to add to the overlay pane element. */\n panelClass;\n /** Margin between the overlay and the viewport edges. */\n viewportMargin = 0;\n /** Strategy to be used when handling scroll events while the overlay is open. */\n scrollStrategy;\n /** Whether the overlay is open. */\n open = false;\n /** Whether the overlay can be closed by user interaction. */\n disableClose = false;\n /** CSS selector which to set the transform origin. */\n transformOriginSelector;\n /** Whether or not the overlay should attach a backdrop. */\n hasBackdrop = false;\n /** Whether or not the overlay should be locked when scrolling. */\n lockPosition = false;\n /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n flexibleDimensions = false;\n /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n growAfterOpen = false;\n /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n push = false;\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 /** Event emitted when the backdrop is clicked. */\n backdropClick = new EventEmitter();\n /** Event emitted when the position has changed. */\n positionChange = new EventEmitter();\n /** Event emitted when the overlay has been attached. */\n attach = new EventEmitter();\n /** Event emitted when the overlay has been detached. */\n detach = new EventEmitter();\n /** Emits when there are keyboard events that are targeted at the overlay. */\n overlayKeydown = new EventEmitter();\n /** Emits when there are mouse outside click events that are targeted at the overlay. */\n overlayOutsideClick = new EventEmitter();\n // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.\n constructor() {\n const templateRef = inject(TemplateRef);\n const viewContainerRef = inject(ViewContainerRef);\n this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\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 const origin = this._getOriginElement();\n const target = _getEventTarget(event);\n if (!origin || origin !== target && !origin.contains(target)) {\n this.overlayOutsideClick.next(event);\n }\n });\n }\n /** Builds the overlay config based on the directive's inputs */\n _buildConfig() {\n const positionStrategy = this._position = this.positionStrategy || this._createPositionStrategy();\n const overlayConfig = new OverlayConfig({\n direction: this._dir || 'ltr',\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.setOrigin(this._getOrigin()).withPositions(positions).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).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.position().flexibleConnectedTo(this._getOrigin());\n this._updatePositionStrategy(strategy);\n return strategy;\n }\n _getOrigin() {\n if (this.origin instanceof CdkOverlayOrigin) {\n return this.origin.elementRef;\n } else {\n return this.origin;\n }\n }\n _getOriginElement() {\n if (this.origin instanceof CdkOverlayOrigin) {\n return this.origin.elementRef.nativeElement;\n }\n if (this.origin instanceof ElementRef) {\n return this.origin.nativeElement;\n }\n if (typeof Element !== 'undefined' && this.origin instanceof Element) {\n return this.origin;\n }\n return null;\n }\n /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */\n _attachOverlay() {\n if (!this._overlayRef) {\n this._createOverlay();\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 } 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.pipe(takeWhile(() => this.positionChange.observers.length > 0)).subscribe(position => {\n this._ngZone.run(() => 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 傻fac = function CdkConnectedOverlay_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || CdkConnectedOverlay)();\n };\n static 傻dir = /* @__PURE__ */i0.傻傻defineDirective({\n type: CdkConnectedOverlay,\n selectors: [[\"\", \"cdk-connected-overlay\", \"\"], [\"\", \"connected-overlay\", \"\"], [\"\", \"cdkConnectedOverlay\", \"\"]],\n inputs: {\n origin: [0, \"cdkConnectedOverlayOrigin\", \"origin\"],\n positions: [0, \"cdkConnectedOverlayPositions\", \"positions\"],\n positionStrategy: [0, \"cdkConnectedOverlayPositionStrategy\", \"positionStrategy\"],\n offsetX: [0, \"cdkConnectedOverlayOffsetX\", \"offsetX\"],\n offsetY: [0, \"cdkConnectedOverlayOffsetY\", \"offsetY\"],\n width: [0, \"cdkConnectedOverlayWidth\", \"width\"],\n height: [0, \"cdkConnectedOverlayHeight\", \"height\"],\n minWidth: [0, \"cdkConnectedOverlayMinWidth\", \"minWidth\"],\n minHeight: [0, \"cdkConnectedOverlayMinHeight\", \"minHeight\"],\n backdropClass: [0, \"cdkConnectedOverlayBackdropClass\", \"backdropClass\"],\n panelClass: [0, \"cdkConnectedOverlayPanelClass\", \"panelClass\"],\n viewportMargin: [0, \"cdkConnectedOverlayViewportMargin\", \"viewportMargin\"],\n scrollStrategy: [0, \"cdkConnectedOverlayScrollStrategy\", \"scrollStrategy\"],\n open: [0, \"cdkConnectedOverlayOpen\", \"open\"],\n disableClose: [0, \"cdkConnectedOverlayDisableClose\", \"disableClose\"],\n transformOriginSelector: [0, \"cdkConnectedOverlayTransformOriginOn\", \"transformOriginSelector\"],\n hasBackdrop: [2, \"cdkConnectedOverlayHasBackdrop\", \"hasBackdrop\", booleanAttribute],\n lockPosition: [2, \"cdkConnectedOverlayLockPosition\", \"lockPosition\", booleanAttribute],\n flexibleDimensions: [2, \"cdkConnectedOverlayFlexibleDimensions\", \"flexibleDimensions\", booleanAttribute],\n growAfterOpen: [2, \"cdkConnectedOverlayGrowAfterOpen\", \"growAfterOpen\", booleanAttribute],\n push: [2, \"cdkConnectedOverlayPush\", \"push\", booleanAttribute],\n disposeOnNavigation: [2, \"cdkConnectedOverlayDisposeOnNavigation\", \"disposeOnNavigation\", booleanAttribute]\n },\n outputs: {\n backdropClick: \"backdropClick\",\n positionChange: \"positionChange\",\n attach: \"attach\",\n detach: \"detach\",\n overlayKeydown: \"overlayKeydown\",\n overlayOutsideClick: \"overlayOutsideClick\"\n },\n exportAs: [\"cdkConnectedOverlay\"],\n features: [i0.傻傻InputTransformsFeature, i0.傻傻NgOnChangesFeature]\n });\n }\n return CdkConnectedOverlay;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\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};\nlet OverlayModule = /*#__PURE__*/(() => {\n class OverlayModule {\n static 傻fac = function OverlayModule_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || OverlayModule)();\n };\n static 傻mod = /* @__PURE__ */i0.傻傻defineNgModule({\n type: OverlayModule\n });\n static 傻inj = /* @__PURE__ */i0.傻傻defineInjector({\n providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER],\n imports: [BidiModule, PortalModule, ScrollingModule, ScrollingModule]\n });\n }\n return OverlayModule;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\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 */\nlet FullscreenOverlayContainer = /*#__PURE__*/(() => {\n class FullscreenOverlayContainer extends OverlayContainer {\n _renderer = inject(RendererFactory2).createRenderer(null, null);\n _fullScreenEventName;\n _cleanupFullScreenListener;\n constructor() {\n super();\n }\n ngOnDestroy() {\n super.ngOnDestroy();\n this._cleanupFullScreenListener?.();\n }\n _createContainer() {\n const eventName = this._getEventName();\n super._createContainer();\n this._adjustParentForFullscreenChange();\n if (eventName) {\n this._cleanupFullScreenListener?.();\n this._cleanupFullScreenListener = this._renderer.listen('document', eventName, () => {\n this._adjustParentForFullscreenChange();\n });\n }\n }\n _adjustParentForFullscreenChange() {\n if (this._containerElement) {\n const fullscreenElement = this.getFullscreenElement();\n const parent = fullscreenElement || this._document.body;\n parent.appendChild(this._containerElement);\n }\n }\n _getEventName() {\n if (!this._fullScreenEventName) {\n const _document = this._document;\n if (_document.fullscreenEnabled) {\n this._fullScreenEventName = 'fullscreenchange';\n } else if (_document.webkitFullscreenEnabled) {\n this._fullScreenEventName = 'webkitfullscreenchange';\n } else if (_document.mozFullScreenEnabled) {\n this._fullScreenEventName = 'mozfullscreenchange';\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 || _document.webkitFullscreenElement || _document.mozFullScreenElement || _document.msFullscreenElement || null;\n }\n static 傻fac = function FullscreenOverlayContainer_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || FullscreenOverlayContainer)();\n };\n static 傻prov = /* @__PURE__ */i0.傻傻defineInjectable({\n token: FullscreenOverlayContainer,\n factory: FullscreenOverlayContainer.傻fac,\n providedIn: 'root'\n });\n }\n return FullscreenOverlayContainer;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\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"],"mappings":"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","names":["scrollBehaviorSupported","supportsScrollBehavior","BlockScrollStrategy","_viewportRuler","document","root","coerceCssPixelValue","html","body","htmlStyle","bodyStyle","previousHtmlScrollBehavior","previousBodyScrollBehavior","viewport","CloseScrollStrategy","_scrollDispatcher","_ngZone","_viewportRuler","_config","overlayRef","stream","filter","scrollable","scrollPosition","NoopScrollStrategy","isElementScrolledOutsideView","element","scrollContainers","containerBounds","outsideAbove","outsideBelow","outsideLeft","outsideRight","isElementClippedByScrolling","scrollContainerRect","clippedAbove","clippedBelow","clippedLeft","clippedRight","RepositionScrollStrategy","throttle","overlayRect","width","height","ScrollStrategyOptions","inject","ScrollDispatcher","ViewportRuler","NgZone","DOCUMENT","config","BlockScrollStrategy","__ngFactoryType__","傻傻defineInjectable","OverlayConfig","configKeys","key","ConnectedOverlayPositionChange","connectionPair","scrollableViewProperties","BaseOverlayDispatcher","inject","DOCUMENT","overlayRef","index","__ngFactoryType__","傻傻defineInjectable","OverlayKeyboardDispatcher","NgZone","RendererFactory2","event","overlays","i","傻OverlayKeyboardDispatcher_BaseFactory","傻傻getInheritedFactory","OverlayOutsideClickDispatcher","Platform","body","_getEventTarget","target","origin","containsPierceShadowDom","outsidePointerEvents","傻OverlayOutsideClickDispatcher_BaseFactory","parent","child","supportsShadowRoot","current","_CdkOverlayStyleLoader","傻傻defineComponent","rf","ctx","OverlayContainer","_CdkPrivateStyleLoader","containerClass","_isTestEnvironment","oppositePlatformContainers","container","OverlayRef","Subject","Subscription","_portalOutlet","_host","_pane","_config","_ngZone","_keyboardDispatcher","_document","_location","_outsideClickDispatcher","_animationsDisabled","_injector","_renderer","untracked","afterRender","portal","attachResult","afterNextRender","detachmentResult","isAttached","strategy","sizeConfig","__spreadValues","dir","__spreadProps","classes","direction","style","coerceCssPixelValue","enablePointer","showingClass","backdropToDetach","element","cssClasses","isAdd","coerceArray","c","subscription","takeUntil","merge","scrollStrategy","backdrop","boundingBoxClass","cssUnitPattern","FlexibleConnectedPositionStrategy","connectedTo","_viewportRuler","_platform","_overlayContainer","originRect","overlayRect","viewportRect","containerRect","flexibleFits","fallback","pos","originPoint","overlayPoint","overlayFit","bestFit","bestScore","fit","score","extendStyles","lastPosition","scrollables","positions","margin","flexibleDimensions","growAfterOpen","canPush","isLocked","offset","selector","x","startX","endX","y","overlayStartX","overlayStartY","point","rawOverlayRect","viewport","position","overlay","getRoundedBoundingClientRect","offsetX","offsetY","leftOverflow","rightOverflow","topOverflow","bottomOverflow","visibleWidth","visibleHeight","visibleArea","availableHeight","availableWidth","minHeight","getPixelValue","minWidth","verticalFit","horizontalFit","start","scrollPosition","overflowRight","overflowBottom","overflowTop","overflowLeft","pushX","pushY","scrollVisibility","compareScrollVisibility","changeEvent","ConnectedOverlayPositionChange","elements","xOrigin","yOrigin","isRtl","height","top","bottom","smallestDistanceToViewportEdge","previousHeight","isBoundedByRightViewportEdge","isBoundedByLeftViewportEdge","width","left","right","previousWidth","boundingBoxRect","styles","maxHeight","maxWidth","hasExactPosition","hasFlexibleDimensions","config","transformString","documentHeight","horizontalStyleProperty","documentWidth","originBounds","overlayBounds","scrollContainerBounds","scrollable","isElementClippedByScrolling","isElementScrolledOutsideView","length","overflows","currentValue","currentOverflow","axis","cssClass","ElementRef","destination","source","key","input","value","units","clientRect","a","b","wrapperClass","GlobalPositionStrategy","overlayRef","config","value","offset","styles","parentStyles","width","height","maxWidth","maxHeight","shouldBeFlushHorizontally","shouldBeFlushVertically","xPosition","xOffset","isRtl","marginLeft","marginRight","justifyContent","parent","OverlayPositionBuilder","inject","ViewportRuler","DOCUMENT","Platform","OverlayContainer","origin","FlexibleConnectedPositionStrategy","__ngFactoryType__","傻傻defineInjectable","Overlay","ScrollStrategyOptions","OverlayKeyboardDispatcher","Injector","NgZone","Directionality","Location","OverlayOutsideClickDispatcher","ANIMATION_MODULE_TYPE","_IdGenerator","RendererFactory2","_CdkPrivateStyleLoader","_CdkOverlayStyleLoader","host","pane","portalOutlet","overlayConfig","OverlayConfig","OverlayRef","EnvironmentInjector","ApplicationRef","DomPortalOutlet","defaultPositionList","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY","InjectionToken","overlay","CdkOverlayOrigin","ElementRef","傻傻defineDirective","CdkConnectedOverlay","Subscription","offsetX","offsetY","EventEmitter","templateRef","TemplateRef","viewContainerRef","ViewContainerRef","TemplatePortal","changes","event","hasModifierKey","target","_getEventTarget","positionStrategy","positions","currentPosition","strategy","takeWhile","position","booleanAttribute","傻傻InputTransformsFeature","傻傻NgOnChangesFeature","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER","OverlayModule","傻傻defineNgModule","傻傻defineInjector","BidiModule","PortalModule","ScrollingModule"],"x_google_ignoreList":[0]}