@angular/cdk 8.0.0-beta.2 → 8.0.0

package/esm5/overlay.es5.js

@@ -9,7 +9,7 @@ import { coerceCssPixelValue, coerceArray, coerceBooleanProperty } from '@angula
 import { ScrollDispatcher, ViewportRuler, ScrollingModule, VIEWPORT_RULER_PROVIDER } from '@angular/cdk/scrolling';
 export { ViewportRuler, VIEWPORT_RULER_PROVIDER, CdkScrollable, ScrollDispatcher } from '@angular/cdk/scrolling';
 import { DOCUMENT, Location } from '@angular/common';
-import { Inject, Injectable, NgZone, Optional, NgModule, SkipSelf, ApplicationRef, ComponentFactoryResolver, Injector, ElementRef, Directive, EventEmitter, InjectionToken, Input, Output, TemplateRef, ViewContainerRef, defineInjectable, inject } from '@angular/core';
+import { Inject, Injectable, NgZone, Optional, NgModule, SkipSelf, ApplicationRef, ComponentFactoryResolver, Injector, ElementRef, Directive, EventEmitter, InjectionToken, Input, Output, TemplateRef, ViewContainerRef, ɵɵdefineInjectable, ɵɵinject } from '@angular/core';
 import { __assign, __extends } from 'tslib';
 import { Observable, Subject, merge, Subscription } from 'rxjs';
 import { take, takeUntil } from 'rxjs/operators';
