text: /**
   * @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
   */
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/cdk/scrolling'), require('@angular/cdk/bidi'), require('@angular/cdk/portal'), require('rxjs/operators/take'), require('rxjs/Subject'), require('rxjs/Subscription'), require('@angular/common'), require('rxjs/operators/filter'), require('rxjs/observable/fromEvent'), require('@angular/cdk/coercion'), require('@angular/cdk/keycodes')) :
  	typeof define === 'function' && define.amd ? define(['exports', '@angular/core', '@angular/cdk/scrolling', '@angular/cdk/bidi', '@angular/cdk/portal', 'rxjs/operators/take', 'rxjs/Subject', 'rxjs/Subscription', '@angular/common', 'rxjs/operators/filter', 'rxjs/observable/fromEvent', '@angular/cdk/coercion', '@angular/cdk/keycodes'], factory) :
  	(factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.overlay = global.ng.cdk.overlay || {}),global.ng.core,global.ng.cdk.scrolling,global.ng.cdk.bidi,global.ng.cdk.portal,global.Rx.operators,global.Rx,global.Rx,global.ng.common,global.Rx.operators,global.Rx.Observable,global.ng.cdk.coercion,global.ng.cdk.keycodes));
  }(this, (function (exports,_angular_core,_angular_cdk_scrolling,_angular_cdk_bidi,_angular_cdk_portal,rxjs_operators_take,rxjs_Subject,rxjs_Subscription,_angular_common,rxjs_operators_filter,rxjs_observable_fromEvent,_angular_cdk_coercion,_angular_cdk_keycodes) { 'use strict';
  
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0
  
  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.
  
  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = Object.setPrototypeOf ||
      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
      function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = Object.assign || function __assign(t) {
      for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
      }
      return t;
  };
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Scroll strategy that doesn't do anything.
   */
  var NoopScrollStrategy = (function () {
      function NoopScrollStrategy() {
      }
      /** Does nothing, as this scroll strategy is a no-op. */
      /**
       * Does nothing, as this scroll strategy is a no-op.
       * @return {?}
       */
      NoopScrollStrategy.prototype.enable = /**
       * Does nothing, as this scroll strategy is a no-op.
       * @return {?}
       */
      function () { };
      /** Does nothing, as this scroll strategy is a no-op. */
      /**
       * Does nothing, as this scroll strategy is a no-op.
       * @return {?}
       */
      NoopScrollStrategy.prototype.disable = /**
       * Does nothing, as this scroll strategy is a no-op.
       * @return {?}
       */
      function () { };
      /** Does nothing, as this scroll strategy is a no-op. */
      /**
       * Does nothing, as this scroll strategy is a no-op.
       * @return {?}
       */
      NoopScrollStrategy.prototype.attach = /**
       * Does nothing, as this scroll strategy is a no-op.
       * @return {?}
       */
      function () { };
      return NoopScrollStrategy;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Initial configuration used when creating an overlay.
   */
  var OverlayConfig = (function () {
      function OverlayConfig(config) {
          var _this = this;
          /**
           * Strategy to be used when handling scroll events while the overlay is open.
           */
          this.scrollStrategy = new NoopScrollStrategy();
          /**
           * Custom class to add to the overlay pane.
           */
          this.panelClass = '';
          /**
           * Whether the overlay has a backdrop.
           */
          this.hasBackdrop = false;
          /**
           * Custom class to add to the backdrop
           */
          this.backdropClass = 'cdk-overlay-dark-backdrop';
          /**
           * The direction of the text in the overlay panel.
           */
          this.direction = 'ltr';
          if (config) {
              Object.keys(config).forEach(function (key) { return _this[key] = config[key]; });
          }
      }
      return OverlayConfig;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /** Horizontal dimension of a connection point on the perimeter of the origin or overlay element. */
  /**
   * A connection point on the origin element.
   * @record
   */
  
  /**
   * A connection point on the overlay element.
   * @record
   */
  
  /**
   * The points of the origin element and the overlay element to connect.
   */
  var ConnectionPositionPair = (function () {
      function ConnectionPositionPair(origin, overlay, offsetX, offsetY) {
          this.offsetX = offsetX;
          this.offsetY = offsetY;
          this.originX = origin.originX;
          this.originY = origin.originY;
          this.overlayX = overlay.overlayX;
          this.overlayY = overlay.overlayY;
      }
      return ConnectionPositionPair;
  }());
  /**
   * Set of properties regarding the position of the origin and overlay relative to the viewport
   * with respect to the containing Scrollable elements.
   *
   * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the
   * bounds of any one of the strategy's Scrollable's bounding client rectangle.
   *
   * The overlay and origin are outside view if there is no overlap between their bounding client
   * rectangle and any one of the strategy's Scrollable's bounding client rectangle.
   *
   *       -----------                    -----------
   *       | outside |                    | clipped |
   *       |  view   |              --------------------------
   *       |         |              |     |         |        |
   *       ----------               |     -----------        |
   *  --------------------------    |                        |
   *  |                        |    |      Scrollable        |
   *  |                        |    |                        |
   *  |                        |     --------------------------
   *  |      Scrollable        |
   *  |                        |
   *  --------------------------
   *
   *  \@docs-private
   */
  var ScrollingVisibility = (function () {
      function ScrollingVisibility() {
      }
      return ScrollingVisibility;
  }());
  /**
   * The change event emitted by the strategy when a fallback position is used.
   */
  var ConnectedOverlayPositionChange = (function () {
      function ConnectedOverlayPositionChange(connectionPair, /** @docs-private */
          scrollableViewProperties) {
          this.connectionPair = connectionPair;
          this.scrollableViewProperties = scrollableViewProperties;
      }
      /** @nocollapse */
      ConnectedOverlayPositionChange.ctorParameters = function () { return [
          { type: ConnectionPositionPair, },
          { type: ScrollingVisibility, decorators: [{ type: _angular_core.Optional },] },
      ]; };
      return ConnectedOverlayPositionChange;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Describes a strategy that will be used by an overlay to handle scroll events while it is open.
   * @record
   */
  
  /**
   * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.
   * @return {?}
   */
  function getMatScrollStrategyAlreadyAttachedError() {
      return Error("Scroll strategy has already been attached.");
  }
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Strategy that will close the overlay as soon as the user starts scrolling.
   */
  var CloseScrollStrategy = (function () {
      function CloseScrollStrategy(_scrollDispatcher, _ngZone) {
          this._scrollDispatcher = _scrollDispatcher;
          this._ngZone = _ngZone;
          this._scrollSubscription = null;
      }
      /** Attaches this scroll strategy to an overlay. */
      /**
       * Attaches this scroll strategy to an overlay.
       * @param {?} overlayRef
       * @return {?}
       */
      CloseScrollStrategy.prototype.attach = /**
       * Attaches this scroll strategy to an overlay.
       * @param {?} overlayRef
       * @return {?}
       */
      function (overlayRef) {
          if (this._overlayRef) {
              throw getMatScrollStrategyAlreadyAttachedError();
          }
          this._overlayRef = overlayRef;
      };
      /** Enables the closing of the attached on scroll. */
      /**
       * Enables the closing of the attached on scroll.
       * @return {?}
       */
      CloseScrollStrategy.prototype.enable = /**
       * Enables the closing of the attached on scroll.
       * @return {?}
       */
      function () {
          var _this = this;
          if (!this._scrollSubscription) {
              this._scrollSubscription = this._scrollDispatcher.scrolled(0).subscribe(function () {
                  _this._ngZone.run(function () {
                      _this.disable();
                      if (_this._overlayRef.hasAttached()) {
                          _this._overlayRef.detach();
                      }
                  });
              });
          }
      };
      /** Disables the closing the attached overlay on scroll. */
      /**
       * Disables the closing the attached overlay on scroll.
       * @return {?}
       */
      CloseScrollStrategy.prototype.disable = /**
       * Disables the closing the attached overlay on scroll.
       * @return {?}
       */
      function () {
          if (this._scrollSubscription) {
              this._scrollSubscription.unsubscribe();
              this._scrollSubscription = null;
          }
      };
      return CloseScrollStrategy;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Strategy that will prevent the user from scrolling while the overlay is visible.
   */
  var BlockScrollStrategy = (function () {
      function BlockScrollStrategy(_viewportRuler) {
          this._viewportRuler = _viewportRuler;
          this._previousHTMLStyles = { top: '', left: '' };
          this._isEnabled = false;
      }
      /** Attaches this scroll strategy to an overlay. */
      /**
       * Attaches this scroll strategy to an overlay.
       * @return {?}
       */
      BlockScrollStrategy.prototype.attach = /**
       * Attaches this scroll strategy to an overlay.
       * @return {?}
       */
      function () { };
      /** Blocks page-level scroll while the attached overlay is open. */
      /**
       * Blocks page-level scroll while the attached overlay is open.
       * @return {?}
       */
      BlockScrollStrategy.prototype.enable = /**
       * Blocks page-level scroll while the attached overlay is open.
       * @return {?}
       */
      function () {
          if (this._canBeEnabled()) {
              var /** @type {?} */ root = document.documentElement;
              this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();
              // Cache the previous inline styles in case the user had set them.
              this._previousHTMLStyles.left = root.style.left || '';
              this._previousHTMLStyles.top = root.style.top || '';
              // Note: we're using the `html` node, instead of the `body`, because the `body` may
              // have the user agent margin, whereas the `html` is guaranteed not to have one.
              root.style.left = -this._previousScrollPosition.left + "px";
              root.style.top = -this._previousScrollPosition.top + "px";
              root.classList.add('cdk-global-scrollblock');
              this._isEnabled = true;
          }
      };
      /** Unblocks page-level scroll while the attached overlay is open. */
      /**
       * Unblocks page-level scroll while the attached overlay is open.
       * @return {?}
       */
      BlockScrollStrategy.prototype.disable = /**
       * Unblocks page-level scroll while the attached overlay is open.
       * @return {?}
       */
      function () {
          if (this._isEnabled) {
              var /** @type {?} */ html = document.documentElement;
              var /** @type {?} */ body = document.body;
              var /** @type {?} */ previousHtmlScrollBehavior = html.style['scrollBehavior'] || '';
              var /** @type {?} */ previousBodyScrollBehavior = body.style['scrollBehavior'] || '';
              this._isEnabled = false;
              html.style.left = this._previousHTMLStyles.left;
              html.style.top = this._previousHTMLStyles.top;
              html.classList.remove('cdk-global-scrollblock');
              // Disable user-defined smooth scrolling temporarily while we restore the scroll position.
              // See https://developer.mozilla.org/en-US/docs/Web/CSS/scroll-behavior
              html.style['scrollBehavior'] = body.style['scrollBehavior'] = 'auto';
              window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);
              html.style['scrollBehavior'] = previousHtmlScrollBehavior;
              body.style['scrollBehavior'] = previousBodyScrollBehavior;
          }
      };
      /**
       * @return {?}
       */
      BlockScrollStrategy.prototype._canBeEnabled = /**
       * @return {?}
       */
      function () {
          // Since the scroll strategies can't be singletons, we have to use a global CSS class
          // (`cdk-global-scrollblock`) to make sure that we don't try to disable global
          // scrolling multiple times.
          if (document.documentElement.classList.contains('cdk-global-scrollblock') || this._isEnabled) {
              return false;
          }
          var /** @type {?} */ body = document.body;
          var /** @type {?} */ viewport = this._viewportRuler.getViewportSize();
          return body.scrollHeight > viewport.height || body.scrollWidth > viewport.width;
      };
      return BlockScrollStrategy;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Gets whether an element is scrolled outside of view by any of its parent scrolling containers.
   * \@docs-private
   * @param {?} element Dimensions of the element (from getBoundingClientRect)
   * @param {?} scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)
   * @return {?} Whether the element is scrolled out of view
   */
  function isElementScrolledOutsideView(element, scrollContainers) {
      return scrollContainers.some(function (containerBounds) {
          var /** @type {?} */ outsideAbove = element.bottom < containerBounds.top;
          var /** @type {?} */ outsideBelow = element.top > containerBounds.bottom;
          var /** @type {?} */ outsideLeft = element.right < containerBounds.left;
          var /** @type {?} */ outsideRight = element.left > containerBounds.right;
          return outsideAbove || outsideBelow || outsideLeft || outsideRight;
      });
  }
  /**
   * Gets whether an element is clipped by any of its scrolling containers.
   * \@docs-private
   * @param {?} element Dimensions of the element (from getBoundingClientRect)
   * @param {?} scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)
   * @return {?} Whether the element is clipped
   */
  function isElementClippedByScrolling(element, scrollContainers) {
      return scrollContainers.some(function (scrollContainerRect) {
          var /** @type {?} */ clippedAbove = element.top < scrollContainerRect.top;
          var /** @type {?} */ clippedBelow = element.bottom > scrollContainerRect.bottom;
          var /** @type {?} */ clippedLeft = element.left < scrollContainerRect.left;
          var /** @type {?} */ clippedRight = element.right > scrollContainerRect.right;
          return clippedAbove || clippedBelow || clippedLeft || clippedRight;
      });
  }
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Config options for the RepositionScrollStrategy.
   * @record
   */
  
  /**
   * Strategy that will update the element position as the user is scrolling.
   */
  var RepositionScrollStrategy = (function () {
      function RepositionScrollStrategy(_scrollDispatcher, _viewportRuler, _ngZone, _config) {
          this._scrollDispatcher = _scrollDispatcher;
          this._viewportRuler = _viewportRuler;
          this._ngZone = _ngZone;
          this._config = _config;
          this._scrollSubscription = null;
      }
      /** Attaches this scroll strategy to an overlay. */
      /**
       * Attaches this scroll strategy to an overlay.
       * @param {?} overlayRef
       * @return {?}
       */
      RepositionScrollStrategy.prototype.attach = /**
       * Attaches this scroll strategy to an overlay.
       * @param {?} overlayRef
       * @return {?}
       */
      function (overlayRef) {
          if (this._overlayRef) {
              throw getMatScrollStrategyAlreadyAttachedError();
          }
          this._overlayRef = overlayRef;
      };
      /** Enables repositioning of the attached overlay on scroll. */
      /**
       * Enables repositioning of the attached overlay on scroll.
       * @return {?}
       */
      RepositionScrollStrategy.prototype.enable = /**
       * Enables repositioning of the attached overlay on scroll.
       * @return {?}
       */
      function () {
          var _this = this;
          if (!this._scrollSubscription) {
              var /** @type {?} */ throttle = this._config ? this._config.scrollThrottle : 0;
              this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe(function () {
                  _this._overlayRef.updatePosition();
                  // TODO(crisbeto): make `close` on by default once all components can handle it.
                  if (_this._config && _this._config.autoClose) {
                      var /** @type {?} */ overlayRect = _this._overlayRef.overlayElement.getBoundingClientRect();
                      var _a = _this._viewportRuler.getViewportSize(), width = _a.width, height = _a.height;
                      // TODO(crisbeto): include all ancestor scroll containers here once
                      // we have a way of exposing the trigger element to the scroll strategy.
                      var /** @type {?} */ 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(); });
                      }
                  }
              });
          }
      };
      /** Disables repositioning of the attached overlay on scroll. */
      /**
       * Disables repositioning of the attached overlay on scroll.
       * @return {?}
       */
      RepositionScrollStrategy.prototype.disable = /**
       * Disables repositioning of the attached overlay on scroll.
       * @return {?}
       */
      function () {
          if (this._scrollSubscription) {
              this._scrollSubscription.unsubscribe();
              this._scrollSubscription = null;
          }
      };
      return RepositionScrollStrategy;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Options for how an overlay will handle scrolling.
   *
   * Users can provide a custom value for `ScrollStrategyOptions` to replace the default
   * behaviors. This class primarily acts as a factory for ScrollStrategy instances.
   */
  var ScrollStrategyOptions = (function () {
      function ScrollStrategyOptions(_scrollDispatcher, _viewportRuler, _ngZone) {
          var _this = this;
          this._scrollDispatcher = _scrollDispatcher;
          this._viewportRuler = _viewportRuler;
          this._ngZone = _ngZone;
          /**
           * Do nothing on scroll.
           */
          this.noop = function () { return new NoopScrollStrategy(); };
          /**
           * Close the overlay as soon as the user scrolls.
           */
          this.close = function () { return new CloseScrollStrategy(_this._scrollDispatcher, _this._ngZone); };
          /**
           * Block scrolling.
           */
          this.block = function () { return new BlockScrollStrategy(_this._viewportRuler); };
          /**
           * 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);
          };
      }
      ScrollStrategyOptions.decorators = [
          { type: _angular_core.Injectable },
      ];
      /** @nocollapse */
      ScrollStrategyOptions.ctorParameters = function () { return [
          { type: _angular_cdk_scrolling.ScrollDispatcher, },
          { type: _angular_cdk_scrolling.ViewportRuler, },
          { type: _angular_core.NgZone, },
      ]; };
      return ScrollStrategyOptions;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Reference to an overlay that has been created with the Overlay service.
   * Used to manipulate or dispose of said overlay.
   */
  var OverlayRef = (function () {
      function OverlayRef(_portalOutlet, _pane, _config, _ngZone, _keyboardDispatcher) {
          this._portalOutlet = _portalOutlet;
          this._pane = _pane;
          this._config = _config;
          this._ngZone = _ngZone;
          this._keyboardDispatcher = _keyboardDispatcher;
          this._backdropElement = null;
          this._backdropClick = new rxjs_Subject.Subject();
          this._attachments = new rxjs_Subject.Subject();
          this._detachments = new rxjs_Subject.Subject();
          /**
           * Stream of keydown events dispatched to this overlay.
           */
          this._keydownEvents = new rxjs_Subject.Subject();
          if (_config.scrollStrategy) {
              _config.scrollStrategy.attach(this);
          }
      }
      Object.defineProperty(OverlayRef.prototype, "overlayElement", {
          /** The overlay's HTML element */
          get: /**
           * The overlay's HTML element
           * @return {?}
           */
          function () {
              return this._pane;
          },
          enumerable: true,
          configurable: true
      });
      /**
       * Attaches content, given via a Portal, to the overlay.
       * If the overlay is configured to have a backdrop, it will be created.
       *
       * @param portal Portal instance to which to attach the overlay.
       * @returns The portal attachment result.
       */
      /**
       * Attaches content, given via a Portal, to the overlay.
       * If the overlay is configured to have a backdrop, it will be created.
       *
       * @param {?} portal Portal instance to which to attach the overlay.
       * @return {?} The portal attachment result.
       */
      OverlayRef.prototype.attach = /**
       * Attaches content, given via a Portal, to the overlay.
       * If the overlay is configured to have a backdrop, it will be created.
       *
       * @param {?} portal Portal instance to which to attach the overlay.
       * @return {?} The portal attachment result.
       */
      function (portal) {
          var _this = this;
          var /** @type {?} */ attachResult = this._portalOutlet.attach(portal);
          if (this._config.positionStrategy) {
              this._config.positionStrategy.attach(this);
          }
          // Update the pane element with the given configuration.
          this._updateStackingOrder();
          this._updateElementSize();
          this._updateElementDirection();
          if (this._config.scrollStrategy) {
              this._config.scrollStrategy.enable();
          }
          // 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.asObservable().pipe(rxjs_operators_take.take(1)).subscribe(function () {
              _this.updatePosition();
          });
          // Enable pointer events for the overlay pane element.
          this._togglePointerEvents(true);
          if (this._config.hasBackdrop) {
              this._attachBackdrop();
          }
          if (this._config.panelClass) {
              // We can't do a spread here, because IE doesn't support setting multiple classes.
              if (Array.isArray(this._config.panelClass)) {
                  this._config.panelClass.forEach(function (cls) { return _this._pane.classList.add(cls); });
              }
              else {
                  this._pane.classList.add(this._config.panelClass);
              }
          }
          // Only emit the `attachments` event once all other setup is done.
          this._attachments.next();
          // Track this overlay by the keyboard dispatcher
          this._keyboardDispatcher.add(this);
          return attachResult;
      };
      /**
       * Detaches an overlay from a portal.
       * @returns The portal detachment result.
       */
      /**
       * Detaches an overlay from a portal.
       * @return {?} The portal detachment result.
       */
      OverlayRef.prototype.detach = /**
       * Detaches an overlay from a portal.
       * @return {?} The portal detachment result.
       */
      function () {
          if (!this.hasAttached()) {
              return;
          }
          this.detachBackdrop();
          // When the overlay is detached, the pane element should disable pointer events.
          // This is necessary because otherwise the pane element will cover the page and disable
          // pointer events therefore. Depends on the position strategy and the applied pane boundaries.
          this._togglePointerEvents(false);
          if (this._config.positionStrategy && this._config.positionStrategy.detach) {
              this._config.positionStrategy.detach();
          }
          if (this._config.scrollStrategy) {
              this._config.scrollStrategy.disable();
          }
          var /** @type {?} */ detachmentResult = this._portalOutlet.detach();
          // Only emit after everything is detached.
          this._detachments.next();
          // Remove this overlay from keyboard dispatcher tracking
          this._keyboardDispatcher.remove(this);
          return detachmentResult;
      };
      /** Cleans up the overlay from the DOM. */
      /**
       * Cleans up the overlay from the DOM.
       * @return {?}
       */
      OverlayRef.prototype.dispose = /**
       * Cleans up the overlay from the DOM.
       * @return {?}
       */
      function () {
          var /** @type {?} */ isAttached = this.hasAttached();
          if (this._config.positionStrategy) {
              this._config.positionStrategy.dispose();
          }
          if (this._config.scrollStrategy) {
              this._config.scrollStrategy.disable();
          }
          this.detachBackdrop();
          this._keyboardDispatcher.remove(this);
          this._portalOutlet.dispose();
          this._attachments.complete();
          this._backdropClick.complete();
          this._keydownEvents.complete();
          if (isAttached) {
              this._detachments.next();
          }
          this._detachments.complete();
      };
      /** Whether the overlay has attached content. */
      /**
       * Whether the overlay has attached content.
       * @return {?}
       */
      OverlayRef.prototype.hasAttached = /**
       * Whether the overlay has attached content.
       * @return {?}
       */
      function () {
          return this._portalOutlet.hasAttached();
      };
      /** Gets an observable that emits when the backdrop has been clicked. */
      /**
       * Gets an observable that emits when the backdrop has been clicked.
       * @return {?}
       */
      OverlayRef.prototype.backdropClick = /**
       * Gets an observable that emits when the backdrop has been clicked.
       * @return {?}
       */
      function () {
          return this._backdropClick.asObservable();
      };
      /** Gets an observable that emits when the overlay has been attached. */
      /**
       * Gets an observable that emits when the overlay has been attached.
       * @return {?}
       */
      OverlayRef.prototype.attachments = /**
       * Gets an observable that emits when the overlay has been attached.
       * @return {?}
       */
      function () {
          return this._attachments.asObservable();
      };
      /** Gets an observable that emits when the overlay has been detached. */
      /**
       * Gets an observable that emits when the overlay has been detached.
       * @return {?}
       */
      OverlayRef.prototype.detachments = /**
       * Gets an observable that emits when the overlay has been detached.
       * @return {?}
       */
      function () {
          return this._detachments.asObservable();
      };
      /** Gets an observable of keydown events targeted to this overlay. */
      /**
       * Gets an observable of keydown events targeted to this overlay.
       * @return {?}
       */
      OverlayRef.prototype.keydownEvents = /**
       * Gets an observable of keydown events targeted to this overlay.
       * @return {?}
       */
      function () {
          return this._keydownEvents.asObservable();
      };
      /** Gets the the current overlay configuration, which is immutable. */
      /**
       * Gets the the current overlay configuration, which is immutable.
       * @return {?}
       */
      OverlayRef.prototype.getConfig = /**
       * Gets the the current overlay configuration, which is immutable.
       * @return {?}
       */
      function () {
          return this._config;
      };
      /** Updates the position of the overlay based on the position strategy. */
      /**
       * Updates the position of the overlay based on the position strategy.
       * @return {?}
       */
      OverlayRef.prototype.updatePosition = /**
       * Updates the position of the overlay based on the position strategy.
       * @return {?}
       */
      function () {
          if (this._config.positionStrategy) {
              this._config.positionStrategy.apply();
          }
      };
      /** Update the size properties of the overlay. */
      /**
       * Update the size properties of the overlay.
       * @param {?} sizeConfig
       * @return {?}
       */
      OverlayRef.prototype.updateSize = /**
       * Update the size properties of the overlay.
       * @param {?} sizeConfig
       * @return {?}
       */
      function (sizeConfig) {
          this._config = __assign({}, this._config, sizeConfig);
          this._updateElementSize();
      };
      /** Sets the LTR/RTL direction for the overlay. */
      /**
       * Sets the LTR/RTL direction for the overlay.
       * @param {?} dir
       * @return {?}
       */
      OverlayRef.prototype.setDirection = /**
       * Sets the LTR/RTL direction for the overlay.
       * @param {?} dir
       * @return {?}
       */
      function (dir) {
          this._config = __assign({}, this._config, { direction: dir });
          this._updateElementDirection();
      };
      /**
       * Updates the text direction of the overlay panel.
       * @return {?}
       */
      OverlayRef.prototype._updateElementDirection = /**
       * Updates the text direction of the overlay panel.
       * @return {?}
       */
      function () {
          this._pane.setAttribute('dir', /** @type {?} */ ((this._config.direction)));
      };
      /**
       * Updates the size of the overlay element based on the overlay config.
       * @return {?}
       */
      OverlayRef.prototype._updateElementSize = /**
       * Updates the size of the overlay element based on the overlay config.
       * @return {?}
       */
      function () {
          if (this._config.width || this._config.width === 0) {
              this._pane.style.width = formatCssUnit(this._config.width);
          }
          if (this._config.height || this._config.height === 0) {
              this._pane.style.height = formatCssUnit(this._config.height);
          }
          if (this._config.minWidth || this._config.minWidth === 0) {
              this._pane.style.minWidth = formatCssUnit(this._config.minWidth);
          }
          if (this._config.minHeight || this._config.minHeight === 0) {
              this._pane.style.minHeight = formatCssUnit(this._config.minHeight);
          }
          if (this._config.maxWidth || this._config.maxWidth === 0) {
              this._pane.style.maxWidth = formatCssUnit(this._config.maxWidth);
          }
          if (this._config.maxHeight || this._config.maxHeight === 0) {
              this._pane.style.maxHeight = formatCssUnit(this._config.maxHeight);
          }
      };
      /**
       * Toggles the pointer events for the overlay pane element.
       * @param {?} enablePointer
       * @return {?}
       */
      OverlayRef.prototype._togglePointerEvents = /**
       * Toggles the pointer events for the overlay pane element.
       * @param {?} enablePointer
       * @return {?}
       */
      function (enablePointer) {
          this._pane.style.pointerEvents = enablePointer ? 'auto' : 'none';
      };
      /**
       * Attaches a backdrop for this overlay.
       * @return {?}
       */
      OverlayRef.prototype._attachBackdrop = /**
       * Attaches a backdrop for this overlay.
       * @return {?}
       */
      function () {
          var _this = this;
          this._backdropElement = document.createElement('div');
          this._backdropElement.classList.add('cdk-overlay-backdrop');
          if (this._config.backdropClass) {
              this._backdropElement.classList.add(this._config.backdropClass);
          } /** @type {?} */
          ((
          // Insert the backdrop before the pane in the DOM order,
          // in order to handle stacked overlays properly.
          this._pane.parentElement)).insertBefore(this._backdropElement, this._pane);
          // 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 () { return _this._backdropClick.next(null); });
          // Add class to fade-in the backdrop after one frame.
          this._ngZone.runOutsideAngular(function () {
              requestAnimationFrame(function () {
                  if (_this._backdropElement) {
                      _this._backdropElement.classList.add('cdk-overlay-backdrop-showing');
                  }
              });
          });
      };
      /**
       * Updates the stacking order of the element, moving it to the top if necessary.
       * This is required in cases where one overlay was detached, while another one,
       * that should be behind it, was destroyed. The next time both of them are opened,
       * the stacking will be wrong, because the detached element's pane will still be
       * in its original DOM position.
       * @return {?}
       */
      OverlayRef.prototype._updateStackingOrder = /**
       * Updates the stacking order of the element, moving it to the top if necessary.
       * This is required in cases where one overlay was detached, while another one,
       * that should be behind it, was destroyed. The next time both of them are opened,
       * the stacking will be wrong, because the detached element's pane will still be
       * in its original DOM position.
       * @return {?}
       */
      function () {
          if (this._pane.nextSibling) {
              /** @type {?} */ ((this._pane.parentNode)).appendChild(this._pane);
          }
      };
      /** Detaches the backdrop (if any) associated with the overlay. */
      /**
       * Detaches the backdrop (if any) associated with the overlay.
       * @return {?}
       */
      OverlayRef.prototype.detachBackdrop = /**
       * Detaches the backdrop (if any) associated with the overlay.
       * @return {?}
       */
      function () {
          var _this = this;
          var /** @type {?} */ backdropToDetach = this._backdropElement;
          if (backdropToDetach) {
              var /** @type {?} */ finishDetach_1 = function () {
                  // It may not be attached to anything in certain cases (e.g. unit tests).
                  if (backdropToDetach && backdropToDetach.parentNode) {
                      backdropToDetach.parentNode.removeChild(backdropToDetach);
                  }
                  // 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.
                  if (_this._backdropElement == backdropToDetach) {
                      _this._backdropElement = null;
                  }
              };
              backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
              if (this._config.backdropClass) {
                  backdropToDetach.classList.remove(this._config.backdropClass);
              }
              backdropToDetach.addEventListener('transitionend', finishDetach_1);
              // 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.
              this._ngZone.runOutsideAngular(function () {
                  setTimeout(finishDetach_1, 500);
              });
          }
      };
      return OverlayRef;
  }());
  /**
   * @param {?} value
   * @return {?}
   */
  function formatCssUnit(value) {
      return typeof value === 'string' ? /** @type {?} */ (value) : value + "px";
  }
  /**
   * Size properties for an overlay.
   * @record
   */
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * A strategy for positioning overlays. Using this strategy, an overlay is given an
   * implicit position relative some origin element. The relative position is defined in terms of
   * a point on the origin element that is connected to a point on the overlay element. For example,
   * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner
   * of the overlay.
   */
  var ConnectedPositionStrategy = (function () {
      function ConnectedPositionStrategy(originPos, overlayPos, _connectedTo, _viewportRuler, _document) {
          this._connectedTo = _connectedTo;
          this._viewportRuler = _viewportRuler;
          this._document = _document;
          /**
           * Layout direction of the position strategy.
           */
          this._dir = 'ltr';
          /**
           * The offset in pixels for the overlay connection point on the x-axis
           */
          this._offsetX = 0;
          /**
           * The offset in pixels for the overlay connection point on the y-axis
           */
          this._offsetY = 0;
          /**
           * The Scrollable containers used to check scrollable view properties on position change.
           */
          this.scrollables = [];
          /**
           * Subscription to viewport resize events.
           */
          this._resizeSubscription = rxjs_Subscription.Subscription.EMPTY;
          /**
           * Ordered list of preferred positions, from most to least desirable.
           */
          this._preferredPositions = [];
          /**
           * Whether the position strategy is applied currently.
           */
          this._applied = false;
          /**
           * Whether the overlay position is locked.
           */
          this._positionLocked = false;
          this._onPositionChange = new rxjs_Subject.Subject();
          this._origin = this._connectedTo.nativeElement;
          this.withFallbackPosition(originPos, overlayPos);
      }
      Object.defineProperty(ConnectedPositionStrategy.prototype, "_isRtl", {
          /** Whether the we're dealing with an RTL context */
          get: /**
           * Whether the we're dealing with an RTL context
           * @return {?}
           */
          function () {
              return this._dir === 'rtl';
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(ConnectedPositionStrategy.prototype, "onPositionChange", {
          /** Emits an event when the connection point changes. */
          get: /**
           * Emits an event when the connection point changes.
           * @return {?}
           */
          function () {
              return this._onPositionChange.asObservable();
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(ConnectedPositionStrategy.prototype, "positions", {
          /** Ordered list of preferred positions, from most to least desirable. */
          get: /**
           * Ordered list of preferred positions, from most to least desirable.
           * @return {?}
           */
          function () {
              return this._preferredPositions;
          },
          enumerable: true,
          configurable: true
      });
      /** Attach this position strategy to an overlay. */
      /**
       * Attach this position strategy to an overlay.
       * @param {?} overlayRef
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.attach = /**
       * Attach this position strategy to an overlay.
       * @param {?} overlayRef
       * @return {?}
       */
      function (overlayRef) {
          var _this = this;
          this._overlayRef = overlayRef;
          this._pane = overlayRef.overlayElement;
          this._resizeSubscription.unsubscribe();
          this._resizeSubscription = this._viewportRuler.change().subscribe(function () { return _this.apply(); });
      };
      /** Disposes all resources used by the position strategy. */
      /**
       * Disposes all resources used by the position strategy.
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.dispose = /**
       * Disposes all resources used by the position strategy.
       * @return {?}
       */
      function () {
          this._applied = false;
          this._resizeSubscription.unsubscribe();
      };
      /** @docs-private */
      /**
       * \@docs-private
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.detach = /**
       * \@docs-private
       * @return {?}
       */
      function () {
          this._applied = false;
          this._resizeSubscription.unsubscribe();
      };
      /**
       * Updates the position of the overlay element, using whichever preferred position relative
       * to the origin fits on-screen.
       * @docs-private
       */
      /**
       * Updates the position of the overlay element, using whichever preferred position relative
       * to the origin fits on-screen.
       * \@docs-private
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.apply = /**
       * Updates the position of the overlay element, using whichever preferred position relative
       * to the origin fits on-screen.
       * \@docs-private
       * @return {?}
       */
      function () {
          // If the position has been applied already (e.g. when the overlay was opened) and the
          // consumer opted into locking in the position, re-use the  old position, in order to
          // prevent the overlay from jumping around.
          if (this._applied && this._positionLocked && this._lastConnectedPosition) {
              this.recalculateLastPosition();
              return;
          }
          this._applied = true;
          // We need the bounding rects for the origin and the overlay to determine how to position
          // the overlay relative to the origin.
          var /** @type {?} */ element = this._pane;
          var /** @type {?} */ originRect = this._origin.getBoundingClientRect();
          var /** @type {?} */ overlayRect = element.getBoundingClientRect();
          // We use the viewport size to determine whether a position would go off-screen.
          var /** @type {?} */ viewportSize = this._viewportRuler.getViewportSize();
          // Fallback point if none of the fallbacks fit into the viewport.
          var /** @type {?} */ fallbackPoint;
          var /** @type {?} */ fallbackPosition;
          // We want to place the overlay in the first of the preferred positions such that the
          // overlay fits on-screen.
          for (var _i = 0, _a = this._preferredPositions; _i < _a.length; _i++) {
              var pos = _a[_i];
              // Get the (x, y) point of connection on the origin, and then use that to get the
              // (top, left) coordinate for the overlay at `pos`.
              var /** @type {?} */ originPoint = this._getOriginConnectionPoint(originRect, pos);
              var /** @type {?} */ overlayPoint = this._getOverlayPoint(originPoint, overlayRect, viewportSize, pos);
              // If the overlay in the calculated position fits on-screen, put it there and we're done.
              if (overlayPoint.fitsInViewport) {
                  this._setElementPosition(element, overlayRect, overlayPoint, pos);
                  // Save the last connected position in case the position needs to be re-calculated.
                  this._lastConnectedPosition = pos;
                  return;
              }
              else if (!fallbackPoint || fallbackPoint.visibleArea < overlayPoint.visibleArea) {
                  fallbackPoint = overlayPoint;
                  fallbackPosition = pos;
              }
          }
          // If none of the preferred positions were in the viewport, take the one
          // with the largest visible area.
          this._setElementPosition(element, overlayRect, /** @type {?} */ ((fallbackPoint)), /** @type {?} */ ((fallbackPosition)));
      };
      /**
       * Re-positions the overlay element with the trigger in its last calculated position,
       * even if a position higher in the "preferred positions" list would now fit. This
       * allows one to re-align the panel without changing the orientation of the panel.
       */
      /**
       * Re-positions the overlay element with the trigger in its last calculated position,
       * even if a position higher in the "preferred positions" list would now fit. This
       * allows one to re-align the panel without changing the orientation of the panel.
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.recalculateLastPosition = /**
       * Re-positions the overlay element with the trigger in its last calculated position,
       * even if a position higher in the "preferred positions" list would now fit. This
       * allows one to re-align the panel without changing the orientation of the panel.
       * @return {?}
       */
      function () {
          // If the overlay has never been positioned before, do nothing.
          if (!this._lastConnectedPosition) {
              return;
          }
          var /** @type {?} */ originRect = this._origin.getBoundingClientRect();
          var /** @type {?} */ overlayRect = this._pane.getBoundingClientRect();
          var /** @type {?} */ viewportSize = this._viewportRuler.getViewportSize();
          var /** @type {?} */ lastPosition = this._lastConnectedPosition || this._preferredPositions[0];
          var /** @type {?} */ originPoint = this._getOriginConnectionPoint(originRect, lastPosition);
          var /** @type {?} */ overlayPoint = this._getOverlayPoint(originPoint, overlayRect, viewportSize, lastPosition);
          this._setElementPosition(this._pane, overlayRect, overlayPoint, lastPosition);
      };
      /**
       * Sets the list of Scrollable containers that host the origin element so that
       * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
       * Scrollable must be an ancestor element of the strategy's origin element.
       */
      /**
       * Sets the list of Scrollable containers that host the origin element so that
       * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
       * Scrollable must be an ancestor element of the strategy's origin element.
       * @param {?} scrollables
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.withScrollableContainers = /**
       * Sets the list of Scrollable containers that host the origin element so that
       * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
       * Scrollable must be an ancestor element of the strategy's origin element.
       * @param {?} scrollables
       * @return {?}
       */
      function (scrollables) {
          this.scrollables = scrollables;
      };
      /**
       * Adds a new preferred fallback position.
       * @param originPos
       * @param overlayPos
       */
      /**
       * Adds a new preferred fallback position.
       * @param {?} originPos
       * @param {?} overlayPos
       * @param {?=} offsetX
       * @param {?=} offsetY
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.withFallbackPosition = /**
       * Adds a new preferred fallback position.
       * @param {?} originPos
       * @param {?} overlayPos
       * @param {?=} offsetX
       * @param {?=} offsetY
       * @return {?}
       */
      function (originPos, overlayPos, offsetX, offsetY) {
          var /** @type {?} */ position = new ConnectionPositionPair(originPos, overlayPos, offsetX, offsetY);
          this._preferredPositions.push(position);
          return this;
      };
      /**
       * Sets the layout direction so the overlay's position can be adjusted to match.
       * @param dir New layout direction.
       */
      /**
       * Sets the layout direction so the overlay's position can be adjusted to match.
       * @param {?} dir New layout direction.
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.withDirection = /**
       * Sets the layout direction so the overlay's position can be adjusted to match.
       * @param {?} dir New layout direction.
       * @return {?}
       */
      function (dir) {
          this._dir = dir;
          return this;
      };
      /**
       * Sets an offset for the overlay's connection point on the x-axis
       * @param offset New offset in the X axis.
       */
      /**
       * Sets an offset for the overlay's connection point on the x-axis
       * @param {?} offset New offset in the X axis.
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.withOffsetX = /**
       * Sets an offset for the overlay's connection point on the x-axis
       * @param {?} offset New offset in the X axis.
       * @return {?}
       */
      function (offset) {
          this._offsetX = offset;
          return this;
      };
      /**
       * Sets an offset for the overlay's connection point on the y-axis
       * @param  offset New offset in the Y axis.
       */
      /**
       * Sets an offset for the overlay's connection point on the y-axis
       * @param {?} offset New offset in the Y axis.
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.withOffsetY = /**
       * Sets an offset for the overlay's connection point on the y-axis
       * @param {?} offset New offset in the Y axis.
       * @return {?}
       */
      function (offset) {
          this._offsetY = offset;
          return this;
      };
      /**
       * Sets whether the overlay's position should be locked in after it is positioned
       * initially. When an overlay is locked in, it won't attempt to reposition itself
       * when the position is re-applied (e.g. when the user scrolls away).
       * @param isLocked Whether the overlay should locked in.
       */
      /**
       * Sets whether the overlay's position should be locked in after it is positioned
       * initially. When an overlay is locked in, it won't attempt to reposition itself
       * when the position is re-applied (e.g. when the user scrolls away).
       * @param {?} isLocked Whether the overlay should locked in.
       * @return {?}
       */
      ConnectedPositionStrategy.prototype.withLockedPosition = /**
       * Sets whether the overlay's position should be locked in after it is positioned
       * initially. When an overlay is locked in, it won't attempt to reposition itself
       * when the position is re-applied (e.g. when the user scrolls away).
       * @param {?} isLocked Whether the overlay should locked in.
       * @return {?}
       */
      function (isLocked) {
          this._positionLocked = isLocked;
          return this;
      };
      /**
       * Gets the horizontal (x) "start" dimension based on whether the overlay is in an RTL context.
       * @param {?} rect
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._getStartX = /**
       * Gets the horizontal (x) "start" dimension based on whether the overlay is in an RTL context.
       * @param {?} rect
       * @return {?}
       */
      function (rect) {
          return this._isRtl ? rect.right : rect.left;
      };
      /**
       * Gets the horizontal (x) "end" dimension based on whether the overlay is in an RTL context.
       * @param {?} rect
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._getEndX = /**
       * Gets the horizontal (x) "end" dimension based on whether the overlay is in an RTL context.
       * @param {?} rect
       * @return {?}
       */
      function (rect) {
          return this._isRtl ? rect.left : rect.right;
      };
      /**
       * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.
       * @param {?} originRect
       * @param {?} pos
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._getOriginConnectionPoint = /**
       * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.
       * @param {?} originRect
       * @param {?} pos
       * @return {?}
       */
      function (originRect, pos) {
          var /** @type {?} */ originStartX = this._getStartX(originRect);
          var /** @type {?} */ originEndX = this._getEndX(originRect);
          var /** @type {?} */ x;
          if (pos.originX == 'center') {
              x = originStartX + (originRect.width / 2);
          }
          else {
              x = pos.originX == 'start' ? originStartX : originEndX;
          }
          var /** @type {?} */ y;
          if (pos.originY == 'center') {
              y = originRect.top + (originRect.height / 2);
          }
          else {
              y = pos.originY == 'top' ? originRect.top : originRect.bottom;
          }
          return { x: x, y: y };
      };
      /**
       * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and
       * origin point to which the overlay should be connected, as well as how much of the element
       * would be inside the viewport at that position.
       * @param {?} originPoint
       * @param {?} overlayRect
       * @param {?} viewportSize
       * @param {?} pos
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._getOverlayPoint = /**
       * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and
       * origin point to which the overlay should be connected, as well as how much of the element
       * would be inside the viewport at that position.
       * @param {?} originPoint
       * @param {?} overlayRect
       * @param {?} viewportSize
       * @param {?} pos
       * @return {?}
       */
      function (originPoint, overlayRect, viewportSize, pos) {
          // Calculate the (overlayStartX, overlayStartY), the start of the potential overlay position
          // relative to the origin point.
          var /** @type {?} */ overlayStartX;
          if (pos.overlayX == 'center') {
              overlayStartX = -overlayRect.width / 2;
          }
          else if (pos.overlayX === 'start') {
              overlayStartX = this._isRtl ? -overlayRect.width : 0;
          }
          else {
              overlayStartX = this._isRtl ? 0 : -overlayRect.width;
          }
          var /** @type {?} */ overlayStartY;
          if (pos.overlayY == 'center') {
              overlayStartY = -overlayRect.height / 2;
          }
          else {
              overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;
          }
          // The (x, y) offsets of the overlay based on the current position.
          var /** @type {?} */ offsetX = typeof pos.offsetX === 'undefined' ? this._offsetX : pos.offsetX;
          var /** @type {?} */ offsetY = typeof pos.offsetY === 'undefined' ? this._offsetY : pos.offsetY;
          // The (x, y) coordinates of the overlay.
          var /** @type {?} */ x = originPoint.x + overlayStartX + offsetX;
          var /** @type {?} */ y = originPoint.y + overlayStartY + offsetY;
          // How much the overlay would overflow at this position, on each side.
          var /** @type {?} */ leftOverflow = 0 - x;
          var /** @type {?} */ rightOverflow = (x + overlayRect.width) - viewportSize.width;
          var /** @type {?} */ topOverflow = 0 - y;
          var /** @type {?} */ bottomOverflow = (y + overlayRect.height) - viewportSize.height;
          // Visible parts of the element on each axis.
          var /** @type {?} */ visibleWidth = this._subtractOverflows(overlayRect.width, leftOverflow, rightOverflow);
          var /** @type {?} */ visibleHeight = this._subtractOverflows(overlayRect.height, topOverflow, bottomOverflow);
          // The area of the element that's within the viewport.
          var /** @type {?} */ visibleArea = visibleWidth * visibleHeight;
          var /** @type {?} */ fitsInViewport = (overlayRect.width * overlayRect.height) === visibleArea;
          return { x: x, y: y, fitsInViewport: fitsInViewport, visibleArea: visibleArea };
      };
      /**
       * Gets the view properties of the trigger and overlay, including whether they are clipped
       * or completely outside the view of any of the strategy's scrollables.
       * @param {?} overlay
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._getScrollVisibility = /**
       * Gets the view properties of the trigger and overlay, including whether they are clipped
       * or completely outside the view of any of the strategy's scrollables.
       * @param {?} overlay
       * @return {?}
       */
      function (overlay) {
          var /** @type {?} */ originBounds = this._origin.getBoundingClientRect();
          var /** @type {?} */ overlayBounds = overlay.getBoundingClientRect();
          var /** @type {?} */ scrollContainerBounds = this.scrollables.map(function (s) { return s.getElementRef().nativeElement.getBoundingClientRect(); });
          return {
              isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),
              isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),
              isOverlayClipped: isElementClippedByScrolling(overlayBounds, scrollContainerBounds),
              isOverlayOutsideView: isElementScrolledOutsideView(overlayBounds, scrollContainerBounds),
          };
      };
      /**
       * Physically positions the overlay element to the given coordinate.
       * @param {?} element
       * @param {?} overlayRect
       * @param {?} overlayPoint
       * @param {?} pos
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._setElementPosition = /**
       * Physically positions the overlay element to the given coordinate.
       * @param {?} element
       * @param {?} overlayRect
       * @param {?} overlayPoint
       * @param {?} pos
       * @return {?}
       */
      function (element, overlayRect, overlayPoint, pos) {
          // We want to set either `top` or `bottom` based on whether the overlay wants to appear above
          // or below the origin and the direction in which the element will expand.
          var /** @type {?} */ verticalStyleProperty = pos.overlayY === 'bottom' ? 'bottom' : 'top';
          // When using `bottom`, we adjust the y position such that it is the distance
          // from the bottom of the viewport rather than the top.
          var /** @type {?} */ y = verticalStyleProperty === 'top' ?
              overlayPoint.y :
              this._document.documentElement.clientHeight - (overlayPoint.y + overlayRect.height);
          // We want to set either `left` or `right` based on whether the overlay wants to appear "before"
          // or "after" the origin, which determines the direction in which the element will expand.
          // For the horizontal axis, the meaning of "before" and "after" change based on whether the
          // page is in RTL or LTR.
          var /** @type {?} */ horizontalStyleProperty;
          if (this._dir === 'rtl') {
              horizontalStyleProperty = pos.overlayX === 'end' ? 'left' : 'right';
          }
          else {
              horizontalStyleProperty = pos.overlayX === 'end' ? 'right' : 'left';
          }
          // When we're setting `right`, we adjust the x position such that it is the distance
          // from the right edge of the viewport rather than the left edge.
          var /** @type {?} */ x = horizontalStyleProperty === 'left' ?
              overlayPoint.x :
              this._document.documentElement.clientWidth - (overlayPoint.x + overlayRect.width);
          // Reset any existing styles. This is necessary in case the preferred position has
          // changed since the last `apply`.
          ['top', 'bottom', 'left', 'right'].forEach(function (p) { return element.style[p] = null; });
          element.style[verticalStyleProperty] = y + "px";
          element.style[horizontalStyleProperty] = x + "px";
          // Notify that the position has been changed along with its change properties.
          var /** @type {?} */ scrollableViewProperties = this._getScrollVisibility(element);
          var /** @type {?} */ positionChange = new ConnectedOverlayPositionChange(pos, scrollableViewProperties);
          this._onPositionChange.next(positionChange);
      };
      /**
       * Subtracts the amount that an element is overflowing on an axis from it's length.
       * @param {?} length
       * @param {...?} overflows
       * @return {?}
       */
      ConnectedPositionStrategy.prototype._subtractOverflows = /**
       * Subtracts the amount that an element is overflowing on an axis from it's length.
       * @param {?} length
       * @param {...?} overflows
       * @return {?}
       */
      function (length) {
          var overflows = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              overflows[_i - 1] = arguments[_i];
          }
          return overflows.reduce(function (currentValue, currentOverflow) {
              return currentValue - Math.max(currentOverflow, 0);
          }, length);
      };
      return ConnectedPositionStrategy;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * A strategy for positioning overlays. Using this strategy, an overlay is given an
   * explicit position relative to the browser's viewport. We use flexbox, instead of
   * transforms, in order to avoid issues with subpixel rendering which can cause the
   * element to become blurry.
   */
  var GlobalPositionStrategy = (function () {
      function GlobalPositionStrategy(_document) {
          this._document = _document;
          this._cssPosition = 'static';
          this._topOffset = '';
          this._bottomOffset = '';
          this._leftOffset = '';
          this._rightOffset = '';
          this._alignItems = '';
          this._justifyContent = '';
          this._width = '';
          this._height = '';
          this._wrapper = null;
      }
      /**
       * @param {?} overlayRef
       * @return {?}
       */
      GlobalPositionStrategy.prototype.attach = /**
       * @param {?} overlayRef
       * @return {?}
       */
      function (overlayRef) {
          this._overlayRef = overlayRef;
      };
      /**
       * Sets the top position of the overlay. Clears any previously set vertical position.
       * @param value New top offset.
       */
      /**
       * Sets the top position of the overlay. Clears any previously set vertical position.
       * @param {?=} value New top offset.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.top = /**
       * Sets the top position of the overlay. Clears any previously set vertical position.
       * @param {?=} value New top offset.
       * @return {?}
       */
      function (value) {
          if (value === void 0) { value = ''; }
          this._bottomOffset = '';
          this._topOffset = value;
          this._alignItems = 'flex-start';
          return this;
      };
      /**
       * Sets the left position of the overlay. Clears any previously set horizontal position.
       * @param value New left offset.
       */
      /**
       * Sets the left position of the overlay. Clears any previously set horizontal position.
       * @param {?=} value New left offset.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.left = /**
       * Sets the left position of the overlay. Clears any previously set horizontal position.
       * @param {?=} value New left offset.
       * @return {?}
       */
      function (value) {
          if (value === void 0) { value = ''; }
          this._rightOffset = '';
          this._leftOffset = value;
          this._justifyContent = 'flex-start';
          return this;
      };
      /**
       * Sets the bottom position of the overlay. Clears any previously set vertical position.
       * @param value New bottom offset.
       */
      /**
       * Sets the bottom position of the overlay. Clears any previously set vertical position.
       * @param {?=} value New bottom offset.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.bottom = /**
       * Sets the bottom position of the overlay. Clears any previously set vertical position.
       * @param {?=} value New bottom offset.
       * @return {?}
       */
      function (value) {
          if (value === void 0) { value = ''; }
          this._topOffset = '';
          this._bottomOffset = value;
          this._alignItems = 'flex-end';
          return this;
      };
      /**
       * Sets the right position of the overlay. Clears any previously set horizontal position.
       * @param value New right offset.
       */
      /**
       * Sets the right position of the overlay. Clears any previously set horizontal position.
       * @param {?=} value New right offset.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.right = /**
       * Sets the right position of the overlay. Clears any previously set horizontal position.
       * @param {?=} value New right offset.
       * @return {?}
       */
      function (value) {
          if (value === void 0) { value = ''; }
          this._leftOffset = '';
          this._rightOffset = value;
          this._justifyContent = 'flex-end';
          return this;
      };
      /**
       * Sets the overlay width and clears any previously set width.
       * @param value New width for the overlay
       */
      /**
       * Sets the overlay width and clears any previously set width.
       * @param {?=} value New width for the overlay
       * @return {?}
       */
      GlobalPositionStrategy.prototype.width = /**
       * Sets the overlay width and clears any previously set width.
       * @param {?=} value New width for the overlay
       * @return {?}
       */
      function (value) {
          if (value === void 0) { value = ''; }
          this._width = value;
          // When the width is 100%, we should reset the `left` and the offset,
          // in order to ensure that the element is flush against the viewport edge.
          if (value === '100%') {
              this.left('0px');
          }
          return this;
      };
      /**
       * Sets the overlay height and clears any previously set height.
       * @param value New height for the overlay
       */
      /**
       * Sets the overlay height and clears any previously set height.
       * @param {?=} value New height for the overlay
       * @return {?}
       */
      GlobalPositionStrategy.prototype.height = /**
       * Sets the overlay height and clears any previously set height.
       * @param {?=} value New height for the overlay
       * @return {?}
       */
      function (value) {
          if (value === void 0) { value = ''; }
          this._height = value;
          // When the height is 100%, we should reset the `top` and the offset,
          // in order to ensure that the element is flush against the viewport edge.
          if (value === '100%') {
              this.top('0px');
          }
          return this;
      };
      /**
       * Centers the overlay horizontally with an optional offset.
       * Clears any previously set horizontal position.
       *
       * @param offset Overlay offset from the horizontal center.
       */
      /**
       * Centers the overlay horizontally with an optional offset.
       * Clears any previously set horizontal position.
       *
       * @param {?=} offset Overlay offset from the horizontal center.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.centerHorizontally = /**
       * Centers the overlay horizontally with an optional offset.
       * Clears any previously set horizontal position.
       *
       * @param {?=} offset Overlay offset from the horizontal center.
       * @return {?}
       */
      function (offset) {
          if (offset === void 0) { offset = ''; }
          this.left(offset);
          this._justifyContent = 'center';
          return this;
      };
      /**
       * Centers the overlay vertically with an optional offset.
       * Clears any previously set vertical position.
       *
       * @param offset Overlay offset from the vertical center.
       */
      /**
       * Centers the overlay vertically with an optional offset.
       * Clears any previously set vertical position.
       *
       * @param {?=} offset Overlay offset from the vertical center.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.centerVertically = /**
       * Centers the overlay vertically with an optional offset.
       * Clears any previously set vertical position.
       *
       * @param {?=} offset Overlay offset from the vertical center.
       * @return {?}
       */
      function (offset) {
          if (offset === void 0) { offset = ''; }
          this.top(offset);
          this._alignItems = 'center';
          return this;
      };
      /**
       * Apply the position to the element.
       * @docs-private
       *
       * @returns Resolved when the styles have been applied.
       */
      /**
       * Apply the position to the element.
       * \@docs-private
       *
       * @return {?} Resolved when the styles have been applied.
       */
      GlobalPositionStrategy.prototype.apply = /**
       * Apply the position to the element.
       * \@docs-private
       *
       * @return {?} Resolved when the styles have been applied.
       */
      function () {
          var /** @type {?} */ element = this._overlayRef.overlayElement;
          if (!this._wrapper && element.parentNode) {
              this._wrapper = this._document.createElement('div'); /** @type {?} */
              ((this._wrapper)).classList.add('cdk-global-overlay-wrapper');
              element.parentNode.insertBefore(/** @type {?} */ ((this._wrapper)), element); /** @type {?} */
              ((this._wrapper)).appendChild(element);
          }
          var /** @type {?} */ styles = element.style;
          var /** @type {?} */ parentStyles = (/** @type {?} */ (element.parentNode)).style;
          styles.position = this._cssPosition;
          styles.marginTop = this._topOffset;
          styles.marginLeft = this._leftOffset;
          styles.marginBottom = this._bottomOffset;
          styles.marginRight = this._rightOffset;
          styles.width = this._width;
          styles.height = this._height;
          parentStyles.justifyContent = this._justifyContent;
          parentStyles.alignItems = this._alignItems;
      };
      /** Removes the wrapper element from the DOM. */
      /**
       * Removes the wrapper element from the DOM.
       * @return {?}
       */
      GlobalPositionStrategy.prototype.dispose = /**
       * Removes the wrapper element from the DOM.
       * @return {?}
       */
      function () {
          if (this._wrapper && this._wrapper.parentNode) {
              this._wrapper.parentNode.removeChild(this._wrapper);
              this._wrapper = null;
          }
      };
      return GlobalPositionStrategy;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Builder for overlay position strategy.
   */
  var OverlayPositionBuilder = (function () {
      function OverlayPositionBuilder(_viewportRuler, _document) {
          this._viewportRuler = _viewportRuler;
          this._document = _document;
      }
      /**
       * Creates a global position strategy.
       */
      /**
       * Creates a global position strategy.
       * @return {?}
       */
      OverlayPositionBuilder.prototype.global = /**
       * Creates a global position strategy.
       * @return {?}
       */
      function () {
          return new GlobalPositionStrategy(this._document);
      };
      /**
       * Creates a relative position strategy.
       * @param elementRef
       * @param originPos
       * @param overlayPos
       */
      /**
       * Creates a relative position strategy.
       * @param {?} elementRef
       * @param {?} originPos
       * @param {?} overlayPos
       * @return {?}
       */
      OverlayPositionBuilder.prototype.connectedTo = /**
       * Creates a relative position strategy.
       * @param {?} elementRef
       * @param {?} originPos
       * @param {?} overlayPos
       * @return {?}
       */
      function (elementRef, originPos, overlayPos) {
          return new ConnectedPositionStrategy(originPos, overlayPos, elementRef, this._viewportRuler, this._document);
      };
      OverlayPositionBuilder.decorators = [
          { type: _angular_core.Injectable },
      ];
      /** @nocollapse */
      OverlayPositionBuilder.ctorParameters = function () { return [
          { type: _angular_cdk_scrolling.ViewportRuler, },
          { type: undefined, decorators: [{ type: _angular_core.Inject, args: [_angular_common.DOCUMENT,] },] },
      ]; };
      return OverlayPositionBuilder;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Service for dispatching keyboard 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.
   */
  var OverlayKeyboardDispatcher = (function () {
      function OverlayKeyboardDispatcher(_document) {
          this._document = _document;
          /**
           * Currently attached overlays in the order they were attached.
           */
          this._attachedOverlays = [];
      }
      /**
       * @return {?}
       */
      OverlayKeyboardDispatcher.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._unsubscribeFromKeydownEvents();
      };
      /** Add a new overlay to the list of attached overlay refs. */
      /**
       * Add a new overlay to the list of attached overlay refs.
       * @param {?} overlayRef
       * @return {?}
       */
      OverlayKeyboardDispatcher.prototype.add = /**
       * Add a new overlay to the list of attached overlay refs.
       * @param {?} overlayRef
       * @return {?}
       */
      function (overlayRef) {
          // Lazily start dispatcher once first overlay is added
          if (!this._keydownEventSubscription) {
              this._subscribeToKeydownEvents();
          }
          this._attachedOverlays.push(overlayRef);
      };
      /** Remove an overlay from the list of attached overlay refs. */
      /**
       * Remove an overlay from the list of attached overlay refs.
       * @param {?} overlayRef
       * @return {?}
       */
      OverlayKeyboardDispatcher.prototype.remove = /**
       * Remove an overlay from the list of attached overlay refs.
       * @param {?} overlayRef
       * @return {?}
       */
      function (overlayRef) {
          var /** @type {?} */ index = this._attachedOverlays.indexOf(overlayRef);
          if (index > -1) {
              this._attachedOverlays.splice(index, 1);
          }
          // Remove the global listener once there are no more overlays.
          if (this._attachedOverlays.length === 0) {
              this._unsubscribeFromKeydownEvents();
          }
      };
      /**
       * Subscribe to keydown events that land on the body and dispatch those
       * events to the appropriate overlay.
       * @return {?}
       */
      OverlayKeyboardDispatcher.prototype._subscribeToKeydownEvents = /**
       * Subscribe to keydown events that land on the body and dispatch those
       * events to the appropriate overlay.
       * @return {?}
       */
      function () {
          var _this = this;
          var /** @type {?} */ bodyKeydownEvents = rxjs_observable_fromEvent.fromEvent(this._document.body, 'keydown');
          this._keydownEventSubscription = bodyKeydownEvents.pipe(rxjs_operators_filter.filter(function () { return !!_this._attachedOverlays.length; })).subscribe(function (event) {
              // Dispatch keydown event to correct overlay reference
              // Dispatch keydown event to correct overlay reference
              _this._selectOverlayFromEvent(event)._keydownEvents.next(event);
          });
      };
      /**
       * Removes the global keydown subscription.
       * @return {?}
       */
      OverlayKeyboardDispatcher.prototype._unsubscribeFromKeydownEvents = /**
       * Removes the global keydown subscription.
       * @return {?}
       */
      function () {
          if (this._keydownEventSubscription) {
              this._keydownEventSubscription.unsubscribe();
              this._keydownEventSubscription = null;
          }
      };
      /**
       * Select the appropriate overlay from a keydown event.
       * @param {?} event
       * @return {?}
       */
      OverlayKeyboardDispatcher.prototype._selectOverlayFromEvent = /**
       * Select the appropriate overlay from a keydown event.
       * @param {?} event
       * @return {?}
       */
      function (event) {
          // Check if any overlays contain the event
          var /** @type {?} */ targetedOverlay = this._attachedOverlays.find(function (overlay) {
              return overlay.overlayElement === event.target ||
                  overlay.overlayElement.contains(/** @type {?} */ (event.target));
          });
          // Use that overlay if it exists, otherwise choose the most recently attached one
          return targetedOverlay || this._attachedOverlays[this._attachedOverlays.length - 1];
      };
      OverlayKeyboardDispatcher.decorators = [
          { type: _angular_core.Injectable },
      ];
      /** @nocollapse */
      OverlayKeyboardDispatcher.ctorParameters = function () { return [
          { type: undefined, decorators: [{ type: _angular_core.Inject, args: [_angular_common.DOCUMENT,] },] },
      ]; };
      return OverlayKeyboardDispatcher;
  }());
  /**
   * \@docs-private
   * @param {?} dispatcher
   * @param {?} _document
   * @return {?}
   */
  function OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY(dispatcher, _document) {
      return dispatcher || new OverlayKeyboardDispatcher(_document);
  }
  /**
   * \@docs-private
   */
  var OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {
      // If there is already an OverlayKeyboardDispatcher available, use that.
      // Otherwise, provide a new one.
      provide: OverlayKeyboardDispatcher,
      deps: [
          [new _angular_core.Optional(), new _angular_core.SkipSelf(), OverlayKeyboardDispatcher],
          /** @type {?} */ (
          // Coerce to `InjectionToken` so that the `deps` match the "shape"
          // of the type expected by Angular
          _angular_common.DOCUMENT)
      ],
      useFactory: OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY
  };
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Container inside which all overlays will render.
   */
  var OverlayContainer = (function () {
      function OverlayContainer(_document) {
          this._document = _document;
      }
      /**
       * @return {?}
       */
      OverlayContainer.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          if (this._containerElement && this._containerElement.parentNode) {
              this._containerElement.parentNode.removeChild(this._containerElement);
          }
      };
      /**
       * 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
       */
      /**
       * 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.
       * @return {?} the container element
       */
      OverlayContainer.prototype.getContainerElement = /**
       * 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.
       * @return {?} the container element
       */
      function () {
          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.
       */
      /**
       * Create the overlay container element, which is simply a div
       * with the 'cdk-overlay-container' class on the document body.
       * @return {?}
       */
      OverlayContainer.prototype._createContainer = /**
       * Create the overlay container element, which is simply a div
       * with the 'cdk-overlay-container' class on the document body.
       * @return {?}
       */
      function () {
          var /** @type {?} */ container = this._document.createElement('div');
          container.classList.add('cdk-overlay-container');
          this._document.body.appendChild(container);
          this._containerElement = container;
      };
      OverlayContainer.decorators = [
          { type: _angular_core.Injectable },
      ];
      /** @nocollapse */
      OverlayContainer.ctorParameters = function () { return [
          { type: undefined, decorators: [{ type: _angular_core.Inject, args: [_angular_common.DOCUMENT,] },] },
      ]; };
      return OverlayContainer;
  }());
  /**
   * \@docs-private
   * @param {?} parentContainer
   * @param {?} _document
   * @return {?}
   */
  function OVERLAY_CONTAINER_PROVIDER_FACTORY(parentContainer, _document) {
      return parentContainer || new OverlayContainer(_document);
  }
  /**
   * \@docs-private
   */
  var OVERLAY_CONTAINER_PROVIDER = {
      // If there is already an OverlayContainer available, use that. Otherwise, provide a new one.
      provide: OverlayContainer,
      deps: [
          [new _angular_core.Optional(), new _angular_core.SkipSelf(), OverlayContainer],
          /** @type {?} */ (_angular_common.DOCUMENT // We need to use the InjectionToken somewhere to keep TS happy
          ) // We need to use the InjectionToken somewhere to keep TS happy
      ],
      useFactory: OVERLAY_CONTAINER_PROVIDER_FACTORY
  };
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Next overlay unique ID.
   */
  var nextUniqueId = 0;
  /**
   * The default config for newly created overlays.
   */
  var defaultConfig = new OverlayConfig();
  /**
   * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
   * used as a low-level building building block for other components. Dialogs, tooltips, menus,
   * selects, etc. can all be built using overlays. The service should primarily be used by authors
   * of re-usable components rather than developers building end-user applications.
   *
   * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.
   */
  var Overlay = (function () {
      function Overlay(scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder, _keyboardDispatcher, _appRef, _injector, _ngZone, _document) {
          this.scrollStrategies = scrollStrategies;
          this._overlayContainer = _overlayContainer;
          this._componentFactoryResolver = _componentFactoryResolver;
          this._positionBuilder = _positionBuilder;
          this._keyboardDispatcher = _keyboardDispatcher;
          this._appRef = _appRef;
          this._injector = _injector;
          this._ngZone = _ngZone;
          this._document = _document;
      }
      /**
       * Creates an overlay.
       * @param config Configuration applied to the overlay.
       * @returns Reference to the created overlay.
       */
      /**
       * Creates an overlay.
       * @param {?=} config Configuration applied to the overlay.
       * @return {?} Reference to the created overlay.
       */
      Overlay.prototype.create = /**
       * Creates an overlay.
       * @param {?=} config Configuration applied to the overlay.
       * @return {?} Reference to the created overlay.
       */
      function (config) {
          if (config === void 0) { config = defaultConfig; }
          var /** @type {?} */ pane = this._createPaneElement();
          var /** @type {?} */ portalOutlet = this._createPortalOutlet(pane);
          return new OverlayRef(portalOutlet, pane, config, this._ngZone, this._keyboardDispatcher);
      };
      /**
       * Gets a position builder that can be used, via fluent API,
       * to construct and configure a position strategy.
       * @returns An overlay position builder.
       */
      /**
       * Gets a position builder that can be used, via fluent API,
       * to construct and configure a position strategy.
       * @return {?} An overlay position builder.
       */
      Overlay.prototype.position = /**
       * Gets a position builder that can be used, via fluent API,
       * to construct and configure a position strategy.
       * @return {?} An overlay position builder.
       */
      function () {
          return this._positionBuilder;
      };
      /**
       * Creates the DOM element for an overlay and appends it to the overlay container.
       * @return {?} Newly-created pane element
       */
      Overlay.prototype._createPaneElement = /**
       * Creates the DOM element for an overlay and appends it to the overlay container.
       * @return {?} Newly-created pane element
       */
      function () {
          var /** @type {?} */ pane = this._document.createElement('div');
          pane.id = "cdk-overlay-" + nextUniqueId++;
          pane.classList.add('cdk-overlay-pane');
          this._overlayContainer.getContainerElement().appendChild(pane);
          return pane;
      };
      /**
       * Create a DomPortalOutlet into which the overlay content can be loaded.
       * @param {?} pane The DOM element to turn into a portal outlet.
       * @return {?} A portal outlet for the given DOM element.
       */
      Overlay.prototype._createPortalOutlet = /**
       * Create a DomPortalOutlet into which the overlay content can be loaded.
       * @param {?} pane The DOM element to turn into a portal outlet.
       * @return {?} A portal outlet for the given DOM element.
       */
      function (pane) {
          return new _angular_cdk_portal.DomPortalOutlet(pane, this._componentFactoryResolver, this._appRef, this._injector);
      };
      Overlay.decorators = [
          { type: _angular_core.Injectable },
      ];
      /** @nocollapse */
      Overlay.ctorParameters = function () { return [
          { type: ScrollStrategyOptions, },
          { type: OverlayContainer, },
          { type: _angular_core.ComponentFactoryResolver, },
          { type: OverlayPositionBuilder, },
          { type: OverlayKeyboardDispatcher, },
          { type: _angular_core.ApplicationRef, },
          { type: _angular_core.Injector, },
          { type: _angular_core.NgZone, },
          { type: undefined, decorators: [{ type: _angular_core.Inject, args: [_angular_common.DOCUMENT,] },] },
      ]; };
      return Overlay;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Default set of positions for the overlay. Follows the behavior of a dropdown.
   */
  var defaultPositionList = [
      new ConnectionPositionPair({ originX: 'start', originY: 'bottom' }, { overlayX: 'start', overlayY: 'top' }),
      new ConnectionPositionPair({ originX: 'start', originY: 'top' }, { overlayX: 'start', overlayY: 'bottom' }),
      new ConnectionPositionPair({ originX: 'end', originY: 'top' }, { overlayX: 'end', overlayY: 'bottom' }),
      new ConnectionPositionPair({ originX: 'end', originY: 'bottom' }, { overlayX: 'end', overlayY: 'top' }),
  ];
  /**
   * Injection token that determines the scroll handling while the connected overlay is open.
   */
  var CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY = new _angular_core.InjectionToken('cdk-connected-overlay-scroll-strategy');
  /**
   * \@docs-private
   * @param {?} overlay
   * @return {?}
   */
  function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
      return function () { return overlay.scrollStrategies.reposition(); };
  }
  /**
   * \@docs-private
   */
  var CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
      provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,
      deps: [Overlay],
      useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,
  };
  /**
   * Directive applied to an element to make it usable as an origin for an Overlay using a
   * ConnectedPositionStrategy.
   */
  var CdkOverlayOrigin = (function () {
      function CdkOverlayOrigin(elementRef) {
          this.elementRef = elementRef;
      }
      CdkOverlayOrigin.decorators = [
          { type: _angular_core.Directive, args: [{
                      selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
                      exportAs: 'cdkOverlayOrigin',
                  },] },
      ];
      /** @nocollapse */
      CdkOverlayOrigin.ctorParameters = function () { return [
          { type: _angular_core.ElementRef, },
      ]; };
      return CdkOverlayOrigin;
  }());
  /**
   * Directive to facilitate declarative creation of an Overlay using a ConnectedPositionStrategy.
   */
  var CdkConnectedOverlay = (function () {
      // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.
      function CdkConnectedOverlay(_overlay, templateRef, viewContainerRef, _scrollStrategy, _dir, _document) {
          var _this = this;
          this._overlay = _overlay;
          this._scrollStrategy = _scrollStrategy;
          this._dir = _dir;
          this._document = _document;
          this._hasBackdrop = false;
          this._backdropSubscription = rxjs_Subscription.Subscription.EMPTY;
          this._positionSubscription = rxjs_Subscription.Subscription.EMPTY;
          this._offsetX = 0;
          this._offsetY = 0;
          /**
           * Strategy to be used when handling scroll events while the overlay is open.
           */
          this.scrollStrategy = this._scrollStrategy();
          /**
           * Whether the overlay is open.
           */
          this.open = false;
          /**
           * Event emitted when the backdrop is clicked.
           */
          this.backdropClick = new _angular_core.EventEmitter();
          /**
           * Event emitted when the position has changed.
           */
          this.positionChange = new _angular_core.EventEmitter();
          /**
           * Event emitted when the overlay has been attached.
           */
          this.attach = new _angular_core.EventEmitter();
          /**
           * Event emitted when the overlay has been detached.
           */
          this.detach = new _angular_core.EventEmitter();
          /**
           * Event listener that will close the overlay when the user presses escape.
           */
          this._escapeListener = function (event) {
              if (event.keyCode === _angular_cdk_keycodes.ESCAPE) {
                  _this._detachOverlay();
              }
          };
          this._templatePortal = new _angular_cdk_portal.TemplatePortal(templateRef, viewContainerRef);
      }
      Object.defineProperty(CdkConnectedOverlay.prototype, "offsetX", {
          get: /**
           * The offset in pixels for the overlay connection point on the x-axis
           * @return {?}
           */
          function () { return this._offsetX; },
          set: /**
           * @param {?} offsetX
           * @return {?}
           */
          function (offsetX) {
              this._offsetX = offsetX;
              if (this._position) {
                  this._position.withOffsetX(offsetX);
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "offsetY", {
          get: /**
           * The offset in pixels for the overlay connection point on the y-axis
           * @return {?}
           */
          function () { return this._offsetY; },
          set: /**
           * @param {?} offsetY
           * @return {?}
           */
          function (offsetY) {
              this._offsetY = offsetY;
              if (this._position) {
                  this._position.withOffsetY(offsetY);
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "hasBackdrop", {
          get: /**
           * Whether or not the overlay should attach a backdrop.
           * @return {?}
           */
          function () { return this._hasBackdrop; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) { this._hasBackdrop = _angular_cdk_coercion.coerceBooleanProperty(value); },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedOrigin", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.origin; },
          set: /**
           * @param {?} _origin
           * @return {?}
           */
          function (_origin) { this.origin = _origin; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedPositions", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.positions; },
          set: /**
           * @param {?} _positions
           * @return {?}
           */
          function (_positions) { this.positions = _positions; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedOffsetX", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.offsetX; },
          set: /**
           * @param {?} _offsetX
           * @return {?}
           */
          function (_offsetX) { this.offsetX = _offsetX; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedOffsetY", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.offsetY; },
          set: /**
           * @param {?} _offsetY
           * @return {?}
           */
          function (_offsetY) { this.offsetY = _offsetY; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedWidth", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.width; },
          set: /**
           * @param {?} _width
           * @return {?}
           */
          function (_width) { this.width = _width; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedHeight", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.height; },
          set: /**
           * @param {?} _height
           * @return {?}
           */
          function (_height) { this.height = _height; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedMinWidth", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.minWidth; },
          set: /**
           * @param {?} _minWidth
           * @return {?}
           */
          function (_minWidth) { this.minWidth = _minWidth; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedMinHeight", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.minHeight; },
          set: /**
           * @param {?} _minHeight
           * @return {?}
           */
          function (_minHeight) { this.minHeight = _minHeight; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedBackdropClass", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.backdropClass; },
          set: /**
           * @param {?} _backdropClass
           * @return {?}
           */
          function (_backdropClass) { this.backdropClass = _backdropClass; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedScrollStrategy", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.scrollStrategy; },
          set: /**
           * @param {?} _scrollStrategy
           * @return {?}
           */
          function (_scrollStrategy) {
              this.scrollStrategy = _scrollStrategy;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedOpen", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.open; },
          set: /**
           * @param {?} _open
           * @return {?}
           */
          function (_open) { this.open = _open; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "_deprecatedHasBackdrop", {
          get: /**
           * @deprecated
           * @return {?}
           */
          function () { return this.hasBackdrop; },
          set: /**
           * @param {?} _hasBackdrop
           * @return {?}
           */
          function (_hasBackdrop) { this.hasBackdrop = _hasBackdrop; },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "overlayRef", {
          /** The associated overlay reference. */
          get: /**
           * The associated overlay reference.
           * @return {?}
           */
          function () {
              return this._overlayRef;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkConnectedOverlay.prototype, "dir", {
          /** The element's layout direction. */
          get: /**
           * The element's layout direction.
           * @return {?}
           */
          function () {
              return this._dir ? this._dir.value : 'ltr';
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @return {?}
       */
      CdkConnectedOverlay.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._destroyOverlay();
      };
      /**
       * @param {?} changes
       * @return {?}
       */
      CdkConnectedOverlay.prototype.ngOnChanges = /**
       * @param {?} changes
       * @return {?}
       */
      function (changes) {
          if (changes['open'] || changes['_deprecatedOpen']) {
              this.open ? this._attachOverlay() : this._detachOverlay();
          }
      };
      /**
       * Creates an overlay
       * @return {?}
       */
      CdkConnectedOverlay.prototype._createOverlay = /**
       * Creates an overlay
       * @return {?}
       */
      function () {
          if (!this.positions || !this.positions.length) {
              this.positions = defaultPositionList;
          }
          this._overlayRef = this._overlay.create(this._buildConfig());
      };
      /**
       * Builds the overlay config based on the directive's inputs
       * @return {?}
       */
      CdkConnectedOverlay.prototype._buildConfig = /**
       * Builds the overlay config based on the directive's inputs
       * @return {?}
       */
      function () {
          var /** @type {?} */ positionStrategy = this._position = this._createPositionStrategy();
          var /** @type {?} */ overlayConfig = new OverlayConfig({
              positionStrategy: positionStrategy,
              scrollStrategy: this.scrollStrategy,
              hasBackdrop: this.hasBackdrop
          });
          if (this.width || this.width === 0) {
              overlayConfig.width = this.width;
          }
          if (this.height || this.height === 0) {
              overlayConfig.height = this.height;
          }
          if (this.minWidth || this.minWidth === 0) {
              overlayConfig.minWidth = this.minWidth;
          }
          if (this.minHeight || this.minHeight === 0) {
              overlayConfig.minHeight = this.minHeight;
          }
          if (this.backdropClass) {
              overlayConfig.backdropClass = this.backdropClass;
          }
          return overlayConfig;
      };
      /**
       * Returns the position strategy of the overlay to be set on the overlay config
       * @return {?}
       */
      CdkConnectedOverlay.prototype._createPositionStrategy = /**
       * Returns the position strategy of the overlay to be set on the overlay config
       * @return {?}
       */
      function () {
          var /** @type {?} */ pos = this.positions[0];
          var /** @type {?} */ originPoint = { originX: pos.originX, originY: pos.originY };
          var /** @type {?} */ overlayPoint = { overlayX: pos.overlayX, overlayY: pos.overlayY };
          var /** @type {?} */ strategy = this._overlay.position()
              .connectedTo(this.origin.elementRef, originPoint, overlayPoint)
              .withOffsetX(this.offsetX)
              .withOffsetY(this.offsetY);
          this._handlePositionChanges(strategy);
          return strategy;
      };
      /**
       * @param {?} strategy
       * @return {?}
       */
      CdkConnectedOverlay.prototype._handlePositionChanges = /**
       * @param {?} strategy
       * @return {?}
       */
      function (strategy) {
          var _this = this;
          for (var /** @type {?} */ i = 1; i < this.positions.length; i++) {
              strategy.withFallbackPosition({ originX: this.positions[i].originX, originY: this.positions[i].originY }, { overlayX: this.positions[i].overlayX, overlayY: this.positions[i].overlayY });
          }
          this._positionSubscription =
              strategy.onPositionChange.subscribe(function (pos) { return _this.positionChange.emit(pos); });
      };
      /**
       * Attaches the overlay and subscribes to backdrop clicks if backdrop exists
       * @return {?}
       */
      CdkConnectedOverlay.prototype._attachOverlay = /**
       * Attaches the overlay and subscribes to backdrop clicks if backdrop exists
       * @return {?}
       */
      function () {
          var _this = this;
          if (!this._overlayRef) {
              this._createOverlay();
          }
          this._position.withDirection(this.dir);
          this._overlayRef.setDirection(this.dir);
          this._document.addEventListener('keydown', this._escapeListener);
          if (!this._overlayRef.hasAttached()) {
              this._overlayRef.attach(this._templatePortal);
              this.attach.emit();
          }
          if (this.hasBackdrop) {
              this._backdropSubscription = this._overlayRef.backdropClick().subscribe(function () {
                  _this.backdropClick.emit();
              });
          }
      };
      /**
       * Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists
       * @return {?}
       */
      CdkConnectedOverlay.prototype._detachOverlay = /**
       * Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists
       * @return {?}
       */
      function () {
          if (this._overlayRef) {
              this._overlayRef.detach();
              this.detach.emit();
          }
          this._backdropSubscription.unsubscribe();
          this._document.removeEventListener('keydown', this._escapeListener);
      };
      /**
       * Destroys the overlay created by this directive.
       * @return {?}
       */
      CdkConnectedOverlay.prototype._destroyOverlay = /**
       * Destroys the overlay created by this directive.
       * @return {?}
       */
      function () {
          if (this._overlayRef) {
              this._overlayRef.dispose();
          }
          this._backdropSubscription.unsubscribe();
          this._positionSubscription.unsubscribe();
          this._document.removeEventListener('keydown', this._escapeListener);
      };
      CdkConnectedOverlay.decorators = [
          { type: _angular_core.Directive, args: [{
                      selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
                      exportAs: 'cdkConnectedOverlay'
                  },] },
      ];
      /** @nocollapse */
      CdkConnectedOverlay.ctorParameters = function () { return [
          { type: Overlay, },
          { type: _angular_core.TemplateRef, },
          { type: _angular_core.ViewContainerRef, },
          { type: undefined, decorators: [{ type: _angular_core.Inject, args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,] },] },
          { type: _angular_cdk_bidi.Directionality, decorators: [{ type: _angular_core.Optional },] },
          { type: undefined, decorators: [{ type: _angular_core.Optional }, { type: _angular_core.Inject, args: [_angular_common.DOCUMENT,] },] },
      ]; };
      CdkConnectedOverlay.propDecorators = {
          "origin": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayOrigin',] },],
          "positions": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayPositions',] },],
          "offsetX": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayOffsetX',] },],
          "offsetY": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayOffsetY',] },],
          "width": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayWidth',] },],
          "height": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayHeight',] },],
          "minWidth": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayMinWidth',] },],
          "minHeight": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayMinHeight',] },],
          "backdropClass": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayBackdropClass',] },],
          "scrollStrategy": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayScrollStrategy',] },],
          "open": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayOpen',] },],
          "hasBackdrop": [{ type: _angular_core.Input, args: ['cdkConnectedOverlayHasBackdrop',] },],
          "_deprecatedOrigin": [{ type: _angular_core.Input, args: ['origin',] },],
          "_deprecatedPositions": [{ type: _angular_core.Input, args: ['positions',] },],
          "_deprecatedOffsetX": [{ type: _angular_core.Input, args: ['offsetX',] },],
          "_deprecatedOffsetY": [{ type: _angular_core.Input, args: ['offsetY',] },],
          "_deprecatedWidth": [{ type: _angular_core.Input, args: ['width',] },],
          "_deprecatedHeight": [{ type: _angular_core.Input, args: ['height',] },],
          "_deprecatedMinWidth": [{ type: _angular_core.Input, args: ['minWidth',] },],
          "_deprecatedMinHeight": [{ type: _angular_core.Input, args: ['minHeight',] },],
          "_deprecatedBackdropClass": [{ type: _angular_core.Input, args: ['backdropClass',] },],
          "_deprecatedScrollStrategy": [{ type: _angular_core.Input, args: ['scrollStrategy',] },],
          "_deprecatedOpen": [{ type: _angular_core.Input, args: ['open',] },],
          "_deprecatedHasBackdrop": [{ type: _angular_core.Input, args: ['hasBackdrop',] },],
          "backdropClick": [{ type: _angular_core.Output },],
          "positionChange": [{ type: _angular_core.Output },],
          "attach": [{ type: _angular_core.Output },],
          "detach": [{ type: _angular_core.Output },],
      };
      return CdkConnectedOverlay;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  var OVERLAY_PROVIDERS = [
      Overlay,
      OverlayPositionBuilder,
      OVERLAY_KEYBOARD_DISPATCHER_PROVIDER,
      _angular_cdk_scrolling.VIEWPORT_RULER_PROVIDER,
      OVERLAY_CONTAINER_PROVIDER,
      CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,
  ];
  var OverlayModule = (function () {
      function OverlayModule() {
      }
      OverlayModule.decorators = [
          { type: _angular_core.NgModule, args: [{
                      imports: [_angular_cdk_bidi.BidiModule, _angular_cdk_portal.PortalModule, _angular_cdk_scrolling.ScrollDispatchModule],
                      exports: [CdkConnectedOverlay, CdkOverlayOrigin, _angular_cdk_scrolling.ScrollDispatchModule],
                      declarations: [CdkConnectedOverlay, CdkOverlayOrigin],
                      providers: [OVERLAY_PROVIDERS, ScrollStrategyOptions],
                  },] },
      ];
      /** @nocollapse */
      OverlayModule.ctorParameters = function () { return []; };
      return OverlayModule;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Alternative to OverlayContainer that supports correct displaying of overlay elements in
   * Fullscreen mode
   * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen
   *
   * Should be provided in the root component.
   */
  var FullscreenOverlayContainer = (function (_super) {
      __extends(FullscreenOverlayContainer, _super);
      function FullscreenOverlayContainer() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      /**
       * @return {?}
       */
      FullscreenOverlayContainer.prototype._createContainer = /**
       * @return {?}
       */
      function () {
          var _this = this;
          _super.prototype._createContainer.call(this);
          this._adjustParentForFullscreenChange();
          this._addFullscreenChangeListener(function () { return _this._adjustParentForFullscreenChange(); });
      };
      /**
       * @return {?}
       */
      FullscreenOverlayContainer.prototype._adjustParentForFullscreenChange = /**
       * @return {?}
       */
      function () {
          if (!this._containerElement) {
              return;
          }
          var /** @type {?} */ fullscreenElement = this.getFullscreenElement();
          var /** @type {?} */ parent = fullscreenElement || document.body;
          parent.appendChild(this._containerElement);
      };
      /**
       * @param {?} fn
       * @return {?}
       */
      FullscreenOverlayContainer.prototype._addFullscreenChangeListener = /**
       * @param {?} fn
       * @return {?}
       */
      function (fn) {
          if (document.fullscreenEnabled) {
              document.addEventListener('fullscreenchange', fn);
          }
          else if (document.webkitFullscreenEnabled) {
              document.addEventListener('webkitfullscreenchange', fn);
          }
          else if ((/** @type {?} */ (document)).mozFullScreenEnabled) {
              document.addEventListener('mozfullscreenchange', fn);
          }
          else if ((/** @type {?} */ (document)).msFullscreenEnabled) {
              document.addEventListener('MSFullscreenChange', fn);
          }
      };
      /**
       * 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.
      */
      /**
       * 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.
       * @return {?}
       */
      FullscreenOverlayContainer.prototype.getFullscreenElement = /**
       * 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.
       * @return {?}
       */
      function () {
          return document.fullscreenElement ||
              document.webkitFullscreenElement ||
              (/** @type {?} */ (document)).mozFullScreenElement ||
              (/** @type {?} */ (document)).msFullscreenElement ||
              null;
      };
      FullscreenOverlayContainer.decorators = [
          { type: _angular_core.Injectable },
      ];
      /** @nocollapse */
      FullscreenOverlayContainer.ctorParameters = function () { return []; };
      return FullscreenOverlayContainer;
  }(OverlayContainer));
  
  exports.Overlay = Overlay;
  exports.OverlayContainer = OverlayContainer;
  exports.CdkOverlayOrigin = CdkOverlayOrigin;
  exports.CdkConnectedOverlay = CdkConnectedOverlay;
  exports.FullscreenOverlayContainer = FullscreenOverlayContainer;
  exports.OverlayRef = OverlayRef;
  exports.ViewportRuler = _angular_cdk_scrolling.ViewportRuler;
  exports.OverlayKeyboardDispatcher = OverlayKeyboardDispatcher;
  exports.GlobalPositionStrategy = GlobalPositionStrategy;
  exports.ConnectedPositionStrategy = ConnectedPositionStrategy;
  exports.VIEWPORT_RULER_PROVIDER = _angular_cdk_scrolling.VIEWPORT_RULER_PROVIDER;
  exports.ConnectedOverlayDirective = CdkConnectedOverlay;
  exports.OverlayOrigin = CdkOverlayOrigin;
  exports.OverlayConfig = OverlayConfig;
  exports.ConnectionPositionPair = ConnectionPositionPair;
  exports.ScrollingVisibility = ScrollingVisibility;
  exports.ConnectedOverlayPositionChange = ConnectedOverlayPositionChange;
  exports.CdkScrollable = _angular_cdk_scrolling.CdkScrollable;
  exports.ScrollDispatcher = _angular_cdk_scrolling.ScrollDispatcher;
  exports.ScrollStrategyOptions = ScrollStrategyOptions;
  exports.RepositionScrollStrategy = RepositionScrollStrategy;
  exports.CloseScrollStrategy = CloseScrollStrategy;
  exports.NoopScrollStrategy = NoopScrollStrategy;
  exports.BlockScrollStrategy = BlockScrollStrategy;
  exports.OVERLAY_PROVIDERS = OVERLAY_PROVIDERS;
  exports.OverlayModule = OverlayModule;
  exports.ɵg = OVERLAY_KEYBOARD_DISPATCHER_PROVIDER;
  exports.ɵf = OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY;
  exports.ɵb = OVERLAY_CONTAINER_PROVIDER;
  exports.ɵa = OVERLAY_CONTAINER_PROVIDER_FACTORY;
  exports.ɵc = CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY;
  exports.ɵe = CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER;
  exports.ɵd = CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY;
  exports.ɵh = OverlayPositionBuilder;
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  //# sourceMappingURL=cdk-overlay.umd.js.map
  