You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by sc...@apache.org on 2018/04/30 19:31:46 UTC
[05/51] [partial] nifi-fds git commit: update gh-pages
http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/4a326208/node_modules/@angular/cdk/esm5/overlay.es5.js.map
----------------------------------------------------------------------
diff --git a/node_modules/@angular/cdk/esm5/overlay.es5.js.map b/node_modules/@angular/cdk/esm5/overlay.es5.js.map
new file mode 100644
index 0000000..3f626a8
--- /dev/null
+++ b/node_modules/@angular/cdk/esm5/overlay.es5.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"overlay.es5.js","sources":["../../packages/cdk/esm5/overlay/scroll/noop-scroll-strategy.js","../../packages/cdk/esm5/overlay/overlay-config.js","../../packages/cdk/esm5/overlay/overlay-ref.js","../../packages/cdk/esm5/overlay/position/connected-position.js","../../packages/cdk/esm5/overlay/position/scroll-clip.js","../../packages/cdk/esm5/overlay/position/connected-position-strategy.js","../../packages/cdk/esm5/overlay/position/global-position-strategy.js","../../packages/cdk/esm5/overlay/position/overlay-position-builder.js","../../packages/cdk/esm5/overlay/overlay-container.js","../../packages/cdk/esm5/overlay/scroll/scroll-strategy.js","../../packages/cdk/esm5/overlay/scroll/close-scroll-strategy.js","../../packages/cdk/esm5/overlay/scroll/block-scroll-strategy.js","../../packages/cdk/esm5/overlay/scroll/reposition-scroll-strategy.js","../../packages/cdk/esm5/overlay/scroll/scroll-strategy-options.js","../../packages/cdk/esm5/overlay/overlay.js","../../packag
es/cdk/esm5/overlay/fullscreen-overlay-container.js","../../packages/cdk/esm5/overlay/overlay-directives.js","../../packages/cdk/esm5/overlay/overlay-module.js","../../packages/cdk/esm5/overlay/index.js"],"sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Scroll strategy that doesn't do anything.\n */\nvar NoopScrollStrategy = (function () {\n function NoopScrollStrategy() {\n }\n /**\n * @return {?}\n */\n NoopScrollStrategy.prototype.enable = function () { };\n /**\n * @return {?}\n */\n NoopScrollStrategy.prototype.disable = function () { };\n /**\n * @return {?}\n */\n NoopScrollStrategy.prototype.attach = function () { };\n return NoopScrollStrategy;\n}());\nexport { NoopScrollStrategy };\n//# sourceMappingURL=noop-scroll-strategy.js.map","/**\n
* @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { NoopScrollStrategy } from './scroll/noop-scroll-strategy';\n/**\n * OverlayConfig captures the initial configuration used when opening an overlay.\n */\nvar OverlayConfig = (function () {\n /**\n * @param {?=} config\n */\n function OverlayConfig(config) {\n var _this = this;\n /**\n * Strategy to be used when handling scroll events while the overlay is open.\n */\n this.scrollStrategy = new NoopScrollStrategy();\n /**\n * Custom class to add to the overlay pane.\n */\n this.panelClass = '';\n /**\n * Whether the overlay has a backdrop.\n */\n this.hasBackdrop = false;\n /**\n * Custom class to add to the backdrop\n */\n this.backdrop
Class = 'cdk-overlay-dark-backdrop';\n /**\n * The direction of the text in the overlay panel.\n */\n this.direction = 'ltr';\n if (config) {\n Object.keys(config).forEach(function (key) { return _this[key] = config[key]; });\n }\n }\n return OverlayConfig;\n}());\nexport { OverlayConfig };\nfunction OverlayConfig_tsickle_Closure_declarations() {\n /**\n * Strategy with which to position the overlay.\n * @type {?}\n */\n OverlayConfig.prototype.positionStrategy;\n /**\n * Strategy to be used when handling scroll events while the overlay is open.\n * @type {?}\n */\n OverlayConfig.prototype.scrollStrategy;\n /**\n * Custom class to add to the overlay pane.\n * @type {?}\n */\n OverlayConfig.prototype.panelClass;\n /**\n * Whether the overlay has a backdrop.\n * @type {?}\n */\n OverlayConfig.prototype.hasBackdrop;\n /**\n * Custom class to add to
the backdrop\n * @type {?}\n */\n OverlayConfig.prototype.backdropClass;\n /**\n * The width of the overlay panel. If a number is provided, pixel units are assumed.\n * @type {?}\n */\n OverlayConfig.prototype.width;\n /**\n * The height of the overlay panel. If a number is provided, pixel units are assumed.\n * @type {?}\n */\n OverlayConfig.prototype.height;\n /**\n * The min-width of the overlay panel. If a number is provided, pixel units are assumed.\n * @type {?}\n */\n OverlayConfig.prototype.minWidth;\n /**\n * The min-height of the overlay panel. If a number is provided, pixel units are assumed.\n * @type {?}\n */\n OverlayConfig.prototype.minHeight;\n /**\n * The max-width of the overlay panel. If a number is provided, pixel units are assumed.\n * @type {?}\n */\n OverlayConfig.prototype.maxWidth;\n /**\n * The max-height of the overlay panel. If a number is provided
, pixel units are assumed.\n * @type {?}\n */\n OverlayConfig.prototype.maxHeight;\n /**\n * The direction of the text in the overlay panel.\n * @type {?}\n */\n OverlayConfig.prototype.direction;\n}\n//# sourceMappingURL=overlay-config.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Subject } from 'rxjs/Subject';\n/**\n * Reference to an overlay that has been created with the Overlay service.\n * Used to manipulate or dispose of said overlay.\n */\nvar OverlayRef = (function () {\n /**\n * @param {?} _portalHost\n * @param {?} _pane\n * @param {?} _config\n * @param {?} _ngZone\n */\n function OverlayRef(_portalHost, _pane, _config, _ngZone) {\n this._portalHost = _portalHost;\n this._pane = _pane;\n this._config = _config;\n
this._ngZone = _ngZone;\n this._backdropElement = null;\n this._backdropClick = new Subject();\n this._attachments = new Subject();\n this._detachments = new Subject();\n if (_config.scrollStrategy) {\n _config.scrollStrategy.attach(this);\n }\n }\n Object.defineProperty(OverlayRef.prototype, \"overlayElement\", {\n /**\n * The overlay's HTML element\n * @return {?}\n */\n get: function () {\n return this._pane;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Attaches the overlay to a portal instance and adds the backdrop.\n * @param {?} portal Portal instance to which to attach the overlay.\n * @return {?} The portal attachment result.\n */\n OverlayRef.prototype.attach = function (portal) {\n var _this = this;\n var /** @type {?} */ attachResult = this._portalHost.attach(portal);\n if (this._
config.positionStrategy) {\n this._config.positionStrategy.attach(this);\n }\n // Update the pane element with the given configuration.\n this._updateStackingOrder();\n this.updateSize();\n this.updateDirection();\n this.updatePosition();\n if (this._config.scrollStrategy) {\n this._config.scrollStrategy.enable();\n }\n // Enable pointer events for the overlay pane element.\n this._togglePointerEvents(true);\n if (this._config.hasBackdrop) {\n this._attachBackdrop();\n }\n if (this._config.panelClass) {\n // We can't do a spread here, because IE doesn't support setting multiple classes.\n if (Array.isArray(this._config.panelClass)) {\n this._config.panelClass.forEach(function (cls) { return _this._pane.classList.add(cls); });\n }\n else {\n this._pane.classList.add(this._config.panelClass
);\n }\n }\n // Only emit the `attachments` event once all other setup is done.\n this._attachments.next();\n return attachResult;\n };\n /**\n * Detaches an overlay from a portal.\n * @return {?} The portal detachment result.\n */\n OverlayRef.prototype.detach = function () {\n this.detachBackdrop();\n // When the overlay is detached, the pane element should disable pointer events.\n // This is necessary because otherwise the pane element will cover the page and disable\n // pointer events therefore. Depends on the position strategy and the applied pane boundaries.\n this._togglePointerEvents(false);\n if (this._config.positionStrategy && this._config.positionStrategy.detach) {\n this._config.positionStrategy.detach();\n }\n if (this._config.scrollStrategy) {\n this._config.scrollStrategy.disable();\n }\n var /** @type {?} */ detach
mentResult = this._portalHost.detach();\n // Only emit after everything is detached.\n this._detachments.next();\n return detachmentResult;\n };\n /**\n * Cleans up the overlay from the DOM.\n * @return {?}\n */\n OverlayRef.prototype.dispose = function () {\n if (this._config.positionStrategy) {\n this._config.positionStrategy.dispose();\n }\n if (this._config.scrollStrategy) {\n this._config.scrollStrategy.disable();\n }\n this.detachBackdrop();\n this._portalHost.dispose();\n this._attachments.complete();\n this._backdropClick.complete();\n this._detachments.next();\n this._detachments.complete();\n };\n /**\n * Checks whether the overlay has been attached.\n * @return {?}\n */\n OverlayRef.prototype.hasAttached = function () {\n return this._portalHost.hasAttached();\n };\n /**\n * Returns an observable that e
mits when the backdrop has been clicked.\n * @return {?}\n */\n OverlayRef.prototype.backdropClick = function () {\n return this._backdropClick.asObservable();\n };\n /**\n * Returns an observable that emits when the overlay has been attached.\n * @return {?}\n */\n OverlayRef.prototype.attachments = function () {\n return this._attachments.asObservable();\n };\n /**\n * Returns an observable that emits when the overlay has been detached.\n * @return {?}\n */\n OverlayRef.prototype.detachments = function () {\n return this._detachments.asObservable();\n };\n /**\n * Gets the current config of the overlay.\n * @return {?}\n */\n OverlayRef.prototype.getConfig = function () {\n return this._config;\n };\n /**\n * Updates the position of the overlay based on the position strategy.\n * @return {?}\n */\n OverlayRef.prototype.updatePosition = function () {\n i
f (this._config.positionStrategy) {\n this._config.positionStrategy.apply();\n }\n };\n /**\n * Updates the text direction of the overlay panel.\n * @return {?}\n */\n OverlayRef.prototype.updateDirection = function () {\n this._pane.setAttribute('dir', /** @type {?} */ ((this._config.direction)));\n };\n /**\n * Updates the size of the overlay based on the overlay config.\n * @return {?}\n */\n OverlayRef.prototype.updateSize = function () {\n if (this._config.width || this._config.width === 0) {\n this._pane.style.width = formatCssUnit(this._config.width);\n }\n if (this._config.height || this._config.height === 0) {\n this._pane.style.height = formatCssUnit(this._config.height);\n }\n if (this._config.minWidth || this._config.minWidth === 0) {\n this._pane.style.minWidth = formatCssUnit(this._config.minWidth);\n }\n if (this._config.
minHeight || this._config.minHeight === 0) {\n this._pane.style.minHeight = formatCssUnit(this._config.minHeight);\n }\n if (this._config.maxWidth || this._config.maxWidth === 0) {\n this._pane.style.maxWidth = formatCssUnit(this._config.maxWidth);\n }\n if (this._config.maxHeight || this._config.maxHeight === 0) {\n this._pane.style.maxHeight = formatCssUnit(this._config.maxHeight);\n }\n };\n /**\n * Toggles the pointer events for the overlay pane element.\n * @param {?} enablePointer\n * @return {?}\n */\n OverlayRef.prototype._togglePointerEvents = function (enablePointer) {\n this._pane.style.pointerEvents = enablePointer ? 'auto' : 'none';\n };\n /**\n * Attaches a backdrop for this overlay.\n * @return {?}\n */\n OverlayRef.prototype._attachBackdrop = function () {\n var _this = this;\n this._backdropElement = document.createElement('div');\n
this._backdropElement.classList.add('cdk-overlay-backdrop');\n if (this._config.backdropClass) {\n this._backdropElement.classList.add(this._config.backdropClass);\n } /** @type {?} */\n ((\n // Insert the backdrop before the pane in the DOM order,\n // in order to handle stacked overlays properly.\n this._pane.parentElement)).insertBefore(this._backdropElement, this._pane);\n // Forward backdrop clicks such that the consumer of the overlay can perform whatever\n // action desired when such a click occurs (usually closing the overlay).\n this._backdropElement.addEventListener('click', function () { return _this._backdropClick.next(null); });\n // Add class to fade-in the backdrop after one frame.\n requestAnimationFrame(function () {\n if (_this._backdropElement) {\n _this._backdropElement.classList.add('cdk-overlay-backdrop-showing');\n }\n });\
n };\n /**\n * Updates the stacking order of the element, moving it to the top if necessary.\n * This is required in cases where one overlay was detached, while another one,\n * that should be behind it, was destroyed. The next time both of them are opened,\n * the stacking will be wrong, because the detached element's pane will still be\n * in its original DOM position.\n * @return {?}\n */\n OverlayRef.prototype._updateStackingOrder = function () {\n if (this._pane.nextSibling) {\n ((this._pane.parentNode)).appendChild(this._pane);\n }\n };\n /**\n * Detaches the backdrop (if any) associated with the overlay.\n * @return {?}\n */\n OverlayRef.prototype.detachBackdrop = function () {\n var _this = this;\n var /** @type {?} */ backdropToDetach = this._backdropElement;\n if (backdropToDetach) {\n var /** @type {?} */ finishDetach_1 = function () {\n // It
may not be attached to anything in certain cases (e.g. unit tests).\n if (backdropToDetach && backdropToDetach.parentNode) {\n backdropToDetach.parentNode.removeChild(backdropToDetach);\n }\n // It is possible that a new portal has been attached to this overlay since we started\n // removing the backdrop. If that is the case, only clear the backdrop reference if it\n // is still the same instance that we started to remove.\n if (_this._backdropElement == backdropToDetach) {\n _this._backdropElement = null;\n }\n };\n backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');\n if (this._config.backdropClass) {\n backdropToDetach.classList.remove(this._config.backdropClass);\n }\n backdropToDetach.addEventListener('transitionend', finishDetach_1);\n // If
the backdrop doesn't have a transition, the `transitionend` event won't fire.\n // In this case we make it unclickable and we try to remove it after a delay.\n backdropToDetach.style.pointerEvents = 'none';\n // Run this outside the Angular zone because there's nothing that Angular cares about.\n // If it were to run inside the Angular zone, every test that used Overlay would have to be\n // either async or fakeAsync.\n this._ngZone.runOutsideAngular(function () {\n setTimeout(finishDetach_1, 500);\n });\n }\n };\n return OverlayRef;\n}());\nexport { OverlayRef };\nfunction OverlayRef_tsickle_Closure_declarations() {\n /** @type {?} */\n OverlayRef.prototype._backdropElement;\n /** @type {?} */\n OverlayRef.prototype._backdropClick;\n /** @type {?} */\n OverlayRef.prototype._attachments;\n /** @type {?} */\n OverlayRef.prototype._detachments;\n /** @typ
e {?} */\n OverlayRef.prototype._portalHost;\n /** @type {?} */\n OverlayRef.prototype._pane;\n /** @type {?} */\n OverlayRef.prototype._config;\n /** @type {?} */\n OverlayRef.prototype._ngZone;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction formatCssUnit(value) {\n return typeof value === 'string' ? (value) : value + \"px\";\n}\n//# sourceMappingURL=overlay-ref.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Horizontal dimension of a connection point on the perimeter of the origin or overlay element. */\nimport { Optional } from '@angular/core';\n/**\n * The points of the origin element and the overlay element to connect.\n */\nvar ConnectionPositionPair = (function () {\n /**\n * @param {?} origin\n * @param {?} overlay\n */\n function ConnectionPosition
Pair(origin, overlay) {\n this.originX = origin.originX;\n this.originY = origin.originY;\n this.overlayX = overlay.overlayX;\n this.overlayY = overlay.overlayY;\n }\n return ConnectionPositionPair;\n}());\nexport { ConnectionPositionPair };\nfunction ConnectionPositionPair_tsickle_Closure_declarations() {\n /** @type {?} */\n ConnectionPositionPair.prototype.originX;\n /** @type {?} */\n ConnectionPositionPair.prototype.originY;\n /** @type {?} */\n ConnectionPositionPair.prototype.overlayX;\n /** @type {?} */\n ConnectionPositionPair.prototype.overlayY;\n}\n/**\n * Set of properties regarding the position of the origin and overlay relative to the viewport\n * with respect to the containing Scrollable elements.\n *\n * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the\n * bounds of any one of the strategy's Scrollable's bounding client rectangle.\n *\n * The overlay and origin are
outside view if there is no overlap between their bounding client\n * rectangle and any one of the strategy's Scrollable's bounding client rectangle.\n *\n * ----------- -----------\n * | outside | | clipped |\n * | view | --------------------------\n * | | | | | |\n * ---------- | ----------- |\n * -------------------------- | |\n * | | | Scrollable |\n * | | | |\n * | | --------------------------\n * | Scrollable |\n * | |\n * --------------------------\n */\nvar ScrollingVisibility = (function () {\n function ScrollingVisibility() {\n }\n return ScrollingVisibility;\n}());\nexport { ScrollingVisibility };\nfunction ScrollingVisibility_tsickle_Clo
sure_declarations() {\n /** @type {?} */\n ScrollingVisibility.prototype.isOriginClipped;\n /** @type {?} */\n ScrollingVisibility.prototype.isOriginOutsideView;\n /** @type {?} */\n ScrollingVisibility.prototype.isOverlayClipped;\n /** @type {?} */\n ScrollingVisibility.prototype.isOverlayOutsideView;\n}\n/**\n * The change event emitted by the strategy when a fallback position is used.\n */\nvar ConnectedOverlayPositionChange = (function () {\n /**\n * @param {?} connectionPair\n * @param {?} scrollableViewProperties\n */\n function ConnectedOverlayPositionChange(connectionPair, scrollableViewProperties) {\n this.connectionPair = connectionPair;\n this.scrollableViewProperties = scrollableViewProperties;\n }\n /**\n * @nocollapse\n */\n ConnectedOverlayPositionChange.ctorParameters = function () { return [\n { type: ConnectionPositionPair, },\n { type: ScrollingVisibility, decorators: [{ type: O
ptional },] },\n ]; };\n return ConnectedOverlayPositionChange;\n}());\nexport { ConnectedOverlayPositionChange };\nfunction ConnectedOverlayPositionChange_tsickle_Closure_declarations() {\n /**\n * @nocollapse\n * @type {?}\n */\n ConnectedOverlayPositionChange.ctorParameters;\n /** @type {?} */\n ConnectedOverlayPositionChange.prototype.connectionPair;\n /** @type {?} */\n ConnectedOverlayPositionChange.prototype.scrollableViewProperties;\n}\n//# sourceMappingURL=connected-position.js.map","/**\n * Gets whether an element is scrolled outside of view by any of its parent scrolling containers.\n * \\@docs-private\n * @param {?} element Dimensions of the element (from getBoundingClientRect)\n * @param {?} scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)\n * @return {?} Whether the element is scrolled out of view\n */\nexport function isElementScrolledOutsideView(element, scrollContainers) {\n return scro
llContainers.some(function (containerBounds) {\n var /** @type {?} */ outsideAbove = element.bottom < containerBounds.top;\n var /** @type {?} */ outsideBelow = element.top > containerBounds.bottom;\n var /** @type {?} */ outsideLeft = element.right < containerBounds.left;\n var /** @type {?} */ outsideRight = element.left > containerBounds.right;\n return outsideAbove || outsideBelow || outsideLeft || outsideRight;\n });\n}\n/**\n * Gets whether an element is clipped by any of its scrolling containers.\n * \\@docs-private\n * @param {?} element Dimensions of the element (from getBoundingClientRect)\n * @param {?} scrollContainers Dimensions of element's scrolling containers (from getBoundingClientRect)\n * @return {?} Whether the element is clipped\n */\nexport function isElementClippedByScrolling(element, scrollContainers) {\n return scrollContainers.some(function (scrollContainerRect) {\n var /** @type {?} */ clippedAbove = element.
top < scrollContainerRect.top;\n var /** @type {?} */ clippedBelow = element.bottom > scrollContainerRect.bottom;\n var /** @type {?} */ clippedLeft = element.left < scrollContainerRect.left;\n var /** @type {?} */ clippedRight = element.right > scrollContainerRect.right;\n return clippedAbove || clippedBelow || clippedLeft || clippedRight;\n });\n}\n//# sourceMappingURL=scroll-clip.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { ConnectionPositionPair, ConnectedOverlayPositionChange, } from './connected-position';\nimport { Subject } from 'rxjs/Subject';\nimport { Subscription } from 'rxjs/Subscription';\nimport { isElementScrolledOutsideView, isElementClippedByScrolling } from './scroll-clip';\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is
given an\n * implicit position relative some origin element. The relative position is defined in terms of\n * a point on the origin element that is connected to a point on the overlay element. For example,\n * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner\n * of the overlay.\n */\nvar ConnectedPositionStrategy = (function () {\n /**\n * @param {?} originPos\n * @param {?} overlayPos\n * @param {?} _connectedTo\n * @param {?} _viewportRuler\n */\n function ConnectedPositionStrategy(originPos, overlayPos, _connectedTo, _viewportRuler) {\n this._connectedTo = _connectedTo;\n this._viewportRuler = _viewportRuler;\n /**\n * Layout direction of the position strategy.\n */\n this._dir = 'ltr';\n /**\n * The offset in pixels for the overlay connection point on the x-axis\n */\n this._offsetX = 0;\n /**\n * The offset in pixels for th
e overlay connection point on the y-axis\n */\n this._offsetY = 0;\n /**\n * The Scrollable containers used to check scrollable view properties on position change.\n */\n this.scrollables = [];\n /**\n * Subscription to viewport resize events.\n */\n this._resizeSubscription = Subscription.EMPTY;\n /**\n * Ordered list of preferred positions, from most to least desirable.\n */\n this._preferredPositions = [];\n this._onPositionChange = new Subject();\n this._origin = this._connectedTo.nativeElement;\n this.withFallbackPosition(originPos, overlayPos);\n }\n Object.defineProperty(ConnectedPositionStrategy.prototype, \"_isRtl\", {\n /**\n * Whether the we're dealing with an RTL context\n * @return {?}\n */\n get: function () {\n return this._dir === 'rtl';\n },\n enumerable: true,\n conf
igurable: true\n });\n Object.defineProperty(ConnectedPositionStrategy.prototype, \"onPositionChange\", {\n /**\n * Emits an event when the connection point changes.\n * @return {?}\n */\n get: function () {\n return this._onPositionChange.asObservable();\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedPositionStrategy.prototype, \"positions\", {\n /**\n * Ordered list of preferred positions, from most to least desirable.\n * @return {?}\n */\n get: function () {\n return this._preferredPositions;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} overlayRef\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.attach = function (overlayRef) {\n var _this = this;\n this._overlayRef = overlayRef;\n this._pane = overlayRef.overlayE
lement;\n this._resizeSubscription.unsubscribe();\n this._resizeSubscription = this._viewportRuler.change().subscribe(function () { return _this.apply(); });\n };\n /**\n * Performs any cleanup after the element is destroyed.\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.dispose = function () {\n this._resizeSubscription.unsubscribe();\n };\n /**\n * \\@docs-private\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.detach = function () {\n this._resizeSubscription.unsubscribe();\n };\n /**\n * Updates the position of the overlay element, using whichever preferred position relative\n * to the origin fits on-screen.\n * \\@docs-private\n *\n * @return {?} Resolves when the styles have been applied.\n */\n ConnectedPositionStrategy.prototype.apply = function () {\n // We need the bounding rects for the origin and the overlay to determine how to position\n
// the overlay relative to the origin.\n var /** @type {?} */ element = this._pane;\n var /** @type {?} */ originRect = this._origin.getBoundingClientRect();\n var /** @type {?} */ overlayRect = element.getBoundingClientRect();\n // We use the viewport rect to determine whether a position would go off-screen.\n var /** @type {?} */ viewportRect = this._viewportRuler.getViewportRect();\n // Fallback point if none of the fallbacks fit into the viewport.\n var /** @type {?} */ fallbackPoint;\n var /** @type {?} */ fallbackPosition;\n // We want to place the overlay in the first of the preferred positions such that the\n // overlay fits on-screen.\n for (var _i = 0, _a = this._preferredPositions; _i < _a.length; _i++) {\n var pos = _a[_i];\n // Get the (x, y) point of connection on the origin, and then use that to get the\n // (top, left) coordinate for the overlay at `po
s`.\n var /** @type {?} */ originPoint = this._getOriginConnectionPoint(originRect, pos);\n var /** @type {?} */ overlayPoint = this._getOverlayPoint(originPoint, overlayRect, viewportRect, pos);\n // If the overlay in the calculated position fits on-screen, put it there and we're done.\n if (overlayPoint.fitsInViewport) {\n this._setElementPosition(element, overlayRect, overlayPoint, pos);\n // Save the last connected position in case the position needs to be re-calculated.\n this._lastConnectedPosition = pos;\n return;\n }\n else if (!fallbackPoint || fallbackPoint.visibleArea < overlayPoint.visibleArea) {\n fallbackPoint = overlayPoint;\n fallbackPosition = pos;\n }\n }\n // If none of the preferred positions were in the viewport, take the one\n // with the largest visible area.\n this._s
etElementPosition(element, overlayRect, /** @type {?} */ ((fallbackPoint)), /** @type {?} */ ((fallbackPosition)));\n };\n /**\n * This re-aligns the overlay element with the trigger in its last calculated position,\n * even if a position higher in the \"preferred positions\" list would now fit. This\n * allows one to re-align the panel without changing the orientation of the panel.\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.recalculateLastPosition = function () {\n var /** @type {?} */ originRect = this._origin.getBoundingClientRect();\n var /** @type {?} */ overlayRect = this._pane.getBoundingClientRect();\n var /** @type {?} */ viewportRect = this._viewportRuler.getViewportRect();\n var /** @type {?} */ lastPosition = this._lastConnectedPosition || this._preferredPositions[0];\n var /** @type {?} */ originPoint = this._getOriginConnectionPoint(originRect, lastPosition);\n var /** @type {?} */ o
verlayPoint = this._getOverlayPoint(originPoint, overlayRect, viewportRect, lastPosition);\n this._setElementPosition(this._pane, overlayRect, overlayPoint, lastPosition);\n };\n /**\n * Sets the list of Scrollable containers that host the origin element so that\n * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every\n * Scrollable must be an ancestor element of the strategy's origin element.\n * @param {?} scrollables\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.withScrollableContainers = function (scrollables) {\n this.scrollables = scrollables;\n };\n /**\n * Adds a new preferred fallback position.\n * @param {?} originPos\n * @param {?} overlayPos\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.withFallbackPosition = function (originPos, overlayPos) {\n this._preferredPositions.push(new ConnectionPositionPair(originPos, overlayPos));\
n return this;\n };\n /**\n * Sets the layout direction so the overlay's position can be adjusted to match.\n * @param {?} dir New layout direction.\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.withDirection = function (dir) {\n this._dir = dir;\n return this;\n };\n /**\n * Sets an offset for the overlay's connection point on the x-axis\n * @param {?} offset New offset in the X axis.\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.withOffsetX = function (offset) {\n this._offsetX = offset;\n return this;\n };\n /**\n * Sets an offset for the overlay's connection point on the y-axis\n * @param {?} offset New offset in the Y axis.\n * @return {?}\n */\n ConnectedPositionStrategy.prototype.withOffsetY = function (offset) {\n this._offsetY = offset;\n return this;\n };\n /**\n * Gets the horizontal (x) \"start\" dimension based o
n whether the overlay is in an RTL context.\n * @param {?} rect\n * @return {?}\n */\n ConnectedPositionStrategy.prototype._getStartX = function (rect) {\n return this._isRtl ? rect.right : rect.left;\n };\n /**\n * Gets the horizontal (x) \"end\" dimension based on whether the overlay is in an RTL context.\n * @param {?} rect\n * @return {?}\n */\n ConnectedPositionStrategy.prototype._getEndX = function (rect) {\n return this._isRtl ? rect.left : rect.right;\n };\n /**\n * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.\n * @param {?} originRect\n * @param {?} pos\n * @return {?}\n */\n ConnectedPositionStrategy.prototype._getOriginConnectionPoint = function (originRect, pos) {\n var /** @type {?} */ originStartX = this._getStartX(originRect);\n var /** @type {?} */ originEndX = this._getEndX(originRect);\n var /** @type {?} */ x;\n
if (pos.originX == 'center') {\n x = originStartX + (originRect.width / 2);\n }\n else {\n x = pos.originX == 'start' ? originStartX : originEndX;\n }\n var /** @type {?} */ y;\n if (pos.originY == 'center') {\n y = originRect.top + (originRect.height / 2);\n }\n else {\n y = pos.originY == 'top' ? originRect.top : originRect.bottom;\n }\n return { x: x, y: y };\n };\n /**\n * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and\n * origin point to which the overlay should be connected, as well as how much of the element\n * would be inside the viewport at that position.\n * @param {?} originPoint\n * @param {?} overlayRect\n * @param {?} viewportRect\n * @param {?} pos\n * @return {?}\n */\n ConnectedPositionStrategy.prototype._getOverlayPoint = function (originPoint, overlayRect, viewport
Rect, pos) {\n // Calculate the (overlayStartX, overlayStartY), the start of the potential overlay position\n // relative to the origin point.\n var /** @type {?} */ overlayStartX;\n if (pos.overlayX == 'center') {\n overlayStartX = -overlayRect.width / 2;\n }\n else if (pos.overlayX === 'start') {\n overlayStartX = this._isRtl ? -overlayRect.width : 0;\n }\n else {\n overlayStartX = this._isRtl ? 0 : -overlayRect.width;\n }\n var /** @type {?} */ overlayStartY;\n if (pos.overlayY == 'center') {\n overlayStartY = -overlayRect.height / 2;\n }\n else {\n overlayStartY = pos.overlayY == 'top' ? 0 : -overlayRect.height;\n }\n // The (x, y) coordinates of the overlay.\n var /** @type {?} */ x = originPoint.x + overlayStartX + this._offsetX;\n var /** @type {?} */ y = originPoint.y + overlayStartY + this._offsetY;\n
// How much the overlay would overflow at this position, on each side.\n var /** @type {?} */ leftOverflow = 0 - x;\n var /** @type {?} */ rightOverflow = (x + overlayRect.width) - viewportRect.width;\n var /** @type {?} */ topOverflow = 0 - y;\n var /** @type {?} */ bottomOverflow = (y + overlayRect.height) - viewportRect.height;\n // Visible parts of the element on each axis.\n var /** @type {?} */ visibleWidth = this._subtractOverflows(overlayRect.width, leftOverflow, rightOverflow);\n var /** @type {?} */ visibleHeight = this._subtractOverflows(overlayRect.height, topOverflow, bottomOverflow);\n // The area of the element that's within the viewport.\n var /** @type {?} */ visibleArea = visibleWidth * visibleHeight;\n var /** @type {?} */ fitsInViewport = (overlayRect.width * overlayRect.height) === visibleArea;\n return { x: x, y: y, fitsInViewport: fitsInViewport, visibleArea: visibleArea };\n
};\n /**\n * Gets the view properties of the trigger and overlay, including whether they are clipped\n * or completely outside the view of any of the strategy's scrollables.\n * @param {?} overlay\n * @return {?}\n */\n ConnectedPositionStrategy.prototype._getScrollVisibility = function (overlay) {\n var /** @type {?} */ originBounds = this._origin.getBoundingClientRect();\n var /** @type {?} */ overlayBounds = overlay.getBoundingClientRect();\n var /** @type {?} */ scrollContainerBounds = this.scrollables.map(function (s) { return s.getElementRef().nativeElement.getBoundingClientRect(); });\n return {\n isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),\n isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),\n isOverlayClipped: isElementClippedByScrolling(overlayBounds, scrollContainerBounds),\n isOverlayOutsideView: is
ElementScrolledOutsideView(overlayBounds, scrollContainerBounds),\n };\n };\n /**\n * Physically positions the overlay element to the given coordinate.\n * @param {?} element\n * @param {?} overlayRect\n * @param {?} overlayPoint\n * @param {?} pos\n * @return {?}\n */\n ConnectedPositionStrategy.prototype._setElementPosition = function (element, overlayRect, overlayPoint, pos) {\n // We want to set either `top` or `bottom` based on whether the overlay wants to appear above\n // or below the origin and the direction in which the element will expand.\n var /** @type {?} */ verticalStyleProperty = pos.overlayY === 'bottom' ? 'bottom' : 'top';\n // When using `bottom`, we adjust the y position such that it is the distance\n // from the bottom of the viewport rather than the top.\n var /** @type {?} */ y = verticalStyleProperty === 'top' ?\n overlayPoint.y :\n document.documentEle
ment.clientHeight - (overlayPoint.y + overlayRect.height);\n // We want to set either `left` or `right` based on whether the overlay wants to appear \"before\"\n // or \"after\" the origin, which determines the direction in which the element will expand.\n // For the horizontal axis, the meaning of \"before\" and \"after\" change based on whether the\n // page is in RTL or LTR.\n var /** @type {?} */ horizontalStyleProperty;\n if (this._dir === 'rtl') {\n horizontalStyleProperty = pos.overlayX === 'end' ? 'left' : 'right';\n }\n else {\n horizontalStyleProperty = pos.overlayX === 'end' ? 'right' : 'left';\n }\n // When we're setting `right`, we adjust the x position such that it is the distance\n // from the right edge of the viewport rather than the left edge.\n var /** @type {?} */ x = horizontalStyleProperty === 'left' ?\n overlayPoint.x :\n document.doc
umentElement.clientWidth - (overlayPoint.x + overlayRect.width);\n // Reset any existing styles. This is necessary in case the preferred position has\n // changed since the last `apply`.\n ['top', 'bottom', 'left', 'right'].forEach(function (p) { return element.style[p] = null; });\n element.style[verticalStyleProperty] = y + \"px\";\n element.style[horizontalStyleProperty] = x + \"px\";\n // Notify that the position has been changed along with its change properties.\n var /** @type {?} */ scrollableViewProperties = this._getScrollVisibility(element);\n var /** @type {?} */ positionChange = new ConnectedOverlayPositionChange(pos, scrollableViewProperties);\n this._onPositionChange.next(positionChange);\n };\n /**\n * Subtracts the amount that an element is overflowing on an axis from it's length.\n * @param {?} length\n * @param {...?} overflows\n * @return {?}\n */\n ConnectedPositionStrateg
y.prototype._subtractOverflows = function (length) {\n var overflows = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n overflows[_i - 1] = arguments[_i];\n }\n return overflows.reduce(function (currentValue, currentOverflow) {\n return currentValue - Math.max(currentOverflow, 0);\n }, length);\n };\n return ConnectedPositionStrategy;\n}());\nexport { ConnectedPositionStrategy };\nfunction ConnectedPositionStrategy_tsickle_Closure_declarations() {\n /**\n * The overlay to which this strategy is attached.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._overlayRef;\n /**\n * Layout direction of the position strategy.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._dir;\n /**\n * The offset in pixels for the overlay connection point on the x-axis\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._offsetX;\n /**\n * The offset in p
ixels for the overlay connection point on the y-axis\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._offsetY;\n /**\n * The Scrollable containers used to check scrollable view properties on position change.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype.scrollables;\n /**\n * Subscription to viewport resize events.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._resizeSubscription;\n /**\n * Ordered list of preferred positions, from most to least desirable.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._preferredPositions;\n /**\n * The origin element against which the overlay will be positioned.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._origin;\n /**\n * The overlay pane element.\n * @type {?}\n */\n ConnectedPositionStrategy.prototype._pane;\n /**\n * The last position to have been calculated as the best fit position.\
n * @type {?}\n */\n ConnectedPositionStrategy.prototype._lastConnectedPosition;\n /** @type {?} */\n ConnectedPositionStrategy.prototype._onPositionChange;\n /** @type {?} */\n ConnectedPositionStrategy.prototype._connectedTo;\n /** @type {?} */\n ConnectedPositionStrategy.prototype._viewportRuler;\n}\n//# sourceMappingURL=connected-position-strategy.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A strategy for positioning overlays. Using this strategy, an overlay is given an\n * explicit position relative to the browser's viewport. We use flexbox, instead of\n * transforms, in order to avoid issues with subpixel rendering which can cause the\n * element to become blurry.\n */\nvar GlobalPositionStrategy = (function () {\n function GlobalPositionStrategy() {\n this._
cssPosition = 'static';\n this._topOffset = '';\n this._bottomOffset = '';\n this._leftOffset = '';\n this._rightOffset = '';\n this._alignItems = '';\n this._justifyContent = '';\n this._width = '';\n this._height = '';\n this._wrapper = null;\n }\n /**\n * @param {?} overlayRef\n * @return {?}\n */\n GlobalPositionStrategy.prototype.attach = function (overlayRef) {\n this._overlayRef = overlayRef;\n };\n /**\n * Sets the top position of the overlay. Clears any previously set vertical position.\n * @param {?=} value New top offset.\n * @return {?}\n */\n GlobalPositionStrategy.prototype.top = function (value) {\n if (value === void 0) { value = ''; }\n this._bottomOffset = '';\n this._topOffset = value;\n this._alignItems = 'flex-start';\n return this;\n };\n /**\n * Sets the left position of the overlay. Clears any previou
sly set horizontal position.\n * @param {?=} value New left offset.\n * @return {?}\n */\n GlobalPositionStrategy.prototype.left = function (value) {\n if (value === void 0) { value = ''; }\n this._rightOffset = '';\n this._leftOffset = value;\n this._justifyContent = 'flex-start';\n return this;\n };\n /**\n * Sets the bottom position of the overlay. Clears any previously set vertical position.\n * @param {?=} value New bottom offset.\n * @return {?}\n */\n GlobalPositionStrategy.prototype.bottom = function (value) {\n if (value === void 0) { value = ''; }\n this._topOffset = '';\n this._bottomOffset = value;\n this._alignItems = 'flex-end';\n return this;\n };\n /**\n * Sets the right position of the overlay. Clears any previously set horizontal position.\n * @param {?=} value New right offset.\n * @return {?}\n */\n GlobalPositionStrategy.prototyp
e.right = function (value) {\n if (value === void 0) { value = ''; }\n this._leftOffset = '';\n this._rightOffset = value;\n this._justifyContent = 'flex-end';\n return this;\n };\n /**\n * Sets the overlay width and clears any previously set width.\n * @param {?=} value New width for the overlay\n * @return {?}\n */\n GlobalPositionStrategy.prototype.width = function (value) {\n if (value === void 0) { value = ''; }\n this._width = value;\n // When the width is 100%, we should reset the `left` and the offset,\n // in order to ensure that the element is flush against the viewport edge.\n if (value === '100%') {\n this.left('0px');\n }\n return this;\n };\n /**\n * Sets the overlay height and clears any previously set height.\n * @param {?=} value New height for the overlay\n * @return {?}\n */\n GlobalPositionStrategy.prototype.height = fun
ction (value) {\n if (value === void 0) { value = ''; }\n this._height = value;\n // When the height is 100%, we should reset the `top` and the offset,\n // in order to ensure that the element is flush against the viewport edge.\n if (value === '100%') {\n this.top('0px');\n }\n return this;\n };\n /**\n * Centers the overlay horizontally with an optional offset.\n * Clears any previously set horizontal position.\n *\n * @param {?=} offset Overlay offset from the horizontal center.\n * @return {?}\n */\n GlobalPositionStrategy.prototype.centerHorizontally = function (offset) {\n if (offset === void 0) { offset = ''; }\n this.left(offset);\n this._justifyContent = 'center';\n return this;\n };\n /**\n * Centers the overlay vertically with an optional offset.\n * Clears any previously set vertical position.\n *\n * @param {?=} offset Overlay of
fset from the vertical center.\n * @return {?}\n */\n GlobalPositionStrategy.prototype.centerVertically = function (offset) {\n if (offset === void 0) { offset = ''; }\n this.top(offset);\n this._alignItems = 'center';\n return this;\n };\n /**\n * Apply the position to the element.\n * \\@docs-private\n *\n * @return {?} Resolved when the styles have been applied.\n */\n GlobalPositionStrategy.prototype.apply = function () {\n var /** @type {?} */ element = this._overlayRef.overlayElement;\n if (!this._wrapper && element.parentNode) {\n this._wrapper = document.createElement('div');\n this._wrapper.classList.add('cdk-global-overlay-wrapper');\n element.parentNode.insertBefore(this._wrapper, element);\n this._wrapper.appendChild(element);\n }\n var /** @type {?} */ styles = element.style;\n var /** @type {?} */ parentStyles = ((element.pa
rentNode)).style;\n styles.position = this._cssPosition;\n styles.marginTop = this._topOffset;\n styles.marginLeft = this._leftOffset;\n styles.marginBottom = this._bottomOffset;\n styles.marginRight = this._rightOffset;\n styles.width = this._width;\n styles.height = this._height;\n parentStyles.justifyContent = this._justifyContent;\n parentStyles.alignItems = this._alignItems;\n };\n /**\n * Removes the wrapper element from the DOM.\n * @return {?}\n */\n GlobalPositionStrategy.prototype.dispose = function () {\n if (this._wrapper && this._wrapper.parentNode) {\n this._wrapper.parentNode.removeChild(this._wrapper);\n this._wrapper = null;\n }\n };\n return GlobalPositionStrategy;\n}());\nexport { GlobalPositionStrategy };\nfunction GlobalPositionStrategy_tsickle_Closure_declarations() {\n /**\n * The overlay to which this strategy is attached.\n
* @type {?}\n */\n GlobalPositionStrategy.prototype._overlayRef;\n /** @type {?} */\n GlobalPositionStrategy.prototype._cssPosition;\n /** @type {?} */\n GlobalPositionStrategy.prototype._topOffset;\n /** @type {?} */\n GlobalPositionStrategy.prototype._bottomOffset;\n /** @type {?} */\n GlobalPositionStrategy.prototype._leftOffset;\n /** @type {?} */\n GlobalPositionStrategy.prototype._rightOffset;\n /** @type {?} */\n GlobalPositionStrategy.prototype._alignItems;\n /** @type {?} */\n GlobalPositionStrategy.prototype._justifyContent;\n /** @type {?} */\n GlobalPositionStrategy.prototype._width;\n /** @type {?} */\n GlobalPositionStrategy.prototype._height;\n /** @type {?} */\n GlobalPositionStrategy.prototype._wrapper;\n}\n//# sourceMappingURL=global-position-strategy.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can
be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Injectable } from '@angular/core';\nimport { ViewportRuler } from '@angular/cdk/scrolling';\nimport { ConnectedPositionStrategy } from './connected-position-strategy';\nimport { GlobalPositionStrategy } from './global-position-strategy';\n/**\n * Builder for overlay position strategy.\n */\nvar OverlayPositionBuilder = (function () {\n /**\n * @param {?} _viewportRuler\n */\n function OverlayPositionBuilder(_viewportRuler) {\n this._viewportRuler = _viewportRuler;\n }\n /**\n * Creates a global position strategy.\n * @return {?}\n */\n OverlayPositionBuilder.prototype.global = function () {\n return new GlobalPositionStrategy();\n };\n /**\n * Creates a relative position strategy.\n * @param {?} elementRef\n * @param {?} originPos\n * @param {?} overlayPos\n * @return {?}\n */\n OverlayPositionBuilder.prototype.connectedTo =
function (elementRef, originPos, overlayPos) {\n return new ConnectedPositionStrategy(originPos, overlayPos, elementRef, this._viewportRuler);\n };\n OverlayPositionBuilder.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n OverlayPositionBuilder.ctorParameters = function () { return [\n { type: ViewportRuler, },\n ]; };\n return OverlayPositionBuilder;\n}());\nexport { OverlayPositionBuilder };\nfunction OverlayPositionBuilder_tsickle_Closure_declarations() {\n /** @type {?} */\n OverlayPositionBuilder.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n OverlayPositionBuilder.ctorParameters;\n /** @type {?} */\n OverlayPositionBuilder.prototype._viewportRuler;\n}\n//# sourceMappingURL=overlay-position-builder.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the L
ICENSE file at https://angular.io/license\n */\nimport { Injectable, Optional, SkipSelf } from '@angular/core';\n/**\n * The OverlayContainer is the container in which all overlays will load.\n * It should be provided in the root component to ensure it is properly shared.\n */\nvar OverlayContainer = (function () {\n function OverlayContainer() {\n }\n /**\n * @return {?}\n */\n OverlayContainer.prototype.ngOnDestroy = function () {\n if (this._containerElement && this._containerElement.parentNode) {\n this._containerElement.parentNode.removeChild(this._containerElement);\n }\n };\n /**\n * This method returns the overlay container element. It will lazily\n * create the element the first time it is called to facilitate using\n * the container in non-browser environments.\n * @return {?} the container element\n */\n OverlayContainer.prototype.getContainerElement = function () {\n if (!this._containerEle
ment) {\n this._createContainer();\n }\n return this._containerElement;\n };\n /**\n * Create the overlay container element, which is simply a div\n * with the 'cdk-overlay-container' class on the document body.\n * @return {?}\n */\n OverlayContainer.prototype._createContainer = function () {\n var /** @type {?} */ container = document.createElement('div');\n container.classList.add('cdk-overlay-container');\n document.body.appendChild(container);\n this._containerElement = container;\n };\n OverlayContainer.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n OverlayContainer.ctorParameters = function () { return []; };\n return OverlayContainer;\n}());\nexport { OverlayContainer };\nfunction OverlayContainer_tsickle_Closure_declarations() {\n /** @type {?} */\n OverlayContainer.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\
n OverlayContainer.ctorParameters;\n /** @type {?} */\n OverlayContainer.prototype._containerElement;\n}\n/**\n * \\@docs-private\n * @param {?} parentContainer\n * @return {?}\n */\nexport function OVERLAY_CONTAINER_PROVIDER_FACTORY(parentContainer) {\n return parentContainer || new OverlayContainer();\n}\n/**\n * \\@docs-private\n */\nexport var OVERLAY_CONTAINER_PROVIDER = {\n // If there is already an OverlayContainer available, use that. Otherwise, provide a new one.\n provide: OverlayContainer,\n deps: [[new Optional(), new SkipSelf(), OverlayContainer]],\n useFactory: OVERLAY_CONTAINER_PROVIDER_FACTORY\n};\n//# sourceMappingURL=overlay-container.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Returns an error to be thrown when attempting to attach an already-attached scroll st
rategy.\n * @return {?}\n */\nexport function getMatScrollStrategyAlreadyAttachedError() {\n return Error(\"Scroll strategy has already been attached.\");\n}\n//# sourceMappingURL=scroll-strategy.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { getMatScrollStrategyAlreadyAttachedError } from './scroll-strategy';\n/**\n * Strategy that will close the overlay as soon as the user starts scrolling.\n */\nvar CloseScrollStrategy = (function () {\n /**\n * @param {?} _scrollDispatcher\n */\n function CloseScrollStrategy(_scrollDispatcher) {\n this._scrollDispatcher = _scrollDispatcher;\n this._scrollSubscription = null;\n }\n /**\n * @param {?} overlayRef\n * @return {?}\n */\n CloseScrollStrategy.prototype.attach = function (overlayRef) {\n if (this._ove
rlayRef) {\n throw getMatScrollStrategyAlreadyAttachedError();\n }\n this._overlayRef = overlayRef;\n };\n /**\n * @return {?}\n */\n CloseScrollStrategy.prototype.enable = function () {\n var _this = this;\n if (!this._scrollSubscription) {\n this._scrollSubscription = this._scrollDispatcher.scrolled(0, function () {\n if (_this._overlayRef.hasAttached()) {\n _this._overlayRef.detach();\n }\n _this.disable();\n });\n }\n };\n /**\n * @return {?}\n */\n CloseScrollStrategy.prototype.disable = function () {\n if (this._scrollSubscription) {\n this._scrollSubscription.unsubscribe();\n this._scrollSubscription = null;\n }\n };\n return CloseScrollStrategy;\n}());\nexport { CloseScrollStrategy };\nfunction CloseScrollStrategy_tsickle_Closure_declarations() {\n /** @type {?} */\n
CloseScrollStrategy.prototype._scrollSubscription;\n /** @type {?} */\n CloseScrollStrategy.prototype._overlayRef;\n /** @type {?} */\n CloseScrollStrategy.prototype._scrollDispatcher;\n}\n//# sourceMappingURL=close-scroll-strategy.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Strategy that will prevent the user from scrolling while the overlay is visible.\n */\nvar BlockScrollStrategy = (function () {\n /**\n * @param {?} _viewportRuler\n */\n function BlockScrollStrategy(_viewportRuler) {\n this._viewportRuler = _viewportRuler;\n this._previousHTMLStyles = { top: '', left: '' };\n this._isEnabled = false;\n }\n /**\n * @return {?}\n */\n BlockScrollStrategy.prototype.attach = function () { };\n /**\n * @return {?}\n */\n Bl
ockScrollStrategy.prototype.enable = function () {\n if (this._canBeEnabled()) {\n var /** @type {?} */ root = document.documentElement;\n this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();\n // Cache the previous inline styles in case the user had set them.\n this._previousHTMLStyles.left = root.style.left || '';\n this._previousHTMLStyles.top = root.style.top || '';\n // Note: we're using the `html` node, instead of the `body`, because the `body` may\n // have the user agent margin, whereas the `html` is guaranteed not to have one.\n root.style.left = -this._previousScrollPosition.left + \"px\";\n root.style.top = -this._previousScrollPosition.top + \"px\";\n root.classList.add('cdk-global-scrollblock');\n this._isEnabled = true;\n }\n };\n /**\n * @return {?}\n */\n BlockScrollStrategy.prototype.disabl
e = function () {\n if (this._isEnabled) {\n this._isEnabled = false;\n document.documentElement.style.left = this._previousHTMLStyles.left;\n document.documentElement.style.top = this._previousHTMLStyles.top;\n document.documentElement.classList.remove('cdk-global-scrollblock');\n window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);\n }\n };\n /**\n * @return {?}\n */\n BlockScrollStrategy.prototype._canBeEnabled = function () {\n // Since the scroll strategies can't be singletons, we have to use a global CSS class\n // (`cdk-global-scrollblock`) to make sure that we don't try to disable global\n // scrolling multiple times.\n if (document.documentElement.classList.contains('cdk-global-scrollblock') || this._isEnabled) {\n return false;\n }\n var /** @type {?} */ body = document.body;\n var /** @type {?} */
viewport = this._viewportRuler.getViewportRect();\n return body.scrollHeight > viewport.height || body.scrollWidth > viewport.width;\n };\n return BlockScrollStrategy;\n}());\nexport { BlockScrollStrategy };\nfunction BlockScrollStrategy_tsickle_Closure_declarations() {\n /** @type {?} */\n BlockScrollStrategy.prototype._previousHTMLStyles;\n /** @type {?} */\n BlockScrollStrategy.prototype._previousScrollPosition;\n /** @type {?} */\n BlockScrollStrategy.prototype._isEnabled;\n /** @type {?} */\n BlockScrollStrategy.prototype._viewportRuler;\n}\n//# sourceMappingURL=block-scroll-strategy.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { getMatScrollStrategyAlreadyAttachedError } from './scroll-strategy';\n/**\n * Strategy that will update the element position as the user
is scrolling.\n */\nvar RepositionScrollStrategy = (function () {\n /**\n * @param {?} _scrollDispatcher\n * @param {?=} _config\n */\n function RepositionScrollStrategy(_scrollDispatcher, _config) {\n this._scrollDispatcher = _scrollDispatcher;\n this._config = _config;\n this._scrollSubscription = null;\n }\n /**\n * @param {?} overlayRef\n * @return {?}\n */\n RepositionScrollStrategy.prototype.attach = function (overlayRef) {\n if (this._overlayRef) {\n throw getMatScrollStrategyAlreadyAttachedError();\n }\n this._overlayRef = overlayRef;\n };\n /**\n * @return {?}\n */\n RepositionScrollStrategy.prototype.enable = function () {\n var _this = this;\n if (!this._scrollSubscription) {\n var /** @type {?} */ throttle = this._config ? this._config.scrollThrottle : 0;\n this._scrollSubscription = this._scrollDispatcher.scrolled(throttle, fu
nction () {\n _this._overlayRef.updatePosition();\n });\n }\n };\n /**\n * @return {?}\n */\n RepositionScrollStrategy.prototype.disable = function () {\n if (this._scrollSubscription) {\n this._scrollSubscription.unsubscribe();\n this._scrollSubscription = null;\n }\n };\n return RepositionScrollStrategy;\n}());\nexport { RepositionScrollStrategy };\nfunction RepositionScrollStrategy_tsickle_Closure_declarations() {\n /** @type {?} */\n RepositionScrollStrategy.prototype._scrollSubscription;\n /** @type {?} */\n RepositionScrollStrategy.prototype._overlayRef;\n /** @type {?} */\n RepositionScrollStrategy.prototype._scrollDispatcher;\n /** @type {?} */\n RepositionScrollStrategy.prototype._config;\n}\n//# sourceMappingURL=reposition-scroll-strategy.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an
MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Injectable } from '@angular/core';\nimport { CloseScrollStrategy } from './close-scroll-strategy';\nimport { NoopScrollStrategy } from './noop-scroll-strategy';\nimport { BlockScrollStrategy } from './block-scroll-strategy';\nimport { ScrollDispatcher } from '@angular/cdk/scrolling';\nimport { ViewportRuler } from '@angular/cdk/scrolling';\nimport { RepositionScrollStrategy, } from './reposition-scroll-strategy';\n/**\n * Options for how an overlay will handle scrolling.\n *\n * Users can provide a custom value for `ScrollStrategyOptions` to replace the default\n * behaviors. This class primarily acts as a factory for ScrollStrategy instances.\n */\nvar ScrollStrategyOptions = (function () {\n /**\n * @param {?} _scrollDispatcher\n * @param {?} _viewportRuler\n */\n function ScrollStrategyOptions(_scrollDispatcher, _viewportRuler) {\n var _this = this;\n
this._scrollDispatcher = _scrollDispatcher;\n this._viewportRuler = _viewportRuler;\n /**\n * Do nothing on scroll.\n */\n this.noop = function () { return new NoopScrollStrategy(); };\n /**\n * Close the overlay as soon as the user scrolls.\n */\n this.close = function () { return new CloseScrollStrategy(_this._scrollDispatcher); };\n /**\n * Block scrolling.\n */\n this.block = function () { return new BlockScrollStrategy(_this._viewportRuler); };\n /**\n * Update the overlay's position on scroll.\n * @param config Configuration to be used inside the scroll strategy.\n * Allows debouncing the reposition calls.\n */\n this.reposition = function (config) {\n return new RepositionScrollStrategy(_this._scrollDispatcher, config);\n };\n }\n ScrollStrategyOptions.decorators = [\n { type: Injectable },\n ]
;\n /**\n * @nocollapse\n */\n ScrollStrategyOptions.ctorParameters = function () { return [\n { type: ScrollDispatcher, },\n { type: ViewportRuler, },\n ]; };\n return ScrollStrategyOptions;\n}());\nexport { ScrollStrategyOptions };\nfunction ScrollStrategyOptions_tsickle_Closure_declarations() {\n /** @type {?} */\n ScrollStrategyOptions.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n ScrollStrategyOptions.ctorParameters;\n /**\n * Do nothing on scroll.\n * @type {?}\n */\n ScrollStrategyOptions.prototype.noop;\n /**\n * Close the overlay as soon as the user scrolls.\n * @type {?}\n */\n ScrollStrategyOptions.prototype.close;\n /**\n * Block scrolling.\n * @type {?}\n */\n ScrollStrategyOptions.prototype.block;\n /**\n * Update the overlay's position on scroll.\n * \\@param config Configuration to be used inside the scroll strategy.\n * Allows debou
ncing the reposition calls.\n * @type {?}\n */\n ScrollStrategyOptions.prototype.reposition;\n /** @type {?} */\n ScrollStrategyOptions.prototype._scrollDispatcher;\n /** @type {?} */\n ScrollStrategyOptions.prototype._viewportRuler;\n}\n//# sourceMappingURL=scroll-strategy-options.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { ComponentFactoryResolver, Injectable, ApplicationRef, Injector, NgZone, } from '@angular/core';\nimport { DomPortalHost } from '@angular/cdk/portal';\nimport { OverlayConfig } from './overlay-config';\nimport { OverlayRef } from './overlay-ref';\nimport { OverlayPositionBuilder } from './position/overlay-position-builder';\nimport { OverlayContainer } from './overlay-container';\nimport { ScrollStrategyOptions } from './scroll/index';\n/**\n * Next overlay un
ique ID.\n */\nvar nextUniqueId = 0;\n/**\n * The default config for newly created overlays.\n */\nvar defaultConfig = new OverlayConfig();\n/**\n * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be\n * used as a low-level building building block for other components. Dialogs, tooltips, menus,\n * selects, etc. can all be built using overlays. The service should primarily be used by authors\n * of re-usable components rather than developers building end-user applications.\n *\n * An overlay *is* a PortalHost, so any kind of Portal can be loaded into one.\n */\nvar Overlay = (function () {\n /**\n * @param {?} scrollStrategies\n * @param {?} _overlayContainer\n * @param {?} _componentFactoryResolver\n * @param {?} _positionBuilder\n * @param {?} _appRef\n * @param {?} _injector\n * @param {?} _ngZone\n */\n function Overlay(scrollStrategies, _overlayContainer, _componentFactoryResolver, _positionBuilder
, _appRef, _injector, _ngZone) {\n this.scrollStrategies = scrollStrategies;\n this._overlayContainer = _overlayContainer;\n this._componentFactoryResolver = _componentFactoryResolver;\n this._positionBuilder = _positionBuilder;\n this._appRef = _appRef;\n this._injector = _injector;\n this._ngZone = _ngZone;\n }\n /**\n * Creates an overlay.\n * @param {?=} config Config to apply to the overlay.\n * @return {?} Reference to the created overlay.\n */\n Overlay.prototype.create = function (config) {\n if (config === void 0) { config = defaultConfig; }\n var /** @type {?} */ pane = this._createPaneElement();\n var /** @type {?} */ portalHost = this._createPortalHost(pane);\n return new OverlayRef(portalHost, pane, config, this._ngZone);\n };\n /**\n * Returns a position builder that can be used, via fluent API,\n * to construct and configure a position strategy.\n *
@return {?}\n */\n Overlay.prototype.position = function () {\n return this._positionBuilder;\n };\n /**\n * Creates the DOM element for an overlay and appends it to the overlay container.\n * @return {?} Newly-created pane element\n */\n Overlay.prototype._createPaneElement = function () {\n var /** @type {?} */ pane = document.createElement('div');\n pane.id = \"cdk-overlay-\" + nextUniqueId++;\n pane.classList.add('cdk-overlay-pane');\n this._overlayContainer.getContainerElement().appendChild(pane);\n return pane;\n };\n /**\n * Create a DomPortalHost into which the overlay content can be loaded.\n * @param {?} pane The DOM element to turn into a portal host.\n * @return {?} A portal host for the given DOM element.\n */\n Overlay.prototype._createPortalHost = function (pane) {\n return new DomPortalHost(pane, this._componentFactoryResolver, this._appRef, this._injector);\n };\
n Overlay.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n Overlay.ctorParameters = function () { return [\n { type: ScrollStrategyOptions, },\n { type: OverlayContainer, },\n { type: ComponentFactoryResolver, },\n { type: OverlayPositionBuilder, },\n { type: ApplicationRef, },\n { type: Injector, },\n { type: NgZone, },\n ]; };\n return Overlay;\n}());\nexport { Overlay };\nfunction Overlay_tsickle_Closure_declarations() {\n /** @type {?} */\n Overlay.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n Overlay.ctorParameters;\n /** @type {?} */\n Overlay.prototype.scrollStrategies;\n /** @type {?} */\n Overlay.prototype._overlayContainer;\n /** @type {?} */\n Overlay.prototype._componentFactoryResolver;\n /** @type {?} */\n Overlay.prototype._positionBuilder;\n /** @type {?} */\n Overlay.prototype._appRef;\n /** @type
{?} */\n Overlay.prototype._injector;\n /** @type {?} */\n Overlay.prototype._ngZone;\n}\n//# sourceMappingURL=overlay.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as tslib_1 from \"tslib\";\nimport { Injectable } from '@angular/core';\nimport { OverlayContainer } from './overlay-container';\n/**\n * The FullscreenOverlayContainer is the alternative to OverlayContainer\n * that supports correct displaying of overlay elements in Fullscreen mode\n * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen\n * It should be provided in the root component that way:\n * providers: [\n * {provide: OverlayContainer, useClass: FullscreenOverlayContainer}\n * ],\n */\nvar FullscreenOverlayContainer = (function (_super) {\n tslib_1.__extends(FullscreenOverlayContainer, _super);\n
function FullscreenOverlayContainer() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * @return {?}\n */\n FullscreenOverlayContainer.prototype._createContainer = function () {\n var _this = this;\n _super.prototype._createContainer.call(this);\n this._adjustParentForFullscreenChange();\n this._addFullscreenChangeListener(function () { return _this._adjustParentForFullscreenChange(); });\n };\n /**\n * @return {?}\n */\n FullscreenOverlayContainer.prototype._adjustParentForFullscreenChange = function () {\n if (!this._containerElement) {\n return;\n }\n var /** @type {?} */ fullscreenElement = this.getFullscreenElement();\n var /** @type {?} */ parent = fullscreenElement || document.body;\n parent.appendChild(this._containerElement);\n };\n /**\n * @param {?} fn\n * @return {?}\n */\n FullscreenOverlayContainer.prot
otype._addFullscreenChangeListener = function (fn) {\n if (document.fullscreenEnabled) {\n document.addEventListener('fullscreenchange', fn);\n }\n else if (document.webkitFullscreenEnabled) {\n document.addEventListener('webkitfullscreenchange', fn);\n }\n else if (((document)).mozFullScreenEnabled) {\n document.addEventListener('mozfullscreenchange', fn);\n }\n else if (((document)).msFullscreenEnabled) {\n document.addEventListener('MSFullscreenChange', fn);\n }\n };\n /**\n * When the page is put into fullscreen mode, a specific element is specified.\n * Only that element and its children are visible when in fullscreen mode.\n * @return {?}\n */\n FullscreenOverlayContainer.prototype.getFullscreenElement = function () {\n return document.fullscreenElement ||\n document.webkitFullscreenElement ||\n ((document)).mozFullScreenElem
ent ||\n ((document)).msFullscreenElement ||\n null;\n };\n FullscreenOverlayContainer.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n FullscreenOverlayContainer.ctorParameters = function () { return []; };\n return FullscreenOverlayContainer;\n}(OverlayContainer));\nexport { FullscreenOverlayContainer };\nfunction FullscreenOverlayContainer_tsickle_Closure_declarations() {\n /** @type {?} */\n FullscreenOverlayContainer.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n FullscreenOverlayContainer.ctorParameters;\n}\n//# sourceMappingURL=fullscreen-overlay-container.js.map","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, Optional, Output, Re
nderer2, TemplateRef, ViewContainerRef, } from '@angular/core';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ESCAPE } from '@angular/cdk/keycodes';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { Overlay } from './overlay';\nimport { OverlayConfig } from './overlay-config';\nimport { ConnectionPositionPair, } from './position/connected-position';\nimport { Subscription } from 'rxjs/Subscription';\n/**\n * Default set of positions for the overlay. Follows the behavior of a dropdown.\n */\nvar defaultPositionList = [\n new ConnectionPositionPair({ originX: 'start', originY: 'bottom' }, { overlayX: 'start', overlayY: 'top' }),\n new ConnectionPositionPair({ originX: 'start', originY: 'top' }, { overlayX: 'start', overlayY: 'bottom' }),\n];\n/**\n * Injection token that determines the scroll handling while the connected overlay is open.\n */\nexport var MAT_CONNECTED_OVERLAY_SCROLL_S
TRATEGY = new InjectionToken('mat-connected-overlay-scroll-strategy');\n/**\n * \\@docs-private\n * @param {?} overlay\n * @return {?}\n */\nexport function MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {\n return function () { return overlay.scrollStrategies.reposition(); };\n}\n/**\n * \\@docs-private\n */\nexport var MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {\n provide: MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY,\n deps: [Overlay],\n useFactory: MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\nvar OverlayOrigin = (function () {\n /**\n * @param {?} elementRef\n */\n function OverlayOrigin(elementRef) {\n this.elementRef = elementRef;\n }\n OverlayOrigin.decorators = [\n { type: Directive, args: [{\n selector: '[cdk-overlay-origin], [overlay-origin], [cdkO
verlayOrigin]',\n exportAs: 'cdkOverlayOrigin',\n },] },\n ];\n /**\n * @nocollapse\n */\n OverlayOrigin.ctorParameters = function () { return [\n { type: ElementRef, },\n ]; };\n return OverlayOrigin;\n}());\nexport { OverlayOrigin };\nfunction OverlayOrigin_tsickle_Closure_declarations() {\n /** @type {?} */\n OverlayOrigin.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n OverlayOrigin.ctorParameters;\n /** @type {?} */\n OverlayOrigin.prototype.elementRef;\n}\n/**\n * Directive to facilitate declarative creation of an Overlay using a ConnectedPositionStrategy.\n */\nvar ConnectedOverlayDirective = (function () {\n /**\n * @param {?} _overlay\n * @param {?} _renderer\n * @param {?} templateRef\n * @param {?} viewContainerRef\n * @param {?} _scrollStrategy\n * @param {?} _dir\n */\n function ConnectedOverlayDirective(_overlay, _renderer, templateRef,
viewContainerRef, _scrollStrategy, _dir) {\n this._overlay = _overlay;\n this._renderer = _renderer;\n this._scrollStrategy = _scrollStrategy;\n this._dir = _dir;\n this._hasBackdrop = false;\n this._backdropSubscription = Subscription.EMPTY;\n this._positionSubscription = Subscription.EMPTY;\n this._offsetX = 0;\n this._offsetY = 0;\n this._escapeListener = function () { };\n /**\n * Strategy to be used when handling scroll events while the overlay is open.\n */\n this.scrollStrategy = this._scrollStrategy();\n /**\n * Whether the overlay is open.\n */\n this.open = false;\n /**\n * Event emitted when the backdrop is clicked.\n */\n this.backdropClick = new EventEmitter();\n /**\n * Event emitted when the position has changed.\n */\n this.positionChange = new EventEmitter();\n /**\n
* Event emitted when the overlay has been attached.\n */\n this.attach = new EventEmitter();\n /**\n * Event emitted when the overlay has been detached.\n */\n this.detach = new EventEmitter();\n this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\n }\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"offsetX\", {\n /**\n * The offset in pixels for the overlay connection point on the x-axis\n * @return {?}\n */\n get: function () { return this._offsetX; },\n /**\n * @param {?} offsetX\n * @return {?}\n */\n set: function (offsetX) {\n this._offsetX = offsetX;\n if (this._position) {\n this._position.withOffsetX(offsetX);\n }\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"of
fsetY\", {\n /**\n * The offset in pixels for the overlay connection point on the y-axis\n * @return {?}\n */\n get: function () { return this._offsetY; },\n /**\n * @param {?} offsetY\n * @return {?}\n */\n set: function (offsetY) {\n this._offsetY = offsetY;\n if (this._position) {\n this._position.withOffsetY(offsetY);\n }\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"hasBackdrop\", {\n /**\n * Whether or not the overlay should attach a backdrop.\n * @return {?}\n */\n get: function () { return this._hasBackdrop; },\n /**\n * @param {?} value\n * @return {?}\n */\n set: function (value) { this._hasBackdrop = coerceBooleanProperty(value); },\n enumerable: true,\n configurable:
true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedOrigin\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.origin; },\n /**\n * @param {?} _origin\n * @return {?}\n */\n set: function (_origin) { this.origin = _origin; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedPositions\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.positions; },\n /**\n * @param {?} _positions\n * @return {?}\n */\n set: function (_positions) { this.positions = _positions; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedOffsetX\", {\n /**\n * @deprecat
ed\n * @return {?}\n */\n get: function () { return this.offsetX; },\n /**\n * @param {?} _offsetX\n * @return {?}\n */\n set: function (_offsetX) { this.offsetX = _offsetX; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedOffsetY\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.offsetY; },\n /**\n * @param {?} _offsetY\n * @return {?}\n */\n set: function (_offsetY) { this.offsetY = _offsetY; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedWidth\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.width; },\n /**\n * @param {?} _width\n * @r
eturn {?}\n */\n set: function (_width) { this.width = _width; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedHeight\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.height; },\n /**\n * @param {?} _height\n * @return {?}\n */\n set: function (_height) { this.height = _height; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedMinWidth\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.minWidth; },\n /**\n * @param {?} _minWidth\n * @return {?}\n */\n set: function (_minWidth) { this.minWidth = _minWidth; },\n enumerable: true,\n configurable: true\n });\
n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedMinHeight\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.minHeight; },\n /**\n * @param {?} _minHeight\n * @return {?}\n */\n set: function (_minHeight) { this.minHeight = _minHeight; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedBackdropClass\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.backdropClass; },\n /**\n * @param {?} _backdropClass\n * @return {?}\n */\n set: function (_backdropClass) { this.backdropClass = _backdropClass; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedScrollStrategy\", {\
n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.scrollStrategy; },\n /**\n * @param {?} _scrollStrategy\n * @return {?}\n */\n set: function (_scrollStrategy) {\n this.scrollStrategy = _scrollStrategy;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedOpen\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () { return this.open; },\n /**\n * @param {?} _open\n * @return {?}\n */\n set: function (_open) { this.open = _open; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"_deprecatedHasBackdrop\", {\n /**\n * @deprecated\n * @return {?}\n */\n get: function () {
return this.hasBackdrop; },\n /**\n * @param {?} _hasBackdrop\n * @return {?}\n */\n set: function (_hasBackdrop) { this.hasBackdrop = _hasBackdrop; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"overlayRef\", {\n /**\n * The associated overlay reference.\n * @return {?}\n */\n get: function () {\n return this._overlayRef;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectedOverlayDirective.prototype, \"dir\", {\n /**\n * The element's layout direction.\n * @return {?}\n */\n get: function () {\n return this._dir ? this._dir.value : 'ltr';\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n ConnectedOverlayDirective.prototype.ngOnDestroy =
function () {\n this._destroyOverlay();\n };\n /**\n * @param {?} changes\n * @return {?}\n */\n ConnectedOverlayDirective.prototype.ngOnChanges = function (changes) {\n if (changes['open'] || changes['_deprecatedOpen']) {\n this.open ? this._attachOverlay() : this._detachOverlay();\n }\n };\n /**\n * Creates an overlay\n * @return {?}\n */\n ConnectedOverlayDirective.prototype._createOverlay = function () {\n if (!this.positions || !this.positions.length) {\n this.positions = defaultPositionList;\n }\n this._overlayRef = this._overlay.create(this._buildConfig());\n };\n /**\n * Builds the overlay config based on the directive's inputs\n * @return {?}\n */\n ConnectedOverlayDirective.prototype._buildConfig = function () {\n var /** @type {?} */ positionStrategy = this._position = this._createPositionStrategy();\n var /** @type {?} */ overlayCon
fig = new OverlayConfig({\n positionStrategy: positionStrategy,\n scrollStrategy: this.scrollStrategy,\n hasBackdrop: this.hasBackdrop\n });\n if (this.width || this.width === 0) {\n overlayConfig.width = this.width;\n }\n if (this.height || this.height ==
<TRUNCATED>