@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/observers/observe-content.js

@@ -14,183 +14,167 @@ import * as i0 from "@angular/core";
  * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.
  * @docs-private
  */
-let MutationObserverFactory = /** @class */ (() => {
-    class MutationObserverFactory {
-        create(callback) {
-            return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
-        }
+export class MutationObserverFactory {
+    create(callback) {
+        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
     }
-    MutationObserverFactory.ɵprov = i0.ɵɵdefineInjectable({ factory: function MutationObserverFactory_Factory() { return new MutationObserverFactory(); }, token: MutationObserverFactory, providedIn: "root" });
-    MutationObserverFactory.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    return MutationObserverFactory;
-})();
-export { MutationObserverFactory };
+}
+MutationObserverFactory.ɵprov = i0.ɵɵdefineInjectable({ factory: function MutationObserverFactory_Factory() { return new MutationObserverFactory(); }, token: MutationObserverFactory, providedIn: "root" });
+MutationObserverFactory.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 /** An injectable service that allows watching elements for changes to their content. */
-let ContentObserver = /** @class */ (() => {
-    class ContentObserver {
-        constructor(_mutationObserverFactory) {
-            this._mutationObserverFactory = _mutationObserverFactory;
-            /** Keeps track of the existing MutationObservers so they can be reused. */
-            this._observedElements = new Map();
-        }
-        ngOnDestroy() {
-            this._observedElements.forEach((_, element) => this._cleanupObserver(element));
-        }
-        observe(elementOrRef) {
-            const element = coerceElement(elementOrRef);
-            return new Observable((observer) => {
-                const stream = this._observeElement(element);
-                const subscription = stream.subscribe(observer);
-                return () => {
-                    subscription.unsubscribe();
-                    this._unobserveElement(element);
-                };
-            });
-        }
-        /**
-         * Observes the given element by using the existing MutationObserver if available, or creating a
-         * new one if not.
-         */
-        _observeElement(element) {
-            if (!this._observedElements.has(element)) {
-                const stream = new Subject();
-                const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));
-                if (observer) {
-                    observer.observe(element, {
-                        characterData: true,
-                        childList: true,
-                        subtree: true
-                    });
-                }
-                this._observedElements.set(element, { observer, stream, count: 1 });
-            }
-            else {
-                this._observedElements.get(element).count++;
+export class ContentObserver {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        /** Keeps track of the existing MutationObservers so they can be reused. */
+        this._observedElements = new Map();
+    }
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    }
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
+    }
+    /**
+     * Observes the given element by using the existing MutationObserver if available, or creating a
+     * new one if not.
+     */
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));
+            if (observer) {
+                observer.observe(element, {
+                    characterData: true,
+                    childList: true,
+                    subtree: true
+                });
             }
-            return this._observedElements.get(element).stream;
+            this._observedElements.set(element, { observer, stream, count: 1 });
+        }
+        else {
+            this._observedElements.get(element).count++;
         }
-        /**
-         * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
-         * observing this element.
-         */
-        _unobserveElement(element) {
-            if (this._observedElements.has(element)) {
-                this._observedElements.get(element).count--;
-                if (!this._observedElements.get(element).count) {
-                    this._cleanupObserver(element);
-                }
+        return this._observedElements.get(element).stream;
+    }
+    /**
+     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
+     * observing this element.
+     */
+    _unobserveElement(element) {
+        if (this._observedElements.has(element)) {
+            this._observedElements.get(element).count--;
+            if (!this._observedElements.get(element).count) {
+                this._cleanupObserver(element);
             }
         }
-        /** Clean up the underlying MutationObserver for the specified element. */
-        _cleanupObserver(element) {
-            if (this._observedElements.has(element)) {
-                const { observer, stream } = this._observedElements.get(element);
-                if (observer) {
-                    observer.disconnect();
-                }
-                stream.complete();
-                this._observedElements.delete(element);
+    }
+    /** Clean up the underlying MutationObserver for the specified element. */
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.disconnect();
             }
+            stream.complete();
+            this._observedElements.delete(element);
         }
     }
