@angular/cdk 13.0.0-next.6 → 13.0.0-rc.1

package/{fesm2015/overlay.js → fesm2020/overlay.mjs}

@@ -1,14 +1,16 @@
 import * as i1 from '@angular/cdk/scrolling';
-import { ScrollDispatcher, ViewportRuler, ScrollingModule } from '@angular/cdk/scrolling';
+import { ScrollingModule } from '@angular/cdk/scrolling';
 export { CdkScrollable, ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';
-import * as i1$1 from '@angular/common';
-import { DOCUMENT, Location } from '@angular/common';
+import * as i6 from '@angular/common';
+import { DOCUMENT } from '@angular/common';
 import * as i0 from '@angular/core';
-import { Injectable, NgZone, Inject, Optional, ElementRef, ApplicationRef, ComponentFactoryResolver, Injector, InjectionToken, Directive, EventEmitter, TemplateRef, ViewContainerRef, Input, Output, NgModule } from '@angular/core';
+import { Injectable, Inject, Optional, ElementRef, ApplicationRef, InjectionToken, Directive, EventEmitter, Input, Output, NgModule } from '@angular/core';
 import { coerceCssPixelValue, coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';
-import * as i2 from '@angular/cdk/platform';
-import { supportsScrollBehavior, _getEventTarget, Platform, _isTestEnvironment } from '@angular/cdk/platform';
-import { Directionality, BidiModule } from '@angular/cdk/bidi';
+import * as i1$1 from '@angular/cdk/platform';
+import { supportsScrollBehavior, _getEventTarget, _isTestEnvironment } from '@angular/cdk/platform';
+import { __decorate, __param, __metadata } from 'tslib';
+import * as i5 from '@angular/cdk/bidi';
+import { BidiModule } from '@angular/cdk/bidi';
 import { DomPortalOutlet, TemplatePortal, PortalModule } from '@angular/cdk/portal';
 import { Subject, Subscription, merge } from 'rxjs';
 import { take, takeUntil, takeWhile } from 'rxjs/operators';
@@ -190,8 +192,6 @@ class NoopScrollStrategy {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-// TODO(jelbourn): move this to live with the rest of the scrolling code
-// TODO(jelbourn): someday replace this with IntersectionObservers
 /**
  * Gets whether an element is scrolled outside of view by any of its parent scrolling containers.
  * @param element Dimensions of the element (from getBoundingClientRect)
@@ -320,16 +320,15 @@ class ScrollStrategyOptions {
         this._document = document;
     }
 }
-ScrollStrategyOptions.ɵ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" });
-ScrollStrategyOptions.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-ScrollStrategyOptions.ctorParameters = () => [
-    { type: ScrollDispatcher },
-    { type: ViewportRuler },
-    { type: NgZone },
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
+ScrollStrategyOptions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ScrollStrategyOptions, deps: [{ token: i1.ScrollDispatcher }, { token: i1.ViewportRuler }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollStrategyOptions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ScrollStrategyOptions, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ScrollStrategyOptions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ScrollDispatcher }, { type: i1.ViewportRuler }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 /**
  * @license
@@ -436,7 +435,7 @@ class ConnectionPositionPair {
 class ScrollingVisibility {
 }
 /** The change event emitted by the strategy when a fallback position is used. */
-class ConnectedOverlayPositionChange {
+let ConnectedOverlayPositionChange = class ConnectedOverlayPositionChange {
     constructor(
     /** The position used as a result of this change. */
     connectionPair, 
@@ -445,11 +444,12 @@ class ConnectedOverlayPositionChange {
         this.connectionPair = connectionPair;
         this.scrollableViewProperties = scrollableViewProperties;
     }
-}
-ConnectedOverlayPositionChange.ctorParameters = () => [
-    { type: ConnectionPositionPair },
-    { type: ScrollingVisibility, decorators: [{ type: Optional }] }
-];
+};
+ConnectedOverlayPositionChange = __decorate([
+    __param(1, Optional()),
+    __metadata("design:paramtypes", [ConnectionPositionPair,
+        ScrollingVisibility])
+], ConnectedOverlayPositionChange);
 /**
  * Validates whether a vertical position property matches the expected values.
  * @param property Name of the property being validated.
@@ -514,13 +514,15 @@ class BaseOverlayDispatcher {
         }
     }
 }
-BaseOverlayDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseOverlayDispatcher_Factory() { return new BaseOverlayDispatcher(i0.ɵɵinject(i1$1.DOCUMENT)); }, token: BaseOverlayDispatcher, providedIn: "root" });
-BaseOverlayDispatcher.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-BaseOverlayDispatcher.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
+BaseOverlayDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: BaseOverlayDispatcher, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseOverlayDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: BaseOverlayDispatcher, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: BaseOverlayDispatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 /**
  * @license
@@ -571,13 +573,15 @@ class OverlayKeyboardDispatcher extends BaseOverlayDispatcher {
         }
     }
 }
-OverlayKeyboardDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(i0.ɵɵinject(i1$1.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
-OverlayKeyboardDispatcher.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-OverlayKeyboardDispatcher.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
+OverlayKeyboardDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayKeyboardDispatcher, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayKeyboardDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayKeyboardDispatcher, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayKeyboardDispatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 /**
  * @license
@@ -596,9 +600,24 @@ class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
         super(document);
         this._platform = _platform;
         this._cursorStyleIsSet = false;
+        /** Store pointerdown event target to track origin of click. */
+        this._pointerDownListener = (event) => {
+            this._pointerDownEventTarget = _getEventTarget(event);
+        };
         /** Click event listener that will be attached to the body propagate phase. */
         this._clickListener = (event) => {
             const target = _getEventTarget(event);
+            // In case of a click event, we want to check the origin of the click
+            // (e.g. in case where a user starts a click inside the overlay and
+            // releases the click outside of it).
+            // This is done by using the event target of the preceding pointerdown event.
+            // Every click event caused by a pointer device has a preceding pointerdown
+            // event, unless the click was programmatically triggered (e.g. in a unit test).
+            const origin = event.type === 'click' && this._pointerDownEventTarget
+                ? this._pointerDownEventTarget : target;
+            // Reset the stored pointerdown event target, to avoid having it interfere
+            // in subsequent events.
+            this._pointerDownEventTarget = null;
             // We copy the array because the original may be modified asynchronously if the
             // outsidePointerEvents listener decides to detach overlays resulting in index errors inside
             // the for loop.
@@ -613,8 +632,10 @@ class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
                     continue;
                 }
                 // If it's a click inside the overlay, just break - we should do nothing
-                // If it's an outside click dispatch the mouse event, and proceed with the next overlay
-                if (overlayRef.overlayElement.contains(target)) {
+                // If it's an outside click (both origin and target of the click) dispatch the mouse event,
+                // and proceed with the next overlay
+                if (overlayRef.overlayElement.contains(target) ||
+                    overlayRef.overlayElement.contains(origin)) {
                     break;
                 }
                 overlayRef._outsidePointerEvents.next(event);
@@ -632,6 +653,7 @@ class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
         // https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html
         if (!this._isAttached) {
             const body = this._document.body;
+            body.addEventListener('pointerdown', this._pointerDownListener, true);
             body.addEventListener('click', this._clickListener, true);
             body.addEventListener('auxclick', this._clickListener, true);
             body.addEventListener('contextmenu', this._clickListener, true);
@@ -649,6 +671,7 @@ class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
     detach() {
         if (this._isAttached) {
             const body = this._document.body;
+            body.removeEventListener('pointerdown', this._pointerDownListener, true);
             body.removeEventListener('click', this._clickListener, true);
             body.removeEventListener('auxclick', this._clickListener, true);
             body.removeEventListener('contextmenu', this._clickListener, true);
@@ -660,14 +683,15 @@ class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
         }
     }
 }
-OverlayOutsideClickDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayOutsideClickDispatcher_Factory() { return new OverlayOutsideClickDispatcher(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: OverlayOutsideClickDispatcher, providedIn: "root" });
-OverlayOutsideClickDispatcher.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-OverlayOutsideClickDispatcher.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Platform }
-];
+OverlayOutsideClickDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayOutsideClickDispatcher, deps: [{ token: DOCUMENT }, { token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayOutsideClickDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayOutsideClickDispatcher, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayOutsideClickDispatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1$1.Platform }]; } });
 
 /**
  * @license
@@ -683,10 +707,7 @@ class OverlayContainer {
         this._document = document;
     }
     ngOnDestroy() {
-        const container = this._containerElement;
-        if (container && container.parentNode) {
-            container.parentNode.removeChild(container);
-        }
+        this._containerElement?.remove();
     }
     /**
      * This method returns the overlay container element. It will lazily
@@ -710,12 +731,11 @@ class OverlayContainer {
         // module or Angular starts tearing down the testing `NgModule`. See:
         // https://github.com/angular/angular/issues/18831
         if (this._platform.isBrowser || _isTestEnvironment()) {
-            const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform="server"], ` +
-                `.${containerClass}[platform="test"]`);
+            const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform="server"], ` + `.${containerClass}[platform="test"]`);
             // Remove any old containers from the opposite platform.
             // This can happen when transitioning from the server to the client.
             for (let i = 0; i < oppositePlatformContainers.length; i++) {
-                oppositePlatformContainers[i].parentNode.removeChild(oppositePlatformContainers[i]);
+                oppositePlatformContainers[i].remove();
             }
         }
         const container = this._document.createElement('div');
@@ -739,14 +759,15 @@ class OverlayContainer {
         this._containerElement = container;
     }
 }
-OverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: OverlayContainer, providedIn: "root" });
-OverlayContainer.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-OverlayContainer.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Platform }
-];
+OverlayContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayContainer, deps: [{ token: DOCUMENT }, { token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayContainer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayContainer, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayContainer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1$1.Platform }]; } });
 
 /**
  * @license
@@ -827,9 +848,7 @@ class OverlayRef {
         // Update the position once the zone is stable so that the overlay will be fully rendered
         // before attempting to position it, as the position may depend on the size of the rendered
         // content.
-        this._ngZone.onStable
-            .pipe(take(1))
-            .subscribe(() => {
+        this._ngZone.onStable.pipe(take(1)).subscribe(() => {
             // The overlay could've been detached before the zone has stabilized.
             if (this.hasAttached()) {
                 this.updatePosition();
@@ -900,11 +919,8 @@ class OverlayRef {
         this._keydownEvents.complete();
         this._outsidePointerEvents.complete();
         this._outsideClickDispatcher.remove(this);
-        if (this._host && this._host.parentNode) {
-            this._host.parentNode.removeChild(this._host);
-            this._host = null;
-        }
-        this._previousHostParent = this._pane = null;
+        this._host?.remove();
+        this._previousHostParent = this._pane = this._host = null;
         if (isAttached) {
             this._detachments.next();
         }
@@ -960,12 +976,12 @@ class OverlayRef {
     }
     /** Update the size properties of the overlay. */
     updateSize(sizeConfig) {
-        this._config = Object.assign(Object.assign({}, this._config), sizeConfig);
+        this._config = { ...this._config, ...sizeConfig };
         this._updateElementSize();
     }
     /** Sets the LTR/RTL direction for the overlay. */
     setDirection(dir) {
-        this._config = Object.assign(Object.assign({}, this._config), { direction: dir });
+        this._config = { ...this._config, direction: dir };
         this._updateElementDirection();
     }
     /** Add a CSS class or an array of classes to the overlay pane. */
@@ -1121,7 +1137,7 @@ class OverlayRef {
                     }
                     if (this._host && this._host.parentElement) {
                         this._previousHostParent = this._host.parentElement;
-                        this._previousHostParent.removeChild(this._host);
+                        this._host.remove();
                     }
                     subscription.unsubscribe();
                 }
@@ -1141,9 +1157,7 @@ class OverlayRef {
     /** Removes a backdrop element from the DOM. */
     _disposeBackdrop(backdrop) {
         if (backdrop) {
-            if (backdrop.parentNode) {
-                backdrop.parentNode.removeChild(backdrop);
-            }
+            backdrop.remove();
             // It is possible that a new portal has been attached to this overlay since we started
             // removing the backdrop. If that is the case, only clear the backdrop reference if it
             // is still the same instance that we started to remove.
@@ -1218,7 +1232,8 @@ class FlexibleConnectedPositionStrategy {
     }
     /** Attaches this position strategy to an overlay. */
     attach(overlayRef) {
-        if (this._overlayRef && overlayRef !== this._overlayRef &&
+        if (this._overlayRef &&
+            overlayRef !== this._overlayRef &&
             (typeof ngDevMode === 'undefined' || ngDevMode)) {
             throw Error('This position strategy is already attached to an overlay');
         }
@@ -1307,7 +1322,7 @@ class FlexibleConnectedPositionStrategy {
                     position: pos,
                     origin: originPoint,
                     overlayRect,
-                    boundingBoxRect: this._calculateBoundingBoxRect(originPoint, pos)
+                    boundingBoxRect: this._calculateBoundingBoxRect(originPoint, pos),
                 });
                 continue;
             }
@@ -1500,7 +1515,7 @@ class FlexibleConnectedPositionStrategy {
         if (pos.originX == 'center') {
             // Note: when centering we should always use the `left`
             // offset, otherwise the position will be wrong in RTL.
-            x = originRect.left + (originRect.width / 2);
+            x = originRect.left + originRect.width / 2;
         }
         else {
             const startX = this._isRtl() ? originRect.right : originRect.left;
@@ -1509,7 +1524,7 @@ class FlexibleConnectedPositionStrategy {
         }
         let y;
         if (pos.originY == 'center') {
-            y = originRect.top + (originRect.height / 2);
+            y = originRect.top + originRect.height / 2;
         }
         else {
             y = pos.originY == 'top' ? originRect.top : originRect.bottom;
@@ -1563,16 +1578,16 @@ class FlexibleConnectedPositionStrategy {
         }
         // How much the overlay would overflow at this position, on each side.
         let leftOverflow = 0 - x;
-        let rightOverflow = (x + overlay.width) - viewport.width;
+        let rightOverflow = x + overlay.width - viewport.width;
         let topOverflow = 0 - y;
-        let bottomOverflow = (y + overlay.height) - viewport.height;
+        let bottomOverflow = y + overlay.height - viewport.height;
         // Visible parts of the element on each axis.
         let visibleWidth = this._subtractOverflows(overlay.width, leftOverflow, rightOverflow);
         let visibleHeight = this._subtractOverflows(overlay.height, topOverflow, bottomOverflow);
         let visibleArea = visibleWidth * visibleHeight;
         return {
             visibleArea,
-            isCompletelyWithinViewport: (overlay.width * overlay.height) === visibleArea,
+            isCompletelyWithinViewport: overlay.width * overlay.height === visibleArea,
             fitsInViewportVertically: visibleHeight === overlay.height,
             fitsInViewportHorizontally: visibleWidth == overlay.width,
         };
@@ -1589,10 +1604,8 @@ class FlexibleConnectedPositionStrategy {
             const availableWidth = viewport.right - point.x;
             const minHeight = getPixelValue(this._overlayRef.getConfig().minHeight);
             const minWidth = getPixelValue(this._overlayRef.getConfig().minWidth);
-            const verticalFit = fit.fitsInViewportVertically ||
-                (minHeight != null && minHeight <= availableHeight);
-            const horizontalFit = fit.fitsInViewportHorizontally ||
-                (minWidth != null && minWidth <= availableWidth);
+            const verticalFit = fit.fitsInViewportVertically || (minHeight != null && minHeight <= availableHeight);
+            const horizontalFit = fit.fitsInViewportHorizontally || (minWidth != null && minWidth <= availableWidth);
             return verticalFit && horizontalFit;
         }
         return false;
@@ -1615,7 +1628,7 @@ class FlexibleConnectedPositionStrategy {
         if (this._previousPushAmount && this._positionLocked) {
             return {
                 x: start.x + this._previousPushAmount.x,
-                y: start.y + this._previousPushAmount.y
+                y: start.y + this._previousPushAmount.y,
             };
         }
         // Round the overlay rect when comparing against the
@@ -1638,13 +1651,13 @@ class FlexibleConnectedPositionStrategy {
             pushX = overflowLeft || -overflowRight;
         }
         else {
-            pushX = start.x < this._viewportMargin ? (viewport.left - scrollPosition.left) - start.x : 0;
+            pushX = start.x < this._viewportMargin ? viewport.left - scrollPosition.left - start.x : 0;
         }
         if (overlay.height <= viewport.height) {
             pushY = overflowTop || -overflowBottom;
         }
         else {
-            pushY = start.y < this._viewportMargin ? (viewport.top - scrollPosition.top) - start.y : 0;
+            pushY = start.y < this._viewportMargin ? viewport.top - scrollPosition.top - start.y : 0;
         }
         this._previousPushAmount = { x: pushX, y: pushY };
         return {
@@ -1729,15 +1742,13 @@ class FlexibleConnectedPositionStrategy {
             height = smallestDistanceToViewportEdge * 2;
             top = origin.y - smallestDistanceToViewportEdge;
             if (height > previousHeight && !this._isInitialRender && !this._growAfterOpen) {
-                top = origin.y - (previousHeight / 2);
+                top = origin.y - previousHeight / 2;
             }
         }
         // The overlay is opening 'right-ward' (the content flows to the right).
-        const isBoundedByRightViewportEdge = (position.overlayX === 'start' && !isRtl) ||
-            (position.overlayX === 'end' && isRtl);
+        const isBoundedByRightViewportEdge = (position.overlayX === 'start' && !isRtl) || (position.overlayX === 'end' && isRtl);
         // The overlay is opening 'left-ward' (the content flows to the left).
-        const isBoundedByLeftViewportEdge = (position.overlayX === 'end' && !isRtl) ||
-            (position.overlayX === 'start' && isRtl);
+        const isBoundedByLeftViewportEdge = (position.overlayX === 'end' && !isRtl) || (position.overlayX === 'start' && isRtl);
         let width, left, right;
         if (isBoundedByLeftViewportEdge) {
             right = viewport.width - origin.x + this._viewportMargin;
@@ -1757,7 +1768,7 @@ class FlexibleConnectedPositionStrategy {
             width = smallestDistanceToViewportEdge * 2;
             left = origin.x - smallestDistanceToViewportEdge;
             if (width > previousWidth && !this._isInitialRender && !this._growAfterOpen) {
-                left = origin.x - (previousWidth / 2);
+                left = origin.x - previousWidth / 2;
             }
         }
         return { top: top, left: left, bottom: bottom, right: right, width, height };
@@ -1900,7 +1911,9 @@ class FlexibleConnectedPositionStrategy {
         if (this._isPushed) {
             overlayPoint = this._pushOverlayOnScreen(overlayPoint, this._overlayRect, scrollPosition);
         }
-        let virtualKeyboardOffset = this._overlayContainer.getContainerElement().getBoundingClientRect().top;
+        let virtualKeyboardOffset = this._overlayContainer
+            .getContainerElement()
+            .getBoundingClientRect().top;
         // Normally this would be zero, however when the overlay is attached to an input (e.g. in an
         // autocomplete), mobile browsers will shift everything in order to put the input in the middle
         // of the screen and to make space for the virtual keyboard. We need to account for this offset,
@@ -1992,8 +2005,8 @@ class FlexibleConnectedPositionStrategy {
             left: scrollPosition.left + this._viewportMargin,
             right: scrollPosition.left + width - this._viewportMargin,
             bottom: scrollPosition.top + height - this._viewportMargin,
-            width: width - (2 * this._viewportMargin),
-            height: height - (2 * this._viewportMargin),
+            width: width - 2 * this._viewportMargin,
+            height: height - 2 * this._viewportMargin,
         };
     }
     /** Whether the we're dealing with an RTL context */
@@ -2068,7 +2081,7 @@ class FlexibleConnectedPositionStrategy {
             left: origin.x,
             right: origin.x + width,
             height,
-            width
+            width,
         };
     }
 }
@@ -2088,7 +2101,7 @@ function extendStyles(destination, source) {
 function getPixelValue(input) {
     if (typeof input !== 'number' && input != null) {
         const [value, units] = input.split(cssUnitPattern);
-        return (!units || units === 'px') ? parseFloat(value) : null;
+        return !units || units === 'px' ? parseFloat(value) : null;
     }
     return input || null;
 }
@@ -2105,7 +2118,7 @@ function getRoundedBoundingClientRect(clientRect) {
         bottom: Math.floor(clientRect.bottom),
         left: Math.floor(clientRect.left),
         width: Math.floor(clientRect.width),
-        height: Math.floor(clientRect.height)
+        height: Math.floor(clientRect.height),
     };
 }
 
@@ -2299,8 +2312,14 @@ class GlobalPositionStrategy {
         const parent = this._overlayRef.hostElement;
         const parentStyles = parent.style;
         parent.classList.remove(wrapperClass);
-        parentStyles.justifyContent = parentStyles.alignItems = styles.marginTop =
-            styles.marginBottom = styles.marginLeft = styles.marginRight = styles.position = '';
+        parentStyles.justifyContent =
+            parentStyles.alignItems =
+                styles.marginTop =
+                    styles.marginBottom =
+                        styles.marginLeft =
+                            styles.marginRight =
+                                styles.position =
+                                    '';
         this._overlayRef = null;
         this._isDisposed = true;
     }
@@ -2335,16 +2354,15 @@ class OverlayPositionBuilder {
         return new FlexibleConnectedPositionStrategy(origin, this._viewportRuler, this._document, this._platform, this._overlayContainer);
     }
 }
-OverlayPositionBuilder.ɵ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" });
-OverlayPositionBuilder.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-OverlayPositionBuilder.ctorParameters = () => [
-    { type: ViewportRuler },
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Platform },
-    { type: OverlayContainer }
-];
+OverlayPositionBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayPositionBuilder, deps: [{ token: i1.ViewportRuler }, { token: DOCUMENT }, { token: i1$1.Platform }, { token: OverlayContainer }], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayPositionBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayPositionBuilder, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayPositionBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ViewportRuler }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1$1.Platform }, { type: OverlayContainer }]; } });
 
 /**
  * @license
@@ -2437,22 +2455,14 @@ class Overlay {
         return new DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector, this._document);
     }
 }
-Overlay.decorators = [
-    { type: Injectable }
-];
-Overlay.ctorParameters = () => [
-    { type: ScrollStrategyOptions },
-    { type: OverlayContainer },
-    { type: ComponentFactoryResolver },
-    { type: OverlayPositionBuilder },
-    { type: OverlayKeyboardDispatcher },
-    { type: Injector },
-    { type: NgZone },
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Directionality },
-    { type: Location },
-    { type: OverlayOutsideClickDispatcher }
-];
+Overlay.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Overlay, deps: [{ token: ScrollStrategyOptions }, { token: OverlayContainer }, { token: i0.ComponentFactoryResolver }, { token: OverlayPositionBuilder }, { token: OverlayKeyboardDispatcher }, { token: i0.Injector }, { token: i0.NgZone }, { token: DOCUMENT }, { token: i5.Directionality }, { token: i6.Location }, { token: OverlayOutsideClickDispatcher }], target: i0.ɵɵFactoryTarget.Injectable });
+Overlay.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Overlay });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Overlay, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ScrollStrategyOptions }, { type: OverlayContainer }, { type: i0.ComponentFactoryResolver }, { type: OverlayPositionBuilder }, { type: OverlayKeyboardDispatcher }, { type: i0.Injector }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i5.Directionality }, { type: i6.Location }, { type: OverlayOutsideClickDispatcher }]; } });
 
 /**
  * @license
@@ -2467,26 +2477,26 @@ const defaultPositionList = [
         originX: 'start',
         originY: 'bottom',
         overlayX: 'start',
-        overlayY: 'top'
+        overlayY: 'top',
     },
     {
         originX: 'start',
         originY: 'top',
         overlayX: 'start',
-        overlayY: 'bottom'
+        overlayY: 'bottom',
     },
     {
         originX: 'end',
         originY: 'top',
         overlayX: 'end',
-        overlayY: 'bottom'
+        overlayY: 'bottom',
     },
     {
         originX: 'end',
         originY: 'bottom',
         overlayX: 'end',
-        overlayY: 'top'
-    }
+        overlayY: 'top',
+    },
 ];
 /** Injection token that determines the scroll handling while the connected overlay is open. */
 const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = new InjectionToken('cdk-connected-overlay-scroll-strategy');