@@ -20,7 +20,7 @@ import { ESCAPE } from '@angular/cdk/keycodes';
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Strategy that will prevent the user from scrolling while the overlay is visible.
@@ -133,7 +133,7 @@ BlockScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.
@@ -145,7 +145,7 @@ function getMatScrollStrategyAlreadyAttachedError() {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Strategy that will close the overlay as soon as the user starts scrolling.
@@ -164,12 +164,18 @@ CloseScrollStrategy = /** @class */ (function () {
         /**
          * Detaches the overlay ref and disables the scroll strategy.
          */
-        this._detach = function () {
+        this._detach = (/**
+         * @return {?}
+         */
+        function () {
             _this.disable();
             if (_this._overlayRef.hasAttached()) {
-                _this._ngZone.run(function () { return _this._overlayRef.detach(); });
+                _this._ngZone.run((/**
+                 * @return {?}
+                 */
+                function () { return _this._overlayRef.detach(); }));
             }
-        };
+        });
     }
     /** Attaches this scroll strategy to an overlay. */
     /**
@@ -206,7 +212,10 @@ CloseScrollStrategy = /** @class */ (function () {
         var stream = this._scrollDispatcher.scrolled(0);
         if (this._config && this._config.threshold && this._config.threshold > 1) {
             this._initialScrollPosition = this._viewportRuler.getViewportScrollPosition().top;
-            this._scrollSubscription = stream.subscribe(function () {
+            this._scrollSubscription = stream.subscribe((/**
+             * @return {?}
+             */
+            function () {
                 /** @type {?} */
                 var scrollPosition = _this._viewportRuler.getViewportScrollPosition().top;
                 if (Math.abs(scrollPosition - _this._initialScrollPosition) > (/** @type {?} */ ((/** @type {?} */ (_this._config)).threshold))) {
@@ -215,7 +224,7 @@ CloseScrollStrategy = /** @class */ (function () {
                 else {
                     _this._overlayRef.updatePosition();
                 }
-            });
+            }));
         }
         else {
             this._scrollSubscription = stream.subscribe(this._detach);
@@ -251,7 +260,7 @@ CloseScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
@@ -298,7 +307,7 @@ NoopScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 // TODO(jelbourn): move this to live with the rest of the scrolling code
@@ -311,7 +320,11 @@ NoopScrollStrategy = /** @class */ (function () {
  * @return {?} Whether the element is scrolled out of view
  */
 function isElementScrolledOutsideView(element, scrollContainers) {
-    return scrollContainers.some(function (containerBounds) {
+    return scrollContainers.some((/**
+     * @param {?} containerBounds
+     * @return {?}
+     */
+    function (containerBounds) {
         /** @type {?} */
         var outsideAbove = element.bottom < containerBounds.top;
         /** @type {?} */
@@ -321,7 +334,7 @@ function isElementScrolledOutsideView(element, scrollContainers) {
         /** @type {?} */
         var outsideRight = element.left > containerBounds.right;
         return outsideAbove || outsideBelow || outsideLeft || outsideRight;
-    });
+    }));
 }
 /**
  * Gets whether an element is clipped by any of its scrolling containers.
@@ -331,7 +344,11 @@ function isElementScrolledOutsideView(element, scrollContainers) {
  * @return {?} Whether the element is clipped
  */
 function isElementClippedByScrolling(element, scrollContainers) {
-    return scrollContainers.some(function (scrollContainerRect) {
+    return scrollContainers.some((/**
+     * @param {?} scrollContainerRect
+     * @return {?}
+     */
+    function (scrollContainerRect) {
         /** @type {?} */
         var clippedAbove = element.top < scrollContainerRect.top;
         /** @type {?} */
@@ -341,12 +358,12 @@ function isElementClippedByScrolling(element, scrollContainers) {
         /** @type {?} */
         var clippedRight = element.right > scrollContainerRect.right;
         return clippedAbove || clippedBelow || clippedLeft || clippedRight;
-    });
+    }));
 }
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Strategy that will update the element position as the user is scrolling.
@@ -393,7 +410,10 @@ RepositionScrollStrategy = /** @class */ (function () {
         if (!this._scrollSubscription) {
             /** @type {?} */
             var throttle = this._config ? this._config.scrollThrottle : 0;
-            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe(function () {
+            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe((/**
+             * @return {?}
+             */
+            function () {
                 _this._overlayRef.updatePosition();
                 // TODO(crisbeto): make `close` on by default once all components can handle it.
                 if (_this._config && _this._config.autoClose) {
@@ -406,10 +426,13 @@ RepositionScrollStrategy = /** @class */ (function () {
                     var parentRects = [{ width: width, height: height, bottom: height, right: width, top: 0, left: 0 }];
                     if (isElementScrolledOutsideView(overlayRect, parentRects)) {
                         _this.disable();
-                        _this._ngZone.run(function () { return _this._overlayRef.detach(); });
+                        _this._ngZone.run((/**
+                         * @return {?}
+                         */
+                        function () { return _this._overlayRef.detach(); }));
                     }
                 }
-            });
+            }));
         }
     };
     /** Disables repositioning of the attached overlay on scroll. */
@@ -442,7 +465,7 @@ RepositionScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Options for how an overlay will handle scrolling.
@@ -459,22 +482,36 @@ var ScrollStrategyOptions = /** @class */ (function () {
         /**
          * Do nothing on scroll.
          */
-        this.noop = function () { return new NoopScrollStrategy(); };
+        this.noop = (/**
+         * @return {?}
+         */
+        function () { return new NoopScrollStrategy(); });
         /**
          * Close the overlay as soon as the user scrolls.
          * @param config Configuration to be used inside the scroll strategy.
          */
-        this.close = function (config) { return new CloseScrollStrategy(_this._scrollDispatcher, _this._ngZone, _this._viewportRuler, config); };
+        this.close = (/**
+         * @param {?=} config
+         * @return {?}
+         */
+        function (config) { return new CloseScrollStrategy(_this._scrollDispatcher, _this._ngZone, _this._viewportRuler, config); });
         /**
          * Block scrolling.
          */
-        this.block = function () { return new BlockScrollStrategy(_this._viewportRuler, _this._document); };
+        this.block = (/**
+         * @return {?}
+         */
+        function () { return new BlockScrollStrategy(_this._viewportRuler, _this._document); });
         /**
          * Update the overlay's position on scroll.
          * @param config Configuration to be used inside the scroll strategy.
          * Allows debouncing the reposition calls.
          */
-        this.reposition = function (config) { return new RepositionScrollStrategy(_this._scrollDispatcher, _this._viewportRuler, _this._ngZone, config); };
+        this.reposition = (/**
+         * @param {?=} config
+         * @return {?}
+         */
+        function (config) { return new RepositionScrollStrategy(_this._scrollDispatcher, _this._viewportRuler, _this._ngZone, config); });
         this._document = document;
     }
     ScrollStrategyOptions.decorators = [
@@ -487,18 +524,18 @@ var ScrollStrategyOptions = /** @class */ (function () {
         { type: NgZone },
         { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ ScrollStrategyOptions.ngInjectableDef = defineInjectable({ factory: function ScrollStrategyOptions_Factory() { return new ScrollStrategyOptions(inject(ScrollDispatcher), inject(ViewportRuler), inject(NgZone), inject(DOCUMENT)); }, token: ScrollStrategyOptions, providedIn: "root" });
+    /** @nocollapse */ ScrollStrategyOptions.ngInjectableDef = ɵɵdefineInjectable({ factory: function ScrollStrategyOptions_Factory() { return new ScrollStrategyOptions(ɵɵinject(ScrollDispatcher), ɵɵinject(ViewportRuler), ɵɵinject(NgZone), ɵɵinject(DOCUMENT)); }, token: ScrollStrategyOptions, providedIn: "root" });
     return ScrollStrategyOptions;
 }());
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Initial configuration used when creating an overlay.
@@ -532,13 +569,17 @@ OverlayConfig = /** @class */ (function () {
          */
         this.disposeOnNavigation = false;
         if (config) {
-            Object.keys(config).forEach(function (k) {
+            Object.keys(config).forEach((/**
+             * @param {?} k
+             * @return {?}
+             */
+            function (k) {
                 /** @type {?} */
                 var key = (/** @type {?} */ (k));
                 if (typeof config[key] !== 'undefined') {
                     _this[key] = config[key];
                 }
-            });
+            }));
         }
     }
     return OverlayConfig;
@@ -546,7 +587,7 @@ OverlayConfig = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * The points of the origin element and the overlay element to connect.
@@ -665,7 +706,7 @@ function validateHorizontalPosition(property, value) {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Service for dispatching keyboard events that land on the body to appropriate overlay ref,
@@ -682,7 +723,11 @@ var OverlayKeyboardDispatcher = /** @class */ (function () {
         /**
          * Keyboard event listener that will be attached to the body.
          */
-        this._keydownListener = function (event) {
+        this._keydownListener = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
             /** @type {?} */
             var overlays = _this._attachedOverlays;
             for (var i = overlays.length - 1; i > -1; i--) {
@@ -697,7 +742,7 @@ var OverlayKeyboardDispatcher = /** @class */ (function () {
                     break;
                 }
             }
-        };
+        });
         this._document = document;
     }
     /**
@@ -776,7 +821,7 @@ var OverlayKeyboardDispatcher = /** @class */ (function () {
     OverlayKeyboardDispatcher.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ OverlayKeyboardDispatcher.ngInjectableDef = defineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(inject(DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
+    /** @nocollapse */ OverlayKeyboardDispatcher.ngInjectableDef = ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(ɵɵinject(DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
     return OverlayKeyboardDispatcher;
 }());
 /**
@@ -808,7 +853,7 @@ var OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Container inside which all overlays will render.
@@ -882,7 +927,7 @@ var OverlayContainer = /** @class */ (function () {
     OverlayContainer.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ OverlayContainer.ngInjectableDef = defineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(inject(DOCUMENT)); }, token: OverlayContainer, providedIn: "root" });
+    /** @nocollapse */ OverlayContainer.ngInjectableDef = ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(ɵɵinject(DOCUMENT)); }, token: OverlayContainer, providedIn: "root" });
     return OverlayContainer;
 }());
 /**
@@ -910,7 +955,7 @@ var OVERLAY_CONTAINER_PROVIDER = {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Reference to an overlay that has been created with the Overlay service.
@@ -936,15 +981,22 @@ OverlayRef = /** @class */ (function () {
         this._attachments = new Subject();
         this._detachments = new Subject();
         this._locationChanges = Subscription.EMPTY;
-        this._keydownEventsObservable = new Observable(function (observer) {
+        this._keydownEventsObservable = new Observable((/**
+         * @param {?} observer
+         * @return {?}
+         */
+        function (observer) {
             /** @type {?} */
             var subscription = _this._keydownEvents.subscribe(observer);
             _this._keydownEventSubscriptions++;
-            return function () {
+            return (/**
+             * @return {?}
+             */
+            function () {
                 subscription.unsubscribe();
                 _this._keydownEventSubscriptions--;
-            };
-        });
+            });
+        }));
         /**
          * Stream of keydown events dispatched to this overlay.
          */
@@ -1045,12 +1097,15 @@ OverlayRef = /** @class */ (function () {
         this._ngZone.onStable
             .asObservable()
             .pipe(take(1))
-            .subscribe(function () {
+            .subscribe((/**
+         * @return {?}
+         */
+        function () {
             // The overlay could've been detached before the zone has stabilized.
             if (_this.hasAttached()) {
                 _this.updatePosition();
             }
-        });
+        }));
         // Enable pointer events for the overlay pane element.
         this._togglePointerEvents(true);
         if (this._config.hasBackdrop) {
@@ -1066,7 +1121,10 @@ OverlayRef = /** @class */ (function () {
         // @breaking-change 8.0.0 remove the null check for `_location`
         // once the constructor parameter is made required.
         if (this._config.disposeOnNavigation && this._location) {
-            this._locationChanges = this._location.subscribe(function () { return _this.dispose(); });
+            this._locationChanges = this._location.subscribe((/**
+             * @return {?}
+             */
+            function () { return _this.dispose(); }));
         }
         return attachResult;
     };
@@ -1432,16 +1490,26 @@ OverlayRef = /** @class */ (function () {
         (/** @type {?} */ (this._host.parentElement)).insertBefore(this._backdropElement, this._host);
         // Forward backdrop clicks such that the consumer of the overlay can perform whatever
         // action desired when such a click occurs (usually closing the overlay).
-        this._backdropElement.addEventListener('click', function (event) { return _this._backdropClick.next(event); });
+        this._backdropElement.addEventListener('click', (/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) { return _this._backdropClick.next(event); }));
         // Add class to fade-in the backdrop after one frame.
         if (typeof requestAnimationFrame !== 'undefined') {
-            this._ngZone.runOutsideAngular(function () {
-                requestAnimationFrame(function () {
+            this._ngZone.runOutsideAngular((/**
+             * @return {?}
+             */
+            function () {
+                requestAnimationFrame((/**
+                 * @return {?}
+                 */
+                function () {
                     if (_this._backdropElement) {
                         _this._backdropElement.classList.add(showingClass);
                     }
-                });
-            });
+                }));
+            }));
         }
         else {
             this._backdropElement.classList.add(showingClass);
@@ -1496,7 +1564,10 @@ OverlayRef = /** @class */ (function () {
         /** @type {?} */
         var timeoutId;
         /** @type {?} */
-        var finishDetach = function () {
+        var finishDetach = (/**
+         * @return {?}
+         */
+        function () {
             // It may not be attached to anything in certain cases (e.g. unit tests).
             if (backdropToDetach && backdropToDetach.parentNode) {
                 backdropToDetach.parentNode.removeChild(backdropToDetach);
@@ -1511,18 +1582,24 @@ OverlayRef = /** @class */ (function () {
                 _this._toggleClasses((/** @type {?} */ (backdropToDetach)), _this._config.backdropClass, false);
             }
             clearTimeout(timeoutId);
-        };
+        });
         backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
-        this._ngZone.runOutsideAngular(function () {
+        this._ngZone.runOutsideAngular((/**
+         * @return {?}
+         */
+        function () {
             (/** @type {?} */ (backdropToDetach)).addEventListener('transitionend', finishDetach);
-        });
+        }));
         // If the backdrop doesn't have a transition, the `transitionend` event won't fire.
         // In this case we make it unclickable and we try to remove it after a delay.
         backdropToDetach.style.pointerEvents = 'none';
         // Run this outside the Angular zone because there's nothing that Angular cares about.
         // If it were to run inside the Angular zone, every test that used Overlay would have to be
         // either async or fakeAsync.
-        timeoutId = this._ngZone.runOutsideAngular(function () { return setTimeout(finishDetach, 500); });
+        timeoutId = this._ngZone.runOutsideAngular((/**
+         * @return {?}
+         */
+        function () { return setTimeout(finishDetach, 500); }));
     };
     /** Toggles a single CSS class or an array of classes on an element. */
     /**
@@ -1544,10 +1621,14 @@ OverlayRef = /** @class */ (function () {
     function (element, cssClasses, isAdd) {
         /** @type {?} */
         var classList = element.classList;
-        coerceArray(cssClasses).forEach(function (cssClass) {
+        coerceArray(cssClasses).forEach((/**
+         * @param {?} cssClass
+         * @return {?}
+         */
+        function (cssClass) {
             // We can't do a spread here, because IE doesn't support setting multiple classes.
             isAdd ? classList.add(cssClass) : classList.remove(cssClass);
-        });
+        }));
     };
     /** Detaches the overlay content next time the zone stabilizes. */
     /**
@@ -1565,7 +1646,10 @@ OverlayRef = /** @class */ (function () {
         // Normally we wouldn't have to explicitly run this outside the `NgZone`, however
         // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will
         // be patched to run inside the zone, which will throw us into an infinite loop.
-        this._ngZone.runOutsideAngular(function () {
+        this._ngZone.runOutsideAngular((/**
+         * @return {?}
+         */
+        function () {
             // We can't remove the host here immediately, because the overlay pane's content
             // might still be animating. This stream helps us avoid interrupting the animation
             // by waiting for the pane to become empty.
@@ -1573,7 +1657,10 @@ OverlayRef = /** @class */ (function () {
             var subscription = _this._ngZone.onStable
                 .asObservable()
                 .pipe(takeUntil(merge(_this._attachments, _this._detachments)))
-                .subscribe(function () {
+                .subscribe((/**
+             * @return {?}
+             */
+            function () {
                 // Needs a couple of checks for the pane and host, because
                 // they may have been removed by the time the zone stabilizes.
                 if (!_this._pane || !_this._host || _this._pane.children.length === 0) {
@@ -1586,8 +1673,8 @@ OverlayRef = /** @class */ (function () {
                     }
                     subscription.unsubscribe();
                 }
-            });
-        });
+            }));
+        }));
     };
     /** Disposes of a scroll strategy. */
     /**
@@ -1615,7 +1702,7 @@ OverlayRef = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 // TODO: refactor clipping detection into a separate thing (part of scrolling module)
 // TODO: doesn't handle both flexible width and height when it has to scroll along both axis.
@@ -1640,7 +1727,6 @@ var  /**
  */
 FlexibleConnectedPositionStrategy = /** @class */ (function () {
     function FlexibleConnectedPositionStrategy(connectedTo, _viewportRuler, _document, _platform, _overlayContainer) {
-        var _this = this;
         this._viewportRuler = _viewportRuler;
         this._document = _document;
         this._platform = _platform;
@@ -1676,7 +1762,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         /**
          * The Scrollable containers used to check scrollable view properties on position change.
          */
-        this.scrollables = [];
+        this._scrollables = [];
         /**
          * Ordered list of preferred positions, from most to least desirable.
          */
@@ -1697,10 +1783,6 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
          * Default offset for the overlay along the y axis.
          */
         this._offsetY = 0;
-        /**
-         * Amount of subscribers to the `positionChanges` stream.
-         */
-        this._positionChangeSubscriptions = 0;
         /**
          * Keeps track of the CSS classes that the position strategy has applied on the overlay panel.
          */
@@ -1708,15 +1790,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         /**
          * Observable sequence of position changes.
          */
-        this.positionChanges = new Observable(function (observer) {
-            /** @type {?} */
-            var subscription = _this._positionChanges.subscribe(observer);
-            _this._positionChangeSubscriptions++;
-            return function () {
-                subscription.unsubscribe();
-                _this._positionChangeSubscriptions--;
-            };
-        });
+        this.positionChanges = this._positionChanges.asObservable();
         this.setOrigin(connectedTo);
     }
     Object.defineProperty(FlexibleConnectedPositionStrategy.prototype, "positions", {
@@ -1756,13 +1830,16 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         this._isInitialRender = true;
         this._lastPosition = null;
         this._resizeSubscription.unsubscribe();
-        this._resizeSubscription = this._viewportRuler.change().subscribe(function () {
+        this._resizeSubscription = this._viewportRuler.change().subscribe((/**
+         * @return {?}
+         */
+        function () {
             // When the window is resized, we want to trigger the next reposition as if it
             // was an initial render, in order for the strategy to pick a new optimal position,
             // otherwise position locking will cause it to stay at the old one.
             _this._isInitialRender = true;
             _this.apply();
-        });
+        }));
     };
     /**
      * Updates the position of the overlay element, using whichever preferred position relative
@@ -2017,7 +2094,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
      * @return {THIS}
      */
     function (scrollables) {
-        (/** @type {?} */ (this)).scrollables = scrollables;
+        (/** @type {?} */ (this))._scrollables = scrollables;
         return (/** @type {?} */ (this));
     };
     /**
@@ -2570,7 +2647,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         // Notify that the position has been changed along with its change properties.
         // We only emit if we've got any subscriptions, because the scroll visibility
         // calculcations can be somewhat expensive.
-        if (this._positionChangeSubscriptions > 0) {
+        if (this._positionChanges.observers.length) {
             /** @type {?} */
             var scrollableViewProperties = this._getScrollVisibility();
             /** @type {?} */
@@ -3018,9 +3095,13 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         // every time, we should be able to use the scrollTop of the containers if the size of those
         // containers hasn't changed.
         /** @type {?} */
-        var scrollContainerBounds = this.scrollables.map(function (scrollable) {
+        var scrollContainerBounds = this._scrollables.map((/**
+         * @param {?} scrollable
+         * @return {?}
+         */
+        function (scrollable) {
             return scrollable.getElementRef().nativeElement.getBoundingClientRect();
-        });
+        }));
         return {
             isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),
             isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),
@@ -3048,9 +3129,14 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         for (var _i = 1; _i < arguments.length; _i++) {
             overflows[_i - 1] = arguments[_i];
         }
-        return overflows.reduce(function (currentValue, currentOverflow) {
+        return overflows.reduce((/**
+         * @param {?} currentValue
+         * @param {?} currentOverflow
+         * @return {?}
+         */
+        function (currentValue, currentOverflow) {
             return currentValue - Math.max(currentOverflow, 0);
-        }, length);
+        }), length);
     };
     /** Narrows the given viewport rect by the current _viewportMargin. */
     /**
@@ -3152,12 +3238,16 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         }
         // TODO(crisbeto): remove these once Angular's template type
         // checking is advanced enough to catch these cases.
-        this._preferredPositions.forEach(function (pair) {
+        this._preferredPositions.forEach((/**
+         * @param {?} pair
+         * @return {?}
+         */
+        function (pair) {
             validateHorizontalPosition('originX', pair.originX);
             validateVerticalPosition('originY', pair.originY);
             validateHorizontalPosition('overlayX', pair.overlayX);
             validateVerticalPosition('overlayY', pair.overlayY);
-        });
+        }));
     };
     /** Adds a single CSS class or an array of classes on the overlay panel. */
     /**
@@ -3175,12 +3265,16 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
     function (cssClasses) {
         var _this = this;
         if (this._pane) {
-            coerceArray(cssClasses).forEach(function (cssClass) {
+            coerceArray(cssClasses).forEach((/**
+             * @param {?} cssClass
+             * @return {?}
+             */
+            function (cssClass) {
                 if (cssClass !== '' && _this._appliedPanelClasses.indexOf(cssClass) === -1) {
                     _this._appliedPanelClasses.push(cssClass);
                     _this._pane.classList.add(cssClass);
                 }
-            });
+            }));
         }
     };
     /** Clears the classes that the position strategy has applied from the overlay panel. */
@@ -3197,9 +3291,13 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
     function () {
         var _this = this;
         if (this._pane) {
-            this._appliedPanelClasses.forEach(function (cssClass) {
+            this._appliedPanelClasses.forEach((/**
+             * @param {?} cssClass
+             * @return {?}
+             */
+            function (cssClass) {
                 _this._pane.classList.remove(cssClass);
-            });
+            }));
             this._appliedPanelClasses = [];
         }
     };
@@ -3252,7 +3350,7 @@ function extendStyles(dest, source) {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * A strategy for positioning overlays. Using this strategy, an overlay is given an
@@ -3613,7 +3711,7 @@ ConnectedPositionStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
@@ -3984,7 +4082,7 @@ GlobalPositionStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Builder for overlay position strategy.
@@ -4066,13 +4164,13 @@ var OverlayPositionBuilder = /** @class */ (function () {
         { type: Platform },
         { type: OverlayContainer }
     ]; };
-    /** @nocollapse */ OverlayPositionBuilder.ngInjectableDef = defineInjectable({ factory: function OverlayPositionBuilder_Factory() { return new OverlayPositionBuilder(inject(ViewportRuler), inject(DOCUMENT), inject(Platform), inject(OverlayContainer)); }, token: OverlayPositionBuilder, providedIn: "root" });
+    /** @nocollapse */ OverlayPositionBuilder.ngInjectableDef = ɵɵdefineInjectable({ factory: function OverlayPositionBuilder_Factory() { return new OverlayPositionBuilder(ɵɵinject(ViewportRuler), ɵɵinject(DOCUMENT), ɵɵinject(Platform), ɵɵinject(OverlayContainer)); }, token: OverlayPositionBuilder, providedIn: "root" });
     return OverlayPositionBuilder;
 }());
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Next overlay unique ID.
@@ -4240,7 +4338,7 @@ var Overlay = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Default set of positions for the overlay. Follows the behavior of a dropdown.
@@ -4539,12 +4637,16 @@ var CdkConnectedOverlay = /** @class */ (function () {
             this.positions = defaultPositionList;
         }
         this._overlayRef = this._overlay.create(this._buildConfig());
-        this._overlayRef.keydownEvents().subscribe(function (event) {
+        this._overlayRef.keydownEvents().subscribe((/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
             _this.overlayKeydown.next(event);
             if (event.keyCode === ESCAPE) {
                 _this._detachOverlay();
             }
-        });
+        }));
     };
     /** Builds the overlay config based on the directive's inputs */
     /**
@@ -4603,14 +4705,19 @@ var CdkConnectedOverlay = /** @class */ (function () {
     function (positionStrategy) {
         var _this = this;
         /** @type {?} */
-        var positions = this.positions.map(function (currentPosition) { return ({
+        var positions = this.positions.map((/**
+         * @param {?} currentPosition
+         * @return {?}
+         */
+        function (currentPosition) { return ({
             originX: currentPosition.originX,
             originY: currentPosition.originY,
             overlayX: currentPosition.overlayX,
             overlayY: currentPosition.overlayY,
             offsetX: currentPosition.offsetX || _this.offsetX,
-            offsetY: currentPosition.offsetY || _this.offsetY
-        }); });
+            offsetY: currentPosition.offsetY || _this.offsetY,
+            panelClass: currentPosition.panelClass || undefined,
+        }); }));
         return positionStrategy
             .setOrigin(this.origin.elementRef)
             .withPositions(positions)
@@ -4636,7 +4743,11 @@ var CdkConnectedOverlay = /** @class */ (function () {
         /** @type {?} */
         var strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);
         this._updatePositionStrategy(strategy);
-        strategy.positionChanges.subscribe(function (p) { return _this.positionChange.emit(p); });
+        strategy.positionChanges.subscribe((/**
+         * @param {?} p
+         * @return {?}
+         */
+        function (p) { return _this.positionChange.emit(p); }));
         return strategy;
     };
     /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */
@@ -4664,9 +4775,13 @@ var CdkConnectedOverlay = /** @class */ (function () {
             this.attach.emit();
         }
         if (this.hasBackdrop) {
-            this._backdropSubscription = this._overlayRef.backdropClick().subscribe(function (event) {
+            this._backdropSubscription = this._overlayRef.backdropClick().subscribe((/**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
                 _this.backdropClick.emit(event);
-            });
+            }));
         }
         else {
             this._backdropSubscription.unsubscribe();
@@ -4737,7 +4852,10 @@ var CdkConnectedOverlay = /** @class */ (function () {
  * @return {?}
  */
 function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
-    return function () { return overlay.scrollStrategies.reposition(); };
+    return (/**
+     * @return {?}
+     */
+    function () { return overlay.scrollStrategies.reposition(); });
 }
 /**
  * \@docs-private
@@ -4751,7 +4869,7 @@ var CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 var OverlayModule = /** @class */ (function () {
     function OverlayModule() {
@@ -4786,7 +4904,7 @@ var OVERLAY_PROVIDERS = [
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Alternative to OverlayContainer that supports correct displaying of overlay elements in
@@ -4824,7 +4942,10 @@ var FullscreenOverlayContainer = /** @class */ (function (_super) {
         var _this = this;
         _super.prototype._createContainer.call(this);
         this._adjustParentForFullscreenChange();
-        this._addFullscreenChangeListener(function () { return _this._adjustParentForFullscreenChange(); });
+        this._addFullscreenChangeListener((/**
+         * @return {?}
+         */
+        function () { return _this._adjustParentForFullscreenChange(); }));
     };
     /**
      * @private
@@ -4918,18 +5039,18 @@ var FullscreenOverlayContainer = /** @class */ (function (_super) {
     FullscreenOverlayContainer.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ FullscreenOverlayContainer.ngInjectableDef = defineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(inject(DOCUMENT)); }, token: FullscreenOverlayContainer, providedIn: "root" });
+    /** @nocollapse */ FullscreenOverlayContainer.ngInjectableDef = ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(ɵɵinject(DOCUMENT)); }, token: FullscreenOverlayContainer, providedIn: "root" });
     return FullscreenOverlayContainer;
 }(OverlayContainer));
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 export { Overlay, OverlayContainer, CdkOverlayOrigin, CdkConnectedOverlay, FullscreenOverlayContainer, OverlayRef, OverlayKeyboardDispatcher, OverlayPositionBuilder, GlobalPositionStrategy, ConnectedPositionStrategy, FlexibleConnectedPositionStrategy, OverlayConfig, validateVerticalPosition, validateHorizontalPosition, ConnectionPositionPair, ScrollingVisibility, ConnectedOverlayPositionChange, ScrollStrategyOptions, RepositionScrollStrategy, CloseScrollStrategy, NoopScrollStrategy, BlockScrollStrategy, OverlayModule, OVERLAY_PROVIDERS, OVERLAY_KEYBOARD_DISPATCHER_PROVIDER as ɵg, OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY as ɵf, OVERLAY_CONTAINER_PROVIDER as ɵb, OVERLAY_CONTAINER_PROVIDER_FACTORY as ɵa, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵc, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵe, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵd };