@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/overlay/dispatchers/overlay-outside-click-dispatcher.js

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { Platform } from '@angular/cdk/platform';
+import { BaseOverlayDispatcher } from './base-overlay-dispatcher';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/platform";
+/**
+ * Service for dispatching mouse click events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+export class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
+    constructor(document, _platform) {
+        super(document);
+        this._platform = _platform;
+        this._cursorStyleIsSet = false;
+        /** Click event listener that will be attached to the body propagate phase. */
+        this._clickListener = (event) => {
+            // Get the target through the `composedPath` if possible to account for shadow DOM.
+            const target = event.composedPath ? event.composedPath()[0] : event.target;
+            const overlays = this._attachedOverlays;
+            // Dispatch the mouse event to the top overlay which has subscribers to its mouse events.
+            // We want to target all overlays for which the click could be considered as outside click.
+            // As soon as we reach an overlay for which the click is not outside click we break off
+            // the loop.
+            for (let i = overlays.length - 1; i > -1; i--) {
+                const overlayRef = overlays[i];
+                if (overlayRef._outsidePointerEvents.observers.length < 1) {
+                    continue;
+                }
+                const config = overlayRef.getConfig();
+                const excludeElements = [...config.excludeFromOutsideClick, overlayRef.overlayElement];
+                const isInsideClick = excludeElements.some(e => e.contains(target));
+                // If it is inside click just break - we should do nothing
+                // If it is outside click dispatch the mouse event, and proceed with the next overlay
+                if (isInsideClick) {
+                    break;
+                }
+                overlayRef._outsidePointerEvents.next(event);
+            }
+        };
+    }
+    /** Add a new overlay to the list of attached overlay refs. */
+    add(overlayRef) {
+        super.add(overlayRef);
+        // tslint:disable: max-line-length
+        // Safari on iOS does not generate click events for non-interactive
+        // elements. However, we want to receive a click for any element outside
+        // the overlay. We can force a "clickable" state by setting
+        // `cursor: pointer` on the document body.
+        // See https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event#Safari_Mobile
+        // and https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html
+        // tslint:enable: max-line-length
+        if (!this._isAttached) {
+            this._document.body.addEventListener('click', this._clickListener, true);
+            // click event is not fired on iOS. To make element "clickable" we are
+            // setting the cursor to pointer
+            if (this._platform.IOS && !this._cursorStyleIsSet) {
+                this._cursorOriginalValue = this._document.body.style.cursor;
+                this._document.body.style.cursor = 'pointer';
+                this._cursorStyleIsSet = true;
+            }
+            this._isAttached = true;
+        }
+    }
+    /** Detaches the global keyboard event listener. */
+    detach() {
+        if (this._isAttached) {
+            this._document.body.removeEventListener('click', this._clickListener, true);
+            if (this._platform.IOS && this._cursorStyleIsSet) {
+                this._document.body.style.cursor = this._cursorOriginalValue;
+                this._cursorStyleIsSet = false;
+            }
+            this._isAttached = false;
+        }
+    }
+}
+OverlayOutsideClickDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayOutsideClickDispatcher_Factory() { return new OverlayOutsideClickDispatcher(i0.ɵɵinject(i1.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 }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-outside-click-dispatcher.js","sourceRoot":"","sources":["../../../../../../../src/cdk/overlay/dispatchers/overlay-outside-click-dispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable} from '@angular/core';\nimport {OverlayReference} from '../overlay-reference';\nimport {Platform} from '@angular/cdk/platform';\nimport {BaseOverlayDispatcher} from './base-overlay-dispatcher';\n\n/**\n * Service for dispatching mouse click events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\n@Injectable({providedIn: 'root'})\nexport class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {\n  private _cursorOriginalValue: string;\n  private _cursorStyleIsSet = false;\n\n  constructor(@Inject(DOCUMENT) document: any, private _platform: Platform) {\n    super(document);\n  }\n\n  /** Add a new overlay to the list of attached overlay refs. */\n  add(overlayRef: OverlayReference): void {\n    super.add(overlayRef);\n\n    // tslint:disable: max-line-length\n    // Safari on iOS does not generate click events for non-interactive\n    // elements. However, we want to receive a click for any element outside\n    // the overlay. We can force a \"clickable\" state by setting\n    // `cursor: pointer` on the document body.\n    // See https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event#Safari_Mobile\n    // and https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html\n    // tslint:enable: max-line-length\n    if (!this._isAttached) {\n      this._document.body.addEventListener('click', this._clickListener, true);\n\n      // click event is not fired on iOS. To make element \"clickable\" we are\n      // setting the cursor to pointer\n      if (this._platform.IOS && !this._cursorStyleIsSet) {\n        this._cursorOriginalValue = this._document.body.style.cursor;\n        this._document.body.style.cursor = 'pointer';\n        this._cursorStyleIsSet = true;\n      }\n\n      this._isAttached = true;\n    }\n  }\n\n  /** Detaches the global keyboard event listener. */\n  protected detach() {\n    if (this._isAttached) {\n      this._document.body.removeEventListener('click', this._clickListener, true);\n      if (this._platform.IOS && this._cursorStyleIsSet) {\n        this._document.body.style.cursor = this._cursorOriginalValue;\n        this._cursorStyleIsSet = false;\n      }\n      this._isAttached = false;\n    }\n  }\n\n  /** Click event listener that will be attached to the body propagate phase. */\n  private _clickListener = (event: MouseEvent) => {\n    // Get the target through the `composedPath` if possible to account for shadow DOM.\n    const target = event.composedPath ? event.composedPath()[0] : event.target;\n    const overlays = this._attachedOverlays;\n\n    // Dispatch the mouse event to the top overlay which has subscribers to its mouse events.\n    // We want to target all overlays for which the click could be considered as outside click.\n    // As soon as we reach an overlay for which the click is not outside click we break off\n    // the loop.\n    for (let i = overlays.length - 1; i > -1; i--) {\n      const overlayRef = overlays[i];\n      if (overlayRef._outsidePointerEvents.observers.length < 1) {\n        continue;\n      }\n\n      const config = overlayRef.getConfig();\n      const excludeElements = [...config.excludeFromOutsideClick!, overlayRef.overlayElement];\n      const isInsideClick: boolean = excludeElements.some(e => e.contains(target));\n\n      // If it is inside click just break - we should do nothing\n      // If it is outside click dispatch the mouse event, and proceed with the next overlay\n      if (isInsideClick) {\n        break;\n      }\n\n      overlayRef._outsidePointerEvents.next(event);\n    }\n  }\n}\n"]}

package/esm2015/overlay/fullscreen-overlay-container.js

@@ -19,85 +19,81 @@ import * as i2 from "@angular/cdk/platform";
  *
  * Should be provided in the root component.
  */
-let FullscreenOverlayContainer = /** @class */ (() => {
-    class FullscreenOverlayContainer extends OverlayContainer {
-        constructor(_document, 
-        /**
-         * @deprecated `platform` parameter to become required.
-         * @breaking-change 10.0.0
-         */
-        platform) {
-            super(_document, platform);
-        }
-        ngOnDestroy() {
-            super.ngOnDestroy();
-            if (this._fullScreenEventName && this._fullScreenListener) {
-                this._document.removeEventListener(this._fullScreenEventName, this._fullScreenListener);
-            }
+export class FullscreenOverlayContainer extends OverlayContainer {
+    constructor(_document, 
+    /**
+     * @deprecated `platform` parameter to become required.
+     * @breaking-change 10.0.0
+     */
+    platform) {
+        super(_document, platform);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this._fullScreenEventName && this._fullScreenListener) {
+            this._document.removeEventListener(this._fullScreenEventName, this._fullScreenListener);
         }
-        _createContainer() {
-            super._createContainer();
-            this._adjustParentForFullscreenChange();
-            this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());
+    }
+    _createContainer() {
+        super._createContainer();
+        this._adjustParentForFullscreenChange();
+        this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());
+    }
+    _adjustParentForFullscreenChange() {
+        if (!this._containerElement) {
+            return;
         }
-        _adjustParentForFullscreenChange() {
-            if (!this._containerElement) {
-                return;
+        const fullscreenElement = this.getFullscreenElement();
+        const parent = fullscreenElement || this._document.body;
+        parent.appendChild(this._containerElement);
+    }
+    _addFullscreenChangeListener(fn) {
+        const eventName = this._getEventName();
+        if (eventName) {
+            if (this._fullScreenListener) {
+                this._document.removeEventListener(eventName, this._fullScreenListener);
             }
-            const fullscreenElement = this.getFullscreenElement();
-            const parent = fullscreenElement || this._document.body;
-            parent.appendChild(this._containerElement);
+            this._document.addEventListener(eventName, fn);
+            this._fullScreenListener = fn;
         }
-        _addFullscreenChangeListener(fn) {
-            const eventName = this._getEventName();
-            if (eventName) {
-                if (this._fullScreenListener) {
-                    this._document.removeEventListener(eventName, this._fullScreenListener);
-                }
-                this._document.addEventListener(eventName, fn);
-                this._fullScreenListener = fn;
+    }
+    _getEventName() {
+        if (!this._fullScreenEventName) {
+            const _document = this._document;
+            if (_document.fullscreenEnabled) {
+                this._fullScreenEventName = 'fullscreenchange';
             }
-        }
-        _getEventName() {
-            if (!this._fullScreenEventName) {
-                const _document = this._document;
-                if (_document.fullscreenEnabled) {
-                    this._fullScreenEventName = 'fullscreenchange';
-                }
-                else if (_document.webkitFullscreenEnabled) {
-                    this._fullScreenEventName = 'webkitfullscreenchange';
-                }
-                else if (_document.mozFullScreenEnabled) {
-                    this._fullScreenEventName = 'mozfullscreenchange';
-                }
-                else if (_document.msFullscreenEnabled) {
-                    this._fullScreenEventName = 'MSFullscreenChange';
-                }
+            else if (_document.webkitFullscreenEnabled) {
+                this._fullScreenEventName = 'webkitfullscreenchange';
+            }
+            else if (_document.mozFullScreenEnabled) {
+                this._fullScreenEventName = 'mozfullscreenchange';
+            }
+            else if (_document.msFullscreenEnabled) {
+                this._fullScreenEventName = 'MSFullscreenChange';
             }
-            return this._fullScreenEventName;
-        }
-        /**
-         * When the page is put into fullscreen mode, a specific element is specified.
-         * Only that element and its children are visible when in fullscreen mode.
-         */
-        getFullscreenElement() {
-            const _document = this._document;
-            return _document.fullscreenElement ||
-                _document.webkitFullscreenElement ||
-                _document.mozFullScreenElement ||
-                _document.msFullscreenElement ||
-                null;
         }
+        return this._fullScreenEventName;
+    }
+    /**
+     * When the page is put into fullscreen mode, a specific element is specified.
+     * Only that element and its children are visible when in fullscreen mode.
+     */
+    getFullscreenElement() {
+        const _document = this._document;
+        return _document.fullscreenElement ||
+            _document.webkitFullscreenElement ||
+            _document.mozFullScreenElement ||
+            _document.msFullscreenElement ||
+            null;
     }
-    FullscreenOverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(i0.ɵɵinject(i1.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 }
-    ];
-    return FullscreenOverlayContainer;
-})();
-export { FullscreenOverlayContainer };
-//# sourceMappingURL=data:application/json;base64,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
+}
+FullscreenOverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(i0.ɵɵinject(i1.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 }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/overlay/index.js

@@ -2,7 +2,8 @@
  * Generated bundle index. Do not edit.
  */
 export * from './public-api';
-export { OVERLAY_KEYBOARD_DISPATCHER_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_g, OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_f } from './keyboard/overlay-keyboard-dispatcher';
-export { OVERLAY_CONTAINER_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_b, OVERLAY_CONTAINER_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_a } from './overlay-container';
-export { CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵangular_material_src_cdk_overlay_overlay_c, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_e, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_d } from './overlay-directives';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL292ZXJsYXkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUU3QixPQUFPLEVBQUMsb0NBQW9DLElBQUksMkNBQTJDLEVBQUMsNENBQTRDLElBQUksMkNBQTJDLEVBQUMsTUFBTSx3Q0FBd0MsQ0FBQztBQUN2TyxPQUFPLEVBQUMsMEJBQTBCLElBQUksMkNBQTJDLEVBQUMsa0NBQWtDLElBQUksMkNBQTJDLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNoTSxPQUFPLEVBQUMscUNBQXFDLElBQUksMkNBQTJDLEVBQUMsOENBQThDLElBQUksMkNBQTJDLEVBQUMsc0RBQXNELElBQUksMkNBQTJDLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcblxuZXhwb3J0IHtPVkVSTEFZX0tFWUJPQVJEX0RJU1BBVENIRVJfUFJPVklERVIgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2csT1ZFUkxBWV9LRVlCT0FSRF9ESVNQQVRDSEVSX1BST1ZJREVSX0ZBQ1RPUlkgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2Z9IGZyb20gJy4va2V5Ym9hcmQvb3ZlcmxheS1rZXlib2FyZC1kaXNwYXRjaGVyJztcbmV4cG9ydCB7T1ZFUkxBWV9DT05UQUlORVJfUFJPVklERVIgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2IsT1ZFUkxBWV9DT05UQUlORVJfUFJPVklERVJfRkFDVE9SWSBhcyDJtWFuZ3VsYXJfbWF0ZXJpYWxfc3JjX2Nka19vdmVybGF5X292ZXJsYXlfYX0gZnJvbSAnLi9vdmVybGF5LWNvbnRhaW5lcic7XG5leHBvcnQge0NES19DT05ORUNURURfT1ZFUkxBWV9TQ1JPTExfU1RSQVRFR1kgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2MsQ0RLX0NPTk5FQ1RFRF9PVkVSTEFZX1NDUk9MTF9TVFJBVEVHWV9QUk9WSURFUiBhcyDJtWFuZ3VsYXJfbWF0ZXJpYWxfc3JjX2Nka19vdmVybGF5X292ZXJsYXlfZSxDREtfQ09OTkVDVEVEX09WRVJMQVlfU0NST0xMX1NUUkFURUdZX1BST1ZJREVSX0ZBQ1RPUlkgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2R9IGZyb20gJy4vb3ZlcmxheS1kaXJlY3RpdmVzJzsiXX0=
+export { BaseOverlayDispatcher as ɵangular_material_src_cdk_overlay_overlay_h } from './dispatchers/base-overlay-dispatcher';
+export { OVERLAY_KEYBOARD_DISPATCHER_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_b, OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_a } from './dispatchers/overlay-keyboard-dispatcher';
+export { OVERLAY_CONTAINER_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_d, OVERLAY_CONTAINER_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_c } from './overlay-container';
+export { CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵangular_material_src_cdk_overlay_overlay_e, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵangular_material_src_cdk_overlay_overlay_g, CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵangular_material_src_cdk_overlay_overlay_f } from './overlay-directives';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL292ZXJsYXkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUU3QixPQUFPLEVBQUMscUJBQXFCLElBQUksMkNBQTJDLEVBQUMsTUFBTSx1Q0FBdUMsQ0FBQztBQUMzSCxPQUFPLEVBQUMsb0NBQW9DLElBQUksMkNBQTJDLEVBQUMsNENBQTRDLElBQUksMkNBQTJDLEVBQUMsTUFBTSwyQ0FBMkMsQ0FBQztBQUMxTyxPQUFPLEVBQUMsMEJBQTBCLElBQUksMkNBQTJDLEVBQUMsa0NBQWtDLElBQUksMkNBQTJDLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNoTSxPQUFPLEVBQUMscUNBQXFDLElBQUksMkNBQTJDLEVBQUMsOENBQThDLElBQUksMkNBQTJDLEVBQUMsc0RBQXNELElBQUksMkNBQTJDLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcblxuZXhwb3J0IHtCYXNlT3ZlcmxheURpc3BhdGNoZXIgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2h9IGZyb20gJy4vZGlzcGF0Y2hlcnMvYmFzZS1vdmVybGF5LWRpc3BhdGNoZXInO1xuZXhwb3J0IHtPVkVSTEFZX0tFWUJPQVJEX0RJU1BBVENIRVJfUFJPVklERVIgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2IsT1ZFUkxBWV9LRVlCT0FSRF9ESVNQQVRDSEVSX1BST1ZJREVSX0ZBQ1RPUlkgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2F9IGZyb20gJy4vZGlzcGF0Y2hlcnMvb3ZlcmxheS1rZXlib2FyZC1kaXNwYXRjaGVyJztcbmV4cG9ydCB7T1ZFUkxBWV9DT05UQUlORVJfUFJPVklERVIgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2QsT1ZFUkxBWV9DT05UQUlORVJfUFJPVklERVJfRkFDVE9SWSBhcyDJtWFuZ3VsYXJfbWF0ZXJpYWxfc3JjX2Nka19vdmVybGF5X292ZXJsYXlfY30gZnJvbSAnLi9vdmVybGF5LWNvbnRhaW5lcic7XG5leHBvcnQge0NES19DT05ORUNURURfT1ZFUkxBWV9TQ1JPTExfU1RSQVRFR1kgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2UsQ0RLX0NPTk5FQ1RFRF9PVkVSTEFZX1NDUk9MTF9TVFJBVEVHWV9QUk9WSURFUiBhcyDJtWFuZ3VsYXJfbWF0ZXJpYWxfc3JjX2Nka19vdmVybGF5X292ZXJsYXlfZyxDREtfQ09OTkVDVEVEX09WRVJMQVlfU0NST0xMX1NUUkFURUdZX1BST1ZJREVSX0ZBQ1RPUlkgYXMgybVhbmd1bGFyX21hdGVyaWFsX3NyY19jZGtfb3ZlcmxheV9vdmVybGF5X2Z9IGZyb20gJy4vb3ZlcmxheS1kaXJlY3RpdmVzJzsiXX0=

package/esm2015/overlay/overlay-config.js

@@ -23,6 +23,10 @@ export class OverlayConfig {
          * the `HashLocationStrategy`).
          */
         this.disposeOnNavigation = false;
+        /**
+         * Array of HTML elements clicking on which should not be considered as outside click
+         */
+        this.excludeFromOutsideClick = [];
         if (config) {
             // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,
             // loses the array generic type in the `for of`. But we *also* have to use `Array` because
@@ -42,4 +46,4 @@ export class OverlayConfig {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL292ZXJsYXkvb3ZlcmxheS1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBSUgsT0FBTyxFQUFpQixrQkFBa0IsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBR2xFLDJEQUEyRDtBQUMzRCxNQUFNLE9BQU8sYUFBYTtJQW9EeEIsWUFBWSxNQUFzQjtRQWhEbEMsaUZBQWlGO1FBQ2pGLG1CQUFjLEdBQW9CLElBQUksa0JBQWtCLEVBQUUsQ0FBQztRQUUzRCwrQ0FBK0M7UUFDL0MsZUFBVSxHQUF1QixFQUFFLENBQUM7UUFFcEMsMENBQTBDO1FBQzFDLGdCQUFXLEdBQWEsS0FBSyxDQUFDO1FBRTlCLDBDQUEwQztRQUMxQyxrQkFBYSxHQUF1QiwyQkFBMkIsQ0FBQztRQTBCaEU7Ozs7V0FJRztRQUNILHdCQUFtQixHQUFhLEtBQUssQ0FBQztRQUV0Qzs7V0FFRztRQUNILDRCQUF1QixHQUFtQixFQUFFLENBQUM7UUFHM0MsSUFBSSxNQUFNLEVBQUU7WUFDVixxRUFBcUU7WUFDckUsMEZBQTBGO1lBQzFGLDZGQUE2RjtZQUM3RixNQUFNLFVBQVUsR0FDWixNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBNEQsQ0FBQztZQUNuRixLQUFLLE1BQU0sR0FBRyxJQUFJLFVBQVUsRUFBRTtnQkFDNUIsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssU0FBUyxFQUFFO29CQUM3Qiw0RUFBNEU7b0JBQzVFLG9GQUFvRjtvQkFDcEYsdUZBQXVGO29CQUN2Rix3RkFBd0Y7b0JBQ3hGLHFGQUFxRjtvQkFDckYsdUNBQXVDO29CQUN2QyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBUSxDQUFDO2lCQUNoQzthQUNGO1NBQ0Y7SUFDSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtQb3NpdGlvblN0cmF0ZWd5fSBmcm9tICcuL3Bvc2l0aW9uL3Bvc2l0aW9uLXN0cmF0ZWd5JztcbmltcG9ydCB7RGlyZWN0aW9uLCBEaXJlY3Rpb25hbGl0eX0gZnJvbSAnQGFuZ3VsYXIvY2RrL2JpZGknO1xuaW1wb3J0IHtTY3JvbGxTdHJhdGVneSwgTm9vcFNjcm9sbFN0cmF0ZWd5fSBmcm9tICcuL3Njcm9sbC9pbmRleCc7XG5cblxuLyoqIEluaXRpYWwgY29uZmlndXJhdGlvbiB1c2VkIHdoZW4gY3JlYXRpbmcgYW4gb3ZlcmxheS4gKi9cbmV4cG9ydCBjbGFzcyBPdmVybGF5Q29uZmlnIHtcbiAgLyoqIFN0cmF0ZWd5IHdpdGggd2hpY2ggdG8gcG9zaXRpb24gdGhlIG92ZXJsYXkuICovXG4gIHBvc2l0aW9uU3RyYXRlZ3k/OiBQb3NpdGlvblN0cmF0ZWd5O1xuXG4gIC8qKiBTdHJhdGVneSB0byBiZSB1c2VkIHdoZW4gaGFuZGxpbmcgc2Nyb2xsIGV2ZW50cyB3aGlsZSB0aGUgb3ZlcmxheSBpcyBvcGVuLiAqL1xuICBzY3JvbGxTdHJhdGVneT86IFNjcm9sbFN0cmF0ZWd5ID0gbmV3IE5vb3BTY3JvbGxTdHJhdGVneSgpO1xuXG4gIC8qKiBDdXN0b20gY2xhc3MgdG8gYWRkIHRvIHRoZSBvdmVybGF5IHBhbmUuICovXG4gIHBhbmVsQ2xhc3M/OiBzdHJpbmcgfCBzdHJpbmdbXSA9ICcnO1xuXG4gIC8qKiBXaGV0aGVyIHRoZSBvdmVybGF5IGhhcyBhIGJhY2tkcm9wLiAqL1xuICBoYXNCYWNrZHJvcD86IGJvb2xlYW4gPSBmYWxzZTtcblxuICAvKiogQ3VzdG9tIGNsYXNzIHRvIGFkZCB0byB0aGUgYmFja2Ryb3AgKi9cbiAgYmFja2Ryb3BDbGFzcz86IHN0cmluZyB8IHN0cmluZ1tdID0gJ2Nkay1vdmVybGF5LWRhcmstYmFja2Ryb3AnO1xuXG4gIC8qKiBUaGUgd2lkdGggb2YgdGhlIG92ZXJsYXkgcGFuZWwuIElmIGEgbnVtYmVyIGlzIHByb3ZpZGVkLCBwaXhlbCB1bml0cyBhcmUgYXNzdW1lZC4gKi9cbiAgd2lkdGg/OiBudW1iZXIgfCBzdHJpbmc7XG5cbiAgLyoqIFRoZSBoZWlnaHQgb2YgdGhlIG92ZXJsYXkgcGFuZWwuIElmIGEgbnVtYmVyIGlzIHByb3ZpZGVkLCBwaXhlbCB1bml0cyBhcmUgYXNzdW1lZC4gKi9cbiAgaGVpZ2h0PzogbnVtYmVyIHwgc3RyaW5nO1xuXG4gIC8qKiBUaGUgbWluLXdpZHRoIG9mIHRoZSBvdmVybGF5IHBhbmVsLiBJZiBhIG51bWJlciBpcyBwcm92aWRlZCwgcGl4ZWwgdW5pdHMgYXJlIGFzc3VtZWQuICovXG4gIG1pbldpZHRoPzogbnVtYmVyIHwgc3RyaW5nO1xuXG4gIC8qKiBUaGUgbWluLWhlaWdodCBvZiB0aGUgb3ZlcmxheSBwYW5lbC4gSWYgYSBudW1iZXIgaXMgcHJvdmlkZWQsIHBpeGVsIHVuaXRzIGFyZSBhc3N1bWVkLiAqL1xuICBtaW5IZWlnaHQ/OiBudW1iZXIgfCBzdHJpbmc7XG5cbiAgLyoqIFRoZSBtYXgtd2lkdGggb2YgdGhlIG92ZXJsYXkgcGFuZWwuIElmIGEgbnVtYmVyIGlzIHByb3ZpZGVkLCBwaXhlbCB1bml0cyBhcmUgYXNzdW1lZC4gKi9cbiAgbWF4V2lkdGg/OiBudW1iZXIgfCBzdHJpbmc7XG5cbiAgLyoqIFRoZSBtYXgtaGVpZ2h0IG9mIHRoZSBvdmVybGF5IHBhbmVsLiBJZiBhIG51bWJlciBpcyBwcm92aWRlZCwgcGl4ZWwgdW5pdHMgYXJlIGFzc3VtZWQuICovXG4gIG1heEhlaWdodD86IG51bWJlciB8IHN0cmluZztcblxuICAvKipcbiAgICogRGlyZWN0aW9uIG9mIHRoZSB0ZXh0IGluIHRoZSBvdmVybGF5IHBhbmVsLiBJZiBhIGBEaXJlY3Rpb25hbGl0eWAgaW5zdGFuY2VcbiAgICogaXMgcGFzc2VkIGluLCB0aGUgb3ZlcmxheSB3aWxsIGhhbmRsZSBjaGFuZ2VzIHRvIGl0cyB2YWx1ZSBhdXRvbWF0aWNhbGx5LlxuICAgKi9cbiAgZGlyZWN0aW9uPzogRGlyZWN0aW9uIHwgRGlyZWN0aW9uYWxpdHk7XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdGhlIG92ZXJsYXkgc2hvdWxkIGJlIGRpc3Bvc2VkIG9mIHdoZW4gdGhlIHVzZXIgZ29lcyBiYWNrd2FyZHMvZm9yd2FyZHMgaW4gaGlzdG9yeS5cbiAgICogTm90ZSB0aGF0IHRoaXMgdXN1YWxseSBkb2Vzbid0IGluY2x1ZGUgY2xpY2tpbmcgb24gbGlua3MgKHVubGVzcyB0aGUgdXNlciBpcyB1c2luZ1xuICAgKiB0aGUgYEhhc2hMb2NhdGlvblN0cmF0ZWd5YCkuXG4gICAqL1xuICBkaXNwb3NlT25OYXZpZ2F0aW9uPzogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIC8qKlxuICAgKiBBcnJheSBvZiBIVE1MIGVsZW1lbnRzIGNsaWNraW5nIG9uIHdoaWNoIHNob3VsZCBub3QgYmUgY29uc2lkZXJlZCBhcyBvdXRzaWRlIGNsaWNrXG4gICAqL1xuICBleGNsdWRlRnJvbU91dHNpZGVDbGljaz86IEhUTUxFbGVtZW50W10gPSBbXTtcblxuICBjb25zdHJ1Y3Rvcihjb25maWc/OiBPdmVybGF5Q29uZmlnKSB7XG4gICAgaWYgKGNvbmZpZykge1xuICAgICAgLy8gVXNlIGBJdGVyYWJsZWAgaW5zdGVhZCBvZiBgQXJyYXlgIGJlY2F1c2UgVHlwZVNjcmlwdCwgYXMgb2YgMy42LjMsXG4gICAgICAvLyBsb3NlcyB0aGUgYXJyYXkgZ2VuZXJpYyB0eXBlIGluIHRoZSBgZm9yIG9mYC4gQnV0IHdlICphbHNvKiBoYXZlIHRvIHVzZSBgQXJyYXlgIGJlY2F1c2VcbiAgICAgIC8vIHR5cGVzY3JpcHQgd29uJ3QgaXRlcmF0ZSBvdmVyIGFuIGBJdGVyYWJsZWAgdW5sZXNzIHlvdSBjb21waWxlIHdpdGggYC0tZG93bmxldmVsSXRlcmF0aW9uYFxuICAgICAgY29uc3QgY29uZmlnS2V5cyA9XG4gICAgICAgICAgT2JqZWN0LmtleXMoY29uZmlnKSBhcyBJdGVyYWJsZTxrZXlvZiBPdmVybGF5Q29uZmlnPiAmIChrZXlvZiBPdmVybGF5Q29uZmlnKVtdO1xuICAgICAgZm9yIChjb25zdCBrZXkgb2YgY29uZmlnS2V5cykge1xuICAgICAgICBpZiAoY29uZmlnW2tleV0gIT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgIC8vIFR5cGVTY3JpcHQsIGFzIG9mIHZlcnNpb24gMy41LCBzZWVzIHRoZSBsZWZ0LWhhbmQtc2lkZSBvZiB0aGlzIGV4cHJlc3Npb25cbiAgICAgICAgICAvLyBhcyBcIkkgZG9uJ3Qga25vdyAqd2hpY2gqIGtleSB0aGlzIGlzLCBzbyB0aGUgb25seSB2YWxpZCB2YWx1ZSBpcyB0aGUgaW50ZXJzZWN0aW9uXG4gICAgICAgICAgLy8gb2YgYWxsIHRoZSBwb3NpYmxlIHZhbHVlcy5cIiBJbiB0aGlzIGNhc2UsIHRoYXQgaGFwcGVucyB0byBiZSBgdW5kZWZpbmVkYC4gVHlwZVNjcmlwdFxuICAgICAgICAgIC8vIGlzIG5vdCBzbWFydCBlbm91Z2ggdG8gc2VlIHRoYXQgdGhlIHJpZ2h0LWhhbmQtc2lkZSBpcyBhY3R1YWxseSBhbiBhY2Nlc3Mgb2YgdGhlIHNhbWVcbiAgICAgICAgICAvLyBleGFjdCB0eXBlIHdpdGggdGhlIHNhbWUgZXhhY3Qga2V5LCBtZWFuaW5nIHRoYXQgdGhlIHZhbHVlIHR5cGUgbXVzdCBiZSBpZGVudGljYWwuXG4gICAgICAgICAgLy8gU28gd2UgdXNlIGBhbnlgIHRvIHdvcmsgYXJvdW5kIHRoaXMuXG4gICAgICAgICAgdGhpc1trZXldID0gY29uZmlnW2tleV0gYXMgYW55O1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2015/overlay/overlay-container.js

@@ -18,84 +18,80 @@ import * as i2 from "@angular/cdk/platform";
 const isTestEnvironment = typeof window !== 'undefined' && !!window &&
     !!(window.__karma__ || window.jasmine);
 /** Container inside which all overlays will render. */
-let OverlayContainer = /** @class */ (() => {
-    class OverlayContainer {
-        constructor(document, 
-        /**
-         * @deprecated `platform` parameter to become required.
-         * @breaking-change 10.0.0
-         */
-        _platform) {
-            this._platform = _platform;
-            this._document = document;
+export class OverlayContainer {
+    constructor(document, 
+    /**
+     * @deprecated `platform` parameter to become required.
+     * @breaking-change 10.0.0
+     */
+    _platform) {
+        this._platform = _platform;
+        this._document = document;
+    }
+    ngOnDestroy() {
+        const container = this._containerElement;
+        if (container && container.parentNode) {
+            container.parentNode.removeChild(container);
         }
-        ngOnDestroy() {
-            const container = this._containerElement;
-            if (container && container.parentNode) {
-                container.parentNode.removeChild(container);
-            }
+    }
+    /**
+     * This method returns the overlay container element. It will lazily
+     * create the element the first time  it is called to facilitate using
+     * the container in non-browser environments.
+     * @returns the container element
+     */
+    getContainerElement() {
+        if (!this._containerElement) {
+            this._createContainer();
         }
-        /**
-         * This method returns the overlay container element. It will lazily
-         * create the element the first time  it is called to facilitate using
-         * the container in non-browser environments.
-         * @returns the container element
-         */
-        getContainerElement() {
-            if (!this._containerElement) {
-                this._createContainer();
+        return this._containerElement;
+    }
+    /**
+     * Create the overlay container element, which is simply a div
+     * with the 'cdk-overlay-container' class on the document body.
+     */
+    _createContainer() {
+        // @breaking-change 10.0.0 Remove null check for `_platform`.
+        const isBrowser = this._platform ? this._platform.isBrowser : typeof window !== 'undefined';
+        const containerClass = 'cdk-overlay-container';
+        if (isBrowser || isTestEnvironment) {
+            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]);
             }
-            return this._containerElement;
         }
-        /**
-         * Create the overlay container element, which is simply a div
-         * with the 'cdk-overlay-container' class on the document body.
-         */
-        _createContainer() {
-            // @breaking-change 10.0.0 Remove null check for `_platform`.
-            const isBrowser = this._platform ? this._platform.isBrowser : typeof window !== 'undefined';
-            const containerClass = 'cdk-overlay-container';
-            if (isBrowser || isTestEnvironment) {
-                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]);
-                }
-            }
-            const container = this._document.createElement('div');
-            container.classList.add(containerClass);
-            // A long time ago we kept adding new overlay containers whenever a new app was instantiated,
-            // but at some point we added logic which clears the duplicate ones in order to avoid leaks.
-            // The new logic was a little too aggressive since it was breaking some legitimate use cases.
-            // To mitigate the problem we made it so that only containers from a different platform are
-            // cleared, but the side-effect was that people started depending on the overly-aggressive
-            // logic to clean up their tests for them. Until we can introduce an overlay-specific testing
-            // module which does the cleanup, we try to detect that we're in a test environment and we
-            // always clear the container. See #17006.
-            // TODO(crisbeto): remove the test environment check once we have an overlay testing module.
-            if (isTestEnvironment) {
-                container.setAttribute('platform', 'test');
-            }
-            else if (!isBrowser) {
-                container.setAttribute('platform', 'server');
-            }
-            this._document.body.appendChild(container);
-            this._containerElement = container;
+        const container = this._document.createElement('div');
+        container.classList.add(containerClass);
+        // A long time ago we kept adding new overlay containers whenever a new app was instantiated,
+        // but at some point we added logic which clears the duplicate ones in order to avoid leaks.
+        // The new logic was a little too aggressive since it was breaking some legitimate use cases.
+        // To mitigate the problem we made it so that only containers from a different platform are
+        // cleared, but the side-effect was that people started depending on the overly-aggressive
+        // logic to clean up their tests for them. Until we can introduce an overlay-specific testing
+        // module which does the cleanup, we try to detect that we're in a test environment and we
+        // always clear the container. See #17006.
+        // TODO(crisbeto): remove the test environment check once we have an overlay testing module.
+        if (isTestEnvironment) {
+            container.setAttribute('platform', 'test');
         }
+        else if (!isBrowser) {
+            container.setAttribute('platform', 'server');
+        }
+        this._document.body.appendChild(container);
+        this._containerElement = container;
     }
-    OverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(i0.ɵɵinject(i1.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 }
-    ];
-    return OverlayContainer;
-})();
-export { OverlayContainer };
+}
+OverlayContainer.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(i0.ɵɵinject(i1.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 }
+];
 /** @docs-private @deprecated @breaking-change 8.0.0 */
 export function OVERLAY_CONTAINER_PROVIDER_FACTORY(parentContainer, _document) {
     return parentContainer || new OverlayContainer(_document);
@@ -110,4 +106,4 @@ export const OVERLAY_CONTAINER_PROVIDER = {
     ],
     useFactory: OVERLAY_CONTAINER_PROVIDER_FACTORY
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-container.js","sourceRoot":"","sources":["../../../../../../src/cdk/overlay/overlay-container.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {DOCUMENT} from '@angular/common';\nimport {\n  Inject,\n  Injectable,\n  InjectionToken,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n} from '@angular/core';\nimport {Platform} from '@angular/cdk/platform';\n\n/**\n * Whether we're in a testing environment.\n * TODO(crisbeto): remove this once we have an overlay testing module.\n */\nconst isTestEnvironment: boolean = typeof window !== 'undefined' && !!window &&\n  !!((window as any).__karma__ || (window as any).jasmine);\n\n/** Container inside which all overlays will render. */\n@Injectable({providedIn: 'root'})\nexport class OverlayContainer implements OnDestroy {\n  protected _containerElement: HTMLElement;\n  protected _document: Document;\n\n  constructor(\n    @Inject(DOCUMENT) document: any,\n    /**\n     * @deprecated `platform` parameter to become required.\n     * @breaking-change 10.0.0\n     */\n    protected _platform?: Platform) {\n    this._document = document;\n  }\n\n  ngOnDestroy() {\n    const container = this._containerElement;\n\n    if (container && container.parentNode) {\n      container.parentNode.removeChild(container);\n    }\n  }\n\n  /**\n   * This method returns the overlay container element. It will lazily\n   * create the element the first time  it is called to facilitate using\n   * the container in non-browser environments.\n   * @returns the container element\n   */\n  getContainerElement(): HTMLElement {\n    if (!this._containerElement) {\n      this._createContainer();\n    }\n\n    return this._containerElement;\n  }\n\n  /**\n   * Create the overlay container element, which is simply a div\n   * with the 'cdk-overlay-container' class on the document body.\n   */\n  protected _createContainer(): void {\n    // @breaking-change 10.0.0 Remove null check for `_platform`.\n    const isBrowser = this._platform ? this._platform.isBrowser : typeof window !== 'undefined';\n    const containerClass = 'cdk-overlay-container';\n\n    if (isBrowser || isTestEnvironment) {\n      const oppositePlatformContainers =\n          this._document.querySelectorAll(`.${containerClass}[platform=\"server\"], ` +\n                                          `.${containerClass}[platform=\"test\"]`);\n\n      // Remove any old containers from the opposite platform.\n      // This can happen when transitioning from the server to the client.\n      for (let i = 0; i < oppositePlatformContainers.length; i++) {\n        oppositePlatformContainers[i].parentNode!.removeChild(oppositePlatformContainers[i]);\n      }\n    }\n\n    const container = this._document.createElement('div');\n    container.classList.add(containerClass);\n\n    // A long time ago we kept adding new overlay containers whenever a new app was instantiated,\n    // but at some point we added logic which clears the duplicate ones in order to avoid leaks.\n    // The new logic was a little too aggressive since it was breaking some legitimate use cases.\n    // To mitigate the problem we made it so that only containers from a different platform are\n    // cleared, but the side-effect was that people started depending on the overly-aggressive\n    // logic to clean up their tests for them. Until we can introduce an overlay-specific testing\n    // module which does the cleanup, we try to detect that we're in a test environment and we\n    // always clear the container. See #17006.\n    // TODO(crisbeto): remove the test environment check once we have an overlay testing module.\n    if (isTestEnvironment) {\n      container.setAttribute('platform', 'test');\n    } else if (!isBrowser) {\n      container.setAttribute('platform', 'server');\n    }\n\n    this._document.body.appendChild(container);\n    this._containerElement = container;\n  }\n}\n\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport function OVERLAY_CONTAINER_PROVIDER_FACTORY(parentContainer: OverlayContainer,\n  _document: any) {\n  return parentContainer || new OverlayContainer(_document);\n}\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport const OVERLAY_CONTAINER_PROVIDER = {\n  // If there is already an OverlayContainer available, use that. Otherwise, provide a new one.\n  provide: OverlayContainer,\n  deps: [\n    [new Optional(), new SkipSelf(), OverlayContainer],\n    DOCUMENT as InjectionToken<any> // We need to use the InjectionToken somewhere to keep TS happy\n  ],\n  useFactory: OVERLAY_CONTAINER_PROVIDER_FACTORY\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-container.js","sourceRoot":"","sources":["../../../../../../src/cdk/overlay/overlay-container.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {DOCUMENT} from '@angular/common';\nimport {\n  Inject,\n  Injectable,\n  InjectionToken,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n} from '@angular/core';\nimport {Platform} from '@angular/cdk/platform';\n\n/**\n * Whether we're in a testing environment.\n * TODO(crisbeto): remove this once we have an overlay testing module.\n */\nconst isTestEnvironment: boolean = typeof window !== 'undefined' && !!window &&\n  !!((window as any).__karma__ || (window as any).jasmine);\n\n/** Container inside which all overlays will render. */\n@Injectable({providedIn: 'root'})\nexport class OverlayContainer implements OnDestroy {\n  protected _containerElement: HTMLElement;\n  protected _document: Document;\n\n  constructor(\n    @Inject(DOCUMENT) document: any,\n    /**\n     * @deprecated `platform` parameter to become required.\n     * @breaking-change 10.0.0\n     */\n    protected _platform?: Platform) {\n    this._document = document;\n  }\n\n  ngOnDestroy() {\n    const container = this._containerElement;\n\n    if (container && container.parentNode) {\n      container.parentNode.removeChild(container);\n    }\n  }\n\n  /**\n   * This method returns the overlay container element. It will lazily\n   * create the element the first time  it is called to facilitate using\n   * the container in non-browser environments.\n   * @returns the container element\n   */\n  getContainerElement(): HTMLElement {\n    if (!this._containerElement) {\n      this._createContainer();\n    }\n\n    return this._containerElement;\n  }\n\n  /**\n   * Create the overlay container element, which is simply a div\n   * with the 'cdk-overlay-container' class on the document body.\n   */\n  protected _createContainer(): void {\n    // @breaking-change 10.0.0 Remove null check for `_platform`.\n    const isBrowser = this._platform ? this._platform.isBrowser : typeof window !== 'undefined';\n    const containerClass = 'cdk-overlay-container';\n\n    if (isBrowser || isTestEnvironment) {\n      const oppositePlatformContainers =\n          this._document.querySelectorAll(`.${containerClass}[platform=\"server\"], ` +\n                                          `.${containerClass}[platform=\"test\"]`);\n\n      // Remove any old containers from the opposite platform.\n      // This can happen when transitioning from the server to the client.\n      for (let i = 0; i < oppositePlatformContainers.length; i++) {\n        oppositePlatformContainers[i].parentNode!.removeChild(oppositePlatformContainers[i]);\n      }\n    }\n\n    const container = this._document.createElement('div');\n    container.classList.add(containerClass);\n\n    // A long time ago we kept adding new overlay containers whenever a new app was instantiated,\n    // but at some point we added logic which clears the duplicate ones in order to avoid leaks.\n    // The new logic was a little too aggressive since it was breaking some legitimate use cases.\n    // To mitigate the problem we made it so that only containers from a different platform are\n    // cleared, but the side-effect was that people started depending on the overly-aggressive\n    // logic to clean up their tests for them. Until we can introduce an overlay-specific testing\n    // module which does the cleanup, we try to detect that we're in a test environment and we\n    // always clear the container. See #17006.\n    // TODO(crisbeto): remove the test environment check once we have an overlay testing module.\n    if (isTestEnvironment) {\n      container.setAttribute('platform', 'test');\n    } else if (!isBrowser) {\n      container.setAttribute('platform', 'server');\n    }\n\n    this._document.body.appendChild(container);\n    this._containerElement = container;\n  }\n}\n\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport function OVERLAY_CONTAINER_PROVIDER_FACTORY(parentContainer: OverlayContainer,\n  _document: any) {\n  return parentContainer || new OverlayContainer(_document);\n}\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport const OVERLAY_CONTAINER_PROVIDER = {\n  // If there is already an OverlayContainer available, use that. Otherwise, provide a new one.\n  provide: OverlayContainer,\n  deps: [\n    [new Optional(), new SkipSelf(), OverlayContainer],\n    DOCUMENT as InjectionToken<any> // We need to use the InjectionToken somewhere to keep TS happy\n  ],\n  useFactory: OVERLAY_CONTAINER_PROVIDER_FACTORY\n};\n"]}