-    ContentObserver.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContentObserver_Factory() { return new ContentObserver(i0.ɵɵinject(MutationObserverFactory)); }, token: ContentObserver, providedIn: "root" });
-    ContentObserver.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    ContentObserver.ctorParameters = () => [
-        { type: MutationObserverFactory }
-    ];
-    return ContentObserver;
-})();
-export { ContentObserver };
+}
+ContentObserver.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContentObserver_Factory() { return new ContentObserver(i0.ɵɵinject(MutationObserverFactory)); }, token: ContentObserver, providedIn: "root" });
+ContentObserver.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+ContentObserver.ctorParameters = () => [
+    { type: MutationObserverFactory }
+];
 /**
  * Directive that triggers a callback whenever the content of
  * its associated element has changed.
  */
-let CdkObserveContent = /** @class */ (() => {
-    class CdkObserveContent {
-        constructor(_contentObserver, _elementRef, _ngZone) {
-            this._contentObserver = _contentObserver;
-            this._elementRef = _elementRef;
-            this._ngZone = _ngZone;
-            /** Event emitted for each change in the element's content. */
-            this.event = new EventEmitter();
-            this._disabled = false;
-            this._currentSubscription = null;
-        }
-        /**
-         * Whether observing content is disabled. This option can be used
-         * to disconnect the underlying MutationObserver until it is needed.
-         */
-        get disabled() { return this._disabled; }
-        set disabled(value) {
-            this._disabled = coerceBooleanProperty(value);
-            this._disabled ? this._unsubscribe() : this._subscribe();
-        }
-        /** Debounce interval for emitting the changes. */
-        get debounce() { return this._debounce; }
-        set debounce(value) {
-            this._debounce = coerceNumberProperty(value);
+export class CdkObserveContent {
+    constructor(_contentObserver, _elementRef, _ngZone) {
+        this._contentObserver = _contentObserver;
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        /** Event emitted for each change in the element's content. */
+        this.event = new EventEmitter();
+        this._disabled = false;
+        this._currentSubscription = null;
+    }
+    /**
+     * Whether observing content is disabled. This option can be used
+     * to disconnect the underlying MutationObserver until it is needed.
+     */
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._disabled ? this._unsubscribe() : this._subscribe();
+    }
+    /** Debounce interval for emitting the changes. */
+    get debounce() { return this._debounce; }
+    set debounce(value) {
+        this._debounce = coerceNumberProperty(value);
+        this._subscribe();
+    }
+    ngAfterContentInit() {
+        if (!this._currentSubscription && !this.disabled) {
             this._subscribe();
         }
-        ngAfterContentInit() {
-            if (!this._currentSubscription && !this.disabled) {
-                this._subscribe();
-            }
-        }
-        ngOnDestroy() {
-            this._unsubscribe();
-        }
-        _subscribe() {
-            this._unsubscribe();
-            const stream = this._contentObserver.observe(this._elementRef);
-            // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.
-            // Consider brining it back inside the zone next time we're making breaking changes.
-            // Bringing it back inside can cause things like infinite change detection loops and changed
-            // after checked errors if people's code isn't handling it properly.
-            this._ngZone.runOutsideAngular(() => {
-                this._currentSubscription =
-                    (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);
-            });
-        }
-        _unsubscribe() {
-            if (this._currentSubscription) {
-                this._currentSubscription.unsubscribe();
-            }
-        }
     }
-    CdkObserveContent.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkObserveContent]',
-                    exportAs: 'cdkObserveContent',
-                },] }
-    ];
-    CdkObserveContent.ctorParameters = () => [
-        { type: ContentObserver },
-        { type: ElementRef },
-        { type: NgZone }
-    ];
-    CdkObserveContent.propDecorators = {
-        event: [{ type: Output, args: ['cdkObserveContent',] }],
-        disabled: [{ type: Input, args: ['cdkObserveContentDisabled',] }],
-        debounce: [{ type: Input }]
-    };
-    return CdkObserveContent;
-})();
-export { CdkObserveContent };
-let ObserversModule = /** @class */ (() => {
-    class ObserversModule {
+    ngOnDestroy() {
+        this._unsubscribe();
+    }
+    _subscribe() {
+        this._unsubscribe();
+        const stream = this._contentObserver.observe(this._elementRef);
+        // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.
+        // Consider brining it back inside the zone next time we're making breaking changes.
+        // Bringing it back inside can cause things like infinite change detection loops and changed
+        // after checked errors if people's code isn't handling it properly.
+        this._ngZone.runOutsideAngular(() => {
+            this._currentSubscription =
+                (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);
+        });
+    }
+    _unsubscribe() {
+        if (this._currentSubscription) {
+            this._currentSubscription.unsubscribe();
+        }
     }
-    ObserversModule.decorators = [
-        { type: NgModule, args: [{
-                    exports: [CdkObserveContent],
-                    declarations: [CdkObserveContent],
-                    providers: [MutationObserverFactory]
-                },] }
-    ];
-    return ObserversModule;
-})();
-export { ObserversModule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observe-content.js","sourceRoot":"","sources":["../../../../../../src/cdk/observers/observe-content.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  coerceElement,\n  BooleanInput\n} from '@angular/cdk/coercion';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Injectable,\n  Input,\n  NgModule,\n  NgZone,\n  OnDestroy,\n  Output,\n} from '@angular/core';\nimport {Observable, Subject, Subscription, Observer} from 'rxjs';\nimport {debounceTime} from 'rxjs/operators';\n\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * @docs-private\n */\n@Injectable({providedIn: 'root'})\nexport class MutationObserverFactory {\n  create(callback: MutationCallback): MutationObserver | null {\n    return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n  }\n}\n\n\n/** An injectable service that allows watching elements for changes to their content. */\n@Injectable({providedIn: 'root'})\nexport class ContentObserver implements OnDestroy {\n  /** Keeps track of the existing MutationObservers so they can be reused. */\n  private _observedElements = new Map<Element, {\n    observer: MutationObserver | null,\n    stream: Subject<MutationRecord[]>,\n    count: number\n  }>();\n\n  constructor(private _mutationObserverFactory: MutationObserverFactory) {}\n\n  ngOnDestroy() {\n    this._observedElements.forEach((_, element) => this._cleanupObserver(element));\n  }\n\n  /**\n   * Observe content changes on an element.\n   * @param element The element to observe for content changes.\n   */\n  observe(element: Element): Observable<MutationRecord[]>;\n\n  /**\n   * Observe content changes on an element.\n   * @param element The element to observe for content changes.\n   */\n  observe(element: ElementRef<Element>): Observable<MutationRecord[]>;\n\n  observe(elementOrRef: Element | ElementRef<Element>): Observable<MutationRecord[]> {\n    const element = coerceElement(elementOrRef);\n\n    return new Observable((observer: Observer<MutationRecord[]>) => {\n      const stream = this._observeElement(element);\n      const subscription = stream.subscribe(observer);\n\n      return () => {\n        subscription.unsubscribe();\n        this._unobserveElement(element);\n      };\n    });\n  }\n\n  /**\n   * Observes the given element by using the existing MutationObserver if available, or creating a\n   * new one if not.\n   */\n  private _observeElement(element: Element): Subject<MutationRecord[]> {\n    if (!this._observedElements.has(element)) {\n      const stream = new Subject<MutationRecord[]>();\n      const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));\n      if (observer) {\n        observer.observe(element, {\n          characterData: true,\n          childList: true,\n          subtree: true\n        });\n      }\n      this._observedElements.set(element, {observer, stream, count: 1});\n    } else {\n      this._observedElements.get(element)!.count++;\n    }\n    return this._observedElements.get(element)!.stream;\n  }\n\n  /**\n   * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is\n   * observing this element.\n   */\n  private _unobserveElement(element: Element) {\n    if (this._observedElements.has(element)) {\n      this._observedElements.get(element)!.count--;\n      if (!this._observedElements.get(element)!.count) {\n        this._cleanupObserver(element);\n      }\n    }\n  }\n\n  /** Clean up the underlying MutationObserver for the specified element. */\n  private _cleanupObserver(element: Element) {\n    if (this._observedElements.has(element)) {\n      const {observer, stream} = this._observedElements.get(element)!;\n      if (observer) {\n        observer.disconnect();\n      }\n      stream.complete();\n      this._observedElements.delete(element);\n    }\n  }\n}\n\n\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\n@Directive({\n  selector: '[cdkObserveContent]',\n  exportAs: 'cdkObserveContent',\n})\nexport class CdkObserveContent implements AfterContentInit, OnDestroy {\n  /** Event emitted for each change in the element's content. */\n  @Output('cdkObserveContent') event = new EventEmitter<MutationRecord[]>();\n\n  /**\n   * Whether observing content is disabled. This option can be used\n   * to disconnect the underlying MutationObserver until it is needed.\n   */\n  @Input('cdkObserveContentDisabled')\n  get disabled() { return this._disabled; }\n  set disabled(value: any) {\n    this._disabled = coerceBooleanProperty(value);\n    this._disabled ? this._unsubscribe() : this._subscribe();\n  }\n  private _disabled = false;\n\n  /** Debounce interval for emitting the changes. */\n  @Input()\n  get debounce(): number { return this._debounce; }\n  set debounce(value: number) {\n    this._debounce = coerceNumberProperty(value);\n    this._subscribe();\n  }\n  private _debounce: number;\n\n  private _currentSubscription: Subscription | null = null;\n\n  constructor(private _contentObserver: ContentObserver,\n              private _elementRef: ElementRef<HTMLElement>,\n              private _ngZone: NgZone) {}\n\n  ngAfterContentInit() {\n    if (!this._currentSubscription && !this.disabled) {\n      this._subscribe();\n    }\n  }\n\n  ngOnDestroy() {\n    this._unsubscribe();\n  }\n\n  private _subscribe() {\n    this._unsubscribe();\n    const stream = this._contentObserver.observe(this._elementRef);\n\n    // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.\n    // Consider brining it back inside the zone next time we're making breaking changes.\n    // Bringing it back inside can cause things like infinite change detection loops and changed\n    // after checked errors if people's code isn't handling it properly.\n    this._ngZone.runOutsideAngular(() => {\n      this._currentSubscription =\n          (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);\n    });\n  }\n\n  private _unsubscribe() {\n    if (this._currentSubscription) {\n      this._currentSubscription.unsubscribe();\n    }\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_debounce: BooleanInput;\n}\n\n\n@NgModule({\n  exports: [CdkObserveContent],\n  declarations: [CdkObserveContent],\n  providers: [MutationObserverFactory]\n})\nexport class ObserversModule {}\n"]}
+}
+CdkObserveContent.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkObserveContent]',
+                exportAs: 'cdkObserveContent',
+            },] }
+];
+CdkObserveContent.ctorParameters = () => [
+    { type: ContentObserver },
+    { type: ElementRef },
+    { type: NgZone }
+];
+CdkObserveContent.propDecorators = {
+    event: [{ type: Output, args: ['cdkObserveContent',] }],
+    disabled: [{ type: Input, args: ['cdkObserveContentDisabled',] }],
+    debounce: [{ type: Input }]
+};
+export class ObserversModule {
+}
+ObserversModule.decorators = [
+    { type: NgModule, args: [{
+                exports: [CdkObserveContent],
+                declarations: [CdkObserveContent],
+                providers: [MutationObserverFactory]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observe-content.js","sourceRoot":"","sources":["../../../../../../src/cdk/observers/observe-content.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  coerceElement,\n  BooleanInput\n} from '@angular/cdk/coercion';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Injectable,\n  Input,\n  NgModule,\n  NgZone,\n  OnDestroy,\n  Output,\n} from '@angular/core';\nimport {Observable, Subject, Subscription, Observer} from 'rxjs';\nimport {debounceTime} from 'rxjs/operators';\n\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * @docs-private\n */\n@Injectable({providedIn: 'root'})\nexport class MutationObserverFactory {\n  create(callback: MutationCallback): MutationObserver | null {\n    return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n  }\n}\n\n\n/** An injectable service that allows watching elements for changes to their content. */\n@Injectable({providedIn: 'root'})\nexport class ContentObserver implements OnDestroy {\n  /** Keeps track of the existing MutationObservers so they can be reused. */\n  private _observedElements = new Map<Element, {\n    observer: MutationObserver | null,\n    stream: Subject<MutationRecord[]>,\n    count: number\n  }>();\n\n  constructor(private _mutationObserverFactory: MutationObserverFactory) {}\n\n  ngOnDestroy() {\n    this._observedElements.forEach((_, element) => this._cleanupObserver(element));\n  }\n\n  /**\n   * Observe content changes on an element.\n   * @param element The element to observe for content changes.\n   */\n  observe(element: Element): Observable<MutationRecord[]>;\n\n  /**\n   * Observe content changes on an element.\n   * @param element The element to observe for content changes.\n   */\n  observe(element: ElementRef<Element>): Observable<MutationRecord[]>;\n\n  observe(elementOrRef: Element | ElementRef<Element>): Observable<MutationRecord[]> {\n    const element = coerceElement(elementOrRef);\n\n    return new Observable((observer: Observer<MutationRecord[]>) => {\n      const stream = this._observeElement(element);\n      const subscription = stream.subscribe(observer);\n\n      return () => {\n        subscription.unsubscribe();\n        this._unobserveElement(element);\n      };\n    });\n  }\n\n  /**\n   * Observes the given element by using the existing MutationObserver if available, or creating a\n   * new one if not.\n   */\n  private _observeElement(element: Element): Subject<MutationRecord[]> {\n    if (!this._observedElements.has(element)) {\n      const stream = new Subject<MutationRecord[]>();\n      const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));\n      if (observer) {\n        observer.observe(element, {\n          characterData: true,\n          childList: true,\n          subtree: true\n        });\n      }\n      this._observedElements.set(element, {observer, stream, count: 1});\n    } else {\n      this._observedElements.get(element)!.count++;\n    }\n    return this._observedElements.get(element)!.stream;\n  }\n\n  /**\n   * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is\n   * observing this element.\n   */\n  private _unobserveElement(element: Element) {\n    if (this._observedElements.has(element)) {\n      this._observedElements.get(element)!.count--;\n      if (!this._observedElements.get(element)!.count) {\n        this._cleanupObserver(element);\n      }\n    }\n  }\n\n  /** Clean up the underlying MutationObserver for the specified element. */\n  private _cleanupObserver(element: Element) {\n    if (this._observedElements.has(element)) {\n      const {observer, stream} = this._observedElements.get(element)!;\n      if (observer) {\n        observer.disconnect();\n      }\n      stream.complete();\n      this._observedElements.delete(element);\n    }\n  }\n}\n\n\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\n@Directive({\n  selector: '[cdkObserveContent]',\n  exportAs: 'cdkObserveContent',\n})\nexport class CdkObserveContent implements AfterContentInit, OnDestroy {\n  /** Event emitted for each change in the element's content. */\n  @Output('cdkObserveContent') event = new EventEmitter<MutationRecord[]>();\n\n  /**\n   * Whether observing content is disabled. This option can be used\n   * to disconnect the underlying MutationObserver until it is needed.\n   */\n  @Input('cdkObserveContentDisabled')\n  get disabled() { return this._disabled; }\n  set disabled(value: any) {\n    this._disabled = coerceBooleanProperty(value);\n    this._disabled ? this._unsubscribe() : this._subscribe();\n  }\n  private _disabled = false;\n\n  /** Debounce interval for emitting the changes. */\n  @Input()\n  get debounce(): number { return this._debounce; }\n  set debounce(value: number) {\n    this._debounce = coerceNumberProperty(value);\n    this._subscribe();\n  }\n  private _debounce: number;\n\n  private _currentSubscription: Subscription | null = null;\n\n  constructor(private _contentObserver: ContentObserver,\n              private _elementRef: ElementRef<HTMLElement>,\n              private _ngZone: NgZone) {}\n\n  ngAfterContentInit() {\n    if (!this._currentSubscription && !this.disabled) {\n      this._subscribe();\n    }\n  }\n\n  ngOnDestroy() {\n    this._unsubscribe();\n  }\n\n  private _subscribe() {\n    this._unsubscribe();\n    const stream = this._contentObserver.observe(this._elementRef);\n\n    // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone.\n    // Consider brining it back inside the zone next time we're making breaking changes.\n    // Bringing it back inside can cause things like infinite change detection loops and changed\n    // after checked errors if people's code isn't handling it properly.\n    this._ngZone.runOutsideAngular(() => {\n      this._currentSubscription =\n          (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);\n    });\n  }\n\n  private _unsubscribe() {\n    if (this._currentSubscription) {\n      this._currentSubscription.unsubscribe();\n    }\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_debounce: BooleanInput;\n}\n\n\n@NgModule({\n  exports: [CdkObserveContent],\n  declarations: [CdkObserveContent],\n  providers: [MutationObserverFactory]\n})\nexport class ObserversModule {}\n"]}

package/esm2015/overlay/dispatchers/base-overlay-dispatcher.js

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Service for dispatching events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+export class BaseOverlayDispatcher {
+    constructor(document) {
+        /** Currently attached overlays in the order they were attached. */
+        this._attachedOverlays = [];
+        this._document = document;
+    }
+    ngOnDestroy() {
+        this.detach();
+    }
+    /** Add a new overlay to the list of attached overlay refs. */
+    add(overlayRef) {
+        // Ensure that we don't get the same overlay multiple times.
+        this.remove(overlayRef);
+        this._attachedOverlays.push(overlayRef);
+    }
+    /** Remove an overlay from the list of attached overlay refs. */
+    remove(overlayRef) {
+        const 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.detach();
+        }
+    }
+}
+BaseOverlayDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseOverlayDispatcher_Factory() { return new BaseOverlayDispatcher(i0.ɵɵinject(i1.DOCUMENT)); }, token: BaseOverlayDispatcher, providedIn: "root" });
+BaseOverlayDispatcher.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+BaseOverlayDispatcher.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1vdmVybGF5LWRpc3BhdGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL292ZXJsYXkvZGlzcGF0Y2hlcnMvYmFzZS1vdmVybGF5LWRpc3BhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQ3pDLE9BQU8sRUFBQyxNQUFNLEVBQUUsVUFBVSxFQUFZLE1BQU0sZUFBZSxDQUFDOzs7QUFJNUQ7Ozs7R0FJRztBQUVILE1BQU0sT0FBZ0IscUJBQXFCO0lBUXpDLFlBQThCLFFBQWE7UUFOM0MsbUVBQW1FO1FBQ25FLHNCQUFpQixHQUF1QixFQUFFLENBQUM7UUFNekMsSUFBSSxDQUFDLFNBQVMsR0FBRyxRQUFRLENBQUM7SUFDNUIsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDaEIsQ0FBQztJQUVELDhEQUE4RDtJQUM5RCxHQUFHLENBQUMsVUFBNEI7UUFDOUIsNERBQTREO1FBQzVELElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDeEIsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBRUQsZ0VBQWdFO0lBQ2hFLE1BQU0sQ0FBQyxVQUE0QjtRQUNqQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBRXpELElBQUksS0FBSyxHQUFHLENBQUMsQ0FBQyxFQUFFO1lBQ2QsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7U0FDekM7UUFFRCw4REFBOEQ7UUFDOUQsSUFBSSxJQUFJLENBQUMsaUJBQWlCLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtZQUN2QyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7U0FDZjtJQUNILENBQUM7Ozs7WUFwQ0YsVUFBVSxTQUFDLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQzs7OzRDQVNqQixNQUFNLFNBQUMsUUFBUSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0RPQ1VNRU5UfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtJbmplY3QsIEluamVjdGFibGUsIE9uRGVzdHJveX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge092ZXJsYXlSZWZlcmVuY2V9IGZyb20gJy4uL292ZXJsYXktcmVmZXJlbmNlJztcblxuXG4vKipcbiAqIFNlcnZpY2UgZm9yIGRpc3BhdGNoaW5nIGV2ZW50cyB0aGF0IGxhbmQgb24gdGhlIGJvZHkgdG8gYXBwcm9wcmlhdGUgb3ZlcmxheSByZWYsXG4gKiBpZiBhbnkuIEl0IG1haW50YWlucyBhIGxpc3Qgb2YgYXR0YWNoZWQgb3ZlcmxheXMgdG8gZGV0ZXJtaW5lIGJlc3Qgc3VpdGVkIG92ZXJsYXkgYmFzZWRcbiAqIG9uIGV2ZW50IHRhcmdldCBhbmQgb3JkZXIgb2Ygb3ZlcmxheSBvcGVucy5cbiAqL1xuQEluamVjdGFibGUoe3Byb3ZpZGVkSW46ICdyb290J30pXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZU92ZXJsYXlEaXNwYXRjaGVyIGltcGxlbWVudHMgT25EZXN0cm95IHtcblxuICAvKiogQ3VycmVudGx5IGF0dGFjaGVkIG92ZXJsYXlzIGluIHRoZSBvcmRlciB0aGV5IHdlcmUgYXR0YWNoZWQuICovXG4gIF9hdHRhY2hlZE92ZXJsYXlzOiBPdmVybGF5UmVmZXJlbmNlW10gPSBbXTtcblxuICBwcm90ZWN0ZWQgX2RvY3VtZW50OiBEb2N1bWVudDtcbiAgcHJvdGVjdGVkIF9pc0F0dGFjaGVkOiBib29sZWFuO1xuXG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoRE9DVU1FTlQpIGRvY3VtZW50OiBhbnkpIHtcbiAgICB0aGlzLl9kb2N1bWVudCA9IGRvY3VtZW50O1xuICB9XG5cbiAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgdGhpcy5kZXRhY2goKTtcbiAgfVxuXG4gIC8qKiBBZGQgYSBuZXcgb3ZlcmxheSB0byB0aGUgbGlzdCBvZiBhdHRhY2hlZCBvdmVybGF5IHJlZnMuICovXG4gIGFkZChvdmVybGF5UmVmOiBPdmVybGF5UmVmZXJlbmNlKTogdm9pZCB7XG4gICAgLy8gRW5zdXJlIHRoYXQgd2UgZG9uJ3QgZ2V0IHRoZSBzYW1lIG92ZXJsYXkgbXVsdGlwbGUgdGltZXMuXG4gICAgdGhpcy5yZW1vdmUob3ZlcmxheVJlZik7XG4gICAgdGhpcy5fYXR0YWNoZWRPdmVybGF5cy5wdXNoKG92ZXJsYXlSZWYpO1xuICB9XG5cbiAgLyoqIFJlbW92ZSBhbiBvdmVybGF5IGZyb20gdGhlIGxpc3Qgb2YgYXR0YWNoZWQgb3ZlcmxheSByZWZzLiAqL1xuICByZW1vdmUob3ZlcmxheVJlZjogT3ZlcmxheVJlZmVyZW5jZSk6IHZvaWQge1xuICAgIGNvbnN0IGluZGV4ID0gdGhpcy5fYXR0YWNoZWRPdmVybGF5cy5pbmRleE9mKG92ZXJsYXlSZWYpO1xuXG4gICAgaWYgKGluZGV4ID4gLTEpIHtcbiAgICAgIHRoaXMuX2F0dGFjaGVkT3ZlcmxheXMuc3BsaWNlKGluZGV4LCAxKTtcbiAgICB9XG5cbiAgICAvLyBSZW1vdmUgdGhlIGdsb2JhbCBsaXN0ZW5lciBvbmNlIHRoZXJlIGFyZSBubyBtb3JlIG92ZXJsYXlzLlxuICAgIGlmICh0aGlzLl9hdHRhY2hlZE92ZXJsYXlzLmxlbmd0aCA9PT0gMCkge1xuICAgICAgdGhpcy5kZXRhY2goKTtcbiAgICB9XG4gIH1cblxuICAvKiogRGV0YWNoZXMgdGhlIGdsb2JhbCBldmVudCBsaXN0ZW5lci4gKi9cbiAgcHJvdGVjdGVkIGFic3RyYWN0IGRldGFjaCgpOiB2b2lkO1xufVxuIl19

