default-src_app_custom-elements_code_code_component_ts-src_app_custom-elements_code_code_module_ts-es5.b38066bf54d633ed7580.js.map

{"version":3,"sources":["webpack:///node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/portal.js","webpack:///node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/overlay.js","webpack:///node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/layout.js","webpack:///node_modules/rxjs/_esm2015/internal/operators/skip.js","webpack:///node_modules/@angular/material/__ivy_ngcc__/fesm2015/snack-bar.js","webpack:///node_modules/@angular/cdk/__ivy_ngcc__/fesm2015/clipboard.js","webpack:///src/app/custom-elements/code/code.component.ts","webpack:///src/app/custom-elements/code/code.module.ts","webpack:///src/app/custom-elements/code/pretty-printer.service.ts"],"names":["Portal","host","this","_attachedHost","attach","detach","ComponentPortal","component","viewContainerRef","injector","componentFactoryResolver","super","TemplatePortal","template","context","templateRef","elementRef","DomPortal","element","nativeElement","BasePortalOutlet","_isDisposed","attachDomPortal","_attachedPortal","portal","attachComponentPortal","attachTemplatePortal","setAttachedHost","_invokeDisposeFn","hasAttached","fn","_disposeFn","DomPortalOutlet","outletElement","_componentFactoryResolver","_appRef","_defaultInjector","_document","anchorNode","createComment","parentNode","insertBefore","appendChild","replaceChild","componentRef","componentFactory","resolveComponentFactory","createComponent","length","setDisposeFn","destroy","create","attachView","hostView","detachView","_getComponentRootNode","viewContainer","viewRef","createEmbeddedView","rootNodes","forEach","rootNode","detectChanges","index","indexOf","remove","removeChild","CdkPortal","ɵfac","t","ɵdir","type","selectors","exportAs","features","CdkPortalOutlet","_viewContainerRef","_isInitialized","attached","_getRootNode","_attachedRef","ref","emit","clear","nodeType","ELEMENT_NODE","inputs","outputs","PortalModule","ɵmod","ɵinj","scrollBehaviorSupported","BlockScrollStrategy","_viewportRuler","document","_previousHTMLStyles","top","left","_isEnabled","_canBeEnabled","root","documentElement","_previousScrollPosition","getViewportScrollPosition","style","classList","add","html","htmlStyle","bodyStyle","body","previousHtmlScrollBehavior","scrollBehavior","previousBodyScrollBehavior","window","scroll","contains","viewport","getViewportSize","scrollHeight","height","scrollWidth","width","CloseScrollStrategy","_scrollDispatcher","_ngZone","_config","_scrollSubscription","_detach","disable","_overlayRef","run","overlayRef","stream","scrolled","threshold","_initialScrollPosition","subscribe","scrollPosition","Math","abs","updatePosition","unsubscribe","NoopScrollStrategy","isElementScrolledOutsideView","scrollContainers","some","containerBounds","bottom","right","isElementClippedByScrolling","scrollContainerRect","RepositionScrollStrategy","scrollThrottle","autoClose","overlayRect","overlayElement","getBoundingClientRect","ScrollStrategyOptions","noop","close","config","block","reposition","ɵprov","factory","token","providedIn","OverlayConfig","scrollStrategy","panelClass","hasBackdrop","backdropClass","disposeOnNavigation","Object","keys","key","ConnectionPositionPair","origin","overlay","offsetX","offsetY","originX","originY","overlayX","overlayY","ConnectedOverlayPositionChange","connectionPair","scrollableViewProperties","BaseOverlayDispatcher","_attachedOverlays","push","splice","OverlayKeyboardDispatcher","_keydownListener","event","overlays","i","_keydownEvents","observers","next","_isAttached","addEventListener","removeEventListener","OverlayOutsideClickDispatcher","_platform","_cursorStyleIsSet","_clickListener","target","composedPath","slice","_outsidePointerEvents","IOS","_cursorOriginalValue","cursor","isTestEnvironment","__karma__","jasmine","OverlayContainer","container","_containerElement","_createContainer","isBrowser","oppositePlatformContainers","querySelectorAll","createElement","setAttribute","OverlayRef","_portalOutlet","_host","_pane","_keyboardDispatcher","_location","_outsideClickDispatcher","_backdropElement","_backdropClick","Subject","_attachments","_detachments","_locationChanges","Subscription","_backdropClickHandler","_scrollStrategy","_positionStrategy","positionStrategy","attachResult","parentElement","_previousHostParent","_updateStackingOrder","_updateElementSize","_updateElementDirection","enable","onStable","pipe","take","_togglePointerEvents","_attachBackdrop","_toggleClasses","dispose","detachBackdrop","detachmentResult","_detachContentWhenStable","isAttached","_disposeScrollStrategy","complete","apply","strategy","sizeConfig","assign","dir","direction","classes","value","getDirection","minWidth","minHeight","maxWidth","maxHeight","enablePointer","pointerEvents","requestAnimationFrame","runOutsideAngular","nextSibling","timeoutId","backdropToDetach","finishDetach","clearTimeout","setTimeout","cssClasses","isAdd","cssClass","subscription","takeUntil","merge","children","cssUnitPattern","FlexibleConnectedPositionStrategy","connectedTo","_overlayContainer","_lastBoundingBoxSize","_isPushed","_canPush","_growAfterOpen","_hasFlexibleDimensions","_positionLocked","_viewportMargin","_scrollables","_preferredPositions","_positionChanges","_resizeSubscription","_offsetX","_offsetY","_appliedPanelClasses","positionChanges","setOrigin","_validatePositions","hostElement","_boundingBox","_isInitialRender","_lastPosition","change","reapplyLastPosition","_clearPanelClasses","_resetOverlayElementStyles","_resetBoundingBoxStyles","_viewportRect","_getNarrowedViewportRect","_originRect","_getOriginRect","_overlayRect","fallback","originRect","viewportRect","flexibleFits","pos","originPoint","_getOriginPoint","overlayPoint","_getOverlayPoint","overlayFit","_getOverlayFit","isCompletelyWithinViewport","_applyPosition","_canFitWithFlexibleDimensions","position","boundingBoxRect","_calculateBoundingBoxRect","visibleArea","bestFit","bestScore","fit","score","weight","_previousPushAmount","extendStyles","alignItems","justifyContent","lastPosition","scrollables","positions","margin","flexibleDimensions","growAfterOpen","canPush","isLocked","_origin","offset","selector","_transformOriginSelector","x","startX","_isRtl","endX","y","overlayStartX","overlayStartY","point","rawOverlayRect","getRoundedBoundingClientRect","_getOffset","topOverflow","bottomOverflow","visibleWidth","_subtractOverflows","visibleHeight","fitsInViewportVertically","fitsInViewportHorizontally","availableHeight","availableWidth","getPixelValue","getConfig","horizontalFit","start","pushX","pushY","overflowRight","max","overflowBottom","overflowTop","overflowLeft","_setTransformOrigin","_setOverlayElementStyles","_setBoundingBoxStyles","_addPanelClasses","_getScrollVisibility","changeEvent","xOrigin","elements","yOrigin","transformOrigin","isRtl","smallestDistanceToViewportEdge","min","previousHeight","previousWidth","styles","_hasExactPosition","transform","hasExactPosition","hasFlexibleDimensions","_getExactOverlayY","_getExactOverlayX","transformString","trim","_pushOverlayOnScreen","virtualKeyboardOffset","getContainerElement","clientHeight","clientWidth","originBounds","overlayBounds","scrollContainerBounds","map","scrollable","getElementRef","isOriginClipped","isOriginOutsideView","isOverlayClipped","isOverlayOutsideView","overflows","reduce","currentValue","currentOverflow","axis","Element","destination","source","hasOwnProperty","input","split","units","parseFloat","clientRect","floor","mediaQueryStyleNode","ConnectedPositionStrategy","originPos","overlayPos","viewportRuler","platform","overlayContainer","withFlexibleDimensions","withPush","withViewportMargin","withFallbackPosition","onPositionChange","_direction","setDirection","withScrollableContainers","withPositions","withDefaultOffsetX","withDefaultOffsetY","withLockedPosition","GlobalPositionStrategy","_cssPosition","_topOffset","_bottomOffset","_leftOffset","_rightOffset","_alignItems","_justifyContent","_width","_height","updateSize","parentStyles","shouldBeFlushHorizontally","shouldBeFlushVertically","marginLeft","marginTop","marginBottom","marginRight","parent","OverlayPositionBuilder","nextUniqueId","Overlay","scrollStrategies","_positionBuilder","_injector","_directionality","_createHostElement","pane","_createPaneElement","portalOutlet","_createPortalOutlet","overlayConfig","id","get","CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER","provide","deps","useFactory","OverlayModule","providers","imports","SkipOperator","total","subscriber","SkipSubscriber","count","Subscriber","mediaQueriesForWebkitCompatibility","Set","MediaMatcher","_matchMedia","matchMedia","bind","noopMatchMedia","query","WEBKIT","has","head","sheet","insertRule","e","console","error","matches","media","addListener","removeListener","BreakpointObserver","_mediaMatcher","_zone","_queries","Map","_destroySubject","splitQueries","mediaQuery","_registerQuery","mql","observables","observable","stateObservable","combineLatest","concat","lift","debounceTime","breakpointStates","response","breakpoints","output","Observable","observer","handler","startWith","set","queries","a1","a2","SimpleSnackBar_div_2_Template","rf","ctx","_r2","action","ctx_r0","data","MatSnackBarContainer_ng_template_1_Template","MAT_SNACK_BAR_DATA","MatSnackBarConfig","politeness","announcementMessage","duration","horizontalPosition","verticalPosition","MAX_TIMEOUT","pow","MatSnackBarRef","containerInstance","_afterDismissed","_afterOpened","_onAction","_dismissedByAction","onAction","dismiss","_onExit","_finishDismiss","closed","exit","_durationTimeoutId","dismissWithAction","dismissedByAction","_onEnter","SimpleSnackBar","snackBarRef","ɵcmp","hostAttrs","decls","vars","consts","message","hasAction","directives","encapsulation","changeDetection","matSnackBarAnimations","snackBarState","opacity","MatSnackBarContainer","_elementRef","_changeDetectorRef","snackBarConfig","_announceDelay","_destroyed","_onAnnounce","_animationState","_assertNotAttached","_applySnackBarClasses","_live","FIREFOX","_role","fromState","toState","_completeExit","onEnter","_screenReaderAnnounce","_announceTimeoutId","onMicrotaskEmpty","panelClasses","Array","isArray","inertElement","querySelector","liveElement","focusedElement","activeElement","HTMLElement","removeAttribute","focus","viewQuery","_t","first","hostVars","hostBindings","$event","onAnimationEnd","animation","MatSnackBarModule","MAT_SNACK_BAR_DEFAULT_OPTIONS","MatSnackBar","_overlay","_breakpointObserver","_parentSnackBar","_defaultConfig","_snackBarRefAtThisLevel","simpleSnackBarComponent","snackBarContainerComponent","handsetCssClass","_openedSnackBarRef","_attach","openFromComponent","useValue","containerPortal","containerRef","instance","content","userConfig","_createOverlay","_attachSnackBarContainer","$implicit","_createInjector","contentRef","observe","detachments","state","announce","_animateSnackBar","afterDismissed","enter","afterOpened","_dismissAfter","global","isLeft","isRight","centerHorizontally","PendingCopy","text","textarea","_textarea","successful","currentFocus","select","setSelectionRange","execCommand","_a","Clipboard","pendingCopy","beginCopy","copy","CodeComponent","snackbar","pretty","clipboard","logger","ariaLabel","codeFormatted","_code","code","formatDisplayedCode","showMissingCodeMessage","_header","header","indent","lines","linenums","getLinenums","leftAlignedCode","Number","MAX_VALUE","line","lineIndent","search","substr","join","setCodeHtml","codeText","getCodeText","skipPrettify","of","prettifyCode","formatCode","language","tap","formattedCode","warn","src","path","region","codeContainer","innerHTML","textContent","log","open","Error","parseInt","isNaN","CodeModule","PrettyPrinter","prettyPrintOne","getPrettyPrintOne","ppo","Promise","resolve","then","err","msg"],"mappings":"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","file":"x","sourcesContent":["import { ElementRef, Directive, TemplateRef, ViewContainerRef, EventEmitter, ComponentFactoryResolver, Inject, Output, NgModule } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Throws an exception when attempting to attach a null portal to a host.\n * @docs-private\n */\nimport * as ɵngcc0 from '@angular/core';\nfunction throwNullPortalError() {\n    throw Error('Must provide a portal to attach');\n}\n/**\n * Throws an exception when attempting to attach a portal to a host that is already attached.\n * @docs-private\n */\nfunction throwPortalAlreadyAttachedError() {\n    throw Error('Host already has a portal attached');\n}\n/**\n * Throws an exception when attempting to attach a portal to an already-disposed host.\n * @docs-private\n */\nfunction throwPortalOutletAlreadyDisposedError() {\n    throw Error('This PortalOutlet has already been disposed');\n}\n/**\n * Throws an exception when attempting to attach an unknown portal type.\n * @docs-private\n */\nfunction throwUnknownPortalTypeError() {\n    throw Error('Attempting to attach an unknown Portal type. BasePortalOutlet accepts either ' +\n        'a ComponentPortal or a TemplatePortal.');\n}\n/**\n * Throws an exception when attempting to attach a portal to a null host.\n * @docs-private\n */\nfunction throwNullPortalOutletError() {\n    throw Error('Attempting to attach a portal to a null PortalOutlet');\n}\n/**\n * Throws an exception when attempting to detach a portal that is not attached.\n * @docs-private\n */\nfunction throwNoPortalAttachedError() {\n    throw Error('Attempting to detach a portal that is not attached to a host');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A `Portal` is something that you want to render somewhere else.\n * It can be attach to / detached from a `PortalOutlet`.\n */\nclass Portal {\n    /** Attach this portal to a host. */\n    attach(host) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (host == null) {\n                throwNullPortalOutletError();\n            }\n            if (host.hasAttached()) {\n                throwPortalAlreadyAttachedError();\n            }\n        }\n        this._attachedHost = host;\n        return host.attach(this);\n    }\n    /** Detach this portal from its host */\n    detach() {\n        let host = this._attachedHost;\n        if (host != null) {\n            this._attachedHost = null;\n            host.detach();\n        }\n        else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throwNoPortalAttachedError();\n        }\n    }\n    /** Whether this portal is attached to a host. */\n    get isAttached() {\n        return this._attachedHost != null;\n    }\n    /**\n     * Sets the PortalOutlet reference without performing `attach()`. This is used directly by\n     * the PortalOutlet when it is performing an `attach()` or `detach()`.\n     */\n    setAttachedHost(host) {\n        this._attachedHost = host;\n    }\n}\n/**\n * A `ComponentPortal` is a portal that instantiates some Component upon attachment.\n */\nclass ComponentPortal extends Portal {\n    constructor(component, viewContainerRef, injector, componentFactoryResolver) {\n        super();\n        this.component = component;\n        this.viewContainerRef = viewContainerRef;\n        this.injector = injector;\n        this.componentFactoryResolver = componentFactoryResolver;\n    }\n}\n/**\n * A `TemplatePortal` is a portal that represents some embedded template (TemplateRef).\n */\nclass TemplatePortal extends Portal {\n    constructor(template, viewContainerRef, context) {\n        super();\n        this.templateRef = template;\n        this.viewContainerRef = viewContainerRef;\n        this.context = context;\n    }\n    get origin() {\n        return this.templateRef.elementRef;\n    }\n    /**\n     * Attach the portal to the provided `PortalOutlet`.\n     * When a context is provided it will override the `context` property of the `TemplatePortal`\n     * instance.\n     */\n    attach(host, context = this.context) {\n        this.context = context;\n        return super.attach(host);\n    }\n    detach() {\n        this.context = undefined;\n        return super.detach();\n    }\n}\n/**\n * A `DomPortal` is a portal whose DOM element will be taken from its current position\n * in the DOM and moved into a portal outlet, when it is attached. On detach, the content\n * will be restored to its original position.\n */\nclass DomPortal extends Portal {\n    constructor(element) {\n        super();\n        this.element = element instanceof ElementRef ? element.nativeElement : element;\n    }\n}\n/**\n * Partial implementation of PortalOutlet that handles attaching\n * ComponentPortal and TemplatePortal.\n */\nclass BasePortalOutlet {\n    constructor() {\n        /** Whether this host has already been permanently disposed. */\n        this._isDisposed = false;\n        // @breaking-change 10.0.0 `attachDomPortal` to become a required abstract method.\n        this.attachDomPortal = null;\n    }\n    /** Whether this host has an attached portal. */\n    hasAttached() {\n        return !!this._attachedPortal;\n    }\n    /** Attaches a portal. */\n    attach(portal) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!portal) {\n                throwNullPortalError();\n            }\n            if (this.hasAttached()) {\n                throwPortalAlreadyAttachedError();\n            }\n            if (this._isDisposed) {\n                throwPortalOutletAlreadyDisposedError();\n            }\n        }\n        if (portal instanceof ComponentPortal) {\n            this._attachedPortal = portal;\n            return this.attachComponentPortal(portal);\n        }\n        else if (portal instanceof TemplatePortal) {\n            this._attachedPortal = portal;\n            return this.attachTemplatePortal(portal);\n            // @breaking-change 10.0.0 remove null check for `this.attachDomPortal`.\n        }\n        else if (this.attachDomPortal && portal instanceof DomPortal) {\n            this._attachedPortal = portal;\n            return this.attachDomPortal(portal);\n        }\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            throwUnknownPortalTypeError();\n        }\n    }\n    /** Detaches a previously attached portal. */\n    detach() {\n        if (this._attachedPortal) {\n            this._attachedPortal.setAttachedHost(null);\n            this._attachedPortal = null;\n        }\n        this._invokeDisposeFn();\n    }\n    /** Permanently dispose of this portal host. */\n    dispose() {\n        if (this.hasAttached()) {\n            this.detach();\n        }\n        this._invokeDisposeFn();\n        this._isDisposed = true;\n    }\n    /** @docs-private */\n    setDisposeFn(fn) {\n        this._disposeFn = fn;\n    }\n    _invokeDisposeFn() {\n        if (this._disposeFn) {\n            this._disposeFn();\n            this._disposeFn = null;\n        }\n    }\n}\n/**\n * @deprecated Use `BasePortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nclass BasePortalHost extends BasePortalOutlet {\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A PortalOutlet for attaching portals to an arbitrary DOM element outside of the Angular\n * application context.\n */\nclass DomPortalOutlet extends BasePortalOutlet {\n    constructor(\n    /** Element into which the content is projected. */\n    outletElement, _componentFactoryResolver, _appRef, _defaultInjector, \n    /**\n     * @deprecated `_document` Parameter to be made required.\n     * @breaking-change 10.0.0\n     */\n    _document) {\n        super();\n        this.outletElement = outletElement;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._appRef = _appRef;\n        this._defaultInjector = _defaultInjector;\n        /**\n         * Attaches a DOM portal by transferring its content into the outlet.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * @breaking-change 10.0.0\n         */\n        this.attachDomPortal = (portal) => {\n            // @breaking-change 10.0.0 Remove check and error once the\n            // `_document` constructor parameter is required.\n            if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('Cannot attach DOM portal without _document constructor parameter');\n            }\n            const element = portal.element;\n            if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('DOM portal content must be attached to a parent node.');\n            }\n            // Anchor used to save the element's previous position so\n            // that we can restore it when the portal is detached.\n            const anchorNode = this._document.createComment('dom-portal');\n            element.parentNode.insertBefore(anchorNode, element);\n            this.outletElement.appendChild(element);\n            this._attachedPortal = portal;\n            super.setDisposeFn(() => {\n                // We can't use `replaceWith` here because IE doesn't support it.\n                if (anchorNode.parentNode) {\n                    anchorNode.parentNode.replaceChild(element, anchorNode);\n                }\n            });\n        };\n        this._document = _document;\n    }\n    /**\n     * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.\n     * @param portal Portal to be attached\n     * @returns Reference to the created component.\n     */\n    attachComponentPortal(portal) {\n        const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;\n        const componentFactory = resolver.resolveComponentFactory(portal.component);\n        let componentRef;\n        // If the portal specifies a ViewContainerRef, we will use that as the attachment point\n        // for the component (in terms of Angular's component tree, not rendering).\n        // When the ViewContainerRef is missing, we use the factory to create the component directly\n        // and then manually attach the view to the application.\n        if (portal.viewContainerRef) {\n            componentRef = portal.viewContainerRef.createComponent(componentFactory, portal.viewContainerRef.length, portal.injector || portal.viewContainerRef.injector);\n            this.setDisposeFn(() => componentRef.destroy());\n        }\n        else {\n            componentRef = componentFactory.create(portal.injector || this._defaultInjector);\n            this._appRef.attachView(componentRef.hostView);\n            this.setDisposeFn(() => {\n                this._appRef.detachView(componentRef.hostView);\n                componentRef.destroy();\n            });\n        }\n        // At this point the component has been instantiated, so we move it to the location in the DOM\n        // where we want it to be rendered.\n        this.outletElement.appendChild(this._getComponentRootNode(componentRef));\n        this._attachedPortal = portal;\n        return componentRef;\n    }\n    /**\n     * Attaches a template portal to the DOM as an embedded view.\n     * @param portal Portal to be attached.\n     * @returns Reference to the created embedded view.\n     */\n    attachTemplatePortal(portal) {\n        let viewContainer = portal.viewContainerRef;\n        let viewRef = viewContainer.createEmbeddedView(portal.templateRef, portal.context);\n        // The method `createEmbeddedView` will add the view as a child of the viewContainer.\n        // But for the DomPortalOutlet the view can be added everywhere in the DOM\n        // (e.g Overlay Container) To move the view to the specified host element. We just\n        // re-append the existing root nodes.\n        viewRef.rootNodes.forEach(rootNode => this.outletElement.appendChild(rootNode));\n        // Note that we want to detect changes after the nodes have been moved so that\n        // any directives inside the portal that are looking at the DOM inside a lifecycle\n        // hook won't be invoked too early.\n        viewRef.detectChanges();\n        this.setDisposeFn((() => {\n            let index = viewContainer.indexOf(viewRef);\n            if (index !== -1) {\n                viewContainer.remove(index);\n            }\n        }));\n        this._attachedPortal = portal;\n        // TODO(jelbourn): Return locals from view.\n        return viewRef;\n    }\n    /**\n     * Clears out a portal from the DOM.\n     */\n    dispose() {\n        super.dispose();\n        if (this.outletElement.parentNode != null) {\n            this.outletElement.parentNode.removeChild(this.outletElement);\n        }\n    }\n    /** Gets the root HTMLElement for an instantiated component. */\n    _getComponentRootNode(componentRef) {\n        return componentRef.hostView.rootNodes[0];\n    }\n}\n/**\n * @deprecated Use `DomPortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nclass DomPortalHost extends DomPortalOutlet {\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Directive version of a `TemplatePortal`. Because the directive *is* a TemplatePortal,\n * the directive instance itself can be attached to a host, enabling declarative use of portals.\n */\nclass CdkPortal extends TemplatePortal {\n    constructor(templateRef, viewContainerRef) {\n        super(templateRef, viewContainerRef);\n    }\n}\nCdkPortal.ɵfac = function CdkPortal_Factory(t) { return new (t || CdkPortal)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef)); };\nCdkPortal.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkPortal, selectors: [[\"\", \"cdkPortal\", \"\"]], exportAs: [\"cdkPortal\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature] });\nCdkPortal.ctorParameters = () => [\n    { type: TemplateRef },\n    { type: ViewContainerRef }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkPortal, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkPortal]',\n                exportAs: 'cdkPortal'\n            }]\n    }], function () { return [{ type: ɵngcc0.TemplateRef }, { type: ɵngcc0.ViewContainerRef }]; }, null); })();\n/**\n * @deprecated Use `CdkPortal` instead.\n * @breaking-change 9.0.0\n */\nclass TemplatePortalDirective extends CdkPortal {\n}\nTemplatePortalDirective.ɵfac = /*@__PURE__*/ function () { let ɵTemplatePortalDirective_BaseFactory; return function TemplatePortalDirective_Factory(t) { return (ɵTemplatePortalDirective_BaseFactory || (ɵTemplatePortalDirective_BaseFactory = ɵngcc0.ɵɵgetInheritedFactory(TemplatePortalDirective)))(t || TemplatePortalDirective); }; }();\nTemplatePortalDirective.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: TemplatePortalDirective, selectors: [[\"\", \"cdk-portal\", \"\"], [\"\", \"portal\", \"\"]], exportAs: [\"cdkPortal\"], features: [ɵngcc0.ɵɵProvidersFeature([{\n                provide: CdkPortal,\n                useExisting: TemplatePortalDirective\n            }]), ɵngcc0.ɵɵInheritDefinitionFeature] });\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(TemplatePortalDirective, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-portal], [portal]',\n                exportAs: 'cdkPortal',\n                providers: [{\n                        provide: CdkPortal,\n                        useExisting: TemplatePortalDirective\n                    }]\n            }]\n    }], null, null); })();\n/**\n * Directive version of a PortalOutlet. Because the directive *is* a PortalOutlet, portals can be\n * directly attached to it, enabling declarative use.\n *\n * Usage:\n * `<ng-template [cdkPortalOutlet]=\"greeting\"></ng-template>`\n */\nclass CdkPortalOutlet extends BasePortalOutlet {\n    constructor(_componentFactoryResolver, _viewContainerRef, \n    /**\n     * @deprecated `_document` parameter to be made required.\n     * @breaking-change 9.0.0\n     */\n    _document) {\n        super();\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._viewContainerRef = _viewContainerRef;\n        /** Whether the portal component is initialized. */\n        this._isInitialized = false;\n        /** Emits when a portal is attached to the outlet. */\n        this.attached = new EventEmitter();\n        /**\n         * Attaches the given DomPortal to this PortalHost by moving all of the portal content into it.\n         * @param portal Portal to be attached.\n         * @deprecated To be turned into a method.\n         * @breaking-change 10.0.0\n         */\n        this.attachDomPortal = (portal) => {\n            // @breaking-change 9.0.0 Remove check and error once the\n            // `_document` constructor parameter is required.\n            if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('Cannot attach DOM portal without _document constructor parameter');\n            }\n            const element = portal.element;\n            if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                throw Error('DOM portal content must be attached to a parent node.');\n            }\n            // Anchor used to save the element's previous position so\n            // that we can restore it when the portal is detached.\n            const anchorNode = this._document.createComment('dom-portal');\n            portal.setAttachedHost(this);\n            element.parentNode.insertBefore(anchorNode, element);\n            this._getRootNode().appendChild(element);\n            this._attachedPortal = portal;\n            super.setDisposeFn(() => {\n                if (anchorNode.parentNode) {\n                    anchorNode.parentNode.replaceChild(element, anchorNode);\n                }\n            });\n        };\n        this._document = _document;\n    }\n    /** Portal associated with the Portal outlet. */\n    get portal() {\n        return this._attachedPortal;\n    }\n    set portal(portal) {\n        // Ignore the cases where the `portal` is set to a falsy value before the lifecycle hooks have\n        // run. This handles the cases where the user might do something like `<div cdkPortalOutlet>`\n        // and attach a portal programmatically in the parent component. When Angular does the first CD\n        // round, it will fire the setter with empty string, causing the user's content to be cleared.\n        if (this.hasAttached() && !portal && !this._isInitialized) {\n            return;\n        }\n        if (this.hasAttached()) {\n            super.detach();\n        }\n        if (portal) {\n            super.attach(portal);\n        }\n        this._attachedPortal = portal;\n    }\n    /** Component or view reference that is attached to the portal. */\n    get attachedRef() {\n        return this._attachedRef;\n    }\n    ngOnInit() {\n        this._isInitialized = true;\n    }\n    ngOnDestroy() {\n        super.dispose();\n        this._attachedPortal = null;\n        this._attachedRef = null;\n    }\n    /**\n     * Attach the given ComponentPortal to this PortalOutlet using the ComponentFactoryResolver.\n     *\n     * @param portal Portal to be attached to the portal outlet.\n     * @returns Reference to the created component.\n     */\n    attachComponentPortal(portal) {\n        portal.setAttachedHost(this);\n        // If the portal specifies an origin, use that as the logical location of the component\n        // in the application tree. Otherwise use the location of this PortalOutlet.\n        const viewContainerRef = portal.viewContainerRef != null ?\n            portal.viewContainerRef :\n            this._viewContainerRef;\n        const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;\n        const componentFactory = resolver.resolveComponentFactory(portal.component);\n        const ref = viewContainerRef.createComponent(componentFactory, viewContainerRef.length, portal.injector || viewContainerRef.injector);\n        // If we're using a view container that's different from the injected one (e.g. when the portal\n        // specifies its own) we need to move the component into the outlet, otherwise it'll be rendered\n        // inside of the alternate view container.\n        if (viewContainerRef !== this._viewContainerRef) {\n            this._getRootNode().appendChild(ref.hostView.rootNodes[0]);\n        }\n        super.setDisposeFn(() => ref.destroy());\n        this._attachedPortal = portal;\n        this._attachedRef = ref;\n        this.attached.emit(ref);\n        return ref;\n    }\n    /**\n     * Attach the given TemplatePortal to this PortalHost as an embedded View.\n     * @param portal Portal to be attached.\n     * @returns Reference to the created embedded view.\n     */\n    attachTemplatePortal(portal) {\n        portal.setAttachedHost(this);\n        const viewRef = this._viewContainerRef.createEmbeddedView(portal.templateRef, portal.context);\n        super.setDisposeFn(() => this._viewContainerRef.clear());\n        this._attachedPortal = portal;\n        this._attachedRef = viewRef;\n        this.attached.emit(viewRef);\n        return viewRef;\n    }\n    /** Gets the root node of the portal outlet. */\n    _getRootNode() {\n        const nativeElement = this._viewContainerRef.element.nativeElement;\n        // The directive could be set on a template which will result in a comment\n        // node being the root. Use the comment's parent node if that is the case.\n        return (nativeElement.nodeType === nativeElement.ELEMENT_NODE ?\n            nativeElement : nativeElement.parentNode);\n    }\n}\nCdkPortalOutlet.ɵfac = function CdkPortalOutlet_Factory(t) { return new (t || CdkPortalOutlet)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(DOCUMENT)); };\nCdkPortalOutlet.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkPortalOutlet, selectors: [[\"\", \"cdkPortalOutlet\", \"\"]], inputs: { portal: [\"cdkPortalOutlet\", \"portal\"] }, outputs: { attached: \"attached\" }, exportAs: [\"cdkPortalOutlet\"], features: [ɵngcc0.ɵɵInheritDefinitionFeature] });\nCdkPortalOutlet.ctorParameters = () => [\n    { type: ComponentFactoryResolver },\n    { type: ViewContainerRef },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\nCdkPortalOutlet.propDecorators = {\n    attached: [{ type: Output }]\n};\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkPortalOutlet, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkPortalOutlet]',\n                exportAs: 'cdkPortalOutlet',\n                inputs: ['portal: cdkPortalOutlet']\n            }]\n    }], function () { return [{ type: ɵngcc0.ComponentFactoryResolver }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, { attached: [{\n            type: Output\n        }] }); })();\n/**\n * @deprecated Use `CdkPortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nclass PortalHostDirective extends CdkPortalOutlet {\n}\nPortalHostDirective.ɵfac = /*@__PURE__*/ function () { let ɵPortalHostDirective_BaseFactory; return function PortalHostDirective_Factory(t) { return (ɵPortalHostDirective_BaseFactory || (ɵPortalHostDirective_BaseFactory = ɵngcc0.ɵɵgetInheritedFactory(PortalHostDirective)))(t || PortalHostDirective); }; }();\nPortalHostDirective.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: PortalHostDirective, selectors: [[\"\", \"cdkPortalHost\", \"\"], [\"\", \"portalHost\", \"\"]], inputs: { portal: [\"cdkPortalHost\", \"portal\"] }, exportAs: [\"cdkPortalHost\"], features: [ɵngcc0.ɵɵProvidersFeature([{\n                provide: CdkPortalOutlet,\n                useExisting: PortalHostDirective\n            }]), ɵngcc0.ɵɵInheritDefinitionFeature] });\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(PortalHostDirective, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkPortalHost], [portalHost]',\n                exportAs: 'cdkPortalHost',\n                inputs: ['portal: cdkPortalHost'],\n                providers: [{\n                        provide: CdkPortalOutlet,\n                        useExisting: PortalHostDirective\n                    }]\n            }]\n    }], null, null); })();\nclass PortalModule {\n}\nPortalModule.ɵfac = function PortalModule_Factory(t) { return new (t || PortalModule)(); };\nPortalModule.ɵmod = /*@__PURE__*/ ɵngcc0.ɵɵdefineNgModule({ type: PortalModule });\nPortalModule.ɵinj = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjector({});\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(PortalModule, [{\n        type: NgModule,\n        args: [{\n                exports: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective],\n                declarations: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective]\n            }]\n    }], null, null); })();\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(PortalModule, { declarations: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective], exports: [CdkPortal, CdkPortalOutlet, TemplatePortalDirective, PortalHostDirective] }); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Custom injector to be used when providing custom\n * injection tokens to components inside a portal.\n * @docs-private\n * @deprecated Use `Injector.create` instead.\n * @breaking-change 11.0.0\n */\nclass PortalInjector {\n    constructor(_parentInjector, _customTokens) {\n        this._parentInjector = _parentInjector;\n        this._customTokens = _customTokens;\n    }\n    get(token, notFoundValue) {\n        const value = this._customTokens.get(token);\n        if (typeof value !== 'undefined') {\n            return value;\n        }\n        return this._parentInjector.get(token, notFoundValue);\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BasePortalHost, BasePortalOutlet, CdkPortal, CdkPortalOutlet, ComponentPortal, DomPortal, DomPortalHost, DomPortalOutlet, Portal, PortalHostDirective, PortalInjector, PortalModule, TemplatePortal, TemplatePortalDirective };\n\n//# sourceMappingURL=portal.js.map","import * as i1 from '@angular/cdk/scrolling';\nimport { ScrollDispatcher, ViewportRuler, ScrollingModule } from '@angular/cdk/scrolling';\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/scrolling';\nimport * as ɵngcc2 from '@angular/cdk/platform';\nimport * as ɵngcc3 from '@angular/cdk/bidi';\nimport * as ɵngcc4 from '@angular/common';\nexport { CdkScrollable, ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';\nimport * as i1$1 from '@angular/common';\nimport { DOCUMENT, Location } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { Injectable, NgZone, Inject, Optional, ElementRef, ApplicationRef, ComponentFactoryResolver, Injector, InjectionToken, Directive, EventEmitter, TemplateRef, ViewContainerRef, Input, Output, NgModule } from '@angular/core';\nimport { coerceCssPixelValue, coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i2 from '@angular/cdk/platform';\nimport { supportsScrollBehavior, Platform } from '@angular/cdk/platform';\nimport { Directionality, BidiModule } from '@angular/cdk/bidi';\nimport { DomPortalOutlet, TemplatePortal, PortalModule } from '@angular/cdk/portal';\nimport { Subject, Subscription, merge } from 'rxjs';\nimport { take, takeUntil, takeWhile } from 'rxjs/operators';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst scrollBehaviorSupported = supportsScrollBehavior();\n/**\n * Strategy that will prevent the user from scrolling while the overlay is visible.\n */\nclass BlockScrollStrategy {\n    constructor(_viewportRuler, document) {\n        this._viewportRuler = _viewportRuler;\n        this._previousHTMLStyles = { top: '', left: '' };\n        this._isEnabled = false;\n        this._document = document;\n    }\n    /** Attaches this scroll strategy to an overlay. */\n    attach() { }\n    /** Blocks page-level scroll while the attached overlay is open. */\n    enable() {\n        if (this._canBeEnabled()) {\n            const root = this._document.documentElement;\n            this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();\n            // Cache the previous inline styles in case the user had set them.\n            this._previousHTMLStyles.left = root.style.left || '';\n            this._previousHTMLStyles.top = root.style.top || '';\n            // Note: we're using the `html` node, instead of the `body`, because the `body` may\n            // have the user agent margin, whereas the `html` is guaranteed not to have one.\n            root.style.left = coerceCssPixelValue(-this._previousScrollPosition.left);\n            root.style.top = coerceCssPixelValue(-this._previousScrollPosition.top);\n            root.classList.add('cdk-global-scrollblock');\n            this._isEnabled = true;\n        }\n    }\n    /** Unblocks page-level scroll while the attached overlay is open. */\n    disable() {\n        if (this._isEnabled) {\n            const html = this._document.documentElement;\n            const body = this._document.body;\n            const htmlStyle = html.style;\n            const bodyStyle = body.style;\n            const previousHtmlScrollBehavior = htmlStyle.scrollBehavior || '';\n            const previousBodyScrollBehavior = bodyStyle.scrollBehavior || '';\n            this._isEnabled = false;\n            htmlStyle.left = this._previousHTMLStyles.left;\n            htmlStyle.top = this._previousHTMLStyles.top;\n            html.classList.remove('cdk-global-scrollblock');\n            // Disable user-defined smooth scrolling temporarily while we restore the scroll position.\n            // See https://developer.mozilla.org/en-US/docs/Web/CSS/scroll-behavior\n            // Note that we don't mutate the property if the browser doesn't support `scroll-behavior`,\n            // because it can throw off feature detections in `supportsScrollBehavior` which\n            // checks for `'scrollBehavior' in documentElement.style`.\n            if (scrollBehaviorSupported) {\n                htmlStyle.scrollBehavior = bodyStyle.scrollBehavior = 'auto';\n            }\n            window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);\n            if (scrollBehaviorSupported) {\n                htmlStyle.scrollBehavior = previousHtmlScrollBehavior;\n                bodyStyle.scrollBehavior = previousBodyScrollBehavior;\n            }\n        }\n    }\n    _canBeEnabled() {\n        // Since the scroll strategies can't be singletons, we have to use a global CSS class\n        // (`cdk-global-scrollblock`) to make sure that we don't try to disable global\n        // scrolling multiple times.\n        const html = this._document.documentElement;\n        if (html.classList.contains('cdk-global-scrollblock') || this._isEnabled) {\n            return false;\n        }\n        const body = this._document.body;\n        const viewport = this._viewportRuler.getViewportSize();\n        return body.scrollHeight > viewport.height || body.scrollWidth > viewport.width;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.\n */\nfunction getMatScrollStrategyAlreadyAttachedError() {\n    return Error(`Scroll strategy has already been attached.`);\n}\n\n/**\n * Strategy that will close the overlay as soon as the user starts scrolling.\n */\nclass CloseScrollStrategy {\n    constructor(_scrollDispatcher, _ngZone, _viewportRuler, _config) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._ngZone = _ngZone;\n        this._viewportRuler = _viewportRuler;\n        this._config = _config;\n        this._scrollSubscription = null;\n        /** Detaches the overlay ref and disables the scroll strategy. */\n        this._detach = () => {\n            this.disable();\n            if (this._overlayRef.hasAttached()) {\n                this._ngZone.run(() => this._overlayRef.detach());\n            }\n        };\n    }\n    /** Attaches this scroll strategy to an overlay. */\n    attach(overlayRef) {\n        if (this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatScrollStrategyAlreadyAttachedError();\n        }\n        this._overlayRef = overlayRef;\n    }\n    /** Enables the closing of the attached overlay on scroll. */\n    enable() {\n        if (this._scrollSubscription) {\n            return;\n        }\n        const stream = this._scrollDispatcher.scrolled(0);\n        if (this._config && this._config.threshold && this._config.threshold > 1) {\n            this._initialScrollPosition = this._viewportRuler.getViewportScrollPosition().top;\n            this._scrollSubscription = stream.subscribe(() => {\n                const scrollPosition = this._viewportRuler.getViewportScrollPosition().top;\n                if (Math.abs(scrollPosition - this._initialScrollPosition) > this._config.threshold) {\n                    this._detach();\n                }\n                else {\n                    this._overlayRef.updatePosition();\n                }\n            });\n        }\n        else {\n            this._scrollSubscription = stream.subscribe(this._detach);\n        }\n    }\n    /** Disables the closing the attached overlay on scroll. */\n    disable() {\n        if (this._scrollSubscription) {\n            this._scrollSubscription.unsubscribe();\n            this._scrollSubscription = null;\n        }\n    }\n    detach() {\n        this.disable();\n        this._overlayRef = null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\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 * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// TODO(jelbourn): move this to live with the rest of the scrolling code\n// TODO(jelbourn): someday replace this with IntersectionObservers\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 * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Strategy that will update the element position as the user is scrolling.\n */\nclass RepositionScrollStrategy {\n    constructor(_scrollDispatcher, _viewportRuler, _ngZone, _config) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewportRuler = _viewportRuler;\n        this._ngZone = _ngZone;\n        this._config = _config;\n        this._scrollSubscription = null;\n    }\n    /** Attaches this scroll strategy to an overlay. */\n    attach(overlayRef) {\n        if (this._overlayRef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatScrollStrategyAlreadyAttachedError();\n        }\n        this._overlayRef = overlayRef;\n    }\n    /** Enables repositioning of the attached overlay on scroll. */\n    enable() {\n        if (!this._scrollSubscription) {\n            const throttle = this._config ? this._config.scrollThrottle : 0;\n            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe(() => {\n                this._overlayRef.updatePosition();\n                // TODO(crisbeto): make `close` on by default once all components can handle it.\n                if (this._config && this._config.autoClose) {\n                    const overlayRect = this._overlayRef.overlayElement.getBoundingClientRect();\n                    const { width, height } = this._viewportRuler.getViewportSize();\n                    // TODO(crisbeto): include all ancestor scroll containers here once\n                    // we have a way of exposing the trigger element to the scroll strategy.\n                    const parentRects = [{ width, height, bottom: height, right: width, top: 0, left: 0 }];\n                    if (isElementScrolledOutsideView(overlayRect, parentRects)) {\n                        this.disable();\n                        this._ngZone.run(() => this._overlayRef.detach());\n                    }\n                }\n            });\n        }\n    }\n    /** Disables repositioning of the attached overlay on scroll. */\n    disable() {\n        if (this._scrollSubscription) {\n            this._scrollSubscription.unsubscribe();\n            this._scrollSubscription = null;\n        }\n    }\n    detach() {\n        this.disable();\n        this._overlayRef = null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Options for how an overlay will handle scrolling.\n *\n * Users can provide a custom value for `ScrollStrategyOptions` to replace the default\n * behaviors. This class primarily acts as a factory for ScrollStrategy instances.\n */\nclass ScrollStrategyOptions {\n    constructor(_scrollDispatcher, _viewportRuler, _ngZone, document) {\n        this._scrollDispatcher = _scrollDispatcher;\n        this._viewportRuler = _viewportRuler;\n        this._ngZone = _ngZone;\n        /** Do nothing on scroll. */\n        this.noop = () => new NoopScrollStrategy();\n        /**\n         * Close the overlay as soon as the user scrolls.\n         * @param config Configuration to be used inside the scroll strategy.\n         */\n        this.close = (config) => new CloseScrollStrategy(this._scrollDispatcher, this._ngZone, this._viewportRuler, config);\n        /** Block scrolling. */\n        this.block = () => new BlockScrollStrategy(this._viewportRuler, this._document);\n        /**\n         * Update the overlay's position on scroll.\n         * @param config Configuration to be used inside the scroll strategy.\n         * Allows debouncing the reposition calls.\n         */\n        this.reposition = (config) => new RepositionScrollStrategy(this._scrollDispatcher, this._viewportRuler, this._ngZone, config);\n        this._document = document;\n    }\n}\nScrollStrategyOptions.ɵfac = function ScrollStrategyOptions_Factory(t) { return new (t || ScrollStrategyOptions)(ɵngcc0.ɵɵinject(ɵngcc1.ScrollDispatcher), ɵngcc0.ɵɵinject(ɵngcc1.ViewportRuler), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT)); };\nScrollStrategyOptions.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScrollStrategyOptions_Factory() { return new ScrollStrategyOptions(i0.ɵɵinject(i1.ScrollDispatcher), i0.ɵɵinject(i1.ViewportRuler), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1$1.DOCUMENT)); }, token: ScrollStrategyOptions, providedIn: \"root\" });\nScrollStrategyOptions.ctorParameters = () => [\n    { type: ScrollDispatcher },\n    { type: ViewportRuler },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(ScrollStrategyOptions, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.ScrollDispatcher }, { type: ɵngcc1.ViewportRuler }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Initial configuration used when creating an overlay. */\nclass OverlayConfig {\n    constructor(config) {\n        /** Strategy to be used when handling scroll events while the overlay is open. */\n        this.scrollStrategy = new NoopScrollStrategy();\n        /** Custom class to add to the overlay pane. */\n        this.panelClass = '';\n        /** Whether the overlay has a backdrop. */\n        this.hasBackdrop = false;\n        /** Custom class to add to the backdrop */\n        this.backdropClass = 'cdk-overlay-dark-backdrop';\n        /**\n         * Whether the overlay should be disposed of when the user goes backwards/forwards in history.\n         * Note that this usually doesn't include clicking on links (unless the user is using\n         * the `HashLocationStrategy`).\n         */\n        this.disposeOnNavigation = false;\n        if (config) {\n            // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,\n            // loses the array generic type in the `for of`. But we *also* have to use `Array` because\n            // typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`\n            const configKeys = Object.keys(config);\n            for (const key of configKeys) {\n                if (config[key] !== undefined) {\n                    // TypeScript, as of version 3.5, sees the left-hand-side of this expression\n                    // as \"I don't know *which* key this is, so the only valid value is the intersection\n                    // of all the posible 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/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** The points of the origin element and the overlay element to connect. */\nclass ConnectionPositionPair {\n    constructor(origin, overlay, \n    /** Offset along the X axis. */\n    offsetX, \n    /** Offset along the Y axis. */\n    offsetY, \n    /** Class(es) to be applied to the panel while this position is active. */\n    panelClass) {\n        this.offsetX = offsetX;\n        this.offsetY = offsetY;\n        this.panelClass = panelClass;\n        this.originX = origin.originX;\n        this.originY = origin.originY;\n        this.overlayX = overlay.overlayX;\n        this.overlayY = overlay.overlayY;\n    }\n}\n/**\n * Set of properties regarding the position of the origin and overlay relative to the viewport\n * with respect to the containing Scrollable elements.\n *\n * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the\n * bounds of any one of the strategy's Scrollable's bounding client rectangle.\n *\n * The overlay and origin are outside view if there is no overlap between their bounding client\n * rectangle and any one of the strategy's Scrollable's bounding client rectangle.\n *\n *       -----------                    -----------\n *       | outside |                    | clipped |\n *       |  view   |              --------------------------\n *       |         |              |     |         |        |\n *       ----------               |     -----------        |\n *  --------------------------    |                        |\n *  |                        |    |      Scrollable        |\n *  |                        |    |                        |\n *  |                        |     --------------------------\n *  |      Scrollable        |\n *  |                        |\n *  --------------------------\n *\n *  @docs-private\n */\nclass ScrollingVisibility {\n}\n/** The change event emitted by the strategy when a fallback position is used. */\nclass ConnectedOverlayPositionChange {\n    constructor(\n    /** The position used as a result of this change. */\n    connectionPair, \n    /** @docs-private */\n    scrollableViewProperties) {\n        this.connectionPair = connectionPair;\n        this.scrollableViewProperties = scrollableViewProperties;\n    }\n}\nConnectedOverlayPositionChange.ctorParameters = () => [\n    { type: ConnectionPositionPair },\n    { type: ScrollingVisibility, decorators: [{ type: Optional }] }\n];\n/**\n * Validates whether a vertical position property matches the expected values.\n * @param property Name of the property being validated.\n * @param value Value of the property being validated.\n * @docs-private\n */\nfunction validateVerticalPosition(property, value) {\n    if (value !== 'top' && value !== 'bottom' && value !== 'center') {\n        throw Error(`ConnectedPosition: Invalid ${property} \"${value}\". ` +\n            `Expected \"top\", \"bottom\" or \"center\".`);\n    }\n}\n/**\n * Validates whether a horizontal position property matches the expected values.\n * @param property Name of the property being validated.\n * @param value Value of the property being validated.\n * @docs-private\n */\nfunction validateHorizontalPosition(property, value) {\n    if (value !== 'start' && value !== 'end' && value !== 'center') {\n        throw Error(`ConnectedPosition: Invalid ${property} \"${value}\". ` +\n            `Expected \"start\", \"end\" or \"center\".`);\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Service for dispatching events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass BaseOverlayDispatcher {\n    constructor(document) {\n        /** Currently attached overlays in the order they were attached. */\n        this._attachedOverlays = [];\n        this._document = document;\n    }\n    ngOnDestroy() {\n        this.detach();\n    }\n    /** Add a new overlay to the list of attached overlay refs. */\n    add(overlayRef) {\n        // Ensure that we don't get the same overlay multiple times.\n        this.remove(overlayRef);\n        this._attachedOverlays.push(overlayRef);\n    }\n    /** Remove an overlay from the list of attached overlay refs. */\n    remove(overlayRef) {\n        const index = this._attachedOverlays.indexOf(overlayRef);\n        if (index > -1) {\n            this._attachedOverlays.splice(index, 1);\n        }\n        // Remove the global listener once there are no more overlays.\n        if (this._attachedOverlays.length === 0) {\n            this.detach();\n        }\n    }\n}\nBaseOverlayDispatcher.ɵfac = function BaseOverlayDispatcher_Factory(t) { return new (t || BaseOverlayDispatcher)(ɵngcc0.ɵɵinject(DOCUMENT)); };\nBaseOverlayDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseOverlayDispatcher_Factory() { return new BaseOverlayDispatcher(i0.ɵɵinject(i1$1.DOCUMENT)); }, token: BaseOverlayDispatcher, providedIn: \"root\" });\nBaseOverlayDispatcher.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(BaseOverlayDispatcher, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Service for dispatching keyboard events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass OverlayKeyboardDispatcher extends BaseOverlayDispatcher {\n    constructor(document) {\n        super(document);\n        /** Keyboard event listener that will be attached to the body. */\n        this._keydownListener = (event) => {\n            const overlays = this._attachedOverlays;\n            for (let i = overlays.length - 1; i > -1; i--) {\n                // Dispatch the keydown event to the top overlay which has subscribers to its keydown events.\n                // We want to target the most recent overlay, rather than trying to match where the event came\n                // from, because some components might open an overlay, but keep focus on a trigger element\n                // (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,\n                // because we don't want overlays that don't handle keyboard events to block the ones below\n                // them that do.\n                if (overlays[i]._keydownEvents.observers.length > 0) {\n                    overlays[i]._keydownEvents.next(event);\n                    break;\n                }\n            }\n        };\n    }\n    /** Add a new overlay to the list of attached overlay refs. */\n    add(overlayRef) {\n        super.add(overlayRef);\n        // Lazily start dispatcher once first overlay is added\n        if (!this._isAttached) {\n            this._document.body.addEventListener('keydown', this._keydownListener);\n            this._isAttached = true;\n        }\n    }\n    /** Detaches the global keyboard event listener. */\n    detach() {\n        if (this._isAttached) {\n            this._document.body.removeEventListener('keydown', this._keydownListener);\n            this._isAttached = false;\n        }\n    }\n}\nOverlayKeyboardDispatcher.ɵfac = function OverlayKeyboardDispatcher_Factory(t) { return new (t || OverlayKeyboardDispatcher)(ɵngcc0.ɵɵinject(DOCUMENT)); };\nOverlayKeyboardDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(i0.ɵɵinject(i1$1.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: \"root\" });\nOverlayKeyboardDispatcher.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(OverlayKeyboardDispatcher, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Service for dispatching mouse click events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\nclass OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {\n    constructor(document, _platform) {\n        super(document);\n        this._platform = _platform;\n        this._cursorStyleIsSet = false;\n        /** Click event listener that will be attached to the body propagate phase. */\n        this._clickListener = (event) => {\n            // Get the target through the `composedPath` if possible to account for shadow DOM.\n            const target = event.composedPath ? event.composedPath()[0] : event.target;\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 dispatch the mouse event, and proceed with the next overlay\n                if (overlayRef.overlayElement.contains(target)) {\n                    break;\n                }\n                overlayRef._outsidePointerEvents.next(event);\n            }\n        };\n    }\n    /** Add a new overlay to the list of attached overlay refs. */\n    add(overlayRef) {\n        super.add(overlayRef);\n        // Safari on iOS does not generate click events for non-interactive\n        // elements. However, we want to receive a click for any element outside\n        // the overlay. We can force a \"clickable\" state by setting\n        // `cursor: pointer` on the document body. See:\n        // https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event#Safari_Mobile\n        // https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html\n        if (!this._isAttached) {\n            const body = this._document.body;\n            body.addEventListener('click', this._clickListener, true);\n            body.addEventListener('auxclick', this._clickListener, true);\n            body.addEventListener('contextmenu', this._clickListener, true);\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('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}\nOverlayOutsideClickDispatcher.ɵfac = function OverlayOutsideClickDispatcher_Factory(t) { return new (t || OverlayOutsideClickDispatcher)(ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform)); };\nOverlayOutsideClickDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayOutsideClickDispatcher_Factory() { return new OverlayOutsideClickDispatcher(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: OverlayOutsideClickDispatcher, providedIn: \"root\" });\nOverlayOutsideClickDispatcher.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(OverlayOutsideClickDispatcher, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Whether we're in a testing environment.\n * TODO(crisbeto): remove this once we have an overlay testing module.\n */\nconst isTestEnvironment = typeof window !== 'undefined' && !!window &&\n    !!(window.__karma__ || window.jasmine);\n/** Container inside which all overlays will render. */\nclass OverlayContainer {\n    constructor(document, _platform) {\n        this._platform = _platform;\n        this._document = document;\n    }\n    ngOnDestroy() {\n        const container = this._containerElement;\n        if (container && container.parentNode) {\n            container.parentNode.removeChild(container);\n        }\n    }\n    /**\n     * This method returns the overlay container element. It will lazily\n     * create the element the first time  it is called to facilitate using\n     * the container in non-browser environments.\n     * @returns the container element\n     */\n    getContainerElement() {\n        if (!this._containerElement) {\n            this._createContainer();\n        }\n        return this._containerElement;\n    }\n    /**\n     * Create the overlay container element, which is simply a div\n     * with the 'cdk-overlay-container' class on the document body.\n     */\n    _createContainer() {\n        const containerClass = 'cdk-overlay-container';\n        if (this._platform.isBrowser || isTestEnvironment) {\n            const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform=\"server\"], ` +\n                `.${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].parentNode.removeChild(oppositePlatformContainers[i]);\n            }\n        }\n        const container = this._document.createElement('div');\n        container.classList.add(containerClass);\n        // A long time ago we kept adding new overlay containers whenever a new app was instantiated,\n        // but at some point we added logic which clears the duplicate ones in order to avoid leaks.\n        // The new logic was a little too aggressive since it was breaking some legitimate use cases.\n        // To mitigate the problem we made it so that only containers from a different platform are\n        // cleared, but the side-effect was that people started depending on the overly-aggressive\n        // logic to clean up their tests for them. Until we can introduce an overlay-specific testing\n        // module which does the cleanup, we try to detect that we're in a test environment and we\n        // always clear the container. See #17006.\n        // TODO(crisbeto): remove the test environment check once we have an overlay testing module.\n        if (isTestEnvironment) {\n            container.setAttribute('platform', 'test');\n        }\n        else if (!this._platform.isBrowser) {\n            container.setAttribute('platform', 'server');\n        }\n        this._document.body.appendChild(container);\n        this._containerElement = container;\n    }\n}\nOverlayContainer.ɵfac = function OverlayContainer_Factory(t) { return new (t || OverlayContainer)(ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform)); };\nOverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: OverlayContainer, providedIn: \"root\" });\nOverlayContainer.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(OverlayContainer, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Reference to an overlay that has been created with the Overlay service.\n * Used to manipulate or dispose of said overlay.\n */\nclass OverlayRef {\n    constructor(_portalOutlet, _host, _pane, _config, _ngZone, _keyboardDispatcher, _document, _location, _outsideClickDispatcher) {\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._backdropElement = null;\n        this._backdropClick = new Subject();\n        this._attachments = new Subject();\n        this._detachments = new Subject();\n        this._locationChanges = Subscription.EMPTY;\n        this._backdropClickHandler = (event) => this._backdropClick.next(event);\n        /** Stream of keydown events dispatched to this overlay. */\n        this._keydownEvents = new Subject();\n        /** Stream of mouse outside events dispatched to this overlay. */\n        this._outsidePointerEvents = new Subject();\n        if (_config.scrollStrategy) {\n            this._scrollStrategy = _config.scrollStrategy;\n            this._scrollStrategy.attach(this);\n        }\n        this._positionStrategy = _config.positionStrategy;\n    }\n    /** The overlay's HTML element */\n    get overlayElement() {\n        return this._pane;\n    }\n    /** The overlay's backdrop HTML element. */\n    get backdropElement() {\n        return this._backdropElement;\n    }\n    /**\n     * Wrapper around the panel element. Can be used for advanced\n     * positioning where a wrapper with specific styling is\n     * required around the overlay pane.\n     */\n    get hostElement() {\n        return this._host;\n    }\n    /**\n     * Attaches content, given via a Portal, to the overlay.\n     * If the overlay is configured to have a backdrop, it will be created.\n     *\n     * @param portal Portal instance to which to attach the overlay.\n     * @returns The portal attachment result.\n     */\n    attach(portal) {\n        let attachResult = this._portalOutlet.attach(portal);\n        // Update the pane element with the given configuration.\n        if (!this._host.parentElement && this._previousHostParent) {\n            this._previousHostParent.appendChild(this._host);\n        }\n        if (this._positionStrategy) {\n            this._positionStrategy.attach(this);\n        }\n        this._updateStackingOrder();\n        this._updateElementSize();\n        this._updateElementDirection();\n        if (this._scrollStrategy) {\n            this._scrollStrategy.enable();\n        }\n        // Update the position once the zone is stable so that the overlay will be fully rendered\n        // before attempting to position it, as the position may depend on the size of the rendered\n        // content.\n        this._ngZone.onStable\n            .pipe(take(1))\n            .subscribe(() => {\n            // The overlay could've been detached before the zone has stabilized.\n            if (this.hasAttached()) {\n                this.updatePosition();\n            }\n        });\n        // Enable pointer events for the overlay pane element.\n        this._togglePointerEvents(true);\n        if (this._config.hasBackdrop) {\n            this._attachBackdrop();\n        }\n        if (this._config.panelClass) {\n            this._toggleClasses(this._pane, this._config.panelClass, true);\n        }\n        // Only emit the `attachments` event once all other setup is done.\n        this._attachments.next();\n        // Track this overlay by the keyboard dispatcher\n        this._keyboardDispatcher.add(this);\n        if (this._config.disposeOnNavigation) {\n            this._locationChanges = this._location.subscribe(() => this.dispose());\n        }\n        this._outsideClickDispatcher.add(this);\n        return attachResult;\n    }\n    /**\n     * Detaches an overlay from a portal.\n     * @returns The portal detachment result.\n     */\n    detach() {\n        if (!this.hasAttached()) {\n            return;\n        }\n        this.detachBackdrop();\n        // When the overlay is detached, the pane element should disable pointer events.\n        // This is necessary because otherwise the pane element will cover the page and disable\n        // pointer events therefore. Depends on the position strategy and the applied pane boundaries.\n        this._togglePointerEvents(false);\n        if (this._positionStrategy && this._positionStrategy.detach) {\n            this._positionStrategy.detach();\n        }\n        if (this._scrollStrategy) {\n            this._scrollStrategy.disable();\n        }\n        const detachmentResult = this._portalOutlet.detach();\n        // Only emit after everything is detached.\n        this._detachments.next();\n        // Remove this overlay from keyboard dispatcher tracking.\n        this._keyboardDispatcher.remove(this);\n        // Keeping the host element in the DOM can cause scroll jank, because it still gets\n        // rendered, even though it's transparent and unclickable which is why we remove it.\n        this._detachContentWhenStable();\n        this._locationChanges.unsubscribe();\n        this._outsideClickDispatcher.remove(this);\n        return detachmentResult;\n    }\n    /** Cleans up the overlay from the DOM. */\n    dispose() {\n        const isAttached = this.hasAttached();\n        if (this._positionStrategy) {\n            this._positionStrategy.dispose();\n        }\n        this._disposeScrollStrategy();\n        this.detachBackdrop();\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        if (this._host && this._host.parentNode) {\n            this._host.parentNode.removeChild(this._host);\n            this._host = null;\n        }\n        this._previousHostParent = this._pane = null;\n        if (isAttached) {\n            this._detachments.next();\n        }\n        this._detachments.complete();\n    }\n    /** Whether the overlay has attached content. */\n    hasAttached() {\n        return this._portalOutlet.hasAttached();\n    }\n    /** Gets an observable that emits when the backdrop has been clicked. */\n    backdropClick() {\n        return this._backdropClick;\n    }\n    /** Gets an observable that emits when the overlay has been attached. */\n    attachments() {\n        return this._attachments;\n    }\n    /** Gets an observable that emits when the overlay has been detached. */\n    detachments() {\n        return this._detachments;\n    }\n    /** Gets an observable of keydown events targeted to this overlay. */\n    keydownEvents() {\n        return this._keydownEvents;\n    }\n    /** Gets an observable of pointer events targeted outside this overlay. */\n    outsidePointerEvents() {\n        return this._outsidePointerEvents;\n    }\n    /** Gets the current overlay configuration, which is immutable. */\n    getConfig() {\n        return this._config;\n    }\n    /** Updates the position of the overlay based on the position strategy. */\n    updatePosition() {\n        if (this._positionStrategy) {\n            this._positionStrategy.apply();\n        }\n    }\n    /** Switches to a new position strategy and updates the overlay position. */\n    updatePositionStrategy(strategy) {\n        if (strategy === this._positionStrategy) {\n            return;\n        }\n        if (this._positionStrategy) {\n            this._positionStrategy.dispose();\n        }\n        this._positionStrategy = strategy;\n        if (this.hasAttached()) {\n            strategy.attach(this);\n            this.updatePosition();\n        }\n    }\n    /** Update the size properties of the overlay. */\n    updateSize(sizeConfig) {\n        this._config = Object.assign(Object.assign({}, this._config), sizeConfig);\n        this._updateElementSize();\n    }\n    /** Sets the LTR/RTL direction for the overlay. */\n    setDirection(dir) {\n        this._config = Object.assign(Object.assign({}, this._config), { direction: dir });\n        this._updateElementDirection();\n    }\n    /** Add a CSS class or an array of classes to the overlay pane. */\n    addPanelClass(classes) {\n        if (this._pane) {\n            this._toggleClasses(this._pane, classes, true);\n        }\n    }\n    /** Remove a CSS class or an array of classes from the overlay pane. */\n    removePanelClass(classes) {\n        if (this._pane) {\n            this._toggleClasses(this._pane, classes, false);\n        }\n    }\n    /**\n     * Returns the layout direction of the overlay panel.\n     */\n    getDirection() {\n        const direction = this._config.direction;\n        if (!direction) {\n            return 'ltr';\n        }\n        return typeof direction === 'string' ? direction : direction.value;\n    }\n    /** Switches to a new scroll strategy. */\n    updateScrollStrategy(strategy) {\n        if (strategy === this._scrollStrategy) {\n            return;\n        }\n        this._disposeScrollStrategy();\n        this._scrollStrategy = strategy;\n        if (this.hasAttached()) {\n            strategy.attach(this);\n            strategy.enable();\n        }\n    }\n    /** Updates the text direction of the overlay panel. */\n    _updateElementDirection() {\n        this._host.setAttribute('dir', this.getDirection());\n    }\n    /** Updates the size of the overlay element based on the overlay config. */\n    _updateElementSize() {\n        if (!this._pane) {\n            return;\n        }\n        const style = this._pane.style;\n        style.width = coerceCssPixelValue(this._config.width);\n        style.height = coerceCssPixelValue(this._config.height);\n        style.minWidth = coerceCssPixelValue(this._config.minWidth);\n        style.minHeight = coerceCssPixelValue(this._config.minHeight);\n        style.maxWidth = coerceCssPixelValue(this._config.maxWidth);\n        style.maxHeight = coerceCssPixelValue(this._config.maxHeight);\n    }\n    /** Toggles the pointer events for the overlay pane element. */\n    _togglePointerEvents(enablePointer) {\n        this._pane.style.pointerEvents = enablePointer ? '' : 'none';\n    }\n    /** Attaches a backdrop for this overlay. */\n    _attachBackdrop() {\n        const showingClass = 'cdk-overlay-backdrop-showing';\n        this._backdropElement = this._document.createElement('div');\n        this._backdropElement.classList.add('cdk-overlay-backdrop');\n        if (this._config.backdropClass) {\n            this._toggleClasses(this._backdropElement, this._config.backdropClass, true);\n        }\n        // Insert the backdrop before the pane in the DOM order,\n        // in order to handle stacked overlays properly.\n        this._host.parentElement.insertBefore(this._backdropElement, this._host);\n        // Forward backdrop clicks such that the consumer of the overlay can perform whatever\n        // action desired when such a click occurs (usually closing the overlay).\n        this._backdropElement.addEventListener('click', this._backdropClickHandler);\n        // Add class to fade-in the backdrop after one frame.\n        if (typeof requestAnimationFrame !== 'undefined') {\n            this._ngZone.runOutsideAngular(() => {\n                requestAnimationFrame(() => {\n                    if (this._backdropElement) {\n                        this._backdropElement.classList.add(showingClass);\n                    }\n                });\n            });\n        }\n        else {\n            this._backdropElement.classList.add(showingClass);\n        }\n    }\n    /**\n     * Updates the stacking order of the element, moving it to the top if necessary.\n     * This is required in cases where one overlay was detached, while another one,\n     * that should be behind it, was destroyed. The next time both of them are opened,\n     * the stacking will be wrong, because the detached element's pane will still be\n     * in its original DOM position.\n     */\n    _updateStackingOrder() {\n        if (this._host.nextSibling) {\n            this._host.parentNode.appendChild(this._host);\n        }\n    }\n    /** Detaches the backdrop (if any) associated with the overlay. */\n    detachBackdrop() {\n        let backdropToDetach = this._backdropElement;\n        if (!backdropToDetach) {\n            return;\n        }\n        let timeoutId;\n        let finishDetach = () => {\n            // It may not be attached to anything in certain cases (e.g. unit tests).\n            if (backdropToDetach) {\n                backdropToDetach.removeEventListener('click', this._backdropClickHandler);\n                backdropToDetach.removeEventListener('transitionend', finishDetach);\n                if (backdropToDetach.parentNode) {\n                    backdropToDetach.parentNode.removeChild(backdropToDetach);\n                }\n            }\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 == backdropToDetach) {\n                this._backdropElement = null;\n            }\n            if (this._config.backdropClass) {\n                this._toggleClasses(backdropToDetach, this._config.backdropClass, false);\n            }\n            clearTimeout(timeoutId);\n        };\n        backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');\n        this._ngZone.runOutsideAngular(() => {\n            backdropToDetach.addEventListener('transitionend', finishDetach);\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        timeoutId = this._ngZone.runOutsideAngular(() => setTimeout(finishDetach, 500));\n    }\n    /** Toggles a single CSS class or an array of classes on an element. */\n    _toggleClasses(element, cssClasses, isAdd) {\n        const classList = element.classList;\n        coerceArray(cssClasses).forEach(cssClass => {\n            // We can't do a spread here, because IE doesn't support setting multiple classes.\n            // Also trying to add an empty string to a DOMTokenList will throw.\n            if (cssClass) {\n                isAdd ? classList.add(cssClass) : classList.remove(cssClass);\n            }\n        });\n    }\n    /** Detaches the overlay content next time the zone stabilizes. */\n    _detachContentWhenStable() {\n        // Normally we wouldn't have to explicitly run this outside the `NgZone`, however\n        // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will\n        // be patched to run inside the zone, which will throw us into an infinite loop.\n        this._ngZone.runOutsideAngular(() => {\n            // We can't remove the host here immediately, because the overlay pane's content\n            // might still be animating. This stream helps us avoid interrupting the animation\n            // by waiting for the pane to become empty.\n            const subscription = this._ngZone.onStable\n                .pipe(takeUntil(merge(this._attachments, this._detachments)))\n                .subscribe(() => {\n                // Needs a couple of checks for the pane and host, because\n                // they may have been removed by the time the zone stabilizes.\n                if (!this._pane || !this._host || this._pane.children.length === 0) {\n                    if (this._pane && this._config.panelClass) {\n                        this._toggleClasses(this._pane, this._config.panelClass, false);\n                    }\n                    if (this._host && this._host.parentElement) {\n                        this._previousHostParent = this._host.parentElement;\n                        this._previousHostParent.removeChild(this._host);\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}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\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    constructor(connectedTo, _viewportRuler, _document, _platform, _overlayContainer) {\n        this._viewportRuler = _viewportRuler;\n        this._document = _document;\n        this._platform = _platform;\n        this._overlayContainer = _overlayContainer;\n        /** Last size used for the bounding box. Used to avoid resizing the overlay after open. */\n        this._lastBoundingBoxSize = { width: 0, height: 0 };\n        /** Whether the overlay was pushed in a previous positioning. */\n        this._isPushed = false;\n        /** Whether the overlay can be pushed on-screen on the initial open. */\n        this._canPush = true;\n        /** Whether the overlay can grow via flexible width/height after the initial open. */\n        this._growAfterOpen = false;\n        /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n        this._hasFlexibleDimensions = true;\n        /** Whether the overlay position is locked. */\n        this._positionLocked = false;\n        /** Amount of space that must be maintained between the overlay and the edge of the viewport. */\n        this._viewportMargin = 0;\n        /** The Scrollable containers used to check scrollable view properties on position change. */\n        this._scrollables = [];\n        /** Ordered list of preferred positions, from most to least desirable. */\n        this._preferredPositions = [];\n        /** Subject that emits whenever the position changes. */\n        this._positionChanges = new Subject();\n        /** Subscription to viewport size changes. */\n        this._resizeSubscription = Subscription.EMPTY;\n        /** Default offset for the overlay along the x axis. */\n        this._offsetX = 0;\n        /** Default offset for the overlay along the y axis. */\n        this._offsetY = 0;\n        /** Keeps track of the CSS classes that the position strategy has applied on the overlay panel. */\n        this._appliedPanelClasses = [];\n        /** Observable sequence of position changes. */\n        this.positionChanges = this._positionChanges;\n        this.setOrigin(connectedTo);\n    }\n    /** Ordered list of preferred positions, from most to least desirable. */\n    get positions() {\n        return this._preferredPositions;\n    }\n    /** Attaches this position strategy to an overlay. */\n    attach(overlayRef) {\n        if (this._overlayRef && overlayRef !== this._overlayRef &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('This position strategy is already attached to an overlay');\n        }\n        this._validatePositions();\n        overlayRef.hostElement.classList.add(boundingBoxClass);\n        this._overlayRef = overlayRef;\n        this._boundingBox = overlayRef.hostElement;\n        this._pane = overlayRef.overlayElement;\n        this._isDisposed = false;\n        this._isInitialRender = true;\n        this._lastPosition = null;\n        this._resizeSubscription.unsubscribe();\n        this._resizeSubscription = this._viewportRuler.change().subscribe(() => {\n            // When the window is resized, we want to trigger the next reposition as if it\n            // was an initial render, in order for the strategy to pick a new optimal position,\n            // otherwise position locking will cause it to stay at the old one.\n            this._isInitialRender = true;\n            this.apply();\n        });\n    }\n    /**\n     * Updates the position of the overlay element, using whichever preferred position relative\n     * to the origin best fits on-screen.\n     *\n     * The selection of a position goes as follows:\n     *  - If any positions fit completely within the viewport as-is,\n     *      choose the first position that does so.\n     *  - If flexible dimensions are enabled and at least one satifies 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 and the overlay 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        const originRect = this._originRect;\n        const overlayRect = this._overlayRect;\n        const viewportRect = this._viewportRect;\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, pos);\n            // From that point-of-origin, get the exact (x, y) coordinate for the top-left corner of the\n            // overlay in this position. We use the top-left corner for calculations and later translate\n            // this into an appropriate (top, left, bottom, right) style.\n            let overlayPoint = this._getOverlayPoint(originPoint, overlayRect, pos);\n            // Calculate how well the overlay would fit into the viewport with this point.\n            let overlayFit = this._getOverlayFit(overlayPoint, overlayRect, viewportRect, pos);\n            // If the overlay, without any further work, fits into the viewport, use this position.\n            if (overlayFit.isCompletelyWithinViewport) {\n                this._isPushed = false;\n                this._applyPosition(pos, originPoint);\n                return;\n            }\n            // If the overlay has flexible dimensions, we can use this position\n            // so long as there's enough space for the minimum dimensions.\n            if (this._canFitWithFlexibleDimensions(overlayFit, overlayPoint, viewportRect)) {\n                // Save positions where the overlay will fit with flexible dimensions. We will use these\n                // if none of the positions fit *without* flexible dimensions.\n                flexibleFits.push({\n                    position: pos,\n                    origin: originPoint,\n                    overlayRect,\n                    boundingBoxRect: this._calculateBoundingBoxRect(originPoint, pos)\n                });\n                continue;\n            }\n            // If the current preferred position does not fit on the screen, remember the position\n            // if it has more visible area on-screen than we've seen and move onto the next preferred\n            // position.\n            if (!fallback || fallback.overlayFit.visibleArea < overlayFit.visibleArea) {\n                fallback = { overlayFit, overlayPoint, originPoint, position: pos, overlayRect };\n            }\n        }\n        // If there are any positions where the overlay would fit with flexible dimensions, choose the\n        // one that has the greatest area available modified by the position's weight\n        if (flexibleFits.length) {\n            let bestFit = null;\n            let bestScore = -1;\n            for (const fit of flexibleFits) {\n                const score = fit.boundingBoxRect.width * fit.boundingBoxRect.height * (fit.position.weight || 1);\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestFit = fit;\n                }\n            }\n            this._isPushed = false;\n            this._applyPosition(bestFit.position, bestFit.origin);\n            return;\n        }\n        // When none of the preferred positions fit within the viewport, take the position\n        // that went off-screen the least and attempt to push it on-screen.\n        if (this._canPush) {\n            // TODO(jelbourn): after pushing, the opening \"direction\" of the overlay might not make sense.\n            this._isPushed = true;\n            this._applyPosition(fallback.position, fallback.originPoint);\n            return;\n        }\n        // All options for getting the overlay within the viewport have been exhausted, so go with the\n        // position that went off-screen the least.\n        this._applyPosition(fallback.position, fallback.originPoint);\n    }\n    detach() {\n        this._clearPanelClasses();\n        this._lastPosition = null;\n        this._previousPushAmount = null;\n        this._resizeSubscription.unsubscribe();\n    }\n    /** Cleanup after the element gets destroyed. */\n    dispose() {\n        if (this._isDisposed) {\n            return;\n        }\n        // We can't use `_resetBoundingBoxStyles` here, because it resets\n        // some properties to zero, rather than removing them.\n        if (this._boundingBox) {\n            extendStyles(this._boundingBox.style, {\n                top: '',\n                left: '',\n                right: '',\n                bottom: '',\n                height: '',\n                width: '',\n                alignItems: '',\n                justifyContent: '',\n            });\n        }\n        if (this._pane) {\n            this._resetOverlayElementStyles();\n        }\n        if (this._overlayRef) {\n            this._overlayRef.hostElement.classList.remove(boundingBoxClass);\n        }\n        this.detach();\n        this._positionChanges.complete();\n        this._overlayRef = this._boundingBox = null;\n        this._isDisposed = true;\n    }\n    /**\n     * This re-aligns the overlay element with the trigger in its last calculated position,\n     * even if a position higher in the \"preferred positions\" list would now fit. This\n     * allows one to re-align the panel without changing the orientation of the panel.\n     */\n    reapplyLastPosition() {\n        if (!this._isDisposed && (!this._platform || this._platform.isBrowser)) {\n            this._originRect = this._getOriginRect();\n            this._overlayRect = this._pane.getBoundingClientRect();\n            this._viewportRect = this._getNarrowedViewportRect();\n            const lastPosition = this._lastPosition || this._preferredPositions[0];\n            const originPoint = this._getOriginPoint(this._originRect, lastPosition);\n            this._applyPosition(lastPosition, originPoint);\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, pos) {\n        let x;\n        if (pos.originX == 'center') {\n            // Note: when centering we should always use the `left`\n            // offset, otherwise the position will be wrong in RTL.\n            x = originRect.left + (originRect.width / 2);\n        }\n        else {\n            const startX = this._isRtl() ? originRect.right : originRect.left;\n            const endX = this._isRtl() ? originRect.left : originRect.right;\n            x = pos.originX == 'start' ? startX : endX;\n        }\n        let y;\n        if (pos.originY == 'center') {\n            y = originRect.top + (originRect.height / 2);\n        }\n        else {\n            y = pos.originY == 'top' ? originRect.top : originRect.bottom;\n        }\n        return { x, y };\n    }\n    /**\n     * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and\n     * origin point to which the overlay should be connected.\n     */\n    _getOverlayPoint(originPoint, overlayRect, pos) {\n        // Calculate the (overlayStartX, overlayStartY), the start of the\n        // potential overlay position relative to the origin point.\n        let overlayStartX;\n        if (pos.overlayX == 'center') {\n            overlayStartX = -overlayRect.width / 2;\n        }\n        else if (pos.overlayX === 'start') {\n            overlayStartX = this._isRtl() ? -overlayRect.width : 0;\n        }\n        else {\n            overlayStartX = this._isRtl() ? 0 : -overlayRect.width;\n        }\n        let overlayStartY;\n        if (pos.overlayY == 'center') {\n            overlayStartY = -overlayRect.height / 2;\n        }\n        else {\n            overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;\n        }\n        // The (x, y) coordinates of the overlay.\n        return {\n            x: originPoint.x + overlayStartX,\n            y: originPoint.y + overlayStartY,\n        };\n    }\n    /** Gets how well an overlay at the given point will fit within the viewport. */\n    _getOverlayFit(point, rawOverlayRect, viewport, position) {\n        // Round the overlay rect when comparing against the\n        // viewport, because the viewport is always rounded.\n        const overlay = getRoundedBoundingClientRect(rawOverlayRect);\n        let { x, y } = point;\n        let offsetX = this._getOffset(position, 'x');\n        let offsetY = this._getOffset(position, 'y');\n        // Account for the offsets since they could push the overlay out of the viewport.\n        if (offsetX) {\n            x += offsetX;\n        }\n        if (offsetY) {\n            y += offsetY;\n        }\n        // How much the overlay would overflow at this position, on each side.\n        let leftOverflow = 0 - x;\n        let rightOverflow = (x + overlay.width) - viewport.width;\n        let topOverflow = 0 - y;\n        let bottomOverflow = (y + overlay.height) - viewport.height;\n        // Visible parts of the element on each axis.\n        let visibleWidth = this._subtractOverflows(overlay.width, leftOverflow, rightOverflow);\n        let visibleHeight = this._subtractOverflows(overlay.height, topOverflow, bottomOverflow);\n        let visibleArea = visibleWidth * visibleHeight;\n        return {\n            visibleArea,\n            isCompletelyWithinViewport: (overlay.width * overlay.height) === visibleArea,\n            fitsInViewportVertically: visibleHeight === overlay.height,\n            fitsInViewportHorizontally: visibleWidth == overlay.width,\n        };\n    }\n    /**\n     * Whether the overlay can fit within the viewport when it may resize either its width or height.\n     * @param fit How well the overlay fits in the viewport at some position.\n     * @param point The (x, y) coordinates of the overlat 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 ||\n                (minHeight != null && minHeight <= availableHeight);\n            const horizontalFit = fit.fitsInViewportHorizontally ||\n                (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 occuring on the\n     * right and bottom).\n     *\n     * @param start Starting point from which the overlay is pushed.\n     * @param overlay Dimensions of the overlay.\n     * @param scrollPosition Current viewport scroll position.\n     * @returns The point at which to position the overlay after pushing. This is effectively a new\n     *     originPoint.\n     */\n    _pushOverlayOnScreen(start, rawOverlayRect, scrollPosition) {\n        // If the position is locked and we've pushed the overlay already, reuse the previous push\n        // amount, rather than pushing it again. If we were to continue pushing, the element would\n        // remain in the viewport, which goes against the expectations when position locking is enabled.\n        if (this._previousPushAmount && this._positionLocked) {\n            return {\n                x: start.x + this._previousPushAmount.x,\n                y: start.y + this._previousPushAmount.y\n            };\n        }\n        // Round the overlay rect when comparing against the\n        // viewport, because the viewport is always rounded.\n        const overlay = getRoundedBoundingClientRect(rawOverlayRect);\n        const viewport = this._viewportRect;\n        // Determine how much the overlay goes outside the viewport on each\n        // side, which we'll use to decide which direction to push it.\n        const overflowRight = Math.max(start.x + overlay.width - viewport.width, 0);\n        const overflowBottom = Math.max(start.y + overlay.height - viewport.height, 0);\n        const overflowTop = Math.max(viewport.top - scrollPosition.top - start.y, 0);\n        const overflowLeft = Math.max(viewport.left - scrollPosition.left - start.x, 0);\n        // Amount by which to push the overlay in each axis such that it remains on-screen.\n        let pushX = 0;\n        let pushY = 0;\n        // If the overlay fits completely within the bounds of the viewport, push it from whichever\n        // direction is goes off-screen. Otherwise, push the top-left corner such that its in the\n        // viewport and allow for the trailing end of the overlay to go out of bounds.\n        if (overlay.width <= viewport.width) {\n            pushX = overflowLeft || -overflowRight;\n        }\n        else {\n            pushX = start.x < this._viewportMargin ? (viewport.left - scrollPosition.left) - start.x : 0;\n        }\n        if (overlay.height <= viewport.height) {\n            pushY = overflowTop || -overflowBottom;\n        }\n        else {\n            pushY = start.y < this._viewportMargin ? (viewport.top - scrollPosition.top) - start.y : 0;\n        }\n        this._previousPushAmount = { x: pushX, y: pushY };\n        return {\n            x: start.x + pushX,\n            y: start.y + pushY,\n        };\n    }\n    /**\n     * Applies a computed position to the overlay and emits a position change.\n     * @param position The position preference\n     * @param originPoint The point on the origin element where the overlay is connected.\n     */\n    _applyPosition(position, originPoint) {\n        this._setTransformOrigin(position);\n        this._setOverlayElementStyles(originPoint, position);\n        this._setBoundingBoxStyles(originPoint, position);\n        if (position.panelClass) {\n            this._addPanelClasses(position.panelClass);\n        }\n        // Save the last connected position in case the position needs to be re-calculated.\n        this._lastPosition = position;\n        // Notify that the position has been changed along with its change properties.\n        // We only emit if we've got any subscriptions, because the scroll visibility\n        // calculcations can be somewhat expensive.\n        if (this._positionChanges.observers.length) {\n            const scrollableViewProperties = this._getScrollVisibility();\n            const changeEvent = new ConnectedOverlayPositionChange(position, scrollableViewProperties);\n            this._positionChanges.next(changeEvent);\n        }\n        this._isInitialRender = false;\n    }\n    /** Sets the transform origin based on the configured selector and the passed-in position.  */\n    _setTransformOrigin(position) {\n        if (!this._transformOriginSelector) {\n            return;\n        }\n        const elements = this._boundingBox.querySelectorAll(this._transformOriginSelector);\n        let xOrigin;\n        let yOrigin = position.overlayY;\n        if (position.overlayX === 'center') {\n            xOrigin = 'center';\n        }\n        else if (this._isRtl()) {\n            xOrigin = position.overlayX === 'start' ? 'right' : 'left';\n        }\n        else {\n            xOrigin = position.overlayX === 'start' ? 'left' : 'right';\n        }\n        for (let i = 0; i < elements.length; i++) {\n            elements[i].style.transformOrigin = `${xOrigin} ${yOrigin}`;\n        }\n    }\n    /**\n     * Gets the position and size of the overlay's sizing container.\n     *\n     * This method does no measuring and applies no styles so that we can cheaply compute the\n     * bounds for all positions and choose the best fit based on these results.\n     */\n    _calculateBoundingBoxRect(origin, position) {\n        const viewport = this._viewportRect;\n        const isRtl = this._isRtl();\n        let height, top, bottom;\n        if (position.overlayY === 'top') {\n            // Overlay is opening \"downward\" and thus is bound by the bottom viewport edge.\n            top = origin.y;\n            height = viewport.height - top + this._viewportMargin;\n        }\n        else if (position.overlayY === 'bottom') {\n            // Overlay is opening \"upward\" and thus is bound by the top viewport edge. We need to add\n            // the viewport margin back in, because the viewport rect is narrowed down to remove the\n            // margin, whereas the `origin` position is calculated based on its `ClientRect`.\n            bottom = viewport.height - origin.y + this._viewportMargin * 2;\n            height = viewport.height - bottom + this._viewportMargin;\n        }\n        else {\n            // If neither top nor bottom, it means that the overlay is vertically centered on the\n            // origin point. Note that we want the position relative to the viewport, rather than\n            // the page, which is why we don't use something like `viewport.bottom - origin.y` and\n            // `origin.y - viewport.top`.\n            const smallestDistanceToViewportEdge = Math.min(viewport.bottom - origin.y + viewport.top, origin.y);\n            const previousHeight = this._lastBoundingBoxSize.height;\n            height = smallestDistanceToViewportEdge * 2;\n            top = origin.y - smallestDistanceToViewportEdge;\n            if (height > previousHeight && !this._isInitialRender && !this._growAfterOpen) {\n                top = origin.y - (previousHeight / 2);\n            }\n        }\n        // The overlay is opening 'right-ward' (the content flows to the right).\n        const isBoundedByRightViewportEdge = (position.overlayX === 'start' && !isRtl) ||\n            (position.overlayX === 'end' && isRtl);\n        // The overlay is opening 'left-ward' (the content flows to the left).\n        const isBoundedByLeftViewportEdge = (position.overlayX === 'end' && !isRtl) ||\n            (position.overlayX === 'start' && isRtl);\n        let width, left, right;\n        if (isBoundedByLeftViewportEdge) {\n            right = viewport.width - origin.x + this._viewportMargin;\n            width = origin.x - this._viewportMargin;\n        }\n        else if (isBoundedByRightViewportEdge) {\n            left = origin.x;\n            width = viewport.right - origin.x;\n        }\n        else {\n            // If neither start nor end, it means that the overlay is horizontally centered on the\n            // origin point. Note that we want the position relative to the viewport, rather than\n            // the page, which is why we don't use something like `viewport.right - origin.x` and\n            // `origin.x - viewport.left`.\n            const smallestDistanceToViewportEdge = Math.min(viewport.right - origin.x + viewport.left, origin.x);\n            const previousWidth = this._lastBoundingBoxSize.width;\n            width = smallestDistanceToViewportEdge * 2;\n            left = origin.x - smallestDistanceToViewportEdge;\n            if (width > previousWidth && !this._isInitialRender && !this._growAfterOpen) {\n                left = origin.x - (previousWidth / 2);\n            }\n        }\n        return { top: top, left: left, bottom: bottom, right: right, width, height };\n    }\n    /**\n     * Sets the position and size of the overlay's sizing wrapper. The wrapper is positioned on the\n     * origin's connection point and stetches to the bounds of the viewport.\n     *\n     * @param origin The point on the origin element where the overlay is connected.\n     * @param position The position preference\n     */\n    _setBoundingBoxStyles(origin, position) {\n        const boundingBoxRect = this._calculateBoundingBoxRect(origin, position);\n        // It's weird if the overlay *grows* while scrolling, so we take the last size into account\n        // when applying a new size.\n        if (!this._isInitialRender && !this._growAfterOpen) {\n            boundingBoxRect.height = Math.min(boundingBoxRect.height, this._lastBoundingBoxSize.height);\n            boundingBoxRect.width = Math.min(boundingBoxRect.width, this._lastBoundingBoxSize.width);\n        }\n        const styles = {};\n        if (this._hasExactPosition()) {\n            styles.top = styles.left = '0';\n            styles.bottom = styles.right = styles.maxHeight = styles.maxWidth = '';\n            styles.width = styles.height = '100%';\n        }\n        else {\n            const maxHeight = this._overlayRef.getConfig().maxHeight;\n            const maxWidth = this._overlayRef.getConfig().maxWidth;\n            styles.height = coerceCssPixelValue(boundingBoxRect.height);\n            styles.top = coerceCssPixelValue(boundingBoxRect.top);\n            styles.bottom = coerceCssPixelValue(boundingBoxRect.bottom);\n            styles.width = coerceCssPixelValue(boundingBoxRect.width);\n            styles.left = coerceCssPixelValue(boundingBoxRect.left);\n            styles.right = coerceCssPixelValue(boundingBoxRect.right);\n            // Push the pane content towards the proper direction.\n            if (position.overlayX === 'center') {\n                styles.alignItems = 'center';\n            }\n            else {\n                styles.alignItems = position.overlayX === 'end' ? 'flex-end' : 'flex-start';\n            }\n            if (position.overlayY === 'center') {\n                styles.justifyContent = 'center';\n            }\n            else {\n                styles.justifyContent = position.overlayY === 'bottom' ? 'flex-end' : 'flex-start';\n            }\n            if (maxHeight) {\n                styles.maxHeight = coerceCssPixelValue(maxHeight);\n            }\n            if (maxWidth) {\n                styles.maxWidth = coerceCssPixelValue(maxWidth);\n            }\n        }\n        this._lastBoundingBoxSize = boundingBoxRect;\n        extendStyles(this._boundingBox.style, styles);\n    }\n    /** Resets the styles for the bounding box so that a new positioning can be computed. */\n    _resetBoundingBoxStyles() {\n        extendStyles(this._boundingBox.style, {\n            top: '0',\n            left: '0',\n            right: '0',\n            bottom: '0',\n            height: '',\n            width: '',\n            alignItems: '',\n            justifyContent: '',\n        });\n    }\n    /** Resets the styles for the overlay pane so that a new positioning can be computed. */\n    _resetOverlayElementStyles() {\n        extendStyles(this._pane.style, {\n            top: '',\n            left: '',\n            bottom: '',\n            right: '',\n            position: '',\n            transform: '',\n        });\n    }\n    /** Sets positioning styles to the overlay element. */\n    _setOverlayElementStyles(originPoint, position) {\n        const styles = {};\n        const hasExactPosition = this._hasExactPosition();\n        const hasFlexibleDimensions = this._hasFlexibleDimensions;\n        const config = this._overlayRef.getConfig();\n        if (hasExactPosition) {\n            const scrollPosition = this._viewportRuler.getViewportScrollPosition();\n            extendStyles(styles, this._getExactOverlayY(position, originPoint, scrollPosition));\n            extendStyles(styles, this._getExactOverlayX(position, originPoint, scrollPosition));\n        }\n        else {\n            styles.position = 'static';\n        }\n        // Use a transform to apply the offsets. We do this because the `center` positions rely on\n        // being in the normal flex flow and setting a `top` / `left` at all will completely throw\n        // off the position. We also can't use margins, because they won't have an effect in some\n        // cases where the element doesn't have anything to \"push off of\". Finally, this works\n        // better both with flexible and non-flexible positioning.\n        let transformString = '';\n        let offsetX = this._getOffset(position, 'x');\n        let offsetY = this._getOffset(position, 'y');\n        if (offsetX) {\n            transformString += `translateX(${offsetX}px) `;\n        }\n        if (offsetY) {\n            transformString += `translateY(${offsetY}px)`;\n        }\n        styles.transform = transformString.trim();\n        // If a maxWidth or maxHeight is specified on the overlay, we remove them. We do this because\n        // we need these values to both be set to \"100%\" for the automatic flexible sizing to work.\n        // The maxHeight and maxWidth are set on the boundingBox in order to enforce the constraint.\n        // Note that this doesn't apply when we have an exact position, in which case we do want to\n        // apply them because they'll be cleared from the bounding box.\n        if (config.maxHeight) {\n            if (hasExactPosition) {\n                styles.maxHeight = coerceCssPixelValue(config.maxHeight);\n            }\n            else if (hasFlexibleDimensions) {\n                styles.maxHeight = '';\n            }\n        }\n        if (config.maxWidth) {\n            if (hasExactPosition) {\n                styles.maxWidth = coerceCssPixelValue(config.maxWidth);\n            }\n            else if (hasFlexibleDimensions) {\n                styles.maxWidth = '';\n            }\n        }\n        extendStyles(this._pane.style, styles);\n    }\n    /** Gets the exact top/bottom for the overlay when not using flexible sizing or when pushing. */\n    _getExactOverlayY(position, originPoint, scrollPosition) {\n        // Reset any existing styles. This is necessary in case the\n        // preferred position has changed since the last `apply`.\n        let styles = { top: '', bottom: '' };\n        let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);\n        if (this._isPushed) {\n            overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);\n        }\n        let virtualKeyboardOffset = this._overlayContainer.getContainerElement().getBoundingClientRect().top;\n        // Normally this would be zero, however when the overlay is attached to an input (e.g. in an\n        // 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        overlayPoint.y -= virtualKeyboardOffset;\n        // We want to set either `top` or `bottom` based on whether the overlay wants to appear\n        // above or below the origin and the direction in which the element will expand.\n        if (position.overlayY === 'bottom') {\n            // When using `bottom`, we adjust the y position such that it is the distance\n            // from the bottom of the viewport rather than the top.\n            const documentHeight = this._document.documentElement.clientHeight;\n            styles.bottom = `${documentHeight - (overlayPoint.y + this._overlayRect.height)}px`;\n        }\n        else {\n            styles.top = coerceCssPixelValue(overlayPoint.y);\n        }\n        return styles;\n    }\n    /** Gets the exact left/right for the overlay when not using flexible sizing or when pushing. */\n    _getExactOverlayX(position, originPoint, scrollPosition) {\n        // Reset any existing styles. This is necessary in case the preferred position has\n        // changed since the last `apply`.\n        let styles = { left: '', right: '' };\n        let overlayPoint = this._getOverlayPoint(originPoint, this._overlayRect, position);\n        if (this._isPushed) {\n            overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);\n        }\n        // We want to set either `left` or `right` based on whether the overlay wants to appear \"before\"\n        // or \"after\" the origin, which determines the direction in which the element will expand.\n        // For the horizontal axis, the meaning of \"before\" and \"after\" change based on whether the\n        // page is in RTL or LTR.\n        let horizontalStyleProperty;\n        if (this._isRtl()) {\n            horizontalStyleProperty = position.overlayX === 'end' ? 'left' : 'right';\n        }\n        else {\n            horizontalStyleProperty = position.overlayX === 'end' ? 'right' : 'left';\n        }\n        // When we're setting `right`, we adjust the x position such that it is the distance\n        // from the right edge of the viewport rather than the left edge.\n        if (horizontalStyleProperty === 'right') {\n            const documentWidth = this._document.documentElement.clientWidth;\n            styles.right = `${documentWidth - (overlayPoint.x + this._overlayRect.width)}px`;\n        }\n        else {\n            styles.left = coerceCssPixelValue(overlayPoint.x);\n        }\n        return styles;\n    }\n    /**\n     * Gets the view properties of the trigger and overlay, including whether they are clipped\n     * or completely outside the view of any of the strategy's scrollables.\n     */\n    _getScrollVisibility() {\n        // Note: needs fresh rects since the position could've changed.\n        const originBounds = this._getOriginRect();\n        const overlayBounds = this._pane.getBoundingClientRect();\n        // TODO(jelbourn): instead of needing all of the client rects for these scrolling containers\n        // every time, we should be able to use the scrollTop of the containers if the size of those\n        // containers hasn't changed.\n        const scrollContainerBounds = this._scrollables.map(scrollable => {\n            return scrollable.getElementRef().nativeElement.getBoundingClientRect();\n        });\n        return {\n            isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),\n            isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),\n            isOverlayClipped: isElementClippedByScrolling(overlayBounds, scrollContainerBounds),\n            isOverlayOutsideView: isElementScrolledOutsideView(overlayBounds, scrollContainerBounds),\n        };\n    }\n    /** Subtracts the amount that an element is overflowing on an axis from its length. */\n    _subtractOverflows(length, ...overflows) {\n        return overflows.reduce((currentValue, currentOverflow) => {\n            return currentValue - Math.max(currentOverflow, 0);\n        }, length);\n    }\n    /** Narrows the given viewport rect by the current _viewportMargin. */\n    _getNarrowedViewportRect() {\n        // We recalculate the viewport rect here ourselves, rather than using the ViewportRuler,\n        // because we want to use the `clientWidth` and `clientHeight` as the base. The difference\n        // being that the client properties don't include the scrollbar, as opposed to `innerWidth`\n        // and `innerHeight` that do. This is necessary, because the overlay container uses\n        // 100% `width` and `height` which don't include the scrollbar either.\n        const width = this._document.documentElement.clientWidth;\n        const height = this._document.documentElement.clientHeight;\n        const scrollPosition = this._viewportRuler.getViewportScrollPosition();\n        return {\n            top: scrollPosition.top + this._viewportMargin,\n            left: scrollPosition.left + this._viewportMargin,\n            right: scrollPosition.left + width - this._viewportMargin,\n            bottom: scrollPosition.top + height - this._viewportMargin,\n            width: width - (2 * this._viewportMargin),\n            height: height - (2 * this._viewportMargin),\n        };\n    }\n    /** Whether the we're dealing with an RTL context */\n    _isRtl() {\n        return this._overlayRef.getDirection() === 'rtl';\n    }\n    /** Determines whether the overlay uses exact or flexible positioning. */\n    _hasExactPosition() {\n        return !this._hasFlexibleDimensions || this._isPushed;\n    }\n    /** Retrieves the offset of a position along the x or y axis. */\n    _getOffset(position, axis) {\n        if (axis === 'x') {\n            // We don't do something like `position['offset' + axis]` in\n            // order to avoid breking minifiers that rename properties.\n            return position.offsetX == null ? this._offsetX : position.offsetX;\n        }\n        return position.offsetY == null ? this._offsetY : position.offsetY;\n    }\n    /** Validates that the current position match the expected values. */\n    _validatePositions() {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!this._preferredPositions.length) {\n                throw Error('FlexibleConnectedPositionStrategy: At least one position is required.');\n            }\n            // TODO(crisbeto): remove these once Angular's template type\n            // checking is advanced enough to catch these cases.\n            this._preferredPositions.forEach(pair => {\n                validateHorizontalPosition('originX', pair.originX);\n                validateVerticalPosition('originY', pair.originY);\n                validateHorizontalPosition('overlayX', pair.overlayX);\n                validateVerticalPosition('overlayY', pair.overlayY);\n            });\n        }\n    }\n    /** Adds a single CSS class or an array of classes on the overlay panel. */\n    _addPanelClasses(cssClasses) {\n        if (this._pane) {\n            coerceArray(cssClasses).forEach(cssClass => {\n                if (cssClass !== '' && this._appliedPanelClasses.indexOf(cssClass) === -1) {\n                    this._appliedPanelClasses.push(cssClass);\n                    this._pane.classList.add(cssClass);\n                }\n            });\n        }\n    }\n    /** Clears the classes that the position strategy has applied from the overlay panel. */\n    _clearPanelClasses() {\n        if (this._pane) {\n            this._appliedPanelClasses.forEach(cssClass => {\n                this._pane.classList.remove(cssClass);\n            });\n            this._appliedPanelClasses = [];\n        }\n    }\n    /** Returns the ClientRect of the current origin. */\n    _getOriginRect() {\n        const origin = this._origin;\n        if (origin instanceof ElementRef) {\n            return origin.nativeElement.getBoundingClientRect();\n        }\n        // Check for Element so SVG elements are also supported.\n        if (origin instanceof Element) {\n            return origin.getBoundingClientRect();\n        }\n        const width = origin.width || 0;\n        const height = origin.height || 0;\n        // If the origin is a point, return a client rect as if it was a 0x0 element at the point.\n        return {\n            top: origin.y,\n            bottom: origin.y + height,\n            left: origin.x,\n            right: origin.x + width,\n            height,\n            width\n        };\n    }\n}\n/** Shallow-extends a stylesheet object with another stylesheet object. */\nfunction extendStyles(destination, source) {\n    for (let key in source) {\n        if (source.hasOwnProperty(key)) {\n            destination[key] = source[key];\n        }\n    }\n    return destination;\n}\n/**\n * Extracts the pixel value as a number from a value, if it's a number\n * or a CSS pixel string (e.g. `1337px`). Otherwise returns null.\n */\nfunction getPixelValue(input) {\n    if (typeof input !== 'number' && input != null) {\n        const [value, units] = input.split(cssUnitPattern);\n        return (!units || units === 'px') ? parseFloat(value) : null;\n    }\n    return input || null;\n}\n/**\n * Gets a version of an element's bounding `ClientRect` where all the values are rounded down to\n * the nearest pixel. This allows us to account for the cases where there may be sub-pixel\n * deviations in the `ClientRect` returned by the browser (e.g. when zoomed in with a percentage\n * size, see #21350).\n */\nfunction getRoundedBoundingClientRect(clientRect) {\n    return {\n        top: Math.floor(clientRect.top),\n        right: Math.floor(clientRect.right),\n        bottom: Math.floor(clientRect.bottom),\n        left: Math.floor(clientRect.left),\n        width: Math.floor(clientRect.width),\n        height: Math.floor(clientRect.height)\n    };\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * implicit position relative to 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 * @deprecated Use `FlexibleConnectedPositionStrategy` instead.\n * @breaking-change 8.0.0\n */\nclass ConnectedPositionStrategy {\n    constructor(originPos, overlayPos, connectedTo, viewportRuler, document, platform, overlayContainer) {\n        /** Ordered list of preferred positions, from most to least desirable. */\n        this._preferredPositions = [];\n        // Since the `ConnectedPositionStrategy` is deprecated and we don't want to maintain\n        // the extra logic, we create an instance of the positioning strategy that has some\n        // defaults that make it behave as the old position strategy and to which we'll\n        // proxy all of the API calls.\n        this._positionStrategy = new FlexibleConnectedPositionStrategy(connectedTo, viewportRuler, document, platform, overlayContainer)\n            .withFlexibleDimensions(false)\n            .withPush(false)\n            .withViewportMargin(0);\n        this.withFallbackPosition(originPos, overlayPos);\n        this.onPositionChange = this._positionStrategy.positionChanges;\n    }\n    /** Ordered list of preferred positions, from most to least desirable. */\n    get positions() {\n        return this._preferredPositions;\n    }\n    /** Attach this position strategy to an overlay. */\n    attach(overlayRef) {\n        this._overlayRef = overlayRef;\n        this._positionStrategy.attach(overlayRef);\n        if (this._direction) {\n            overlayRef.setDirection(this._direction);\n            this._direction = null;\n        }\n    }\n    /** Disposes all resources used by the position strategy. */\n    dispose() {\n        this._positionStrategy.dispose();\n    }\n    /** @docs-private */\n    detach() {\n        this._positionStrategy.detach();\n    }\n    /**\n     * Updates the position of the overlay element, using whichever preferred position relative\n     * to the origin fits on-screen.\n     * @docs-private\n     */\n    apply() {\n        this._positionStrategy.apply();\n    }\n    /**\n     * Re-positions 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    recalculateLastPosition() {\n        this._positionStrategy.reapplyLastPosition();\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._positionStrategy.withScrollableContainers(scrollables);\n    }\n    /**\n     * Adds a new preferred fallback position.\n     * @param originPos\n     * @param overlayPos\n     */\n    withFallbackPosition(originPos, overlayPos, offsetX, offsetY) {\n        const position = new ConnectionPositionPair(originPos, overlayPos, offsetX, offsetY);\n        this._preferredPositions.push(position);\n        this._positionStrategy.withPositions(this._preferredPositions);\n        return this;\n    }\n    /**\n     * Sets the layout direction so the overlay's position can be adjusted to match.\n     * @param dir New layout direction.\n     */\n    withDirection(dir) {\n        // Since the direction might be declared before the strategy is attached,\n        // we save the value in a temporary property and we'll transfer it to the\n        // overlay ref on attachment.\n        if (this._overlayRef) {\n            this._overlayRef.setDirection(dir);\n        }\n        else {\n            this._direction = dir;\n        }\n        return this;\n    }\n    /**\n     * Sets an offset for the overlay's connection point on the x-axis\n     * @param offset New offset in the X axis.\n     */\n    withOffsetX(offset) {\n        this._positionStrategy.withDefaultOffsetX(offset);\n        return this;\n    }\n    /**\n     * Sets an offset for the overlay's connection point on the y-axis\n     * @param  offset New offset in the Y axis.\n     */\n    withOffsetY(offset) {\n        this._positionStrategy.withDefaultOffsetY(offset);\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) {\n        this._positionStrategy.withLockedPosition(isLocked);\n        return this;\n    }\n    /**\n     * Overwrites the current set of positions with an array of new ones.\n     * @param positions Position pairs to be set on the strategy.\n     */\n    withPositions(positions) {\n        this._preferredPositions = positions.slice();\n        this._positionStrategy.withPositions(this._preferredPositions);\n        return this;\n    }\n    /**\n     * Sets the origin element, relative to which to position the overlay.\n     * @param origin Reference to the new origin element.\n     */\n    setOrigin(origin) {\n        this._positionStrategy.setOrigin(origin);\n        return this;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Class to be added to the overlay pane wrapper. */\nconst wrapperClass = 'cdk-global-overlay-wrapper';\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * explicit position relative to the browser's viewport. We use flexbox, instead of\n * transforms, in order to avoid issues with subpixel rendering which can cause the\n * element to become blurry.\n */\nclass GlobalPositionStrategy {\n    constructor() {\n        this._cssPosition = 'static';\n        this._topOffset = '';\n        this._bottomOffset = '';\n        this._leftOffset = '';\n        this._rightOffset = '';\n        this._alignItems = '';\n        this._justifyContent = '';\n        this._width = '';\n        this._height = '';\n    }\n    attach(overlayRef) {\n        const config = overlayRef.getConfig();\n        this._overlayRef = overlayRef;\n        if (this._width && !config.width) {\n            overlayRef.updateSize({ width: this._width });\n        }\n        if (this._height && !config.height) {\n            overlayRef.updateSize({ height: this._height });\n        }\n        overlayRef.hostElement.classList.add(wrapperClass);\n        this._isDisposed = false;\n    }\n    /**\n     * Sets the top position of the overlay. Clears any previously set vertical position.\n     * @param value New top offset.\n     */\n    top(value = '') {\n        this._bottomOffset = '';\n        this._topOffset = value;\n        this._alignItems = 'flex-start';\n        return this;\n    }\n    /**\n     * Sets the left position of the overlay. Clears any previously set horizontal position.\n     * @param value New left offset.\n     */\n    left(value = '') {\n        this._rightOffset = '';\n        this._leftOffset = value;\n        this._justifyContent = 'flex-start';\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._leftOffset = '';\n        this._rightOffset = value;\n        this._justifyContent = 'flex-end';\n        return this;\n    }\n    /**\n     * Sets the overlay width and clears any previously set width.\n     * @param value New width for the overlay\n     * @deprecated Pass the `width` through the `OverlayConfig`.\n     * @breaking-change 8.0.0\n     */\n    width(value = '') {\n        if (this._overlayRef) {\n            this._overlayRef.updateSize({ width: value });\n        }\n        else {\n            this._width = value;\n        }\n        return this;\n    }\n    /**\n     * Sets the overlay height and clears any previously set height.\n     * @param value New height for the overlay\n     * @deprecated Pass the `height` through the `OverlayConfig`.\n     * @breaking-change 8.0.0\n     */\n    height(value = '') {\n        if (this._overlayRef) {\n            this._overlayRef.updateSize({ height: value });\n        }\n        else {\n            this._height = value;\n        }\n        return this;\n    }\n    /**\n     * Centers the overlay horizontally with an optional offset.\n     * Clears any previously set horizontal position.\n     *\n     * @param offset Overlay offset from the horizontal center.\n     */\n    centerHorizontally(offset = '') {\n        this.left(offset);\n        this._justifyContent = 'center';\n        return this;\n    }\n    /**\n     * Centers the overlay vertically with an optional offset.\n     * Clears any previously set vertical position.\n     *\n     * @param offset Overlay offset from the vertical center.\n     */\n    centerVertically(offset = '') {\n        this.top(offset);\n        this._alignItems = 'center';\n        return this;\n    }\n    /**\n     * Apply the position to the element.\n     * @docs-private\n     */\n    apply() {\n        // Since the overlay ref applies the strategy asynchronously, it could\n        // have been disposed before it ends up being applied. If that is the\n        // case, we shouldn't do anything.\n        if (!this._overlayRef || !this._overlayRef.hasAttached()) {\n            return;\n        }\n        const styles = this._overlayRef.overlayElement.style;\n        const parentStyles = this._overlayRef.hostElement.style;\n        const config = this._overlayRef.getConfig();\n        const { width, height, maxWidth, maxHeight } = config;\n        const shouldBeFlushHorizontally = (width === '100%' || width === '100vw') &&\n            (!maxWidth || maxWidth === '100%' || maxWidth === '100vw');\n        const shouldBeFlushVertically = (height === '100%' || height === '100vh') &&\n            (!maxHeight || maxHeight === '100%' || maxHeight === '100vh');\n        styles.position = this._cssPosition;\n        styles.marginLeft = shouldBeFlushHorizontally ? '0' : this._leftOffset;\n        styles.marginTop = shouldBeFlushVertically ? '0' : this._topOffset;\n        styles.marginBottom = this._bottomOffset;\n        styles.marginRight = this._rightOffset;\n        if (shouldBeFlushHorizontally) {\n            parentStyles.justifyContent = 'flex-start';\n        }\n        else if (this._justifyContent === 'center') {\n            parentStyles.justifyContent = 'center';\n        }\n        else if (this._overlayRef.getConfig().direction === 'rtl') {\n            // In RTL the browser will invert `flex-start` and `flex-end` automatically, but we\n            // don't want that because our positioning is explicitly `left` and `right`, hence\n            // why we do another inversion to ensure that the overlay stays in the same position.\n            // TODO: reconsider this if we add `start` and `end` methods.\n            if (this._justifyContent === 'flex-start') {\n                parentStyles.justifyContent = 'flex-end';\n            }\n            else if (this._justifyContent === 'flex-end') {\n                parentStyles.justifyContent = 'flex-start';\n            }\n        }\n        else {\n            parentStyles.justifyContent = this._justifyContent;\n        }\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 =\n            styles.marginBottom = styles.marginLeft = styles.marginRight = styles.position = '';\n        this._overlayRef = null;\n        this._isDisposed = true;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Builder for overlay position strategy. */\nclass OverlayPositionBuilder {\n    constructor(_viewportRuler, _document, _platform, _overlayContainer) {\n        this._viewportRuler = _viewportRuler;\n        this._document = _document;\n        this._platform = _platform;\n        this._overlayContainer = _overlayContainer;\n    }\n    /**\n     * Creates a global position strategy.\n     */\n    global() {\n        return new GlobalPositionStrategy();\n    }\n    /**\n     * Creates a relative position strategy.\n     * @param elementRef\n     * @param originPos\n     * @param overlayPos\n     * @deprecated Use `flexibleConnectedTo` instead.\n     * @breaking-change 8.0.0\n     */\n    connectedTo(elementRef, originPos, overlayPos) {\n        return new ConnectedPositionStrategy(originPos, overlayPos, elementRef, this._viewportRuler, this._document, this._platform, this._overlayContainer);\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}\nOverlayPositionBuilder.ɵfac = function OverlayPositionBuilder_Factory(t) { return new (t || OverlayPositionBuilder)(ɵngcc0.ɵɵinject(ɵngcc1.ViewportRuler), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform), ɵngcc0.ɵɵinject(OverlayContainer)); };\nOverlayPositionBuilder.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayPositionBuilder_Factory() { return new OverlayPositionBuilder(i0.ɵɵinject(i1.ViewportRuler), i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform), i0.ɵɵinject(OverlayContainer)); }, token: OverlayPositionBuilder, providedIn: \"root\" });\nOverlayPositionBuilder.ctorParameters = () => [\n    { type: ViewportRuler },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform },\n    { type: OverlayContainer }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(OverlayPositionBuilder, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.ViewportRuler }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }, { type: OverlayContainer }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Next overlay unique ID. */\nlet nextUniqueId = 0;\n// Note that Overlay is *not* scoped to the app root because of the ComponentFactoryResolver\n// which needs to be different depending on where OverlayModule is imported.\n/**\n * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be\n * used as a low-level building block for other components. Dialogs, tooltips, menus,\n * selects, etc. can all be built using overlays. The service should primarily be used by authors\n * of re-usable components rather than developers building end-user applications.\n *\n * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.\n */\nclass Overlay {\n    constructor(\n    /** Scrolling strategies that can be used when creating an overlay. */\n    scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _injector, _ngZone, _document, _directionality, _location, _outsideClickDispatcher) {\n        this.scrollStrategies = scrollStrategies;\n        this._overlayContainer = _overlayContainer;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._positionBuilder = _positionBuilder;\n        this._keyboardDispatcher = _keyboardDispatcher;\n        this._injector = _injector;\n        this._ngZone = _ngZone;\n        this._document = _document;\n        this._directionality = _directionality;\n        this._location = _location;\n        this._outsideClickDispatcher = _outsideClickDispatcher;\n    }\n    /**\n     * Creates an overlay.\n     * @param config Configuration applied to the overlay.\n     * @returns Reference to the created overlay.\n     */\n    create(config) {\n        const host = this._createHostElement();\n        const pane = this._createPaneElement(host);\n        const portalOutlet = this._createPortalOutlet(pane);\n        const overlayConfig = new OverlayConfig(config);\n        overlayConfig.direction = overlayConfig.direction || this._directionality.value;\n        return new OverlayRef(portalOutlet, host, pane, overlayConfig, this._ngZone, this._keyboardDispatcher, this._document, this._location, this._outsideClickDispatcher);\n    }\n    /**\n     * Gets a position builder that can be used, via fluent API,\n     * to construct and configure a position strategy.\n     * @returns An overlay position builder.\n     */\n    position() {\n        return this._positionBuilder;\n    }\n    /**\n     * Creates the DOM element for an overlay and appends it to the overlay container.\n     * @returns Newly-created pane element\n     */\n    _createPaneElement(host) {\n        const pane = this._document.createElement('div');\n        pane.id = `cdk-overlay-${nextUniqueId++}`;\n        pane.classList.add('cdk-overlay-pane');\n        host.appendChild(pane);\n        return pane;\n    }\n    /**\n     * Creates the host element that wraps around an overlay\n     * and can be used for advanced positioning.\n     * @returns Newly-create host element.\n     */\n    _createHostElement() {\n        const host = this._document.createElement('div');\n        this._overlayContainer.getContainerElement().appendChild(host);\n        return host;\n    }\n    /**\n     * Create a DomPortalOutlet into which the overlay content can be loaded.\n     * @param pane The DOM element to turn into a portal outlet.\n     * @returns A portal outlet for the given DOM element.\n     */\n    _createPortalOutlet(pane) {\n        // We have to resolve the ApplicationRef later in order to allow people\n        // to use overlay-based providers during app initialization.\n        if (!this._appRef) {\n            this._appRef = this._injector.get(ApplicationRef);\n        }\n        return new DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector, this._document);\n    }\n}\nOverlay.ɵfac = function Overlay_Factory(t) { return new (t || Overlay)(ɵngcc0.ɵɵinject(ScrollStrategyOptions), ɵngcc0.ɵɵinject(OverlayContainer), ɵngcc0.ɵɵinject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵinject(OverlayPositionBuilder), ɵngcc0.ɵɵinject(OverlayKeyboardDispatcher), ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc3.Directionality), ɵngcc0.ɵɵinject(ɵngcc4.Location), ɵngcc0.ɵɵinject(OverlayOutsideClickDispatcher)); };\nOverlay.ɵprov = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjectable({ token: Overlay, factory: Overlay.ɵfac });\nOverlay.ctorParameters = () => [\n    { type: ScrollStrategyOptions },\n    { type: OverlayContainer },\n    { type: ComponentFactoryResolver },\n    { type: OverlayPositionBuilder },\n    { type: OverlayKeyboardDispatcher },\n    { type: Injector },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Directionality },\n    { type: Location },\n    { type: OverlayOutsideClickDispatcher }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(Overlay, [{\n        type: Injectable\n    }], function () { return [{ type: ScrollStrategyOptions }, { type: OverlayContainer }, { type: ɵngcc0.ComponentFactoryResolver }, { type: OverlayPositionBuilder }, { type: OverlayKeyboardDispatcher }, { type: ɵngcc0.Injector }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc3.Directionality }, { type: ɵngcc4.Location }, { type: OverlayOutsideClickDispatcher }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Default set of positions for the overlay. Follows the behavior of a dropdown. */\nconst defaultPositionList = [\n    {\n        originX: 'start',\n        originY: 'bottom',\n        overlayX: 'start',\n        overlayY: 'top'\n    },\n    {\n        originX: 'start',\n        originY: 'top',\n        overlayX: 'start',\n        overlayY: 'bottom'\n    },\n    {\n        originX: 'end',\n        originY: 'top',\n        overlayX: 'end',\n        overlayY: 'bottom'\n    },\n    {\n        originX: 'end',\n        originY: 'bottom',\n        overlayX: 'end',\n        overlayY: 'top'\n    }\n];\n/** Injection token that determines the scroll handling while the connected overlay is open. */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = new InjectionToken('cdk-connected-overlay-scroll-strategy');\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\nclass CdkOverlayOrigin {\n    constructor(\n    /** Reference to the element on which the directive is applied. */\n    elementRef) {\n        this.elementRef = elementRef;\n    }\n}\nCdkOverlayOrigin.ɵfac = function CdkOverlayOrigin_Factory(t) { return new (t || CdkOverlayOrigin)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef)); };\nCdkOverlayOrigin.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkOverlayOrigin, selectors: [[\"\", \"cdk-overlay-origin\", \"\"], [\"\", \"overlay-origin\", \"\"], [\"\", \"cdkOverlayOrigin\", \"\"]], exportAs: [\"cdkOverlayOrigin\"] });\nCdkOverlayOrigin.ctorParameters = () => [\n    { type: ElementRef }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkOverlayOrigin, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',\n                exportAs: 'cdkOverlayOrigin'\n            }]\n    }], function () { return [{ type: ɵngcc0.ElementRef }]; }, null); })();\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\nclass CdkConnectedOverlay {\n    // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.\n    constructor(_overlay, templateRef, viewContainerRef, scrollStrategyFactory, _dir) {\n        this._overlay = _overlay;\n        this._dir = _dir;\n        this._hasBackdrop = false;\n        this._lockPosition = false;\n        this._growAfterOpen = false;\n        this._flexibleDimensions = false;\n        this._push = false;\n        this._backdropSubscription = Subscription.EMPTY;\n        this._attachSubscription = Subscription.EMPTY;\n        this._detachSubscription = Subscription.EMPTY;\n        this._positionSubscription = Subscription.EMPTY;\n        /** Margin between the overlay and the viewport edges. */\n        this.viewportMargin = 0;\n        /** Whether the overlay is open. */\n        this.open = false;\n        /** Whether the overlay can be closed by user interaction. */\n        this.disableClose = false;\n        /** Event emitted when the backdrop is clicked. */\n        this.backdropClick = new EventEmitter();\n        /** Event emitted when the position has changed. */\n        this.positionChange = new EventEmitter();\n        /** Event emitted when the overlay has been attached. */\n        this.attach = new EventEmitter();\n        /** Event emitted when the overlay has been detached. */\n        this.detach = new EventEmitter();\n        /** Emits when there are keyboard events that are targeted at the overlay. */\n        this.overlayKeydown = new EventEmitter();\n        /** Emits when there are mouse outside click events that are targeted at the overlay. */\n        this.overlayOutsideClick = new EventEmitter();\n        this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\n        this._scrollStrategyFactory = scrollStrategyFactory;\n        this.scrollStrategy = this._scrollStrategyFactory();\n    }\n    /** The offset in pixels for the overlay connection point on the x-axis */\n    get offsetX() { return this._offsetX; }\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() { return this._offsetY; }\n    set offsetY(offsetY) {\n        this._offsetY = offsetY;\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n        }\n    }\n    /** Whether or not the overlay should attach a backdrop. */\n    get hasBackdrop() { return this._hasBackdrop; }\n    set hasBackdrop(value) { this._hasBackdrop = coerceBooleanProperty(value); }\n    /** Whether or not the overlay should be locked when scrolling. */\n    get lockPosition() { return this._lockPosition; }\n    set lockPosition(value) { this._lockPosition = coerceBooleanProperty(value); }\n    /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n    get flexibleDimensions() { return this._flexibleDimensions; }\n    set flexibleDimensions(value) {\n        this._flexibleDimensions = coerceBooleanProperty(value);\n    }\n    /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n    get growAfterOpen() { return this._growAfterOpen; }\n    set growAfterOpen(value) { this._growAfterOpen = coerceBooleanProperty(value); }\n    /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n    get push() { return this._push; }\n    set push(value) { this._push = coerceBooleanProperty(value); }\n    /** The associated overlay reference. */\n    get overlayRef() {\n        return this._overlayRef;\n    }\n    /** The element's layout direction. */\n    get dir() {\n        return this._dir ? this._dir.value : 'ltr';\n    }\n    ngOnDestroy() {\n        this._attachSubscription.unsubscribe();\n        this._detachSubscription.unsubscribe();\n        this._backdropSubscription.unsubscribe();\n        this._positionSubscription.unsubscribe();\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n        }\n    }\n    ngOnChanges(changes) {\n        if (this._position) {\n            this._updatePositionStrategy(this._position);\n            this._overlayRef.updateSize({\n                width: this.width,\n                minWidth: this.minWidth,\n                height: this.height,\n                minHeight: this.minHeight,\n            });\n            if (changes['origin'] && this.open) {\n                this._position.apply();\n            }\n        }\n        if (changes['open']) {\n            this.open ? this._attachOverlay() : this._detachOverlay();\n        }\n    }\n    /** Creates an overlay */\n    _createOverlay() {\n        if (!this.positions || !this.positions.length) {\n            this.positions = defaultPositionList;\n        }\n        const overlayRef = this._overlayRef = this._overlay.create(this._buildConfig());\n        this._attachSubscription = overlayRef.attachments().subscribe(() => this.attach.emit());\n        this._detachSubscription = overlayRef.detachments().subscribe(() => this.detach.emit());\n        overlayRef.keydownEvents().subscribe((event) => {\n            this.overlayKeydown.next(event);\n            if (event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)) {\n                event.preventDefault();\n                this._detachOverlay();\n            }\n        });\n        this._overlayRef.outsidePointerEvents().subscribe((event) => {\n            this.overlayOutsideClick.next(event);\n        });\n    }\n    /** Builds the overlay config based on the directive's inputs */\n    _buildConfig() {\n        const positionStrategy = this._position =\n            this.positionStrategy || this._createPositionStrategy();\n        const overlayConfig = new OverlayConfig({\n            direction: this._dir,\n            positionStrategy,\n            scrollStrategy: this.scrollStrategy,\n            hasBackdrop: this.hasBackdrop\n        });\n        if (this.width || this.width === 0) {\n            overlayConfig.width = this.width;\n        }\n        if (this.height || this.height === 0) {\n            overlayConfig.height = this.height;\n        }\n        if (this.minWidth || this.minWidth === 0) {\n            overlayConfig.minWidth = this.minWidth;\n        }\n        if (this.minHeight || this.minHeight === 0) {\n            overlayConfig.minHeight = this.minHeight;\n        }\n        if (this.backdropClass) {\n            overlayConfig.backdropClass = this.backdropClass;\n        }\n        if (this.panelClass) {\n            overlayConfig.panelClass = this.panelClass;\n        }\n        return overlayConfig;\n    }\n    /** Updates the state of a position strategy, based on the values of the directive inputs. */\n    _updatePositionStrategy(positionStrategy) {\n        const positions = this.positions.map(currentPosition => ({\n            originX: currentPosition.originX,\n            originY: currentPosition.originY,\n            overlayX: currentPosition.overlayX,\n            overlayY: currentPosition.overlayY,\n            offsetX: currentPosition.offsetX || this.offsetX,\n            offsetY: currentPosition.offsetY || this.offsetY,\n            panelClass: currentPosition.panelClass || undefined,\n        }));\n        return positionStrategy\n            .setOrigin(this.origin.elementRef)\n            .withPositions(positions)\n            .withFlexibleDimensions(this.flexibleDimensions)\n            .withPush(this.push)\n            .withGrowAfterOpen(this.growAfterOpen)\n            .withViewportMargin(this.viewportMargin)\n            .withLockedPosition(this.lockPosition)\n            .withTransformOriginOn(this.transformOriginSelector);\n    }\n    /** Returns the position strategy of the overlay to be set on the overlay config */\n    _createPositionStrategy() {\n        const strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);\n        this._updatePositionStrategy(strategy);\n        return strategy;\n    }\n    /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */\n    _attachOverlay() {\n        if (!this._overlayRef) {\n            this._createOverlay();\n        }\n        else {\n            // Update the overlay size, in case the directive's inputs have changed\n            this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;\n        }\n        if (!this._overlayRef.hasAttached()) {\n            this._overlayRef.attach(this._templatePortal);\n        }\n        if (this.hasBackdrop) {\n            this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {\n                this.backdropClick.emit(event);\n            });\n        }\n        else {\n            this._backdropSubscription.unsubscribe();\n        }\n        this._positionSubscription.unsubscribe();\n        // Only subscribe to `positionChanges` if requested, because putting\n        // together all the information for it can be expensive.\n        if (this.positionChange.observers.length > 0) {\n            this._positionSubscription = this._position.positionChanges\n                .pipe(takeWhile(() => this.positionChange.observers.length > 0))\n                .subscribe(position => {\n                this.positionChange.emit(position);\n                if (this.positionChange.observers.length === 0) {\n                    this._positionSubscription.unsubscribe();\n                }\n            });\n        }\n    }\n    /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */\n    _detachOverlay() {\n        if (this._overlayRef) {\n            this._overlayRef.detach();\n        }\n        this._backdropSubscription.unsubscribe();\n        this._positionSubscription.unsubscribe();\n    }\n}\nCdkConnectedOverlay.ɵfac = function CdkConnectedOverlay_Factory(t) { return new (t || CdkConnectedOverlay)(ɵngcc0.ɵɵdirectiveInject(Overlay), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Directionality, 8)); };\nCdkConnectedOverlay.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkConnectedOverlay, selectors: [[\"\", \"cdk-connected-overlay\", \"\"], [\"\", \"connected-overlay\", \"\"], [\"\", \"cdkConnectedOverlay\", \"\"]], inputs: { viewportMargin: [\"cdkConnectedOverlayViewportMargin\", \"viewportMargin\"], open: [\"cdkConnectedOverlayOpen\", \"open\"], disableClose: [\"cdkConnectedOverlayDisableClose\", \"disableClose\"], scrollStrategy: [\"cdkConnectedOverlayScrollStrategy\", \"scrollStrategy\"], offsetX: [\"cdkConnectedOverlayOffsetX\", \"offsetX\"], offsetY: [\"cdkConnectedOverlayOffsetY\", \"offsetY\"], hasBackdrop: [\"cdkConnectedOverlayHasBackdrop\", \"hasBackdrop\"], lockPosition: [\"cdkConnectedOverlayLockPosition\", \"lockPosition\"], flexibleDimensions: [\"cdkConnectedOverlayFlexibleDimensions\", \"flexibleDimensions\"], growAfterOpen: [\"cdkConnectedOverlayGrowAfterOpen\", \"growAfterOpen\"], push: [\"cdkConnectedOverlayPush\", \"push\"], positions: [\"cdkConnectedOverlayPositions\", \"positions\"], origin: [\"cdkConnectedOverlayOrigin\", \"origin\"], positionStrategy: [\"cdkConnectedOverlayPositionStrategy\", \"positionStrategy\"], width: [\"cdkConnectedOverlayWidth\", \"width\"], height: [\"cdkConnectedOverlayHeight\", \"height\"], minWidth: [\"cdkConnectedOverlayMinWidth\", \"minWidth\"], minHeight: [\"cdkConnectedOverlayMinHeight\", \"minHeight\"], backdropClass: [\"cdkConnectedOverlayBackdropClass\", \"backdropClass\"], panelClass: [\"cdkConnectedOverlayPanelClass\", \"panelClass\"], transformOriginSelector: [\"cdkConnectedOverlayTransformOriginOn\", \"transformOriginSelector\"] }, outputs: { backdropClick: \"backdropClick\", positionChange: \"positionChange\", attach: \"attach\", detach: \"detach\", overlayKeydown: \"overlayKeydown\", overlayOutsideClick: \"overlayOutsideClick\" }, exportAs: [\"cdkConnectedOverlay\"], features: [ɵngcc0.ɵɵNgOnChangesFeature] });\nCdkConnectedOverlay.ctorParameters = () => [\n    { type: Overlay },\n    { type: TemplateRef },\n    { type: ViewContainerRef },\n    { type: undefined, decorators: [{ type: Inject, args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,] }] },\n    { type: Directionality, decorators: [{ type: Optional }] }\n];\nCdkConnectedOverlay.propDecorators = {\n    origin: [{ type: Input, args: ['cdkConnectedOverlayOrigin',] }],\n    positions: [{ type: Input, args: ['cdkConnectedOverlayPositions',] }],\n    positionStrategy: [{ type: Input, args: ['cdkConnectedOverlayPositionStrategy',] }],\n    offsetX: [{ type: Input, args: ['cdkConnectedOverlayOffsetX',] }],\n    offsetY: [{ type: Input, args: ['cdkConnectedOverlayOffsetY',] }],\n    width: [{ type: Input, args: ['cdkConnectedOverlayWidth',] }],\n    height: [{ type: Input, args: ['cdkConnectedOverlayHeight',] }],\n    minWidth: [{ type: Input, args: ['cdkConnectedOverlayMinWidth',] }],\n    minHeight: [{ type: Input, args: ['cdkConnectedOverlayMinHeight',] }],\n    backdropClass: [{ type: Input, args: ['cdkConnectedOverlayBackdropClass',] }],\n    panelClass: [{ type: Input, args: ['cdkConnectedOverlayPanelClass',] }],\n    viewportMargin: [{ type: Input, args: ['cdkConnectedOverlayViewportMargin',] }],\n    scrollStrategy: [{ type: Input, args: ['cdkConnectedOverlayScrollStrategy',] }],\n    open: [{ type: Input, args: ['cdkConnectedOverlayOpen',] }],\n    disableClose: [{ type: Input, args: ['cdkConnectedOverlayDisableClose',] }],\n    transformOriginSelector: [{ type: Input, args: ['cdkConnectedOverlayTransformOriginOn',] }],\n    hasBackdrop: [{ type: Input, args: ['cdkConnectedOverlayHasBackdrop',] }],\n    lockPosition: [{ type: Input, args: ['cdkConnectedOverlayLockPosition',] }],\n    flexibleDimensions: [{ type: Input, args: ['cdkConnectedOverlayFlexibleDimensions',] }],\n    growAfterOpen: [{ type: Input, args: ['cdkConnectedOverlayGrowAfterOpen',] }],\n    push: [{ type: Input, args: ['cdkConnectedOverlayPush',] }],\n    backdropClick: [{ type: Output }],\n    positionChange: [{ type: Output }],\n    attach: [{ type: Output }],\n    detach: [{ type: Output }],\n    overlayKeydown: [{ type: Output }],\n    overlayOutsideClick: [{ type: Output }]\n};\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkConnectedOverlay, [{\n        type: Directive,\n        args: [{\n                selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',\n                exportAs: 'cdkConnectedOverlay'\n            }]\n    }], function () { return [{ type: Overlay }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY]\n            }] }, { type: ɵngcc3.Directionality, decorators: [{\n                type: Optional\n            }] }]; }, { viewportMargin: [{\n            type: Input,\n            args: ['cdkConnectedOverlayViewportMargin']\n        }], open: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOpen']\n        }], disableClose: [{\n            type: Input,\n            args: ['cdkConnectedOverlayDisableClose']\n        }], backdropClick: [{\n            type: Output\n        }], positionChange: [{\n            type: Output\n        }], attach: [{\n            type: Output\n        }], detach: [{\n            type: Output\n        }], overlayKeydown: [{\n            type: Output\n        }], overlayOutsideClick: [{\n            type: Output\n        }], scrollStrategy: [{\n            type: Input,\n            args: ['cdkConnectedOverlayScrollStrategy']\n        }], offsetX: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOffsetX']\n        }], offsetY: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOffsetY']\n        }], hasBackdrop: [{\n            type: Input,\n            args: ['cdkConnectedOverlayHasBackdrop']\n        }], lockPosition: [{\n            type: Input,\n            args: ['cdkConnectedOverlayLockPosition']\n        }], flexibleDimensions: [{\n            type: Input,\n            args: ['cdkConnectedOverlayFlexibleDimensions']\n        }], growAfterOpen: [{\n            type: Input,\n            args: ['cdkConnectedOverlayGrowAfterOpen']\n        }], push: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPush']\n        }], positions: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPositions']\n        }], origin: [{\n            type: Input,\n            args: ['cdkConnectedOverlayOrigin']\n        }], positionStrategy: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPositionStrategy']\n        }], width: [{\n            type: Input,\n            args: ['cdkConnectedOverlayWidth']\n        }], height: [{\n            type: Input,\n            args: ['cdkConnectedOverlayHeight']\n        }], minWidth: [{\n            type: Input,\n            args: ['cdkConnectedOverlayMinWidth']\n        }], minHeight: [{\n            type: Input,\n            args: ['cdkConnectedOverlayMinHeight']\n        }], backdropClass: [{\n            type: Input,\n            args: ['cdkConnectedOverlayBackdropClass']\n        }], panelClass: [{\n            type: Input,\n            args: ['cdkConnectedOverlayPanelClass']\n        }], transformOriginSelector: [{\n            type: Input,\n            args: ['cdkConnectedOverlayTransformOriginOn']\n        }] }); })();\n/** @docs-private */\nfunction CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n    return () => overlay.scrollStrategies.reposition();\n}\n/** @docs-private */\nconst CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {\n    provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass OverlayModule {\n}\nOverlayModule.ɵfac = function OverlayModule_Factory(t) { return new (t || OverlayModule)(); };\nOverlayModule.ɵmod = /*@__PURE__*/ ɵngcc0.ɵɵdefineNgModule({ type: OverlayModule });\nOverlayModule.ɵinj = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjector({ providers: [\n        Overlay,\n        CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,\n    ], imports: [[BidiModule, PortalModule, ScrollingModule], ScrollingModule] });\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(OverlayModule, [{\n        type: NgModule,\n        args: [{\n                imports: [BidiModule, PortalModule, ScrollingModule],\n                exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule],\n                declarations: [CdkConnectedOverlay, CdkOverlayOrigin],\n                providers: [\n                    Overlay,\n                    CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,\n                ]\n            }]\n    }], null, null); })();\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(OverlayModule, { declarations: function () { return [CdkConnectedOverlay, CdkOverlayOrigin]; }, imports: function () { return [BidiModule, PortalModule, ScrollingModule]; }, exports: function () { return [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule]; } }); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Alternative to OverlayContainer that supports correct displaying of overlay elements in\n * Fullscreen mode\n * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen\n *\n * Should be provided in the root component.\n */\nclass FullscreenOverlayContainer extends OverlayContainer {\n    constructor(_document, platform) {\n        super(_document, platform);\n    }\n    ngOnDestroy() {\n        super.ngOnDestroy();\n        if (this._fullScreenEventName && this._fullScreenListener) {\n            this._document.removeEventListener(this._fullScreenEventName, this._fullScreenListener);\n        }\n    }\n    _createContainer() {\n        super._createContainer();\n        this._adjustParentForFullscreenChange();\n        this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());\n    }\n    _adjustParentForFullscreenChange() {\n        if (!this._containerElement) {\n            return;\n        }\n        const fullscreenElement = this.getFullscreenElement();\n        const parent = fullscreenElement || this._document.body;\n        parent.appendChild(this._containerElement);\n    }\n    _addFullscreenChangeListener(fn) {\n        const eventName = this._getEventName();\n        if (eventName) {\n            if (this._fullScreenListener) {\n                this._document.removeEventListener(eventName, this._fullScreenListener);\n            }\n            this._document.addEventListener(eventName, fn);\n            this._fullScreenListener = fn;\n        }\n    }\n    _getEventName() {\n        if (!this._fullScreenEventName) {\n            const _document = this._document;\n            if (_document.fullscreenEnabled) {\n                this._fullScreenEventName = 'fullscreenchange';\n            }\n            else if (_document.webkitFullscreenEnabled) {\n                this._fullScreenEventName = 'webkitfullscreenchange';\n            }\n            else if (_document.mozFullScreenEnabled) {\n                this._fullScreenEventName = 'mozfullscreenchange';\n            }\n            else if (_document.msFullscreenEnabled) {\n                this._fullScreenEventName = 'MSFullscreenChange';\n            }\n        }\n        return this._fullScreenEventName;\n    }\n    /**\n     * When the page is put into fullscreen mode, a specific element is specified.\n     * Only that element and its children are visible when in fullscreen mode.\n     */\n    getFullscreenElement() {\n        const _document = this._document;\n        return _document.fullscreenElement ||\n            _document.webkitFullscreenElement ||\n            _document.mozFullScreenElement ||\n            _document.msFullscreenElement ||\n            null;\n    }\n}\nFullscreenOverlayContainer.ɵfac = function FullscreenOverlayContainer_Factory(t) { return new (t || FullscreenOverlayContainer)(ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc2.Platform)); };\nFullscreenOverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: FullscreenOverlayContainer, providedIn: \"root\" });\nFullscreenOverlayContainer.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },\n    { type: Platform }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(FullscreenOverlayContainer, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }, { type: ɵngcc2.Platform }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BlockScrollStrategy, CdkConnectedOverlay, CdkOverlayOrigin, CloseScrollStrategy, ConnectedOverlayPositionChange, ConnectedPositionStrategy, ConnectionPositionPair, FlexibleConnectedPositionStrategy, FullscreenOverlayContainer, GlobalPositionStrategy, NoopScrollStrategy, Overlay, OverlayConfig, OverlayContainer, OverlayKeyboardDispatcher, OverlayModule, OverlayOutsideClickDispatcher, OverlayPositionBuilder, OverlayRef, RepositionScrollStrategy, ScrollStrategyOptions, ScrollingVisibility, validateHorizontalPosition, validateVerticalPosition, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵangular_material_src_cdk_overlay_overlay_a, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_b, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_c, BaseOverlayDispatcher as ɵangular_material_src_cdk_overlay_overlay_d };\n\n//# sourceMappingURL=overlay.js.map","import * as i0 from '@angular/core';\nimport { NgModule, Injectable, NgZone } from '@angular/core';\nimport { coerceArray } from '@angular/cdk/coercion';\nimport { Subject, combineLatest, concat, Observable } from 'rxjs';\nimport { take, skip, debounceTime, map, startWith, takeUntil } from 'rxjs/operators';\nimport * as i1 from '@angular/cdk/platform';\nimport { Platform } from '@angular/cdk/platform';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/cdk/platform';\nclass LayoutModule {\n}\nLayoutModule.ɵfac = function LayoutModule_Factory(t) { return new (t || LayoutModule)(); };\nLayoutModule.ɵmod = /*@__PURE__*/ ɵngcc0.ɵɵdefineNgModule({ type: LayoutModule });\nLayoutModule.ɵinj = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjector({});\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(LayoutModule, [{\n        type: NgModule,\n        args: [{}]\n    }], null, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Global registry for all dynamically-created, injected media queries. */\nconst mediaQueriesForWebkitCompatibility = new Set();\n/** Style tag that holds all of the dynamically-created media queries. */\nlet mediaQueryStyleNode;\n/** A utility for calling matchMedia queries. */\nclass MediaMatcher {\n    constructor(_platform) {\n        this._platform = _platform;\n        this._matchMedia = this._platform.isBrowser && window.matchMedia ?\n            // matchMedia is bound to the window scope intentionally as it is an illegal invocation to\n            // call it from a different scope.\n            window.matchMedia.bind(window) :\n            noopMatchMedia;\n    }\n    /**\n     * Evaluates the given media query and returns the native MediaQueryList from which results\n     * can be retrieved.\n     * Confirms the layout engine will trigger for the selector query provided and returns the\n     * MediaQueryList for the query provided.\n     */\n    matchMedia(query) {\n        if (this._platform.WEBKIT) {\n            createEmptyStyleRule(query);\n        }\n        return this._matchMedia(query);\n    }\n}\nMediaMatcher.ɵfac = function MediaMatcher_Factory(t) { return new (t || MediaMatcher)(ɵngcc0.ɵɵinject(ɵngcc1.Platform)); };\nMediaMatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function MediaMatcher_Factory() { return new MediaMatcher(i0.ɵɵinject(i1.Platform)); }, token: MediaMatcher, providedIn: \"root\" });\nMediaMatcher.ctorParameters = () => [\n    { type: Platform }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MediaMatcher, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: ɵngcc1.Platform }]; }, null); })();\n/**\n * For Webkit engines that only trigger the MediaQueryListListener when\n * there is at least one CSS selector for the respective media query.\n */\nfunction createEmptyStyleRule(query) {\n    if (mediaQueriesForWebkitCompatibility.has(query)) {\n        return;\n    }\n    try {\n        if (!mediaQueryStyleNode) {\n            mediaQueryStyleNode = document.createElement('style');\n            mediaQueryStyleNode.setAttribute('type', 'text/css');\n            document.head.appendChild(mediaQueryStyleNode);\n        }\n        if (mediaQueryStyleNode.sheet) {\n            mediaQueryStyleNode.sheet\n                .insertRule(`@media ${query} {.fx-query-test{ }}`, 0);\n            mediaQueriesForWebkitCompatibility.add(query);\n        }\n    }\n    catch (e) {\n        console.error(e);\n    }\n}\n/** No-op matchMedia replacement for non-browser platforms. */\nfunction noopMatchMedia(query) {\n    // Use `as any` here to avoid adding additional necessary properties for\n    // the noop matcher.\n    return {\n        matches: query === 'all' || query === '',\n        media: query,\n        addListener: () => { },\n        removeListener: () => { }\n    };\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Utility for checking the matching state of @media queries. */\nclass BreakpointObserver {\n    constructor(_mediaMatcher, _zone) {\n        this._mediaMatcher = _mediaMatcher;\n        this._zone = _zone;\n        /**  A map of all media queries currently being listened for. */\n        this._queries = new Map();\n        /** A subject for all other observables to takeUntil based on. */\n        this._destroySubject = new Subject();\n    }\n    /** Completes the active subject, signalling to all other observables to complete. */\n    ngOnDestroy() {\n        this._destroySubject.next();\n        this._destroySubject.complete();\n    }\n    /**\n     * Whether one or more media queries match the current viewport size.\n     * @param value One or more media queries to check.\n     * @returns Whether any of the media queries match.\n     */\n    isMatched(value) {\n        const queries = splitQueries(coerceArray(value));\n        return queries.some(mediaQuery => this._registerQuery(mediaQuery).mql.matches);\n    }\n    /**\n     * Gets an observable of results for the given queries that will emit new results for any changes\n     * in matching of the given queries.\n     * @param value One or more media queries to check.\n     * @returns A stream of matches for the given queries.\n     */\n    observe(value) {\n        const queries = splitQueries(coerceArray(value));\n        const observables = queries.map(query => this._registerQuery(query).observable);\n        let stateObservable = combineLatest(observables);\n        // Emit the first state immediately, and then debounce the subsequent emissions.\n        stateObservable = concat(stateObservable.pipe(take(1)), stateObservable.pipe(skip(1), debounceTime(0)));\n        return stateObservable.pipe(map(breakpointStates => {\n            const response = {\n                matches: false,\n                breakpoints: {},\n            };\n            breakpointStates.forEach(({ matches, query }) => {\n                response.matches = response.matches || matches;\n                response.breakpoints[query] = matches;\n            });\n            return response;\n        }));\n    }\n    /** Registers a specific query to be listened for. */\n    _registerQuery(query) {\n        // Only set up a new MediaQueryList if it is not already being listened for.\n        if (this._queries.has(query)) {\n            return this._queries.get(query);\n        }\n        const mql = this._mediaMatcher.matchMedia(query);\n        // Create callback for match changes and add it is as a listener.\n        const queryObservable = new Observable((observer) => {\n            // Listener callback methods are wrapped to be placed back in ngZone. Callbacks must be placed\n            // back into the zone because matchMedia is only included in Zone.js by loading the\n            // webapis-media-query.js file alongside the zone.js file.  Additionally, some browsers do not\n            // have MediaQueryList inherit from EventTarget, which causes inconsistencies in how Zone.js\n            // patches it.\n            const handler = (e) => this._zone.run(() => observer.next(e));\n            mql.addListener(handler);\n            return () => {\n                mql.removeListener(handler);\n            };\n        }).pipe(startWith(mql), map(({ matches }) => ({ query, matches })), takeUntil(this._destroySubject));\n        // Add the MediaQueryList to the set of queries.\n        const output = { observable: queryObservable, mql };\n        this._queries.set(query, output);\n        return output;\n    }\n}\nBreakpointObserver.ɵfac = function BreakpointObserver_Factory(t) { return new (t || BreakpointObserver)(ɵngcc0.ɵɵinject(MediaMatcher), ɵngcc0.ɵɵinject(ɵngcc0.NgZone)); };\nBreakpointObserver.ɵprov = i0.ɵɵdefineInjectable({ factory: function BreakpointObserver_Factory() { return new BreakpointObserver(i0.ɵɵinject(MediaMatcher), i0.ɵɵinject(i0.NgZone)); }, token: BreakpointObserver, providedIn: \"root\" });\nBreakpointObserver.ctorParameters = () => [\n    { type: MediaMatcher },\n    { type: NgZone }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(BreakpointObserver, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: MediaMatcher }, { type: ɵngcc0.NgZone }]; }, null); })();\n/**\n * Split each query string into separate query strings if two queries are provided as comma\n * separated.\n */\nfunction splitQueries(queries) {\n    return queries.map(query => query.split(','))\n        .reduce((a1, a2) => a1.concat(a2))\n        .map(query => query.trim());\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// PascalCase is being used as Breakpoints is used like an enum.\n// tslint:disable-next-line:variable-name\nconst Breakpoints = {\n    XSmall: '(max-width: 599.98px)',\n    Small: '(min-width: 600px) and (max-width: 959.98px)',\n    Medium: '(min-width: 960px) and (max-width: 1279.98px)',\n    Large: '(min-width: 1280px) and (max-width: 1919.98px)',\n    XLarge: '(min-width: 1920px)',\n    Handset: '(max-width: 599.98px) and (orientation: portrait), ' +\n        '(max-width: 959.98px) and (orientation: landscape)',\n    Tablet: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait), ' +\n        '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',\n    Web: '(min-width: 840px) and (orientation: portrait), ' +\n        '(min-width: 1280px) and (orientation: landscape)',\n    HandsetPortrait: '(max-width: 599.98px) and (orientation: portrait)',\n    TabletPortrait: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait)',\n    WebPortrait: '(min-width: 840px) and (orientation: portrait)',\n    HandsetLandscape: '(max-width: 959.98px) and (orientation: landscape)',\n    TabletLandscape: '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',\n    WebLandscape: '(min-width: 1280px) and (orientation: landscape)',\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BreakpointObserver, Breakpoints, LayoutModule, MediaMatcher };\n\n//# sourceMappingURL=layout.js.map","import { Subscriber } from '../Subscriber';\nexport function skip(count) {\n    return (source) => source.lift(new SkipOperator(count));\n}\nclass SkipOperator {\n    constructor(total) {\n        this.total = total;\n    }\n    call(subscriber, source) {\n        return source.subscribe(new SkipSubscriber(subscriber, this.total));\n    }\n}\nclass SkipSubscriber extends Subscriber {\n    constructor(destination, total) {\n        super(destination);\n        this.total = total;\n        this.count = 0;\n    }\n    _next(x) {\n        if (++this.count > this.total) {\n            this.destination.next(x);\n        }\n    }\n}\n//# sourceMappingURL=skip.js.map","import * as i1 from '@angular/cdk/overlay';\nimport { OverlayModule, OverlayConfig, Overlay } from '@angular/cdk/overlay';\nimport { BasePortalOutlet, CdkPortalOutlet, PortalModule, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';\nimport { CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Component, ViewEncapsulation, ChangeDetectionStrategy, Inject, NgZone, ElementRef, ChangeDetectorRef, ViewChild, NgModule, Injector, TemplateRef, Injectable, Optional, SkipSelf } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { Subject } from 'rxjs';\nimport { Platform } from '@angular/cdk/platform';\nimport { take, takeUntil } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport * as i2 from '@angular/cdk/a11y';\nimport { LiveAnnouncer } from '@angular/cdk/a11y';\nimport * as i3 from '@angular/cdk/layout';\nimport { Breakpoints, BreakpointObserver } from '@angular/cdk/layout';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token that can be used to access the data that was passed in to a snack bar. */\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/common';\nimport * as ɵngcc2 from '@angular/material/button';\nimport * as ɵngcc3 from '@angular/cdk/platform';\nimport * as ɵngcc4 from '@angular/cdk/portal';\nimport * as ɵngcc5 from '@angular/cdk/overlay';\nimport * as ɵngcc6 from '@angular/cdk/a11y';\nimport * as ɵngcc7 from '@angular/cdk/layout';\n\nfunction SimpleSnackBar_div_2_Template(rf, ctx) { if (rf & 1) {\n    const _r2 = ɵngcc0.ɵɵgetCurrentView();\n    ɵngcc0.ɵɵelementStart(0, \"div\", 1);\n    ɵngcc0.ɵɵelementStart(1, \"button\", 2);\n    ɵngcc0.ɵɵlistener(\"click\", function SimpleSnackBar_div_2_Template_button_click_1_listener() { ɵngcc0.ɵɵrestoreView(_r2); const ctx_r1 = ɵngcc0.ɵɵnextContext(); return ctx_r1.action(); });\n    ɵngcc0.ɵɵtext(2);\n    ɵngcc0.ɵɵelementEnd();\n    ɵngcc0.ɵɵelementEnd();\n} if (rf & 2) {\n    const ctx_r0 = ɵngcc0.ɵɵnextContext();\n    ɵngcc0.ɵɵadvance(2);\n    ɵngcc0.ɵɵtextInterpolate(ctx_r0.data.action);\n} }\nfunction MatSnackBarContainer_ng_template_1_Template(rf, ctx) { }\nconst MAT_SNACK_BAR_DATA = new InjectionToken('MatSnackBarData');\n/**\n * Configuration used when opening a snack-bar.\n */\nclass MatSnackBarConfig {\n    constructor() {\n        /** The politeness level for the MatAriaLiveAnnouncer announcement. */\n        this.politeness = 'assertive';\n        /**\n         * Message to be announced by the LiveAnnouncer. When opening a snackbar without a custom\n         * component or template, the announcement message will default to the specified message.\n         */\n        this.announcementMessage = '';\n        /** The length of time in milliseconds to wait before automatically dismissing the snack bar. */\n        this.duration = 0;\n        /** Data being injected into the child component. */\n        this.data = null;\n        /** The horizontal position to place the snack bar. */\n        this.horizontalPosition = 'center';\n        /** The vertical position to place the snack bar. */\n        this.verticalPosition = 'bottom';\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Maximum amount of milliseconds that can be passed into setTimeout. */\nconst MAX_TIMEOUT = Math.pow(2, 31) - 1;\n/**\n * Reference to a snack bar dispatched from the snack bar service.\n */\nclass MatSnackBarRef {\n    constructor(containerInstance, _overlayRef) {\n        this._overlayRef = _overlayRef;\n        /** Subject for notifying the user that the snack bar has been dismissed. */\n        this._afterDismissed = new Subject();\n        /** Subject for notifying the user that the snack bar has opened and appeared. */\n        this._afterOpened = new Subject();\n        /** Subject for notifying the user that the snack bar action was called. */\n        this._onAction = new Subject();\n        /** Whether the snack bar was dismissed using the action button. */\n        this._dismissedByAction = false;\n        this.containerInstance = containerInstance;\n        // Dismiss snackbar on action.\n        this.onAction().subscribe(() => this.dismiss());\n        containerInstance._onExit.subscribe(() => this._finishDismiss());\n    }\n    /** Dismisses the snack bar. */\n    dismiss() {\n        if (!this._afterDismissed.closed) {\n            this.containerInstance.exit();\n        }\n        clearTimeout(this._durationTimeoutId);\n    }\n    /** Marks the snackbar action clicked. */\n    dismissWithAction() {\n        if (!this._onAction.closed) {\n            this._dismissedByAction = true;\n            this._onAction.next();\n            this._onAction.complete();\n        }\n        clearTimeout(this._durationTimeoutId);\n    }\n    /**\n     * Marks the snackbar action clicked.\n     * @deprecated Use `dismissWithAction` instead.\n     * @breaking-change 8.0.0\n     */\n    closeWithAction() {\n        this.dismissWithAction();\n    }\n    /** Dismisses the snack bar after some duration */\n    _dismissAfter(duration) {\n        // Note that we need to cap the duration to the maximum value for setTimeout, because\n        // it'll revert to 1 if somebody passes in something greater (e.g. `Infinity`). See #17234.\n        this._durationTimeoutId = setTimeout(() => this.dismiss(), Math.min(duration, MAX_TIMEOUT));\n    }\n    /** Marks the snackbar as opened */\n    _open() {\n        if (!this._afterOpened.closed) {\n            this._afterOpened.next();\n            this._afterOpened.complete();\n        }\n    }\n    /** Cleans up the DOM after closing. */\n    _finishDismiss() {\n        this._overlayRef.dispose();\n        if (!this._onAction.closed) {\n            this._onAction.complete();\n        }\n        this._afterDismissed.next({ dismissedByAction: this._dismissedByAction });\n        this._afterDismissed.complete();\n        this._dismissedByAction = false;\n    }\n    /** Gets an observable that is notified when the snack bar is finished closing. */\n    afterDismissed() {\n        return this._afterDismissed;\n    }\n    /** Gets an observable that is notified when the snack bar has opened and appeared. */\n    afterOpened() {\n        return this.containerInstance._onEnter;\n    }\n    /** Gets an observable that is notified when the snack bar action is called. */\n    onAction() {\n        return this._onAction;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A component used to open as the default snack bar, matching material spec.\n * This should only be used internally by the snack bar service.\n */\nclass SimpleSnackBar {\n    constructor(snackBarRef, data) {\n        this.snackBarRef = snackBarRef;\n        this.data = data;\n    }\n    /** Performs the action on the snack bar. */\n    action() {\n        this.snackBarRef.dismissWithAction();\n    }\n    /** If the action button should be shown. */\n    get hasAction() {\n        return !!this.data.action;\n    }\n}\nSimpleSnackBar.ɵfac = function SimpleSnackBar_Factory(t) { return new (t || SimpleSnackBar)(ɵngcc0.ɵɵdirectiveInject(MatSnackBarRef), ɵngcc0.ɵɵdirectiveInject(MAT_SNACK_BAR_DATA)); };\nSimpleSnackBar.ɵcmp = /*@__PURE__*/ ɵngcc0.ɵɵdefineComponent({ type: SimpleSnackBar, selectors: [[\"simple-snack-bar\"]], hostAttrs: [1, \"mat-simple-snackbar\"], decls: 3, vars: 2, consts: [[\"class\", \"mat-simple-snackbar-action\", 4, \"ngIf\"], [1, \"mat-simple-snackbar-action\"], [\"mat-button\", \"\", 3, \"click\"]], template: function SimpleSnackBar_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵelementStart(0, \"span\");\n        ɵngcc0.ɵɵtext(1);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵtemplate(2, SimpleSnackBar_div_2_Template, 3, 1, \"div\", 0);\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵtextInterpolate(ctx.data.message);\n        ɵngcc0.ɵɵadvance(1);\n        ɵngcc0.ɵɵproperty(\"ngIf\", ctx.hasAction);\n    } }, directives: [ɵngcc1.NgIf, ɵngcc2.MatButton], styles: [\".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}\\n\"], encapsulation: 2, changeDetection: 0 });\nSimpleSnackBar.ctorParameters = () => [\n    { type: MatSnackBarRef },\n    { type: undefined, decorators: [{ type: Inject, args: [MAT_SNACK_BAR_DATA,] }] }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(SimpleSnackBar, [{\n        type: Component,\n        args: [{\n                selector: 'simple-snack-bar',\n                template: \"<span>{{data.message}}</span>\\n<div class=\\\"mat-simple-snackbar-action\\\"  *ngIf=\\\"hasAction\\\">\\n  <button mat-button (click)=\\\"action()\\\">{{data.action}}</button>\\n</div>\\n\",\n                encapsulation: ViewEncapsulation.None,\n                changeDetection: ChangeDetectionStrategy.OnPush,\n                host: {\n                    'class': 'mat-simple-snackbar'\n                },\n                styles: [\".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}\\n\"]\n            }]\n    }], function () { return [{ type: MatSnackBarRef }, { type: undefined, decorators: [{\n                type: Inject,\n                args: [MAT_SNACK_BAR_DATA]\n            }] }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Animations used by the Material snack bar.\n * @docs-private\n */\nconst matSnackBarAnimations = {\n    /** Animation that shows and hides a snack bar. */\n    snackBarState: trigger('state', [\n        state('void, hidden', style({\n            transform: 'scale(0.8)',\n            opacity: 0,\n        })),\n        state('visible', style({\n            transform: 'scale(1)',\n            opacity: 1,\n        })),\n        transition('* => visible', animate('150ms cubic-bezier(0, 0, 0.2, 1)')),\n        transition('* => void, * => hidden', animate('75ms cubic-bezier(0.4, 0.0, 1, 1)', style({\n            opacity: 0\n        }))),\n    ])\n};\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Internal component that wraps user-provided snack bar content.\n * @docs-private\n */\nclass MatSnackBarContainer extends BasePortalOutlet {\n    constructor(_ngZone, _elementRef, _changeDetectorRef, _platform, \n    /** The snack bar configuration. */\n    snackBarConfig) {\n        super();\n        this._ngZone = _ngZone;\n        this._elementRef = _elementRef;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._platform = _platform;\n        this.snackBarConfig = snackBarConfig;\n        /** The number of milliseconds to wait before announcing the snack bar's content. */\n        this._announceDelay = 150;\n        /** Whether the component has been destroyed. */\n        this._destroyed = false;\n        /** Subject for notifying that the snack bar has announced to screen readers. */\n        this._onAnnounce = new Subject();\n        /** Subject for notifying that the snack bar has exited from view. */\n        this._onExit = new Subject();\n        /** Subject for notifying that the snack bar has finished entering the view. */\n        this._onEnter = new Subject();\n        /** The state of the snack bar animations. */\n        this._animationState = 'void';\n        /**\n         * Attaches a DOM portal to the snack bar container.\n         * @deprecated To be turned into a method.\n         * @breaking-change 10.0.0\n         */\n        this.attachDomPortal = (portal) => {\n            this._assertNotAttached();\n            this._applySnackBarClasses();\n            return this._portalOutlet.attachDomPortal(portal);\n        };\n        // Use aria-live rather than a live role like 'alert' or 'status'\n        // because NVDA and JAWS have show inconsistent behavior with live roles.\n        if (snackBarConfig.politeness === 'assertive' && !snackBarConfig.announcementMessage) {\n            this._live = 'assertive';\n        }\n        else if (snackBarConfig.politeness === 'off') {\n            this._live = 'off';\n        }\n        else {\n            this._live = 'polite';\n        }\n        // Only set role for Firefox. Set role based on aria-live because setting role=\"alert\" implies\n        // aria-live=\"assertive\" which may cause issues if aria-live is set to \"polite\" above.\n        if (this._platform.FIREFOX) {\n            if (this._live === 'polite') {\n                this._role = 'status';\n            }\n            if (this._live === 'assertive') {\n                this._role = 'alert';\n            }\n        }\n    }\n    /** Attach a component portal as content to this snack bar container. */\n    attachComponentPortal(portal) {\n        this._assertNotAttached();\n        this._applySnackBarClasses();\n        return this._portalOutlet.attachComponentPortal(portal);\n    }\n    /** Attach a template portal as content to this snack bar container. */\n    attachTemplatePortal(portal) {\n        this._assertNotAttached();\n        this._applySnackBarClasses();\n        return this._portalOutlet.attachTemplatePortal(portal);\n    }\n    /** Handle end of animations, updating the state of the snackbar. */\n    onAnimationEnd(event) {\n        const { fromState, toState } = event;\n        if ((toState === 'void' && fromState !== 'void') || toState === 'hidden') {\n            this._completeExit();\n        }\n        if (toState === 'visible') {\n            // Note: we shouldn't use `this` inside the zone callback,\n            // because it can cause a memory leak.\n            const onEnter = this._onEnter;\n            this._ngZone.run(() => {\n                onEnter.next();\n                onEnter.complete();\n            });\n        }\n    }\n    /** Begin animation of snack bar entrance into view. */\n    enter() {\n        if (!this._destroyed) {\n            this._animationState = 'visible';\n            this._changeDetectorRef.detectChanges();\n            this._screenReaderAnnounce();\n        }\n    }\n    /** Begin animation of the snack bar exiting from view. */\n    exit() {\n        // Note: this one transitions to `hidden`, rather than `void`, in order to handle the case\n        // where multiple snack bars are opened in quick succession (e.g. two consecutive calls to\n        // `MatSnackBar.open`).\n        this._animationState = 'hidden';\n        // Mark this element with an 'exit' attribute to indicate that the snackbar has\n        // been dismissed and will soon be removed from the DOM. This is used by the snackbar\n        // test harness.\n        this._elementRef.nativeElement.setAttribute('mat-exit', '');\n        // If the snack bar hasn't been announced by the time it exits it wouldn't have been open\n        // long enough to visually read it either, so clear the timeout for announcing.\n        clearTimeout(this._announceTimeoutId);\n        return this._onExit;\n    }\n    /** Makes sure the exit callbacks have been invoked when the element is destroyed. */\n    ngOnDestroy() {\n        this._destroyed = true;\n        this._completeExit();\n    }\n    /**\n     * Waits for the zone to settle before removing the element. Helps prevent\n     * errors where we end up removing an element which is in the middle of an animation.\n     */\n    _completeExit() {\n        this._ngZone.onMicrotaskEmpty.pipe(take(1)).subscribe(() => {\n            this._onExit.next();\n            this._onExit.complete();\n        });\n    }\n    /** Applies the various positioning and user-configured CSS classes to the snack bar. */\n    _applySnackBarClasses() {\n        const element = this._elementRef.nativeElement;\n        const panelClasses = this.snackBarConfig.panelClass;\n        if (panelClasses) {\n            if (Array.isArray(panelClasses)) {\n                // Note that we can't use a spread here, because IE doesn't support multiple arguments.\n                panelClasses.forEach(cssClass => element.classList.add(cssClass));\n            }\n            else {\n                element.classList.add(panelClasses);\n            }\n        }\n        if (this.snackBarConfig.horizontalPosition === 'center') {\n            element.classList.add('mat-snack-bar-center');\n        }\n        if (this.snackBarConfig.verticalPosition === 'top') {\n            element.classList.add('mat-snack-bar-top');\n        }\n    }\n    /** Asserts that no content is already attached to the container. */\n    _assertNotAttached() {\n        if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw Error('Attempting to attach snack bar content after content is already attached');\n        }\n    }\n    /**\n     * Starts a timeout to move the snack bar content to the live region so screen readers will\n     * announce it.\n     */\n    _screenReaderAnnounce() {\n        if (!this._announceTimeoutId) {\n            this._ngZone.runOutsideAngular(() => {\n                this._announceTimeoutId = setTimeout(() => {\n                    const inertElement = this._elementRef.nativeElement.querySelector('[aria-hidden]');\n                    const liveElement = this._elementRef.nativeElement.querySelector('[aria-live]');\n                    if (inertElement && liveElement) {\n                        // If an element in the snack bar content is focused before being moved\n                        // track it and restore focus after moving to the live region.\n                        let focusedElement = null;\n                        if (this._platform.isBrowser &&\n                            document.activeElement instanceof HTMLElement &&\n                            inertElement.contains(document.activeElement)) {\n                            focusedElement = document.activeElement;\n                        }\n                        inertElement.removeAttribute('aria-hidden');\n                        liveElement.appendChild(inertElement);\n                        focusedElement === null || focusedElement === void 0 ? void 0 : focusedElement.focus();\n                        this._onAnnounce.next();\n                        this._onAnnounce.complete();\n                    }\n                }, this._announceDelay);\n            });\n        }\n    }\n}\nMatSnackBarContainer.ɵfac = function MatSnackBarContainer_Factory(t) { return new (t || MatSnackBarContainer)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.Platform), ɵngcc0.ɵɵdirectiveInject(MatSnackBarConfig)); };\nMatSnackBarContainer.ɵcmp = /*@__PURE__*/ ɵngcc0.ɵɵdefineComponent({ type: MatSnackBarContainer, selectors: [[\"snack-bar-container\"]], viewQuery: function MatSnackBarContainer_Query(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵviewQuery(CdkPortalOutlet, 7);\n    } if (rf & 2) {\n        let _t;\n        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._portalOutlet = _t.first);\n    } }, hostAttrs: [1, \"mat-snack-bar-container\"], hostVars: 1, hostBindings: function MatSnackBarContainer_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵsyntheticHostListener(\"@state.done\", function MatSnackBarContainer_animation_state_done_HostBindingHandler($event) { return ctx.onAnimationEnd($event); });\n    } if (rf & 2) {\n        ɵngcc0.ɵɵsyntheticHostProperty(\"@state\", ctx._animationState);\n    } }, features: [ɵngcc0.ɵɵInheritDefinitionFeature], decls: 3, vars: 2, consts: [[\"aria-hidden\", \"true\"], [\"cdkPortalOutlet\", \"\"]], template: function MatSnackBarContainer_Template(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵelementStart(0, \"div\", 0);\n        ɵngcc0.ɵɵtemplate(1, MatSnackBarContainer_ng_template_1_Template, 0, 0, \"ng-template\", 1);\n        ɵngcc0.ɵɵelementEnd();\n        ɵngcc0.ɵɵelement(2, \"div\");\n    } if (rf & 2) {\n        ɵngcc0.ɵɵadvance(2);\n        ɵngcc0.ɵɵattribute(\"aria-live\", ctx._live)(\"role\", ctx._role);\n    } }, directives: [ɵngcc4.CdkPortalOutlet], styles: [\".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}\\n\"], encapsulation: 2, data: { animation: [matSnackBarAnimations.snackBarState] } });\nMatSnackBarContainer.ctorParameters = () => [\n    { type: NgZone },\n    { type: ElementRef },\n    { type: ChangeDetectorRef },\n    { type: Platform },\n    { type: MatSnackBarConfig }\n];\nMatSnackBarContainer.propDecorators = {\n    _portalOutlet: [{ type: ViewChild, args: [CdkPortalOutlet, { static: true },] }]\n};\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatSnackBarContainer, [{\n        type: Component,\n        args: [{\n                selector: 'snack-bar-container',\n                template: \"<!-- Initially holds the snack bar content, will be empty after announcing to screen readers. -->\\n<div aria-hidden=\\\"true\\\">\\n  <ng-template cdkPortalOutlet></ng-template>\\n</div>\\n\\n<!-- Will receive the snack bar content from the non-live div, move will happen a short delay after opening -->\\n<div [attr.aria-live]=\\\"_live\\\" [attr.role]=\\\"_role\\\"></div>\\n\",\n                // In Ivy embedded views will be change detected from their declaration place, rather than\n                // where they were stamped out. This means that we can't have the snack bar container be OnPush,\n                // because it might cause snack bars that were opened from a template not to be out of date.\n                // tslint:disable-next-line:validate-decorators\n                changeDetection: ChangeDetectionStrategy.Default,\n                encapsulation: ViewEncapsulation.None,\n                animations: [matSnackBarAnimations.snackBarState],\n                host: {\n                    'class': 'mat-snack-bar-container',\n                    '[@state]': '_animationState',\n                    '(@state.done)': 'onAnimationEnd($event)'\n                },\n                styles: [\".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}\\n\"]\n            }]\n    }], function () { return [{ type: ɵngcc0.NgZone }, { type: ɵngcc0.ElementRef }, { type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc3.Platform }, { type: MatSnackBarConfig }]; }, { _portalOutlet: [{\n            type: ViewChild,\n            args: [CdkPortalOutlet, { static: true }]\n        }] }); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatSnackBarModule {\n}\nMatSnackBarModule.ɵfac = function MatSnackBarModule_Factory(t) { return new (t || MatSnackBarModule)(); };\nMatSnackBarModule.ɵmod = /*@__PURE__*/ ɵngcc0.ɵɵdefineNgModule({ type: MatSnackBarModule });\nMatSnackBarModule.ɵinj = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjector({ imports: [[\n            OverlayModule,\n            PortalModule,\n            CommonModule,\n            MatButtonModule,\n            MatCommonModule,\n        ], MatCommonModule] });\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatSnackBarModule, [{\n        type: NgModule,\n        args: [{\n                imports: [\n                    OverlayModule,\n                    PortalModule,\n                    CommonModule,\n                    MatButtonModule,\n                    MatCommonModule,\n                ],\n                exports: [MatSnackBarContainer, MatCommonModule],\n                declarations: [MatSnackBarContainer, SimpleSnackBar],\n                entryComponents: [MatSnackBarContainer, SimpleSnackBar]\n            }]\n    }], null, null); })();\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(MatSnackBarModule, { declarations: function () { return [MatSnackBarContainer, SimpleSnackBar]; }, imports: function () { return [OverlayModule,\n        PortalModule,\n        CommonModule,\n        MatButtonModule,\n        MatCommonModule]; }, exports: function () { return [MatSnackBarContainer, MatCommonModule]; } }); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token that can be used to specify default snack bar. */\nconst MAT_SNACK_BAR_DEFAULT_OPTIONS = new InjectionToken('mat-snack-bar-default-options', {\n    providedIn: 'root',\n    factory: MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY,\n});\n/** @docs-private */\nfunction MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY() {\n    return new MatSnackBarConfig();\n}\n/**\n * Service to dispatch Material Design snack bar messages.\n */\nclass MatSnackBar {\n    constructor(_overlay, _live, _injector, _breakpointObserver, _parentSnackBar, _defaultConfig) {\n        this._overlay = _overlay;\n        this._live = _live;\n        this._injector = _injector;\n        this._breakpointObserver = _breakpointObserver;\n        this._parentSnackBar = _parentSnackBar;\n        this._defaultConfig = _defaultConfig;\n        /**\n         * Reference to the current snack bar in the view *at this level* (in the Angular injector tree).\n         * If there is a parent snack-bar service, all operations should delegate to that parent\n         * via `_openedSnackBarRef`.\n         */\n        this._snackBarRefAtThisLevel = null;\n        /** The component that should be rendered as the snack bar's simple component. */\n        this.simpleSnackBarComponent = SimpleSnackBar;\n        /** The container component that attaches the provided template or component. */\n        this.snackBarContainerComponent = MatSnackBarContainer;\n        /** The CSS class to apply for handset mode. */\n        this.handsetCssClass = 'mat-snack-bar-handset';\n    }\n    /** Reference to the currently opened snackbar at *any* level. */\n    get _openedSnackBarRef() {\n        const parent = this._parentSnackBar;\n        return parent ? parent._openedSnackBarRef : this._snackBarRefAtThisLevel;\n    }\n    set _openedSnackBarRef(value) {\n        if (this._parentSnackBar) {\n            this._parentSnackBar._openedSnackBarRef = value;\n        }\n        else {\n            this._snackBarRefAtThisLevel = value;\n        }\n    }\n    /**\n     * Creates and dispatches a snack bar with a custom component for the content, removing any\n     * currently opened snack bars.\n     *\n     * @param component Component to be instantiated.\n     * @param config Extra configuration for the snack bar.\n     */\n    openFromComponent(component, config) {\n        return this._attach(component, config);\n    }\n    /**\n     * Creates and dispatches a snack bar with a custom template for the content, removing any\n     * currently opened snack bars.\n     *\n     * @param template Template to be instantiated.\n     * @param config Extra configuration for the snack bar.\n     */\n    openFromTemplate(template, config) {\n        return this._attach(template, config);\n    }\n    /**\n     * Opens a snackbar with a message and an optional action.\n     * @param message The message to show in the snackbar.\n     * @param action The label for the snackbar action.\n     * @param config Additional configuration options for the snackbar.\n     */\n    open(message, action = '', config) {\n        const _config = Object.assign(Object.assign({}, this._defaultConfig), config);\n        // Since the user doesn't have access to the component, we can\n        // override the data to pass in our own message and action.\n        _config.data = { message, action };\n        // Since the snack bar has `role=\"alert\"`, we don't\n        // want to announce the same message twice.\n        if (_config.announcementMessage === message) {\n            _config.announcementMessage = undefined;\n        }\n        return this.openFromComponent(this.simpleSnackBarComponent, _config);\n    }\n    /**\n     * Dismisses the currently-visible snack bar.\n     */\n    dismiss() {\n        if (this._openedSnackBarRef) {\n            this._openedSnackBarRef.dismiss();\n        }\n    }\n    ngOnDestroy() {\n        // Only dismiss the snack bar at the current level on destroy.\n        if (this._snackBarRefAtThisLevel) {\n            this._snackBarRefAtThisLevel.dismiss();\n        }\n    }\n    /**\n     * Attaches the snack bar container component to the overlay.\n     */\n    _attachSnackBarContainer(overlayRef, config) {\n        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n        const injector = Injector.create({\n            parent: userInjector || this._injector,\n            providers: [{ provide: MatSnackBarConfig, useValue: config }]\n        });\n        const containerPortal = new ComponentPortal(this.snackBarContainerComponent, config.viewContainerRef, injector);\n        const containerRef = overlayRef.attach(containerPortal);\n        containerRef.instance.snackBarConfig = config;\n        return containerRef.instance;\n    }\n    /**\n     * Places a new component or a template as the content of the snack bar container.\n     */\n    _attach(content, userConfig) {\n        const config = Object.assign(Object.assign(Object.assign({}, new MatSnackBarConfig()), this._defaultConfig), userConfig);\n        const overlayRef = this._createOverlay(config);\n        const container = this._attachSnackBarContainer(overlayRef, config);\n        const snackBarRef = new MatSnackBarRef(container, overlayRef);\n        if (content instanceof TemplateRef) {\n            const portal = new TemplatePortal(content, null, {\n                $implicit: config.data,\n                snackBarRef\n            });\n            snackBarRef.instance = container.attachTemplatePortal(portal);\n        }\n        else {\n            const injector = this._createInjector(config, snackBarRef);\n            const portal = new ComponentPortal(content, undefined, injector);\n            const contentRef = container.attachComponentPortal(portal);\n            // We can't pass this via the injector, because the injector is created earlier.\n            snackBarRef.instance = contentRef.instance;\n        }\n        // Subscribe to the breakpoint observer and attach the mat-snack-bar-handset class as\n        // appropriate. This class is applied to the overlay element because the overlay must expand to\n        // fill the width of the screen for full width snackbars.\n        this._breakpointObserver.observe(Breakpoints.HandsetPortrait).pipe(takeUntil(overlayRef.detachments())).subscribe(state => {\n            const classList = overlayRef.overlayElement.classList;\n            state.matches ? classList.add(this.handsetCssClass) : classList.remove(this.handsetCssClass);\n        });\n        if (config.announcementMessage) {\n            // Wait until the snack bar contents have been announced then deliver this message.\n            container._onAnnounce.subscribe(() => {\n                this._live.announce(config.announcementMessage, config.politeness);\n            });\n        }\n        this._animateSnackBar(snackBarRef, config);\n        this._openedSnackBarRef = snackBarRef;\n        return this._openedSnackBarRef;\n    }\n    /** Animates the old snack bar out and the new one in. */\n    _animateSnackBar(snackBarRef, config) {\n        // When the snackbar is dismissed, clear the reference to it.\n        snackBarRef.afterDismissed().subscribe(() => {\n            // Clear the snackbar ref if it hasn't already been replaced by a newer snackbar.\n            if (this._openedSnackBarRef == snackBarRef) {\n                this._openedSnackBarRef = null;\n            }\n            if (config.announcementMessage) {\n                this._live.clear();\n            }\n        });\n        if (this._openedSnackBarRef) {\n            // If a snack bar is already in view, dismiss it and enter the\n            // new snack bar after exit animation is complete.\n            this._openedSnackBarRef.afterDismissed().subscribe(() => {\n                snackBarRef.containerInstance.enter();\n            });\n            this._openedSnackBarRef.dismiss();\n        }\n        else {\n            // If no snack bar is in view, enter the new snack bar.\n            snackBarRef.containerInstance.enter();\n        }\n        // If a dismiss timeout is provided, set up dismiss based on after the snackbar is opened.\n        if (config.duration && config.duration > 0) {\n            snackBarRef.afterOpened().subscribe(() => snackBarRef._dismissAfter(config.duration));\n        }\n    }\n    /**\n     * Creates a new overlay and places it in the correct location.\n     * @param config The user-specified snack bar config.\n     */\n    _createOverlay(config) {\n        const overlayConfig = new OverlayConfig();\n        overlayConfig.direction = config.direction;\n        let positionStrategy = this._overlay.position().global();\n        // Set horizontal position.\n        const isRtl = config.direction === 'rtl';\n        const isLeft = (config.horizontalPosition === 'left' ||\n            (config.horizontalPosition === 'start' && !isRtl) ||\n            (config.horizontalPosition === 'end' && isRtl));\n        const isRight = !isLeft && config.horizontalPosition !== 'center';\n        if (isLeft) {\n            positionStrategy.left('0');\n        }\n        else if (isRight) {\n            positionStrategy.right('0');\n        }\n        else {\n            positionStrategy.centerHorizontally();\n        }\n        // Set horizontal position.\n        if (config.verticalPosition === 'top') {\n            positionStrategy.top('0');\n        }\n        else {\n            positionStrategy.bottom('0');\n        }\n        overlayConfig.positionStrategy = positionStrategy;\n        return this._overlay.create(overlayConfig);\n    }\n    /**\n     * Creates an injector to be used inside of a snack bar component.\n     * @param config Config that was used to create the snack bar.\n     * @param snackBarRef Reference to the snack bar.\n     */\n    _createInjector(config, snackBarRef) {\n        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n        return Injector.create({\n            parent: userInjector || this._injector,\n            providers: [\n                { provide: MatSnackBarRef, useValue: snackBarRef },\n                { provide: MAT_SNACK_BAR_DATA, useValue: config.data }\n            ]\n        });\n    }\n}\nMatSnackBar.ɵfac = function MatSnackBar_Factory(t) { return new (t || MatSnackBar)(ɵngcc0.ɵɵinject(ɵngcc5.Overlay), ɵngcc0.ɵɵinject(ɵngcc6.LiveAnnouncer), ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc7.BreakpointObserver), ɵngcc0.ɵɵinject(MatSnackBar, 12), ɵngcc0.ɵɵinject(MAT_SNACK_BAR_DEFAULT_OPTIONS)); };\nMatSnackBar.ɵprov = i0.ɵɵdefineInjectable({ factory: function MatSnackBar_Factory() { return new MatSnackBar(i0.ɵɵinject(i1.Overlay), i0.ɵɵinject(i2.LiveAnnouncer), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i3.BreakpointObserver), i0.ɵɵinject(MatSnackBar, 12), i0.ɵɵinject(MAT_SNACK_BAR_DEFAULT_OPTIONS)); }, token: MatSnackBar, providedIn: MatSnackBarModule });\nMatSnackBar.ctorParameters = () => [\n    { type: Overlay },\n    { type: LiveAnnouncer },\n    { type: Injector },\n    { type: BreakpointObserver },\n    { type: MatSnackBar, decorators: [{ type: Optional }, { type: SkipSelf }] },\n    { type: MatSnackBarConfig, decorators: [{ type: Inject, args: [MAT_SNACK_BAR_DEFAULT_OPTIONS,] }] }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatSnackBar, [{\n        type: Injectable,\n        args: [{ providedIn: MatSnackBarModule }]\n    }], function () { return [{ type: ɵngcc5.Overlay }, { type: ɵngcc6.LiveAnnouncer }, { type: ɵngcc0.Injector }, { type: ɵngcc7.BreakpointObserver }, { type: MatSnackBar, decorators: [{\n                type: Optional\n            }, {\n                type: SkipSelf\n            }] }, { type: MatSnackBarConfig, decorators: [{\n                type: Inject,\n                args: [MAT_SNACK_BAR_DEFAULT_OPTIONS]\n            }] }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_SNACK_BAR_DATA, MAT_SNACK_BAR_DEFAULT_OPTIONS, MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY, MatSnackBar, MatSnackBarConfig, MatSnackBarContainer, MatSnackBarModule, MatSnackBarRef, SimpleSnackBar, matSnackBarAnimations };\n\n//# sourceMappingURL=snack-bar.js.map","import * as i1 from '@angular/common';\nimport { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { Injectable, Inject, InjectionToken, EventEmitter, Directive, NgZone, Optional, Input, Output, NgModule } from '@angular/core';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A pending copy-to-clipboard operation.\n *\n * The implementation of copying text to the clipboard modifies the DOM and\n * forces a relayout. This relayout can take too long if the string is large,\n * causing the execCommand('copy') to happen too long after the user clicked.\n * This results in the browser refusing to copy. This object lets the\n * relayout happen in a separate tick from copying by providing a copy function\n * that can be called later.\n *\n * Destroy must be called when no longer in use, regardless of whether `copy` is\n * called.\n */\nimport * as ɵngcc0 from '@angular/core';\nclass PendingCopy {\n    constructor(text, _document) {\n        this._document = _document;\n        const textarea = this._textarea = this._document.createElement('textarea');\n        const styles = textarea.style;\n        // Hide the element for display and accessibility. Set a fixed position so the page layout\n        // isn't affected. We use `fixed` with `top: 0`, because focus is moved into the textarea\n        // for a split second and if it's off-screen, some browsers will attempt to scroll it into view.\n        styles.position = 'fixed';\n        styles.top = styles.opacity = '0';\n        styles.left = '-999em';\n        textarea.setAttribute('aria-hidden', 'true');\n        textarea.value = text;\n        this._document.body.appendChild(textarea);\n    }\n    /** Finishes copying the text. */\n    copy() {\n        const textarea = this._textarea;\n        let successful = false;\n        try { // Older browsers could throw if copy is not supported.\n            if (textarea) {\n                const currentFocus = this._document.activeElement;\n                textarea.select();\n                textarea.setSelectionRange(0, textarea.value.length);\n                successful = this._document.execCommand('copy');\n                if (currentFocus) {\n                    currentFocus.focus();\n                }\n            }\n        }\n        catch (_a) {\n            // Discard error.\n            // Initial setting of {@code successful} will represent failure here.\n        }\n        return successful;\n    }\n    /** Cleans up DOM changes used to perform the copy operation. */\n    destroy() {\n        const textarea = this._textarea;\n        if (textarea) {\n            if (textarea.parentNode) {\n                textarea.parentNode.removeChild(textarea);\n            }\n            this._textarea = undefined;\n        }\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A service for copying text to the clipboard.\n */\nclass Clipboard {\n    constructor(document) {\n        this._document = document;\n    }\n    /**\n     * Copies the provided text into the user's clipboard.\n     *\n     * @param text The string to copy.\n     * @returns Whether the operation was successful.\n     */\n    copy(text) {\n        const pendingCopy = this.beginCopy(text);\n        const successful = pendingCopy.copy();\n        pendingCopy.destroy();\n        return successful;\n    }\n    /**\n     * Prepares a string to be copied later. This is useful for large strings\n     * which take too long to successfully render and be copied in the same tick.\n     *\n     * The caller must call `destroy` on the returned `PendingCopy`.\n     *\n     * @param text The string to copy.\n     * @returns the pending copy operation.\n     */\n    beginCopy(text) {\n        return new PendingCopy(text, this._document);\n    }\n}\nClipboard.ɵfac = function Clipboard_Factory(t) { return new (t || Clipboard)(ɵngcc0.ɵɵinject(DOCUMENT)); };\nClipboard.ɵprov = i0.ɵɵdefineInjectable({ factory: function Clipboard_Factory() { return new Clipboard(i0.ɵɵinject(i1.DOCUMENT)); }, token: Clipboard, providedIn: \"root\" });\nClipboard.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }\n];\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(Clipboard, [{\n        type: Injectable,\n        args: [{ providedIn: 'root' }]\n    }], function () { return [{ type: undefined, decorators: [{\n                type: Inject,\n                args: [DOCUMENT]\n            }] }]; }, null); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Injection token that can be used to provide the default options to `CdkCopyToClipboard`. */\nconst CDK_COPY_TO_CLIPBOARD_CONFIG = new InjectionToken('CDK_COPY_TO_CLIPBOARD_CONFIG');\n/**\n * @deprecated Use `CDK_COPY_TO_CLIPBOARD_CONFIG` instead.\n * @breaking-change 13.0.0\n */\nconst CKD_COPY_TO_CLIPBOARD_CONFIG = CDK_COPY_TO_CLIPBOARD_CONFIG;\n/**\n * Provides behavior for a button that when clicked copies content into user's\n * clipboard.\n */\nclass CdkCopyToClipboard {\n    constructor(_clipboard, _ngZone, config) {\n        this._clipboard = _clipboard;\n        this._ngZone = _ngZone;\n        /** Content to be copied. */\n        this.text = '';\n        /**\n         * How many times to attempt to copy the text. This may be necessary for longer text, because\n         * the browser needs time to fill an intermediate textarea element and copy the content.\n         */\n        this.attempts = 1;\n        /**\n         * Emits when some text is copied to the clipboard. The\n         * emitted value indicates whether copying was successful.\n         */\n        this.copied = new EventEmitter();\n        /** Copies that are currently being attempted. */\n        this._pending = new Set();\n        if (config && config.attempts != null) {\n            this.attempts = config.attempts;\n        }\n    }\n    /** Copies the current text to the clipboard. */\n    copy(attempts = this.attempts) {\n        if (attempts > 1) {\n            let remainingAttempts = attempts;\n            const pending = this._clipboard.beginCopy(this.text);\n            this._pending.add(pending);\n            const attempt = () => {\n                const successful = pending.copy();\n                if (!successful && --remainingAttempts && !this._destroyed) {\n                    // We use 1 for the timeout since it's more predictable when flushing in unit tests.\n                    this._currentTimeout = this._ngZone.runOutsideAngular(() => setTimeout(attempt, 1));\n                }\n                else {\n                    this._currentTimeout = null;\n                    this._pending.delete(pending);\n                    pending.destroy();\n                    this.copied.emit(successful);\n                }\n            };\n            attempt();\n        }\n        else {\n            this.copied.emit(this._clipboard.copy(this.text));\n        }\n    }\n    ngOnDestroy() {\n        if (this._currentTimeout) {\n            clearTimeout(this._currentTimeout);\n        }\n        this._pending.forEach(copy => copy.destroy());\n        this._pending.clear();\n        this._destroyed = true;\n    }\n}\nCdkCopyToClipboard.ɵfac = function CdkCopyToClipboard_Factory(t) { return new (t || CdkCopyToClipboard)(ɵngcc0.ɵɵdirectiveInject(Clipboard), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(CKD_COPY_TO_CLIPBOARD_CONFIG, 8)); };\nCdkCopyToClipboard.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkCopyToClipboard, selectors: [[\"\", \"cdkCopyToClipboard\", \"\"]], hostBindings: function CdkCopyToClipboard_HostBindings(rf, ctx) { if (rf & 1) {\n        ɵngcc0.ɵɵlistener(\"click\", function CdkCopyToClipboard_click_HostBindingHandler() { return ctx.copy(); });\n    } }, inputs: { text: [\"cdkCopyToClipboard\", \"text\"], attempts: [\"cdkCopyToClipboardAttempts\", \"attempts\"] }, outputs: { copied: \"cdkCopyToClipboardCopied\" } });\nCdkCopyToClipboard.ctorParameters = () => [\n    { type: Clipboard },\n    { type: NgZone },\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CKD_COPY_TO_CLIPBOARD_CONFIG,] }] }\n];\nCdkCopyToClipboard.propDecorators = {\n    text: [{ type: Input, args: ['cdkCopyToClipboard',] }],\n    attempts: [{ type: Input, args: ['cdkCopyToClipboardAttempts',] }],\n    copied: [{ type: Output, args: ['cdkCopyToClipboardCopied',] }]\n};\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkCopyToClipboard, [{\n        type: Directive,\n        args: [{\n                selector: '[cdkCopyToClipboard]',\n                host: {\n                    '(click)': 'copy()'\n                }\n            }]\n    }], function () { return [{ type: Clipboard }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{\n                type: Optional\n            }, {\n                type: Inject,\n                args: [CKD_COPY_TO_CLIPBOARD_CONFIG]\n            }] }]; }, { text: [{\n            type: Input,\n            args: ['cdkCopyToClipboard']\n        }], attempts: [{\n            type: Input,\n            args: ['cdkCopyToClipboardAttempts']\n        }], copied: [{\n            type: Output,\n            args: ['cdkCopyToClipboardCopied']\n        }] }); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass ClipboardModule {\n}\nClipboardModule.ɵfac = function ClipboardModule_Factory(t) { return new (t || ClipboardModule)(); };\nClipboardModule.ɵmod = /*@__PURE__*/ ɵngcc0.ɵɵdefineNgModule({ type: ClipboardModule });\nClipboardModule.ɵinj = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjector({});\n(function () { (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(ClipboardModule, [{\n        type: NgModule,\n        args: [{\n                declarations: [CdkCopyToClipboard],\n                exports: [CdkCopyToClipboard]\n            }]\n    }], null, null); })();\n(function () { (typeof ngJitMode === \"undefined\" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(ClipboardModule, { declarations: [CdkCopyToClipboard], exports: [CdkCopyToClipboard] }); })();\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { CDK_COPY_TO_CLIPBOARD_CONFIG, CKD_COPY_TO_CLIPBOARD_CONFIG, CdkCopyToClipboard, Clipboard, ClipboardModule, PendingCopy };\n\n//# sourceMappingURL=clipboard.js.map","import { Component, ElementRef, EventEmitter, Input, OnChanges, Output, ViewChild } from '@angular/core';\nimport { Clipboard } from '@angular/cdk/clipboard';\nimport { Logger } from 'app/shared/logger.service';\nimport { PrettyPrinter } from './pretty-printer.service';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { Observable, of } from 'rxjs';\nimport { tap } from 'rxjs/operators';\n\n/**\n * Formatted Code Block\n *\n * Pretty renders a code block, used in the docs and API reference by the code-example and\n * code-tabs embedded components.\n * It includes a \"copy\" button that will send the content to the clipboard when clicked\n *\n * Example usage:\n *\n * ```\n * <aio-code\n *   [language]=\"ts\"\n *   [linenums]=\"true\"\n *   [path]=\"router/src/app/app.module.ts\"\n *   [region]=\"animations-module\">\n * </aio-code>\n * ```\n *\n *\n * Renders code provided through the `updateCode` method.\n */\n@Component({\n  selector: 'aio-code',\n  template: `\n    <pre class=\"prettyprint lang-{{language}}\">\n      <button *ngIf=\"!hideCopy\" class=\"material-icons copy-button no-print\"\n        title=\"Copy code snippet\"\n        [attr.aria-label]=\"ariaLabel\"\n        (click)=\"doCopy()\">\n        <span aria-hidden=\"true\">content_copy</span>\n      </button>\n      <code class=\"animated fadeIn\" #codeContainer></code>\n    </pre>\n    `\n})\nexport class CodeComponent implements OnChanges {\n  ariaLabel = '';\n\n  /** The code to be copied when clicking the copy button, this should not be HTML encoded */\n  private codeText: string;\n\n  /** Code that should be formatted with current inputs and displayed in the view. */\n  set code(code: string) {\n    this._code = code;\n\n    if (!this._code || !this._code.trim()) {\n      this.showMissingCodeMessage();\n    } else {\n      this.formatDisplayedCode();\n    }\n  }\n  get code(): string { return this._code; }\n  _code: string;\n\n  /** Whether the copy button should be shown. */\n  @Input() hideCopy: boolean;\n\n  /** Language to render the code (e.g. javascript, dart, typescript). */\n  @Input() language: string | undefined;\n\n  /**\n   * Whether to display line numbers:\n   *  - If false: hide\n   *  - If true: show\n   *  - If number: show but start at that number\n   */\n  @Input() linenums: boolean | number | string | undefined;\n\n  /** Path to the source of the code. */\n  @Input() path: string;\n\n  /** Region of the source of the code being displayed. */\n  @Input() region: string;\n\n  /** Optional header to be displayed above the code. */\n  @Input()\n  set header(header: string | undefined) {\n    this._header = header;\n    this.ariaLabel = this.header ? `Copy code snippet from ${this.header}` : '';\n  }\n  get header(): string|undefined { return this._header; }\n  private _header: string | undefined;\n\n  @Output() codeFormatted = new EventEmitter<void>();\n\n  /** The element in the template that will display the formatted code. */\n  @ViewChild('codeContainer', { static: true }) codeContainer: ElementRef;\n\n  constructor(\n    private snackbar: MatSnackBar,\n    private pretty: PrettyPrinter,\n    private clipboard: Clipboard,\n    private logger: Logger) {}\n\n  ngOnChanges() {\n    // If some inputs have changed and there is code displayed, update the view with the latest\n    // formatted code.\n    if (this.code) {\n      this.formatDisplayedCode();\n    }\n  }\n\n  private formatDisplayedCode() {\n    const linenums = this.getLinenums();\n    const leftAlignedCode = leftAlign(this.code);\n    this.setCodeHtml(leftAlignedCode); // start with unformatted code\n    this.codeText = this.getCodeText(); // store the unformatted code as text (for copying)\n\n    const skipPrettify = of(undefined);\n    const prettifyCode = this.pretty\n        .formatCode(leftAlignedCode, this.language, linenums)\n        .pipe(tap(formattedCode => this.setCodeHtml(formattedCode)));\n\n    if (linenums !== false && this.language === 'none') {\n      this.logger.warn(`Using 'linenums' with 'language: none' is currently not supported.`);\n    }\n\n    ((this.language === 'none' ? skipPrettify : prettifyCode) as Observable<unknown>)\n        .subscribe(() => this.codeFormatted.emit(), () => { /* ignore failure to format */ });\n  }\n\n  /** Sets the message showing that the code could not be found. */\n  private showMissingCodeMessage() {\n    const src = this.path ? this.path + (this.region ? '#' + this.region : '') : '';\n    const srcMsg = src ? ` for\\n${src}` : '.';\n    this.setCodeHtml(`<p class=\"code-missing\">The code sample is missing${srcMsg}</p>`);\n  }\n\n  /** Sets the innerHTML of the code container to the provided code string. */\n  private setCodeHtml(formattedCode: string) {\n    // **Security:** Code example content is provided by docs authors and as such its considered to\n    // be safe for innerHTML purposes.\n    this.codeContainer.nativeElement.innerHTML = formattedCode;\n  }\n\n  /** Gets the textContent of the displayed code element. */\n  private getCodeText() {\n    // `prettify` may remove newlines, e.g. when `linenums` are on. Retrieve the content of the\n    // container as text, before prettifying it.\n    // We take the textContent because we don't want it to be HTML encoded.\n    return this.codeContainer.nativeElement.textContent;\n  }\n\n  /** Copies the code snippet to the user's clipboard. */\n  doCopy() {\n    const code = this.codeText;\n    const successfullyCopied = this.clipboard.copy(code);\n\n    if (successfullyCopied) {\n      this.logger.log('Copied code to clipboard:', code);\n      this.snackbar.open('Code Copied', '', { duration: 800 });\n    } else {\n      this.logger.error(new Error(`ERROR copying code to clipboard: \"${code}\"`));\n      this.snackbar.open('Copy failed. Please try again!', '', { duration: 800 });\n    }\n  }\n\n  /** Gets the calculated value of linenums (boolean/number). */\n  getLinenums() {\n    const linenums =\n      typeof this.linenums === 'boolean' ? this.linenums :\n      this.linenums === 'true' ? true :\n      this.linenums === 'false' ? false :\n      typeof this.linenums === 'string' ? parseInt(this.linenums, 10) :\n      this.linenums;\n\n    return (linenums != null) && !isNaN(linenums as number) && linenums;\n  }\n}\n\nfunction leftAlign(text: string): string {\n  let indent = Number.MAX_VALUE;\n\n  const lines = text.split('\\n');\n  lines.forEach(line => {\n    const lineIndent = line.search(/\\S/);\n    if (lineIndent !== -1) {\n      indent = Math.min(lineIndent, indent);\n    }\n  });\n\n  return lines.map(line => line.substr(indent)).join('\\n').trim();\n}\n","import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { CodeComponent } from './code.component';\nimport { MatSnackBarModule } from '@angular/material/snack-bar';\nimport { PrettyPrinter } from './pretty-printer.service';\n\n@NgModule({\n  imports: [ CommonModule, MatSnackBarModule ],\n  declarations: [ CodeComponent ],\n  entryComponents: [ CodeComponent ],\n  exports: [ CodeComponent ],\n  providers: [ PrettyPrinter ]\n})\nexport class CodeModule { }\n","import { Injectable } from '@angular/core';\n\nimport { from, Observable } from 'rxjs';\nimport { first, map, share } from 'rxjs/operators';\n\nimport { Logger } from 'app/shared/logger.service';\n\ntype PrettyPrintOne = (code: string, language?: string, linenums?: number | boolean) => string;\n\n/**\n * Wrapper around the prettify.js library\n */\n@Injectable()\nexport class PrettyPrinter {\n\n  private prettyPrintOne: Observable<PrettyPrintOne>;\n\n  constructor(private logger: Logger) {\n    this.prettyPrintOne = from(this.getPrettyPrintOne()).pipe(share());\n  }\n\n  private getPrettyPrintOne(): Promise<PrettyPrintOne> {\n    const ppo = (window as any).prettyPrintOne;\n    return ppo ? Promise.resolve(ppo) :\n      // `prettyPrintOne` is not on `window`, which means `prettify.js` has not been loaded yet.\n      // Import it; ad a side-effect it will add `prettyPrintOne` on `window`.\n      import('assets/js/prettify.js' as any)\n        .then(\n          () => (window as any).prettyPrintOne,\n          err => {\n            const msg = `Cannot get prettify.js from server: ${err.message}`;\n            this.logger.error(new Error(msg));\n            // return a pretty print fn that always fails.\n            return () => { throw new Error(msg); };\n          });\n  }\n\n  /**\n   * Format code snippet as HTML\n   * @param code - the code snippet to format; should already be HTML encoded\n   * @param [language] - The language of the code to render (could be javascript, html, typescript, etc)\n   * @param [linenums] - Whether to display line numbers:\n   *  - false: don't display\n   *  - true: do display\n   *  - number: do display but start at the given number\n   * @returns Observable<string> - Observable of formatted code\n   */\n  formatCode(code: string, language?: string, linenums?: number | boolean) {\n    return this.prettyPrintOne.pipe(\n      map(ppo => {\n        try {\n          return ppo(code, language, linenums);\n        } catch (err) {\n          const msg = `Could not format code that begins '${code.substr(0, 50)}...'.`;\n          console.error(msg, err);\n          throw new Error(msg);\n        }\n      }),\n      first(),  // complete immediately\n    );\n  }\n}\n"]}