@@ -2501,15 +2511,15 @@ class CdkOverlayOrigin {
         this.elementRef = elementRef;
     }
 }
-CdkOverlayOrigin.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
-                exportAs: 'cdkOverlayOrigin',
-            },] }
-];
-CdkOverlayOrigin.ctorParameters = () => [
-    { type: ElementRef }
-];
+CdkOverlayOrigin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkOverlayOrigin, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+CdkOverlayOrigin.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkOverlayOrigin, selector: "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", exportAs: ["cdkOverlayOrigin"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkOverlayOrigin, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
+                    exportAs: 'cdkOverlayOrigin',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
 /**
  * Directive to facilitate declarative creation of an
  * Overlay using a FlexibleConnectedPositionStrategy.
@@ -2551,7 +2561,9 @@ class CdkConnectedOverlay {
         this.scrollStrategy = this._scrollStrategyFactory();
     }
     /** The offset in pixels for the overlay connection point on the x-axis */
-    get offsetX() { return this._offsetX; }
+    get offsetX() {
+        return this._offsetX;
+    }
     set offsetX(offsetX) {
         this._offsetX = offsetX;
         if (this._position) {
@@ -2559,7 +2571,9 @@ class CdkConnectedOverlay {
         }
     }
     /** The offset in pixels for the overlay connection point on the y-axis */
-    get offsetY() { return this._offsetY; }
+    get offsetY() {
+        return this._offsetY;
+    }
     set offsetY(offsetY) {
         this._offsetY = offsetY;
         if (this._position) {
@@ -2567,22 +2581,40 @@ class CdkConnectedOverlay {
         }
     }
     /** Whether or not the overlay should attach a backdrop. */
-    get hasBackdrop() { return this._hasBackdrop; }
-    set hasBackdrop(value) { this._hasBackdrop = coerceBooleanProperty(value); }
+    get hasBackdrop() {
+        return this._hasBackdrop;
+    }
+    set hasBackdrop(value) {
+        this._hasBackdrop = coerceBooleanProperty(value);
+    }
     /** Whether or not the overlay should be locked when scrolling. */
-    get lockPosition() { return this._lockPosition; }
-    set lockPosition(value) { this._lockPosition = coerceBooleanProperty(value); }
+    get lockPosition() {
+        return this._lockPosition;
+    }
+    set lockPosition(value) {
+        this._lockPosition = coerceBooleanProperty(value);
+    }
     /** Whether the overlay's width and height can be constrained to fit within the viewport. */
-    get flexibleDimensions() { return this._flexibleDimensions; }
+    get flexibleDimensions() {
+        return this._flexibleDimensions;
+    }
     set flexibleDimensions(value) {
         this._flexibleDimensions = coerceBooleanProperty(value);
     }
     /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */
-    get growAfterOpen() { return this._growAfterOpen; }
-    set growAfterOpen(value) { this._growAfterOpen = coerceBooleanProperty(value); }
+    get growAfterOpen() {
+        return this._growAfterOpen;
+    }
+    set growAfterOpen(value) {
+        this._growAfterOpen = coerceBooleanProperty(value);
+    }
     /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */
-    get push() { return this._push; }
-    set push(value) { this._push = coerceBooleanProperty(value); }
+    get push() {
+        return this._push;
+    }
+    set push(value) {
+        this._push = coerceBooleanProperty(value);
+    }
     /** The associated overlay reference. */
     get overlayRef() {
         return this._overlayRef;
@@ -2622,7 +2654,7 @@ class CdkConnectedOverlay {
         if (!this.positions || !this.positions.length) {
             this.positions = defaultPositionList;
         }
-        const overlayRef = this._overlayRef = this._overlay.create(this._buildConfig());
+        const overlayRef = (this._overlayRef = this._overlay.create(this._buildConfig()));
         this._attachSubscription = overlayRef.attachments().subscribe(() => this.attach.emit());
         this._detachSubscription = overlayRef.detachments().subscribe(() => this.detach.emit());
         overlayRef.keydownEvents().subscribe((event) => {
@@ -2638,13 +2670,13 @@ class CdkConnectedOverlay {
     }
     /** Builds the overlay config based on the directive's inputs */
     _buildConfig() {
-        const positionStrategy = this._position =
-            this.positionStrategy || this._createPositionStrategy();
+        const positionStrategy = (this._position =
+            this.positionStrategy || this._createPositionStrategy());
         const overlayConfig = new OverlayConfig({
             direction: this._dir,
             positionStrategy,
             scrollStrategy: this.scrollStrategy,
-            hasBackdrop: this.hasBackdrop
+            hasBackdrop: this.hasBackdrop,
         });
         if (this.width || this.width === 0) {
             overlayConfig.width = this.width;
@@ -2677,7 +2709,8 @@ class CdkConnectedOverlay {
             offsetY: currentPosition.offsetY || this.offsetY,
             panelClass: currentPosition.panelClass || undefined,
         }));
-        return positionStrategy.setOrigin(this._getFlexibleConnectedPositionStrategyOrigin())
+        return positionStrategy
+            .setOrigin(this._getFlexibleConnectedPositionStrategyOrigin())
             .withPositions(positions)
             .withFlexibleDimensions(this.flexibleDimensions)
             .withPush(this.push)
@@ -2688,7 +2721,9 @@ class CdkConnectedOverlay {
     }
     /** Returns the position strategy of the overlay to be set on the overlay config */
     _createPositionStrategy() {
-        const strategy = this._overlay.position().flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());
+        const strategy = this._overlay
+            .position()
+            .flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());
         this._updatePositionStrategy(strategy);
         return strategy;
     }
@@ -2743,48 +2778,95 @@ class CdkConnectedOverlay {
         this._positionSubscription.unsubscribe();
     }
 }
-CdkConnectedOverlay.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
-                exportAs: 'cdkConnectedOverlay'
-            },] }
-];
-CdkConnectedOverlay.ctorParameters = () => [
-    { type: Overlay },
-    { type: TemplateRef },
-    { type: ViewContainerRef },
-    { type: undefined, decorators: [{ type: Inject, args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] }
-];
-CdkConnectedOverlay.propDecorators = {
-    origin: [{ type: Input, args: ['cdkConnectedOverlayOrigin',] }],
-    positions: [{ type: Input, args: ['cdkConnectedOverlayPositions',] }],
-    positionStrategy: [{ type: Input, args: ['cdkConnectedOverlayPositionStrategy',] }],
-    offsetX: [{ type: Input, args: ['cdkConnectedOverlayOffsetX',] }],
-    offsetY: [{ type: Input, args: ['cdkConnectedOverlayOffsetY',] }],
-    width: [{ type: Input, args: ['cdkConnectedOverlayWidth',] }],
-    height: [{ type: Input, args: ['cdkConnectedOverlayHeight',] }],
-    minWidth: [{ type: Input, args: ['cdkConnectedOverlayMinWidth',] }],
-    minHeight: [{ type: Input, args: ['cdkConnectedOverlayMinHeight',] }],
-    backdropClass: [{ type: Input, args: ['cdkConnectedOverlayBackdropClass',] }],
-    panelClass: [{ type: Input, args: ['cdkConnectedOverlayPanelClass',] }],
-    viewportMargin: [{ type: Input, args: ['cdkConnectedOverlayViewportMargin',] }],
-    scrollStrategy: [{ type: Input, args: ['cdkConnectedOverlayScrollStrategy',] }],
-    open: [{ type: Input, args: ['cdkConnectedOverlayOpen',] }],
-    disableClose: [{ type: Input, args: ['cdkConnectedOverlayDisableClose',] }],
-    transformOriginSelector: [{ type: Input, args: ['cdkConnectedOverlayTransformOriginOn',] }],
-    hasBackdrop: [{ type: Input, args: ['cdkConnectedOverlayHasBackdrop',] }],
-    lockPosition: [{ type: Input, args: ['cdkConnectedOverlayLockPosition',] }],
-    flexibleDimensions: [{ type: Input, args: ['cdkConnectedOverlayFlexibleDimensions',] }],
-    growAfterOpen: [{ type: Input, args: ['cdkConnectedOverlayGrowAfterOpen',] }],
-    push: [{ type: Input, args: ['cdkConnectedOverlayPush',] }],
-    backdropClick: [{ type: Output }],
-    positionChange: [{ type: Output }],
-    attach: [{ type: Output }],
-    detach: [{ type: Output }],
-    overlayKeydown: [{ type: Output }],
-    overlayOutsideClick: [{ type: Output }]
-};
+CdkConnectedOverlay.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkConnectedOverlay, deps: [{ token: Overlay }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY }, { token: i5.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkConnectedOverlay.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkConnectedOverlay, selector: "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", inputs: { origin: ["cdkConnectedOverlayOrigin", "origin"], positions: ["cdkConnectedOverlayPositions", "positions"], positionStrategy: ["cdkConnectedOverlayPositionStrategy", "positionStrategy"], offsetX: ["cdkConnectedOverlayOffsetX", "offsetX"], offsetY: ["cdkConnectedOverlayOffsetY", "offsetY"], width: ["cdkConnectedOverlayWidth", "width"], height: ["cdkConnectedOverlayHeight", "height"], minWidth: ["cdkConnectedOverlayMinWidth", "minWidth"], minHeight: ["cdkConnectedOverlayMinHeight", "minHeight"], backdropClass: ["cdkConnectedOverlayBackdropClass", "backdropClass"], panelClass: ["cdkConnectedOverlayPanelClass", "panelClass"], viewportMargin: ["cdkConnectedOverlayViewportMargin", "viewportMargin"], scrollStrategy: ["cdkConnectedOverlayScrollStrategy", "scrollStrategy"], open: ["cdkConnectedOverlayOpen", "open"], disableClose: ["cdkConnectedOverlayDisableClose", "disableClose"], transformOriginSelector: ["cdkConnectedOverlayTransformOriginOn", "transformOriginSelector"], hasBackdrop: ["cdkConnectedOverlayHasBackdrop", "hasBackdrop"], lockPosition: ["cdkConnectedOverlayLockPosition", "lockPosition"], flexibleDimensions: ["cdkConnectedOverlayFlexibleDimensions", "flexibleDimensions"], growAfterOpen: ["cdkConnectedOverlayGrowAfterOpen", "growAfterOpen"], push: ["cdkConnectedOverlayPush", "push"] }, outputs: { backdropClick: "backdropClick", positionChange: "positionChange", attach: "attach", detach: "detach", overlayKeydown: "overlayKeydown", overlayOutsideClick: "overlayOutsideClick" }, exportAs: ["cdkConnectedOverlay"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkConnectedOverlay, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
+                    exportAs: 'cdkConnectedOverlay',
+                }]
+        }], ctorParameters: function () { return [{ type: Overlay }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY]
+                }] }, { type: i5.Directionality, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { origin: [{
+                type: Input,
+                args: ['cdkConnectedOverlayOrigin']
+            }], positions: [{
+                type: Input,
+                args: ['cdkConnectedOverlayPositions']
+            }], positionStrategy: [{
+                type: Input,
+                args: ['cdkConnectedOverlayPositionStrategy']
+            }], offsetX: [{
+                type: Input,
+                args: ['cdkConnectedOverlayOffsetX']
+            }], offsetY: [{
+                type: Input,
+                args: ['cdkConnectedOverlayOffsetY']
+            }], width: [{
+                type: Input,
+                args: ['cdkConnectedOverlayWidth']
+            }], height: [{
+                type: Input,
+                args: ['cdkConnectedOverlayHeight']
+            }], minWidth: [{
+                type: Input,
+                args: ['cdkConnectedOverlayMinWidth']
+            }], minHeight: [{
+                type: Input,
+                args: ['cdkConnectedOverlayMinHeight']
+            }], backdropClass: [{
+                type: Input,
+                args: ['cdkConnectedOverlayBackdropClass']
+            }], panelClass: [{
+                type: Input,
+                args: ['cdkConnectedOverlayPanelClass']
+            }], viewportMargin: [{
+                type: Input,
+                args: ['cdkConnectedOverlayViewportMargin']
+            }], scrollStrategy: [{
+                type: Input,
+                args: ['cdkConnectedOverlayScrollStrategy']
+            }], open: [{
+                type: Input,
+                args: ['cdkConnectedOverlayOpen']
+            }], disableClose: [{
+                type: Input,
+                args: ['cdkConnectedOverlayDisableClose']
+            }], transformOriginSelector: [{
+                type: Input,
+                args: ['cdkConnectedOverlayTransformOriginOn']
+            }], hasBackdrop: [{
+                type: Input,
+                args: ['cdkConnectedOverlayHasBackdrop']
+            }], lockPosition: [{
+                type: Input,
+                args: ['cdkConnectedOverlayLockPosition']
+            }], flexibleDimensions: [{
+                type: Input,
+                args: ['cdkConnectedOverlayFlexibleDimensions']
+            }], growAfterOpen: [{
+                type: Input,
+                args: ['cdkConnectedOverlayGrowAfterOpen']
+            }], push: [{
+                type: Input,
+                args: ['cdkConnectedOverlayPush']
+            }], backdropClick: [{
+                type: Output
+            }], positionChange: [{
+                type: Output
+            }], attach: [{
+                type: Output
+            }], detach: [{
+                type: Output
+            }], overlayKeydown: [{
+                type: Output
+            }], overlayOutsideClick: [{
+                type: Output
+            }] } });
 /** @docs-private */
 function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
     return () => overlay.scrollStrategies.reposition();