package/esm2015/overlay/dispatchers/index.js

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+export { OverlayOutsideClickDispatcher } from './overlay-outside-click-dispatcher';
+export { OverlayKeyboardDispatcher } from './overlay-keyboard-dispatcher';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL292ZXJsYXkvZGlzcGF0Y2hlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLDZCQUE2QixFQUFDLE1BQU0sb0NBQW9DLENBQUM7QUFDakYsT0FBTyxFQUFDLHlCQUF5QixFQUFDLE1BQU0sK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtPdmVybGF5T3V0c2lkZUNsaWNrRGlzcGF0Y2hlcn0gZnJvbSAnLi9vdmVybGF5LW91dHNpZGUtY2xpY2stZGlzcGF0Y2hlcic7XG5leHBvcnQge092ZXJsYXlLZXlib2FyZERpc3BhdGNoZXJ9IGZyb20gJy4vb3ZlcmxheS1rZXlib2FyZC1kaXNwYXRjaGVyJztcbiJdfQ==

package/esm2015/overlay/dispatchers/overlay-keyboard-dispatcher.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable, Optional, SkipSelf, } from '@angular/core';
+import { BaseOverlayDispatcher } from './base-overlay-dispatcher';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * 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.
+ */
+export class OverlayKeyboardDispatcher extends BaseOverlayDispatcher {
+    constructor(document) {
+        super(document);
+        /** Keyboard event listener that will be attached to the body. */
+        this._keydownListener = (event) => {
+            const overlays = this._attachedOverlays;
+            for (let i = overlays.length - 1; i > -1; i--) {
+                // Dispatch the keydown event to the top overlay which has subscribers to its keydown events.
+                // We want to target the most recent overlay, rather than trying to match where the event came
+                // from, because some components might open an overlay, but keep focus on a trigger element
+                // (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,
+                // because we don't want overlays that don't handle keyboard events to block the ones below
+                // them that do.
+                if (overlays[i]._keydownEvents.observers.length > 0) {
+                    overlays[i]._keydownEvents.next(event);
+                    break;
+                }
+            }
+        };
+    }
+    /** Add a new overlay to the list of attached overlay refs. */
+    add(overlayRef) {
+        super.add(overlayRef);
+        // Lazily start dispatcher once first overlay is added
+        if (!this._isAttached) {
+            this._document.body.addEventListener('keydown', this._keydownListener);
+            this._isAttached = true;
+        }
+    }
+    /** Detaches the global keyboard event listener. */
+    detach() {
+        if (this._isAttached) {
+            this._document.body.removeEventListener('keydown', this._keydownListener);
+            this._isAttached = false;
+        }
+    }
+}
+OverlayKeyboardDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(i0.ɵɵinject(i1.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
+OverlayKeyboardDispatcher.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+OverlayKeyboardDispatcher.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+/** @docs-private @deprecated @breaking-change 8.0.0 */
+export function OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY(dispatcher, _document) {
+    return dispatcher || new OverlayKeyboardDispatcher(_document);
+}
+/** @docs-private @deprecated @breaking-change 8.0.0 */
+export const OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {
+    // If there is already an OverlayKeyboardDispatcher available, use that.
+    // Otherwise, provide a new one.
+    provide: OverlayKeyboardDispatcher,
+    deps: [
+        [new Optional(), new SkipSelf(), OverlayKeyboardDispatcher],
+        // Coerce to `InjectionToken` so that the `deps` match the "shape"
+        // of the type expected by Angular
+        DOCUMENT
+    ],
+    useFactory: OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY
+};
+//# sourceMappingURL=data:application/json;base64,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