@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/chips/chip.js

@@ -5,15 +5,15 @@
  * 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 { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { BACKSPACE, DELETE, SPACE } from '@angular/cdk/keycodes';
 import { Platform } from '@angular/cdk/platform';
-import { ContentChild, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, NgZone, Optional, Output, ChangeDetectorRef, Attribute, } from '@angular/core';
-import { mixinTabIndex, MAT_RIPPLE_GLOBAL_OPTIONS, mixinColor, mixinDisableRipple, RippleRenderer, } from '@angular/material/core';
+import { DOCUMENT } from '@angular/common';
+import { Attribute, ChangeDetectorRef, ContentChild, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, Optional, Output, } from '@angular/core';
+import { MAT_RIPPLE_GLOBAL_OPTIONS, mixinColor, mixinDisableRipple, mixinTabIndex, RippleRenderer, } from '@angular/material/core';
+import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
 import { Subject } from 'rxjs';
 import { take } from 'rxjs/operators';
-import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
 /** Event object emitted by MatChip when selected or deselected. */
 export class MatChipSelectionChange {
     constructor(
@@ -28,6 +28,24 @@ export class MatChipSelectionChange {
         this.isUserInput = isUserInput;
     }
 }
+/**
+ * Injection token that can be used to reference instances of `MatChipRemove`. It serves as
+ * alternative token to the actual `MatChipRemove` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+export const MAT_CHIP_REMOVE = new InjectionToken('MatChipRemove');
+/**
+ * Injection token that can be used to reference instances of `MatChipAvatar`. It serves as
+ * alternative token to the actual `MatChipAvatar` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+export const MAT_CHIP_AVATAR = new InjectionToken('MatChipAvatar');
+/**
+ * Injection token that can be used to reference instances of `MatChipTrailingIcon`. It serves as
+ * alternative token to the actual `MatChipTrailingIcon` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+export const MAT_CHIP_TRAILING_ICON = new InjectionToken('MatChipTrailingIcon');
 // Boilerplate for applying mixins to MatChip.
 /** @docs-private */
 class MatChipBase {
@@ -40,314 +58,304 @@ const _MatChipMixinBase = mixinTabIndex(mixinColor(mixinDisableRipple(MatChipBas
  * Dummy directive to add CSS class to chip avatar.
  * @docs-private
  */
-let MatChipAvatar = /** @class */ (() => {
-    class MatChipAvatar {
-    }
-    MatChipAvatar.decorators = [
-        { type: Directive, args: [{
-                    selector: 'mat-chip-avatar, [matChipAvatar]',
-                    host: { 'class': 'mat-chip-avatar' }
-                },] }
-    ];
-    return MatChipAvatar;
-})();
-export { MatChipAvatar };
+export class MatChipAvatar {
+}
+MatChipAvatar.decorators = [
+    { type: Directive, args: [{
+                selector: 'mat-chip-avatar, [matChipAvatar]',
+                host: { 'class': 'mat-chip-avatar' },
+                providers: [{ provide: MAT_CHIP_AVATAR, useExisting: MatChipAvatar }]
+            },] }
+];
 /**
  * Dummy directive to add CSS class to chip trailing icon.
  * @docs-private
  */
-let MatChipTrailingIcon = /** @class */ (() => {
-    class MatChipTrailingIcon {
-    }
-    MatChipTrailingIcon.decorators = [
-        { type: Directive, args: [{
-                    selector: 'mat-chip-trailing-icon, [matChipTrailingIcon]',
-                    host: { 'class': 'mat-chip-trailing-icon' }
-                },] }
-    ];
-    return MatChipTrailingIcon;
-})();
-export { MatChipTrailingIcon };
+export class MatChipTrailingIcon {
+}
+MatChipTrailingIcon.decorators = [
+    { type: Directive, args: [{
+                selector: 'mat-chip-trailing-icon, [matChipTrailingIcon]',
+                host: { 'class': 'mat-chip-trailing-icon' },
+                providers: [{ provide: MAT_CHIP_TRAILING_ICON, useExisting: MatChipTrailingIcon }],
+            },] }
+];
 /**
  * Material design styled Chip component. Used inside the MatChipList component.
  */
-let MatChip = /** @class */ (() => {
-    class MatChip extends _MatChipMixinBase {
-        constructor(_elementRef, _ngZone, platform, globalRippleOptions, 
-        // @breaking-change 8.0.0 `animationMode` parameter to become required.
-        animationMode, 
-        // @breaking-change 9.0.0 `_changeDetectorRef` parameter to become required.
-        _changeDetectorRef, tabIndex, 
-        // @breaking-change 11.0.0 `_document` parameter to become required.
-        _document) {
-            super(_elementRef);
-            this._elementRef = _elementRef;
-            this._ngZone = _ngZone;
-            this._changeDetectorRef = _changeDetectorRef;
-            /** Whether the chip has focus. */
-            this._hasFocus = false;
-            /** Whether the chip list is selectable */
-            this.chipListSelectable = true;
-            /** Whether the chip list is in multi-selection mode. */
-            this._chipListMultiple = false;
-            /** Whether the chip list as a whole is disabled. */
-            this._chipListDisabled = false;
-            this._selected = false;
-            this._selectable = true;
-            this._disabled = false;
-            this._removable = true;
-            /** Emits when the chip is focused. */
-            this._onFocus = new Subject();
-            /** Emits when the chip is blured. */
-            this._onBlur = new Subject();
-            /** Emitted when the chip is selected or deselected. */
-            this.selectionChange = new EventEmitter();
-            /** Emitted when the chip is destroyed. */
-            this.destroyed = new EventEmitter();
-            /** Emitted when a chip is to be removed. */
-            this.removed = new EventEmitter();
-            this._addHostClassName();
-            // Dynamically create the ripple target, append it within the chip, and use it as the
-            // chip's ripple target. Adding the class '.mat-chip-ripple' ensures that it will have
-            // the proper styles.
-            this._chipRippleTarget = (_document || document).createElement('div');
-            this._chipRippleTarget.classList.add('mat-chip-ripple');
-            this._elementRef.nativeElement.appendChild(this._chipRippleTarget);
-            this._chipRipple = new RippleRenderer(this, _ngZone, this._chipRippleTarget, platform);
-            this._chipRipple.setupTriggerEvents(_elementRef);
-            this.rippleConfig = globalRippleOptions || {};
-            this._animationsDisabled = animationMode === 'NoopAnimations';
-            this.tabIndex = tabIndex != null ? (parseInt(tabIndex) || -1) : -1;
-        }
-        /**
-         * Whether ripples are disabled on interaction
-         * @docs-private
-         */
-        get rippleDisabled() {
-            return this.disabled || this.disableRipple || !!this.rippleConfig.disabled;
-        }
-        /** Whether the chip is selected. */
-        get selected() { return this._selected; }
-        set selected(value) {
-            const coercedValue = coerceBooleanProperty(value);
-            if (coercedValue !== this._selected) {
-                this._selected = coercedValue;
-                this._dispatchSelectionChange();
-            }
-        }
-        /** The value of the chip. Defaults to the content inside `<mat-chip>` tags. */
-        get value() {
-            return this._value !== undefined
-                ? this._value
-                : this._elementRef.nativeElement.textContent;
-        }
-        set value(value) { this._value = value; }
-        /**
-         * Whether or not the chip is selectable. When a chip is not selectable,
-         * changes to its selected state are always ignored. By default a chip is
-         * selectable, and it becomes non-selectable if its parent chip list is
-         * not selectable.
-         */
-        get selectable() { return this._selectable && this.chipListSelectable; }
-        set selectable(value) {
-            this._selectable = coerceBooleanProperty(value);
-        }
-        /** Whether the chip is disabled. */
-        get disabled() { return this._chipListDisabled || this._disabled; }
-        set disabled(value) {
-            this._disabled = coerceBooleanProperty(value);
+export class MatChip extends _MatChipMixinBase {
+    constructor(_elementRef, _ngZone, platform, globalRippleOptions, 
+    // @breaking-change 8.0.0 `animationMode` parameter to become required.
+    animationMode, 
+    // @breaking-change 9.0.0 `_changeDetectorRef` parameter to become required.
+    _changeDetectorRef, tabIndex, 
+    // @breaking-change 11.0.0 `_document` parameter to become required.
+    _document) {
+        super(_elementRef);
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._changeDetectorRef = _changeDetectorRef;
+        /** Whether the chip has focus. */
+        this._hasFocus = false;
+        /** Whether the chip list is selectable */
+        this.chipListSelectable = true;
+        /** Whether the chip list is in multi-selection mode. */
+        this._chipListMultiple = false;
+        /** Whether the chip list as a whole is disabled. */
+        this._chipListDisabled = false;
+        this._selected = false;
+        this._selectable = true;
+        this._disabled = false;
+        this._removable = true;
+        /** Emits when the chip is focused. */
+        this._onFocus = new Subject();
+        /** Emits when the chip is blured. */
+        this._onBlur = new Subject();
+        /** Emitted when the chip is selected or deselected. */
+        this.selectionChange = new EventEmitter();
+        /** Emitted when the chip is destroyed. */
+        this.destroyed = new EventEmitter();
+        /** Emitted when a chip is to be removed. */
+        this.removed = new EventEmitter();
+        this._addHostClassName();
+        // Dynamically create the ripple target, append it within the chip, and use it as the
+        // chip's ripple target. Adding the class '.mat-chip-ripple' ensures that it will have
+        // the proper styles.
+        this._chipRippleTarget = (_document || document).createElement('div');
+        this._chipRippleTarget.classList.add('mat-chip-ripple');
+        this._elementRef.nativeElement.appendChild(this._chipRippleTarget);
+        this._chipRipple = new RippleRenderer(this, _ngZone, this._chipRippleTarget, platform);
+        this._chipRipple.setupTriggerEvents(_elementRef);
+        this.rippleConfig = globalRippleOptions || {};
+        this._animationsDisabled = animationMode === 'NoopAnimations';
+        this.tabIndex = tabIndex != null ? (parseInt(tabIndex) || -1) : -1;
+    }
+    /**
+     * Whether ripples are disabled on interaction
+     * @docs-private
+     */
+    get rippleDisabled() {
+        return this.disabled || this.disableRipple || !!this.rippleConfig.disabled;
+    }
+    /** Whether the chip is selected. */
+    get selected() { return this._selected; }
+    set selected(value) {
+        const coercedValue = coerceBooleanProperty(value);
+        if (coercedValue !== this._selected) {
+            this._selected = coercedValue;
+            this._dispatchSelectionChange();
         }
-        /**
-         * Determines whether or not the chip displays the remove styling and emits (removed) events.
-         */
-        get removable() { return this._removable; }
-        set removable(value) {
-            this._removable = coerceBooleanProperty(value);
+    }
+    /** The value of the chip. Defaults to the content inside `<mat-chip>` tags. */
+    get value() {
+        return this._value !== undefined
+            ? this._value
+            : this._elementRef.nativeElement.textContent;
+    }
+    set value(value) { this._value = value; }
+    /**
+     * Whether or not the chip is selectable. When a chip is not selectable,
+     * changes to its selected state are always ignored. By default a chip is
+     * selectable, and it becomes non-selectable if its parent chip list is
+     * not selectable.
+     */
+    get selectable() { return this._selectable && this.chipListSelectable; }
+    set selectable(value) {
+        this._selectable = coerceBooleanProperty(value);
+    }
+    /** Whether the chip is disabled. */
+    get disabled() { return this._chipListDisabled || this._disabled; }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    /**
+     * Determines whether or not the chip displays the remove styling and emits (removed) events.
+     */
+    get removable() { return this._removable; }
+    set removable(value) {
+        this._removable = coerceBooleanProperty(value);
+    }
+    /** The ARIA selected applied to the chip. */
+    get ariaSelected() {
+        // Remove the `aria-selected` when the chip is deselected in single-selection mode, because
+        // it adds noise to NVDA users where "not selected" will be read out for each chip.
+        return this.selectable && (this._chipListMultiple || this.selected) ?
+            this.selected.toString() : null;
+    }
+    _addHostClassName() {
+        const basicChipAttrName = 'mat-basic-chip';
+        const element = this._elementRef.nativeElement;
+        if (element.hasAttribute(basicChipAttrName) ||
+            element.tagName.toLowerCase() === basicChipAttrName) {
+            element.classList.add(basicChipAttrName);
+            return;
         }
-        /** The ARIA selected applied to the chip. */
-        get ariaSelected() {
-            // Remove the `aria-selected` when the chip is deselected in single-selection mode, because
-            // it adds noise to NVDA users where "not selected" will be read out for each chip.
-            return this.selectable && (this._chipListMultiple || this.selected) ?
-                this.selected.toString() : null;
+        else {
+            element.classList.add('mat-standard-chip');
         }
-        _addHostClassName() {
-            const basicChipAttrName = 'mat-basic-chip';
-            const element = this._elementRef.nativeElement;
-            if (element.hasAttribute(basicChipAttrName) ||
-                element.tagName.toLowerCase() === basicChipAttrName) {
-                element.classList.add(basicChipAttrName);
-                return;
-            }
-            else {
-                element.classList.add('mat-standard-chip');
-            }
+    }
+    ngOnDestroy() {
+        this.destroyed.emit({ chip: this });
+        this._chipRipple._removeTriggerEvents();
+    }
+    /** Selects the chip. */
+    select() {
+        if (!this._selected) {
+            this._selected = true;
+            this._dispatchSelectionChange();
+            this._markForCheck();
         }
-        ngOnDestroy() {
-            this.destroyed.emit({ chip: this });
-            this._chipRipple._removeTriggerEvents();
+    }
+    /** Deselects the chip. */
+    deselect() {
+        if (this._selected) {
+            this._selected = false;
+            this._dispatchSelectionChange();
+            this._markForCheck();
         }
-        /** Selects the chip. */
-        select() {
-            if (!this._selected) {
-                this._selected = true;
-                this._dispatchSelectionChange();
-                this._markForCheck();
-            }
+    }
+    /** Select this chip and emit selected event */
+    selectViaInteraction() {
+        if (!this._selected) {
+            this._selected = true;
+            this._dispatchSelectionChange(true);
+            this._markForCheck();
         }
-        /** Deselects the chip. */
-        deselect() {
-            if (this._selected) {
-                this._selected = false;
-                this._dispatchSelectionChange();
-                this._markForCheck();
-            }
+    }
+    /** Toggles the current selected state of this chip. */
+    toggleSelected(isUserInput = false) {
+        this._selected = !this.selected;
+        this._dispatchSelectionChange(isUserInput);
+        this._markForCheck();
+        return this.selected;
+    }
+    /** Allows for programmatic focusing of the chip. */
+    focus() {
+        if (!this._hasFocus) {
+            this._elementRef.nativeElement.focus();
+            this._onFocus.next({ chip: this });
         }
-        /** Select this chip and emit selected event */
-        selectViaInteraction() {
-            if (!this._selected) {
-                this._selected = true;
-                this._dispatchSelectionChange(true);
-                this._markForCheck();
-            }
+        this._hasFocus = true;
+    }
+    /**
+     * Allows for programmatic removal of the chip. Called by the MatChipList when the DELETE or
+     * BACKSPACE keys are pressed.
+     *
+     * Informs any listeners of the removal request. Does not remove the chip from the DOM.
+     */
+    remove() {
+        if (this.removable) {
+            this.removed.emit({ chip: this });
         }
-        /** Toggles the current selected state of this chip. */
-        toggleSelected(isUserInput = false) {
-            this._selected = !this.selected;
-            this._dispatchSelectionChange(isUserInput);
-            this._markForCheck();
-            return this.selected;
+    }
+    /** Handles click events on the chip. */
+    _handleClick(event) {
+        if (this.disabled) {
+            event.preventDefault();
         }
-        /** Allows for programmatic focusing of the chip. */
-        focus() {
-            if (!this._hasFocus) {
-                this._elementRef.nativeElement.focus();
-                this._onFocus.next({ chip: this });
-            }
-            this._hasFocus = true;
+        else {
+            event.stopPropagation();
         }
-        /**
-         * Allows for programmatic removal of the chip. Called by the MatChipList when the DELETE or
-         * BACKSPACE keys are pressed.
-         *
-         * Informs any listeners of the removal request. Does not remove the chip from the DOM.
-         */
-        remove() {
-            if (this.removable) {
-                this.removed.emit({ chip: this });
-            }
+    }
+    /** Handle custom key presses. */
+    _handleKeydown(event) {
+        if (this.disabled) {
+            return;
         }
-        /** Handles click events on the chip. */
-        _handleClick(event) {
-            if (this.disabled) {
+        switch (event.keyCode) {
+            case DELETE:
+            case BACKSPACE:
+                // If we are removable, remove the focused chip
+                this.remove();
+                // Always prevent so page navigation does not occur
                 event.preventDefault();
-            }
-            else {
-                event.stopPropagation();
-            }
-        }
-        /** Handle custom key presses. */
-        _handleKeydown(event) {
-            if (this.disabled) {
-                return;
-            }
-            switch (event.keyCode) {
-                case DELETE:
-                case BACKSPACE:
-                    // If we are removable, remove the focused chip
-                    this.remove();
-                    // Always prevent so page navigation does not occur
-                    event.preventDefault();
-                    break;
-                case SPACE:
-                    // If we are selectable, toggle the focused chip
-                    if (this.selectable) {
-                        this.toggleSelected(true);
-                    }
-                    // Always prevent space from scrolling the page since the list has focus
-                    event.preventDefault();
-                    break;
-            }
-        }
-        _blur() {
-            // When animations are enabled, Angular may end up removing the chip from the DOM a little
-            // earlier than usual, causing it to be blurred and throwing off the logic in the chip list
-            // that moves focus not the next item. To work around the issue, we defer marking the chip
-            // as not focused until the next time the zone stabilizes.
-            this._ngZone.onStable
-                .asObservable()
-                .pipe(take(1))
-                .subscribe(() => {
-                this._ngZone.run(() => {
-                    this._hasFocus = false;
-                    this._onBlur.next({ chip: this });
-                });
-            });
+                break;
+            case SPACE:
+                // If we are selectable, toggle the focused chip
+                if (this.selectable) {
+                    this.toggleSelected(true);
+                }
+                // Always prevent space from scrolling the page since the list has focus
+                event.preventDefault();
+                break;
         }
-        _dispatchSelectionChange(isUserInput = false) {
-            this.selectionChange.emit({
-                source: this,
-                isUserInput,
-                selected: this._selected
+    }
+    _blur() {
+        // When animations are enabled, Angular may end up removing the chip from the DOM a little
+        // earlier than usual, causing it to be blurred and throwing off the logic in the chip list
+        // that moves focus not the next item. To work around the issue, we defer marking the chip
+        // as not focused until the next time the zone stabilizes.
+        this._ngZone.onStable
+            .asObservable()
+            .pipe(take(1))
+            .subscribe(() => {
+            this._ngZone.run(() => {
+                this._hasFocus = false;
+                this._onBlur.next({ chip: this });
             });
-        }
-        _markForCheck() {
-            // @breaking-change 9.0.0 Remove this method once the _changeDetectorRef is a required param.
-            if (this._changeDetectorRef) {
-                this._changeDetectorRef.markForCheck();
-            }
+        });
+    }
+    _dispatchSelectionChange(isUserInput = false) {
+        this.selectionChange.emit({
+            source: this,
+            isUserInput,
+            selected: this._selected
+        });
+    }
+    _markForCheck() {
+        // @breaking-change 9.0.0 Remove this method once the _changeDetectorRef is a required param.
+        if (this._changeDetectorRef) {
+            this._changeDetectorRef.markForCheck();
         }
     }
-    MatChip.decorators = [
-        { type: Directive, args: [{
-                    selector: `mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]`,
-                    inputs: ['color', 'disableRipple', 'tabIndex'],
-                    exportAs: 'matChip',
-                    host: {
-                        'class': 'mat-chip mat-focus-indicator',
-                        '[attr.tabindex]': 'disabled ? null : tabIndex',
-                        'role': 'option',
-                        '[class.mat-chip-selected]': 'selected',
-                        '[class.mat-chip-with-avatar]': 'avatar',
-                        '[class.mat-chip-with-trailing-icon]': 'trailingIcon || removeIcon',
-                        '[class.mat-chip-disabled]': 'disabled',
-                        '[class._mat-animation-noopable]': '_animationsDisabled',
-                        '[attr.disabled]': 'disabled || null',
-                        '[attr.aria-disabled]': 'disabled.toString()',
-                        '[attr.aria-selected]': 'ariaSelected',
-                        '(click)': '_handleClick($event)',
-                        '(keydown)': '_handleKeydown($event)',
-                        '(focus)': 'focus()',
-                        '(blur)': '_blur()',
-                    },
-                },] }
-    ];
-    MatChip.ctorParameters = () => [
-        { type: ElementRef },
-        { type: NgZone },
-        { type: Platform },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_RIPPLE_GLOBAL_OPTIONS,] }] },
-        { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] },
-        { type: ChangeDetectorRef },
-        { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
-    ];
-    MatChip.propDecorators = {
-        avatar: [{ type: ContentChild, args: [MatChipAvatar,] }],
-        trailingIcon: [{ type: ContentChild, args: [MatChipTrailingIcon,] }],
-        removeIcon: [{ type: ContentChild, args: [forwardRef(() => MatChipRemove),] }],
-        selected: [{ type: Input }],
-        value: [{ type: Input }],
-        selectable: [{ type: Input }],
-        disabled: [{ type: Input }],
-        removable: [{ type: Input }],
-        selectionChange: [{ type: Output }],
-        destroyed: [{ type: Output }],
-        removed: [{ type: Output }]
-    };
-    return MatChip;
-})();
-export { MatChip };
+}
+MatChip.decorators = [
+    { type: Directive, args: [{
+                selector: `mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]`,
+                inputs: ['color', 'disableRipple', 'tabIndex'],
+                exportAs: 'matChip',
+                host: {
+                    'class': 'mat-chip mat-focus-indicator',
+                    '[attr.tabindex]': 'disabled ? null : tabIndex',
+                    'role': 'option',
+                    '[class.mat-chip-selected]': 'selected',
+                    '[class.mat-chip-with-avatar]': 'avatar',
+                    '[class.mat-chip-with-trailing-icon]': 'trailingIcon || removeIcon',
+                    '[class.mat-chip-disabled]': 'disabled',
+                    '[class._mat-animation-noopable]': '_animationsDisabled',
+                    '[attr.disabled]': 'disabled || null',
+                    '[attr.aria-disabled]': 'disabled.toString()',
+                    '[attr.aria-selected]': 'ariaSelected',
+                    '(click)': '_handleClick($event)',
+                    '(keydown)': '_handleKeydown($event)',
+                    '(focus)': 'focus()',
+                    '(blur)': '_blur()',
+                },
+            },] }
+];
+MatChip.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone },
+    { type: Platform },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_RIPPLE_GLOBAL_OPTIONS,] }] },
+    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] },
+    { type: ChangeDetectorRef },
+    { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+];
+MatChip.propDecorators = {
+    avatar: [{ type: ContentChild, args: [MAT_CHIP_AVATAR,] }],
+    trailingIcon: [{ type: ContentChild, args: [MAT_CHIP_TRAILING_ICON,] }],
+    removeIcon: [{ type: ContentChild, args: [MAT_CHIP_REMOVE,] }],
+    selected: [{ type: Input }],
+    value: [{ type: Input }],
+    selectable: [{ type: Input }],
+    disabled: [{ type: Input }],
+    removable: [{ type: Input }],
+    selectionChange: [{ type: Output }],
+    destroyed: [{ type: Output }],
+    removed: [{ type: Output }]
+};
 /**
  * Applies proper (click) support and adds styling for use with the Material Design "cancel" icon
  * available at https://material.io/icons/#ic_cancel.
@@ -361,45 +369,42 @@ export { MatChip };
  * You *may* use a custom icon, but you may need to override the `mat-chip-remove` positioning
  * styles to properly center the icon within the chip.
  */
-let MatChipRemove = /** @class */ (() => {
-    class MatChipRemove {
-        constructor(_parentChip, 
-        // @breaking-change 11.0.0 `elementRef` parameter to be made required.
-        elementRef) {
-            this._parentChip = _parentChip;
-            // @breaking-change 11.0.0 Remove null check for `elementRef`.
-            if (elementRef && elementRef.nativeElement.nodeName === 'BUTTON') {
-                elementRef.nativeElement.setAttribute('type', 'button');
-            }
+export class MatChipRemove {
+    constructor(_parentChip, 
+    // @breaking-change 11.0.0 `elementRef` parameter to be made required.
+    elementRef) {
+        this._parentChip = _parentChip;
+        // @breaking-change 11.0.0 Remove null check for `elementRef`.
+        if (elementRef && elementRef.nativeElement.nodeName === 'BUTTON') {
+            elementRef.nativeElement.setAttribute('type', 'button');
         }
-        /** Calls the parent chip's public `remove()` method if applicable. */
-        _handleClick(event) {
-            const parentChip = this._parentChip;
-            if (parentChip.removable && !parentChip.disabled) {
-                parentChip.remove();
-            }
-            // We need to stop event propagation because otherwise the event will bubble up to the
-            // form field and cause the `onContainerClick` method to be invoked. This method would then
-            // reset the focused chip that has been focused after chip removal. Usually the parent
-            // the parent click listener of the `MatChip` would prevent propagation, but it can happen
-            // that the chip is being removed before the event bubbles up.
-            event.stopPropagation();
+    }
+    /** Calls the parent chip's public `remove()` method if applicable. */
+    _handleClick(event) {
+        const parentChip = this._parentChip;
+        if (parentChip.removable && !parentChip.disabled) {
+            parentChip.remove();
         }
+        // We need to stop event propagation because otherwise the event will bubble up to the
+        // form field and cause the `onContainerClick` method to be invoked. This method would then
+        // reset the focused chip that has been focused after chip removal. Usually the parent
+        // the parent click listener of the `MatChip` would prevent propagation, but it can happen
+        // that the chip is being removed before the event bubbles up.
+        event.stopPropagation();
     }
-    MatChipRemove.decorators = [
-        { type: Directive, args: [{
-                    selector: '[matChipRemove]',
-                    host: {
-                        'class': 'mat-chip-remove mat-chip-trailing-icon',
-                        '(click)': '_handleClick($event)',
-                    }
-                },] }
-    ];
-    MatChipRemove.ctorParameters = () => [
-        { type: MatChip },
-        { type: ElementRef }
-    ];
-    return MatChipRemove;
-})();
-export { MatChipRemove };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chip.js","sourceRoot":"","sources":["../../../../../../src/material/chips/chip.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {DOCUMENT} from '@angular/common';\nimport {FocusableOption} from '@angular/cdk/a11y';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {BACKSPACE, DELETE, SPACE} from '@angular/cdk/keycodes';\nimport {Platform} from '@angular/cdk/platform';\nimport {\n  ContentChild,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  ChangeDetectorRef,\n  Attribute,\n} from '@angular/core';\nimport {\n  CanColor,\n  CanColorCtor,\n  CanDisableRipple,\n  CanDisableRippleCtor,\n  HasTabIndex,\n  HasTabIndexCtor,\n  mixinTabIndex,\n  MAT_RIPPLE_GLOBAL_OPTIONS,\n  mixinColor,\n  mixinDisableRipple,\n  RippleConfig,\n  RippleGlobalOptions,\n  RippleRenderer,\n  RippleTarget,\n} from '@angular/material/core';\nimport {Subject} from 'rxjs';\nimport {take} from 'rxjs/operators';\nimport {ANIMATION_MODULE_TYPE} from '@angular/platform-browser/animations';\n\n\n/** Represents an event fired on an individual `mat-chip`. */\nexport interface MatChipEvent {\n  /** The chip the event was fired on. */\n  chip: MatChip;\n}\n\n/** Event object emitted by MatChip when selected or deselected. */\nexport class MatChipSelectionChange {\n  constructor(\n    /** Reference to the chip that emitted the event. */\n    public source: MatChip,\n    /** Whether the chip that emitted the event is selected. */\n    public selected: boolean,\n    /** Whether the selection change was a result of a user interaction. */\n    public isUserInput = false) { }\n}\n\n\n// Boilerplate for applying mixins to MatChip.\n/** @docs-private */\nclass MatChipBase {\n  disabled: boolean;\n  constructor(public _elementRef: ElementRef) {}\n}\n\nconst _MatChipMixinBase: CanColorCtor & CanDisableRippleCtor &\n    HasTabIndexCtor & typeof MatChipBase =\n      mixinTabIndex(mixinColor(mixinDisableRipple(MatChipBase), 'primary'), -1);\n\n/**\n * Dummy directive to add CSS class to chip avatar.\n * @docs-private\n */\n@Directive({\n  selector: 'mat-chip-avatar, [matChipAvatar]',\n  host: {'class': 'mat-chip-avatar'}\n})\nexport class MatChipAvatar {}\n\n/**\n * Dummy directive to add CSS class to chip trailing icon.\n * @docs-private\n */\n@Directive({\n  selector: 'mat-chip-trailing-icon, [matChipTrailingIcon]',\n  host: {'class': 'mat-chip-trailing-icon'}\n})\nexport class MatChipTrailingIcon {}\n\n/**\n * Material design styled Chip component. Used inside the MatChipList component.\n */\n@Directive({\n  selector: `mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]`,\n  inputs: ['color', 'disableRipple', 'tabIndex'],\n  exportAs: 'matChip',\n  host: {\n    'class': 'mat-chip mat-focus-indicator',\n    '[attr.tabindex]': 'disabled ? null : tabIndex',\n    'role': 'option',\n    '[class.mat-chip-selected]': 'selected',\n    '[class.mat-chip-with-avatar]': 'avatar',\n    '[class.mat-chip-with-trailing-icon]': 'trailingIcon || removeIcon',\n    '[class.mat-chip-disabled]': 'disabled',\n    '[class._mat-animation-noopable]': '_animationsDisabled',\n    '[attr.disabled]': 'disabled || null',\n    '[attr.aria-disabled]': 'disabled.toString()',\n    '[attr.aria-selected]': 'ariaSelected',\n    '(click)': '_handleClick($event)',\n    '(keydown)': '_handleKeydown($event)',\n    '(focus)': 'focus()',\n    '(blur)': '_blur()',\n  },\n})\nexport class MatChip extends _MatChipMixinBase implements FocusableOption, OnDestroy, CanColor,\n  CanDisableRipple, RippleTarget, HasTabIndex {\n\n  /** Reference to the RippleRenderer for the chip. */\n  private _chipRipple: RippleRenderer;\n\n  /**\n   * Reference to the element that acts as the chip's ripple target. This element is\n   * dynamically added as a child node of the chip. The chip itself cannot be used as the\n   * ripple target because it must be the host of the focus indicator.\n   */\n  private _chipRippleTarget: HTMLElement;\n\n  /**\n   * Ripple configuration for ripples that are launched on pointer down. The ripple config\n   * is set to the global ripple options since we don't have any configurable options for\n   * the chip ripples.\n   * @docs-private\n   */\n  rippleConfig: RippleConfig & RippleGlobalOptions;\n\n  /**\n   * Whether ripples are disabled on interaction\n   * @docs-private\n   */\n  get rippleDisabled(): boolean {\n    return this.disabled || this.disableRipple || !!this.rippleConfig.disabled;\n  }\n\n  /** Whether the chip has focus. */\n  _hasFocus: boolean = false;\n\n  /** Whether animations for the chip are enabled. */\n  _animationsDisabled: boolean;\n\n  /** Whether the chip list is selectable */\n  chipListSelectable: boolean = true;\n\n  /** Whether the chip list is in multi-selection mode. */\n  _chipListMultiple: boolean = false;\n\n  /** Whether the chip list as a whole is disabled. */\n  _chipListDisabled: boolean = false;\n\n  /** The chip avatar */\n  @ContentChild(MatChipAvatar) avatar: MatChipAvatar;\n\n  /** The chip's trailing icon. */\n  @ContentChild(MatChipTrailingIcon) trailingIcon: MatChipTrailingIcon;\n\n  /** The chip's remove toggler. */\n  @ContentChild(forwardRef(() => MatChipRemove)) removeIcon: MatChipRemove;\n\n  /** Whether the chip is selected. */\n  @Input()\n  get selected(): boolean { return this._selected; }\n  set selected(value: boolean) {\n    const coercedValue = coerceBooleanProperty(value);\n\n    if (coercedValue !== this._selected) {\n      this._selected = coercedValue;\n      this._dispatchSelectionChange();\n    }\n  }\n  protected _selected: boolean = false;\n\n  /** The value of the chip. Defaults to the content inside `<mat-chip>` tags. */\n  @Input()\n  get value(): any {\n    return this._value !== undefined\n      ? this._value\n      : this._elementRef.nativeElement.textContent;\n  }\n  set value(value: any) { this._value = value; }\n  protected _value: any;\n\n  /**\n   * Whether or not the chip is selectable. When a chip is not selectable,\n   * changes to its selected state are always ignored. By default a chip is\n   * selectable, and it becomes non-selectable if its parent chip list is\n   * not selectable.\n   */\n  @Input()\n  get selectable(): boolean { return this._selectable && this.chipListSelectable; }\n  set selectable(value: boolean) {\n    this._selectable = coerceBooleanProperty(value);\n  }\n  protected _selectable: boolean = true;\n\n  /** Whether the chip is disabled. */\n  @Input()\n  get disabled(): boolean { return this._chipListDisabled || this._disabled; }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  protected _disabled: boolean = false;\n\n  /**\n   * Determines whether or not the chip displays the remove styling and emits (removed) events.\n   */\n  @Input()\n  get removable(): boolean { return this._removable; }\n  set removable(value: boolean) {\n    this._removable = coerceBooleanProperty(value);\n  }\n  protected _removable: boolean = true;\n\n  /** Emits when the chip is focused. */\n  readonly _onFocus = new Subject<MatChipEvent>();\n\n  /** Emits when the chip is blured. */\n  readonly _onBlur = new Subject<MatChipEvent>();\n\n  /** Emitted when the chip is selected or deselected. */\n  @Output() readonly selectionChange: EventEmitter<MatChipSelectionChange> =\n      new EventEmitter<MatChipSelectionChange>();\n\n  /** Emitted when the chip is destroyed. */\n  @Output() readonly destroyed: EventEmitter<MatChipEvent> = new EventEmitter<MatChipEvent>();\n\n  /** Emitted when a chip is to be removed. */\n  @Output() readonly removed: EventEmitter<MatChipEvent> = new EventEmitter<MatChipEvent>();\n\n  /** The ARIA selected applied to the chip. */\n  get ariaSelected(): string | null {\n    // Remove the `aria-selected` when the chip is deselected in single-selection mode, because\n    // it adds noise to NVDA users where \"not selected\" will be read out for each chip.\n    return this.selectable && (this._chipListMultiple || this.selected) ?\n        this.selected.toString() : null;\n  }\n\n  constructor(public _elementRef: ElementRef<HTMLElement>,\n              private _ngZone: NgZone,\n              platform: Platform,\n              @Optional() @Inject(MAT_RIPPLE_GLOBAL_OPTIONS)\n              globalRippleOptions: RippleGlobalOptions | null,\n              // @breaking-change 8.0.0 `animationMode` parameter to become required.\n              @Optional() @Inject(ANIMATION_MODULE_TYPE) animationMode?: string,\n              // @breaking-change 9.0.0 `_changeDetectorRef` parameter to become required.\n              private _changeDetectorRef?: ChangeDetectorRef,\n              @Attribute('tabindex') tabIndex?: string,\n              // @breaking-change 11.0.0 `_document` parameter to become required.\n              @Optional() @Inject(DOCUMENT) _document?: any) {\n    super(_elementRef);\n\n    this._addHostClassName();\n\n    // Dynamically create the ripple target, append it within the chip, and use it as the\n    // chip's ripple target. Adding the class '.mat-chip-ripple' ensures that it will have\n    // the proper styles.\n    this._chipRippleTarget = (_document || document).createElement('div');\n    this._chipRippleTarget.classList.add('mat-chip-ripple');\n    this._elementRef.nativeElement.appendChild(this._chipRippleTarget);\n    this._chipRipple = new RippleRenderer(this, _ngZone, this._chipRippleTarget, platform);\n    this._chipRipple.setupTriggerEvents(_elementRef);\n\n    this.rippleConfig = globalRippleOptions || {};\n    this._animationsDisabled = animationMode === 'NoopAnimations';\n    this.tabIndex = tabIndex != null ? (parseInt(tabIndex) || -1) : -1;\n  }\n\n  _addHostClassName() {\n    const basicChipAttrName = 'mat-basic-chip';\n    const element = this._elementRef.nativeElement as HTMLElement;\n\n    if (element.hasAttribute(basicChipAttrName) ||\n        element.tagName.toLowerCase() === basicChipAttrName) {\n      element.classList.add(basicChipAttrName);\n      return;\n    } else {\n      element.classList.add('mat-standard-chip');\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroyed.emit({chip: this});\n    this._chipRipple._removeTriggerEvents();\n  }\n\n  /** Selects the chip. */\n  select(): void {\n    if (!this._selected) {\n      this._selected = true;\n      this._dispatchSelectionChange();\n      this._markForCheck();\n    }\n  }\n\n  /** Deselects the chip. */\n  deselect(): void {\n    if (this._selected) {\n      this._selected = false;\n      this._dispatchSelectionChange();\n      this._markForCheck();\n    }\n  }\n\n  /** Select this chip and emit selected event */\n  selectViaInteraction(): void {\n    if (!this._selected) {\n      this._selected = true;\n      this._dispatchSelectionChange(true);\n      this._markForCheck();\n    }\n  }\n\n  /** Toggles the current selected state of this chip. */\n  toggleSelected(isUserInput: boolean = false): boolean {\n    this._selected = !this.selected;\n    this._dispatchSelectionChange(isUserInput);\n    this._markForCheck();\n    return this.selected;\n  }\n\n  /** Allows for programmatic focusing of the chip. */\n  focus(): void {\n    if (!this._hasFocus) {\n      this._elementRef.nativeElement.focus();\n      this._onFocus.next({chip: this});\n    }\n    this._hasFocus = true;\n  }\n\n  /**\n   * Allows for programmatic removal of the chip. Called by the MatChipList when the DELETE or\n   * BACKSPACE keys are pressed.\n   *\n   * Informs any listeners of the removal request. Does not remove the chip from the DOM.\n   */\n  remove(): void {\n    if (this.removable) {\n      this.removed.emit({chip: this});\n    }\n  }\n\n  /** Handles click events on the chip. */\n  _handleClick(event: Event) {\n    if (this.disabled) {\n      event.preventDefault();\n    } else {\n      event.stopPropagation();\n    }\n  }\n\n  /** Handle custom key presses. */\n  _handleKeydown(event: KeyboardEvent): void {\n    if (this.disabled) {\n      return;\n    }\n\n    switch (event.keyCode) {\n      case DELETE:\n      case BACKSPACE:\n        // If we are removable, remove the focused chip\n        this.remove();\n        // Always prevent so page navigation does not occur\n        event.preventDefault();\n        break;\n      case SPACE:\n        // If we are selectable, toggle the focused chip\n        if (this.selectable) {\n          this.toggleSelected(true);\n        }\n\n        // Always prevent space from scrolling the page since the list has focus\n        event.preventDefault();\n        break;\n    }\n  }\n\n  _blur(): void {\n    // When animations are enabled, Angular may end up removing the chip from the DOM a little\n    // earlier than usual, causing it to be blurred and throwing off the logic in the chip list\n    // that moves focus not the next item. To work around the issue, we defer marking the chip\n    // as not focused until the next time the zone stabilizes.\n    this._ngZone.onStable\n      .asObservable()\n      .pipe(take(1))\n      .subscribe(() => {\n        this._ngZone.run(() => {\n          this._hasFocus = false;\n          this._onBlur.next({chip: this});\n        });\n      });\n  }\n\n  private _dispatchSelectionChange(isUserInput = false) {\n    this.selectionChange.emit({\n      source: this,\n      isUserInput,\n      selected: this._selected\n    });\n  }\n\n  private _markForCheck() {\n    // @breaking-change 9.0.0 Remove this method once the _changeDetectorRef is a required param.\n    if (this._changeDetectorRef) {\n      this._changeDetectorRef.markForCheck();\n    }\n  }\n\n  static ngAcceptInputType_selected: BooleanInput;\n  static ngAcceptInputType_selectable: BooleanInput;\n  static ngAcceptInputType_removable: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_disableRipple: BooleanInput;\n}\n\n\n/**\n * Applies proper (click) support and adds styling for use with the Material Design \"cancel\" icon\n * available at https://material.io/icons/#ic_cancel.\n *\n * Example:\n *\n *     `<mat-chip>\n *       <mat-icon matChipRemove>cancel</mat-icon>\n *     </mat-chip>`\n *\n * You *may* use a custom icon, but you may need to override the `mat-chip-remove` positioning\n * styles to properly center the icon within the chip.\n */\n@Directive({\n  selector: '[matChipRemove]',\n  host: {\n    'class': 'mat-chip-remove mat-chip-trailing-icon',\n    '(click)': '_handleClick($event)',\n  }\n})\nexport class MatChipRemove {\n  constructor(\n    protected _parentChip: MatChip,\n    // @breaking-change 11.0.0 `elementRef` parameter to be made required.\n    elementRef?: ElementRef<HTMLElement>) {\n\n      // @breaking-change 11.0.0 Remove null check for `elementRef`.\n    if (elementRef && elementRef.nativeElement.nodeName === 'BUTTON') {\n      elementRef.nativeElement.setAttribute('type', 'button');\n    }\n   }\n\n  /** Calls the parent chip's public `remove()` method if applicable. */\n  _handleClick(event: Event): void {\n    const parentChip = this._parentChip;\n\n    if (parentChip.removable && !parentChip.disabled) {\n      parentChip.remove();\n    }\n\n    // We need to stop event propagation because otherwise the event will bubble up to the\n    // form field and cause the `onContainerClick` method to be invoked. This method would then\n    // reset the focused chip that has been focused after chip removal. Usually the parent\n    // the parent click listener of the `MatChip` would prevent propagation, but it can happen\n    // that the chip is being removed before the event bubbles up.\n    event.stopPropagation();\n  }\n}\n"]}
+}
+MatChipRemove.decorators = [
+    { type: Directive, args: [{
+                selector: '[matChipRemove]',
+                host: {
+                    'class': 'mat-chip-remove mat-chip-trailing-icon',
+                    '(click)': '_handleClick($event)',
+                },
+                providers: [{ provide: MAT_CHIP_REMOVE, useExisting: MatChipRemove }],
+            },] }
+];
+MatChipRemove.ctorParameters = () => [
+    { type: MatChip },
+    { type: ElementRef }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chip.js","sourceRoot":"","sources":["../../../../../../src/material/chips/chip.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 {FocusableOption} from '@angular/cdk/a11y';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {BACKSPACE, DELETE, SPACE} from '@angular/cdk/keycodes';\nimport {Platform} from '@angular/cdk/platform';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  Attribute,\n  ChangeDetectorRef,\n  ContentChild,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n} from '@angular/core';\nimport {\n  CanColor,\n  CanColorCtor,\n  CanDisableRipple,\n  CanDisableRippleCtor,\n  HasTabIndex,\n  HasTabIndexCtor,\n  MAT_RIPPLE_GLOBAL_OPTIONS,\n  mixinColor,\n  mixinDisableRipple,\n  mixinTabIndex,\n  RippleConfig,\n  RippleGlobalOptions,\n  RippleRenderer,\n  RippleTarget,\n} from '@angular/material/core';\nimport {ANIMATION_MODULE_TYPE} from '@angular/platform-browser/animations';\nimport {Subject} from 'rxjs';\nimport {take} from 'rxjs/operators';\n\n\n/** Represents an event fired on an individual `mat-chip`. */\nexport interface MatChipEvent {\n  /** The chip the event was fired on. */\n  chip: MatChip;\n}\n\n/** Event object emitted by MatChip when selected or deselected. */\nexport class MatChipSelectionChange {\n  constructor(\n    /** Reference to the chip that emitted the event. */\n    public source: MatChip,\n    /** Whether the chip that emitted the event is selected. */\n    public selected: boolean,\n    /** Whether the selection change was a result of a user interaction. */\n    public isUserInput = false) { }\n}\n\n/**\n * Injection token that can be used to reference instances of `MatChipRemove`. It serves as\n * alternative token to the actual `MatChipRemove` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nexport const MAT_CHIP_REMOVE = new InjectionToken<MatChipRemove>('MatChipRemove');\n\n/**\n * Injection token that can be used to reference instances of `MatChipAvatar`. It serves as\n * alternative token to the actual `MatChipAvatar` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nexport const MAT_CHIP_AVATAR = new InjectionToken<MatChipAvatar>('MatChipAvatar');\n\n/**\n * Injection token that can be used to reference instances of `MatChipTrailingIcon`. It serves as\n * alternative token to the actual `MatChipTrailingIcon` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nexport const MAT_CHIP_TRAILING_ICON =\n    new InjectionToken<MatChipTrailingIcon>('MatChipTrailingIcon');\n\n// Boilerplate for applying mixins to MatChip.\n/** @docs-private */\nclass MatChipBase {\n  disabled: boolean;\n  constructor(public _elementRef: ElementRef) {}\n}\n\nconst _MatChipMixinBase: CanColorCtor & CanDisableRippleCtor &\n    HasTabIndexCtor & typeof MatChipBase =\n      mixinTabIndex(mixinColor(mixinDisableRipple(MatChipBase), 'primary'), -1);\n\n/**\n * Dummy directive to add CSS class to chip avatar.\n * @docs-private\n */\n@Directive({\n  selector: 'mat-chip-avatar, [matChipAvatar]',\n  host: {'class': 'mat-chip-avatar'},\n  providers: [{provide: MAT_CHIP_AVATAR, useExisting: MatChipAvatar}]\n})\nexport class MatChipAvatar {}\n\n/**\n * Dummy directive to add CSS class to chip trailing icon.\n * @docs-private\n */\n@Directive({\n  selector: 'mat-chip-trailing-icon, [matChipTrailingIcon]',\n  host: {'class': 'mat-chip-trailing-icon'},\n  providers: [{provide: MAT_CHIP_TRAILING_ICON, useExisting: MatChipTrailingIcon}],\n})\nexport class MatChipTrailingIcon {}\n\n\n/**\n * Material design styled Chip component. Used inside the MatChipList component.\n */\n@Directive({\n  selector: `mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]`,\n  inputs: ['color', 'disableRipple', 'tabIndex'],\n  exportAs: 'matChip',\n  host: {\n    'class': 'mat-chip mat-focus-indicator',\n    '[attr.tabindex]': 'disabled ? null : tabIndex',\n    'role': 'option',\n    '[class.mat-chip-selected]': 'selected',\n    '[class.mat-chip-with-avatar]': 'avatar',\n    '[class.mat-chip-with-trailing-icon]': 'trailingIcon || removeIcon',\n    '[class.mat-chip-disabled]': 'disabled',\n    '[class._mat-animation-noopable]': '_animationsDisabled',\n    '[attr.disabled]': 'disabled || null',\n    '[attr.aria-disabled]': 'disabled.toString()',\n    '[attr.aria-selected]': 'ariaSelected',\n    '(click)': '_handleClick($event)',\n    '(keydown)': '_handleKeydown($event)',\n    '(focus)': 'focus()',\n    '(blur)': '_blur()',\n  },\n})\nexport class MatChip extends _MatChipMixinBase implements FocusableOption, OnDestroy, CanColor,\n  CanDisableRipple, RippleTarget, HasTabIndex {\n\n  /** Reference to the RippleRenderer for the chip. */\n  private _chipRipple: RippleRenderer;\n\n  /**\n   * Reference to the element that acts as the chip's ripple target. This element is\n   * dynamically added as a child node of the chip. The chip itself cannot be used as the\n   * ripple target because it must be the host of the focus indicator.\n   */\n  private _chipRippleTarget: HTMLElement;\n\n  /**\n   * Ripple configuration for ripples that are launched on pointer down. The ripple config\n   * is set to the global ripple options since we don't have any configurable options for\n   * the chip ripples.\n   * @docs-private\n   */\n  rippleConfig: RippleConfig & RippleGlobalOptions;\n\n  /**\n   * Whether ripples are disabled on interaction\n   * @docs-private\n   */\n  get rippleDisabled(): boolean {\n    return this.disabled || this.disableRipple || !!this.rippleConfig.disabled;\n  }\n\n  /** Whether the chip has focus. */\n  _hasFocus: boolean = false;\n\n  /** Whether animations for the chip are enabled. */\n  _animationsDisabled: boolean;\n\n  /** Whether the chip list is selectable */\n  chipListSelectable: boolean = true;\n\n  /** Whether the chip list is in multi-selection mode. */\n  _chipListMultiple: boolean = false;\n\n  /** Whether the chip list as a whole is disabled. */\n  _chipListDisabled: boolean = false;\n\n  // TODO: Remove cast once https://github.com/angular/angular/pull/37506 is available.\n  /** The chip avatar */\n  @ContentChild(MAT_CHIP_AVATAR as any) avatar: MatChipAvatar;\n\n  // TODO: Remove cast once https://github.com/angular/angular/pull/37506 is available.\n  /** The chip's trailing icon. */\n  @ContentChild(MAT_CHIP_TRAILING_ICON as any) trailingIcon: MatChipTrailingIcon;\n\n  // TODO: Remove cast once https://github.com/angular/angular/pull/37506 is available.\n  /** The chip's remove toggler. */\n  @ContentChild(MAT_CHIP_REMOVE as any) removeIcon: MatChipRemove;\n\n  /** Whether the chip is selected. */\n  @Input()\n  get selected(): boolean { return this._selected; }\n  set selected(value: boolean) {\n    const coercedValue = coerceBooleanProperty(value);\n\n    if (coercedValue !== this._selected) {\n      this._selected = coercedValue;\n      this._dispatchSelectionChange();\n    }\n  }\n  protected _selected: boolean = false;\n\n  /** The value of the chip. Defaults to the content inside `<mat-chip>` tags. */\n  @Input()\n  get value(): any {\n    return this._value !== undefined\n      ? this._value\n      : this._elementRef.nativeElement.textContent;\n  }\n  set value(value: any) { this._value = value; }\n  protected _value: any;\n\n  /**\n   * Whether or not the chip is selectable. When a chip is not selectable,\n   * changes to its selected state are always ignored. By default a chip is\n   * selectable, and it becomes non-selectable if its parent chip list is\n   * not selectable.\n   */\n  @Input()\n  get selectable(): boolean { return this._selectable && this.chipListSelectable; }\n  set selectable(value: boolean) {\n    this._selectable = coerceBooleanProperty(value);\n  }\n  protected _selectable: boolean = true;\n\n  /** Whether the chip is disabled. */\n  @Input()\n  get disabled(): boolean { return this._chipListDisabled || this._disabled; }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  protected _disabled: boolean = false;\n\n  /**\n   * Determines whether or not the chip displays the remove styling and emits (removed) events.\n   */\n  @Input()\n  get removable(): boolean { return this._removable; }\n  set removable(value: boolean) {\n    this._removable = coerceBooleanProperty(value);\n  }\n  protected _removable: boolean = true;\n\n  /** Emits when the chip is focused. */\n  readonly _onFocus = new Subject<MatChipEvent>();\n\n  /** Emits when the chip is blured. */\n  readonly _onBlur = new Subject<MatChipEvent>();\n\n  /** Emitted when the chip is selected or deselected. */\n  @Output() readonly selectionChange: EventEmitter<MatChipSelectionChange> =\n      new EventEmitter<MatChipSelectionChange>();\n\n  /** Emitted when the chip is destroyed. */\n  @Output() readonly destroyed: EventEmitter<MatChipEvent> = new EventEmitter<MatChipEvent>();\n\n  /** Emitted when a chip is to be removed. */\n  @Output() readonly removed: EventEmitter<MatChipEvent> = new EventEmitter<MatChipEvent>();\n\n  /** The ARIA selected applied to the chip. */\n  get ariaSelected(): string | null {\n    // Remove the `aria-selected` when the chip is deselected in single-selection mode, because\n    // it adds noise to NVDA users where \"not selected\" will be read out for each chip.\n    return this.selectable && (this._chipListMultiple || this.selected) ?\n        this.selected.toString() : null;\n  }\n\n  constructor(public _elementRef: ElementRef<HTMLElement>,\n              private _ngZone: NgZone,\n              platform: Platform,\n              @Optional() @Inject(MAT_RIPPLE_GLOBAL_OPTIONS)\n              globalRippleOptions: RippleGlobalOptions | null,\n              // @breaking-change 8.0.0 `animationMode` parameter to become required.\n              @Optional() @Inject(ANIMATION_MODULE_TYPE) animationMode?: string,\n              // @breaking-change 9.0.0 `_changeDetectorRef` parameter to become required.\n              private _changeDetectorRef?: ChangeDetectorRef,\n              @Attribute('tabindex') tabIndex?: string,\n              // @breaking-change 11.0.0 `_document` parameter to become required.\n              @Optional() @Inject(DOCUMENT) _document?: any) {\n    super(_elementRef);\n\n    this._addHostClassName();\n\n    // Dynamically create the ripple target, append it within the chip, and use it as the\n    // chip's ripple target. Adding the class '.mat-chip-ripple' ensures that it will have\n    // the proper styles.\n    this._chipRippleTarget = (_document || document).createElement('div');\n    this._chipRippleTarget.classList.add('mat-chip-ripple');\n    this._elementRef.nativeElement.appendChild(this._chipRippleTarget);\n    this._chipRipple = new RippleRenderer(this, _ngZone, this._chipRippleTarget, platform);\n    this._chipRipple.setupTriggerEvents(_elementRef);\n\n    this.rippleConfig = globalRippleOptions || {};\n    this._animationsDisabled = animationMode === 'NoopAnimations';\n    this.tabIndex = tabIndex != null ? (parseInt(tabIndex) || -1) : -1;\n  }\n\n  _addHostClassName() {\n    const basicChipAttrName = 'mat-basic-chip';\n    const element = this._elementRef.nativeElement as HTMLElement;\n\n    if (element.hasAttribute(basicChipAttrName) ||\n        element.tagName.toLowerCase() === basicChipAttrName) {\n      element.classList.add(basicChipAttrName);\n      return;\n    } else {\n      element.classList.add('mat-standard-chip');\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroyed.emit({chip: this});\n    this._chipRipple._removeTriggerEvents();\n  }\n\n  /** Selects the chip. */\n  select(): void {\n    if (!this._selected) {\n      this._selected = true;\n      this._dispatchSelectionChange();\n      this._markForCheck();\n    }\n  }\n\n  /** Deselects the chip. */\n  deselect(): void {\n    if (this._selected) {\n      this._selected = false;\n      this._dispatchSelectionChange();\n      this._markForCheck();\n    }\n  }\n\n  /** Select this chip and emit selected event */\n  selectViaInteraction(): void {\n    if (!this._selected) {\n      this._selected = true;\n      this._dispatchSelectionChange(true);\n      this._markForCheck();\n    }\n  }\n\n  /** Toggles the current selected state of this chip. */\n  toggleSelected(isUserInput: boolean = false): boolean {\n    this._selected = !this.selected;\n    this._dispatchSelectionChange(isUserInput);\n    this._markForCheck();\n    return this.selected;\n  }\n\n  /** Allows for programmatic focusing of the chip. */\n  focus(): void {\n    if (!this._hasFocus) {\n      this._elementRef.nativeElement.focus();\n      this._onFocus.next({chip: this});\n    }\n    this._hasFocus = true;\n  }\n\n  /**\n   * Allows for programmatic removal of the chip. Called by the MatChipList when the DELETE or\n   * BACKSPACE keys are pressed.\n   *\n   * Informs any listeners of the removal request. Does not remove the chip from the DOM.\n   */\n  remove(): void {\n    if (this.removable) {\n      this.removed.emit({chip: this});\n    }\n  }\n\n  /** Handles click events on the chip. */\n  _handleClick(event: Event) {\n    if (this.disabled) {\n      event.preventDefault();\n    } else {\n      event.stopPropagation();\n    }\n  }\n\n  /** Handle custom key presses. */\n  _handleKeydown(event: KeyboardEvent): void {\n    if (this.disabled) {\n      return;\n    }\n\n    switch (event.keyCode) {\n      case DELETE:\n      case BACKSPACE:\n        // If we are removable, remove the focused chip\n        this.remove();\n        // Always prevent so page navigation does not occur\n        event.preventDefault();\n        break;\n      case SPACE:\n        // If we are selectable, toggle the focused chip\n        if (this.selectable) {\n          this.toggleSelected(true);\n        }\n\n        // Always prevent space from scrolling the page since the list has focus\n        event.preventDefault();\n        break;\n    }\n  }\n\n  _blur(): void {\n    // When animations are enabled, Angular may end up removing the chip from the DOM a little\n    // earlier than usual, causing it to be blurred and throwing off the logic in the chip list\n    // that moves focus not the next item. To work around the issue, we defer marking the chip\n    // as not focused until the next time the zone stabilizes.\n    this._ngZone.onStable\n      .asObservable()\n      .pipe(take(1))\n      .subscribe(() => {\n        this._ngZone.run(() => {\n          this._hasFocus = false;\n          this._onBlur.next({chip: this});\n        });\n      });\n  }\n\n  private _dispatchSelectionChange(isUserInput = false) {\n    this.selectionChange.emit({\n      source: this,\n      isUserInput,\n      selected: this._selected\n    });\n  }\n\n  private _markForCheck() {\n    // @breaking-change 9.0.0 Remove this method once the _changeDetectorRef is a required param.\n    if (this._changeDetectorRef) {\n      this._changeDetectorRef.markForCheck();\n    }\n  }\n\n  static ngAcceptInputType_selected: BooleanInput;\n  static ngAcceptInputType_selectable: BooleanInput;\n  static ngAcceptInputType_removable: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_disableRipple: BooleanInput;\n}\n\n/**\n * Applies proper (click) support and adds styling for use with the Material Design \"cancel\" icon\n * available at https://material.io/icons/#ic_cancel.\n *\n * Example:\n *\n *     `<mat-chip>\n *       <mat-icon matChipRemove>cancel</mat-icon>\n *     </mat-chip>`\n *\n * You *may* use a custom icon, but you may need to override the `mat-chip-remove` positioning\n * styles to properly center the icon within the chip.\n */\n@Directive({\n  selector: '[matChipRemove]',\n  host: {\n    'class': 'mat-chip-remove mat-chip-trailing-icon',\n    '(click)': '_handleClick($event)',\n  },\n  providers: [{provide: MAT_CHIP_REMOVE, useExisting: MatChipRemove}],\n})\nexport class MatChipRemove {\n  constructor(\n    protected _parentChip: MatChip,\n    // @breaking-change 11.0.0 `elementRef` parameter to be made required.\n    elementRef?: ElementRef<HTMLElement>) {\n\n      // @breaking-change 11.0.0 Remove null check for `elementRef`.\n    if (elementRef && elementRef.nativeElement.nodeName === 'BUTTON') {\n      elementRef.nativeElement.setAttribute('type', 'button');\n    }\n   }\n\n  /** Calls the parent chip's public `remove()` method if applicable. */\n  _handleClick(event: Event): void {\n    const parentChip = this._parentChip;\n\n    if (parentChip.removable && !parentChip.disabled) {\n      parentChip.remove();\n    }\n\n    // We need to stop event propagation because otherwise the event will bubble up to the\n    // form field and cause the `onContainerClick` method to be invoked. This method would then\n    // reset the focused chip that has been focused after chip removal. Usually the parent\n    // the parent click listener of the `MatChip` would prevent propagation, but it can happen\n    // that the chip is being removed before the event bubbles up.\n    event.stopPropagation();\n  }\n}\n"]}