@@ -2805,17 +2887,18 @@ const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
  */
 class OverlayModule {
 }
-OverlayModule.decorators = [
-    { type: NgModule, args: [{
-                imports: [BidiModule, PortalModule, ScrollingModule],
-                exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule],
-                declarations: [CdkConnectedOverlay, CdkOverlayOrigin],
-                providers: [
-                    Overlay,
-                    CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,
-                ],
-            },] }
-];
+OverlayModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+OverlayModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayModule, declarations: [CdkConnectedOverlay, CdkOverlayOrigin], imports: [BidiModule, PortalModule, ScrollingModule], exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule] });
+OverlayModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayModule, providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER], imports: [[BidiModule, PortalModule, ScrollingModule], ScrollingModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OverlayModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [BidiModule, PortalModule, ScrollingModule],
+                    exports: [CdkConnectedOverlay, CdkOverlayOrigin, ScrollingModule],
+                    declarations: [CdkConnectedOverlay, CdkOverlayOrigin],
+                    providers: [Overlay, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER],
+                }]
+        }] });
 
 /**
  * @license
@@ -2896,21 +2979,22 @@ class FullscreenOverlayContainer extends OverlayContainer {
      */
     getFullscreenElement() {
         const _document = this._document;
-        return _document.fullscreenElement ||
+        return (_document.fullscreenElement ||
             _document.webkitFullscreenElement ||
             _document.mozFullScreenElement ||
             _document.msFullscreenElement ||
-            null;
+            null);
     }
 }
-FullscreenOverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: FullscreenOverlayContainer, providedIn: "root" });
-FullscreenOverlayContainer.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-FullscreenOverlayContainer.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Platform }
-];
+FullscreenOverlayContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FullscreenOverlayContainer, deps: [{ token: DOCUMENT }, { token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+FullscreenOverlayContainer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FullscreenOverlayContainer, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FullscreenOverlayContainer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1$1.Platform }]; } });
 
 /**
  * @license
@@ -2924,5 +3008,5 @@ FullscreenOverlayContainer.ctorParameters = () => [
  * Generated bundle index. Do not edit.
  */
 
-export { BlockScrollStrategy, CdkConnectedOverlay, CdkOverlayOrigin, CloseScrollStrategy, ConnectedOverlayPositionChange, 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 };
-//# sourceMappingURL=overlay.js.map
+export { BlockScrollStrategy, CdkConnectedOverlay, CdkOverlayOrigin, CloseScrollStrategy, ConnectedOverlayPositionChange, ConnectionPositionPair, FlexibleConnectedPositionStrategy, FullscreenOverlayContainer, GlobalPositionStrategy, NoopScrollStrategy, Overlay, OverlayConfig, OverlayContainer, OverlayKeyboardDispatcher, OverlayModule, OverlayOutsideClickDispatcher, OverlayPositionBuilder, OverlayRef, RepositionScrollStrategy, ScrollStrategyOptions, ScrollingVisibility, validateHorizontalPosition, validateVerticalPosition };
+//# sourceMappingURL=overlay.mjs.map