@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/stepper/stepper.js

@@ -35,349 +35,341 @@ export const STEPPER_GLOBAL_OPTIONS = new InjectionToken('STEPPER_GLOBAL_OPTIONS
  * @breaking-change 8.0.0.
  */
 export const MAT_STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS;
-let CdkStep = /** @class */ (() => {
-    class CdkStep {
-        /** @breaking-change 8.0.0 remove the `?` after `stepperOptions` */
-        constructor(_stepper, stepperOptions) {
-            this._stepper = _stepper;
-            /** Whether user has seen the expanded step content or not. */
-            this.interacted = false;
-            this._editable = true;
-            this._optional = false;
-            this._completedOverride = null;
-            this._customError = null;
-            this._stepperOptions = stepperOptions ? stepperOptions : {};
-            this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;
-            this._showError = !!this._stepperOptions.showError;
-        }
-        /** Whether the user can return to this step once it has been marked as completed. */
-        get editable() {
-            return this._editable;
-        }
-        set editable(value) {
-            this._editable = coerceBooleanProperty(value);
-        }
-        /** Whether the completion of step is optional. */
-        get optional() {
-            return this._optional;
-        }
-        set optional(value) {
-            this._optional = coerceBooleanProperty(value);
-        }
-        /** Whether step is marked as completed. */
-        get completed() {
-            return this._completedOverride == null ? this._getDefaultCompleted() : this._completedOverride;
-        }
-        set completed(value) {
-            this._completedOverride = coerceBooleanProperty(value);
-        }
-        _getDefaultCompleted() {
-            return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;
-        }
-        /** Whether step has an error. */
-        get hasError() {
-            return this._customError == null ? this._getDefaultError() : this._customError;
-        }
-        set hasError(value) {
-            this._customError = coerceBooleanProperty(value);
+export class CdkStep {
+    /** @breaking-change 8.0.0 remove the `?` after `stepperOptions` */
+    constructor(_stepper, stepperOptions) {
+        this._stepper = _stepper;
+        /** Whether user has seen the expanded step content or not. */
+        this.interacted = false;
+        this._editable = true;
+        this._optional = false;
+        this._completedOverride = null;
+        this._customError = null;
+        this._stepperOptions = stepperOptions ? stepperOptions : {};
+        this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;
+        this._showError = !!this._stepperOptions.showError;
+    }
+    /** Whether the user can return to this step once it has been marked as completed. */
+    get editable() {
+        return this._editable;
+    }
+    set editable(value) {
+        this._editable = coerceBooleanProperty(value);
+    }
+    /** Whether the completion of step is optional. */
+    get optional() {
+        return this._optional;
+    }
+    set optional(value) {
+        this._optional = coerceBooleanProperty(value);
+    }
+    /** Whether step is marked as completed. */
+    get completed() {
+        return this._completedOverride == null ? this._getDefaultCompleted() : this._completedOverride;
+    }
+    set completed(value) {
+        this._completedOverride = coerceBooleanProperty(value);
+    }
+    _getDefaultCompleted() {
+        return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;
+    }
+    /** Whether step has an error. */
+    get hasError() {
+        return this._customError == null ? this._getDefaultError() : this._customError;
+    }
+    set hasError(value) {
+        this._customError = coerceBooleanProperty(value);
+    }
+    _getDefaultError() {
+        return this.stepControl && this.stepControl.invalid && this.interacted;
+    }
+    /** Selects this step component. */
+    select() {
+        this._stepper.selected = this;
+    }
+    /** Resets the step to its initial state. Note that this includes resetting form data. */
+    reset() {
+        this.interacted = false;
+        if (this._completedOverride != null) {
+            this._completedOverride = false;
         }
-        _getDefaultError() {
-            return this.stepControl && this.stepControl.invalid && this.interacted;
+        if (this._customError != null) {
+            this._customError = false;
         }
-        /** Selects this step component. */
-        select() {
-            this._stepper.selected = this;
+        if (this.stepControl) {
+            this.stepControl.reset();
         }
-        /** Resets the step to its initial state. Note that this includes resetting form data. */
-        reset() {
-            this.interacted = false;
-            if (this._completedOverride != null) {
-                this._completedOverride = false;
-            }
-            if (this._customError != null) {
-                this._customError = false;
+    }
+    ngOnChanges() {
+        // Since basically all inputs of the MatStep get proxied through the view down to the
+        // underlying MatStepHeader, we have to make sure that change detection runs correctly.
+        this._stepper._stateChanged();
+    }
+}
+CdkStep.decorators = [
+    { type: Component, args: [{
+                selector: 'cdk-step',
+                exportAs: 'cdkStep',
+                template: '<ng-template><ng-content></ng-content></ng-template>',
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush
+            },] }
+];
+CdkStep.ctorParameters = () => [
+    { type: CdkStepper, decorators: [{ type: Inject, args: [forwardRef(() => CdkStepper),] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [STEPPER_GLOBAL_OPTIONS,] }] }
+];
+CdkStep.propDecorators = {
+    stepLabel: [{ type: ContentChild, args: [CdkStepLabel,] }],
+    content: [{ type: ViewChild, args: [TemplateRef, { static: true },] }],
+    stepControl: [{ type: Input }],
+    label: [{ type: Input }],
+    errorMessage: [{ type: Input }],
+    ariaLabel: [{ type: Input, args: ['aria-label',] }],
+    ariaLabelledby: [{ type: Input, args: ['aria-labelledby',] }],
+    state: [{ type: Input }],
+    editable: [{ type: Input }],
+    optional: [{ type: Input }],
+    completed: [{ type: Input }],
+    hasError: [{ type: Input }]
+};
+export class CdkStepper {
+    constructor(_dir, _changeDetectorRef, 
+    // @breaking-change 8.0.0 `_elementRef` and `_document` parameters to become required.
+    _elementRef, _document) {
+        this._dir = _dir;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._elementRef = _elementRef;
+        /** Emits when the component is destroyed. */
+        this._destroyed = new Subject();
+        this._linear = false;
+        this._selectedIndex = 0;
+        /** Event emitted when the selected step has changed. */
+        this.selectionChange = new EventEmitter();
+        this._orientation = 'horizontal';
+        this._groupId = nextId++;
+        this._document = _document;
+    }
+    /** The list of step components that the stepper is holding. */
+    get steps() {
+        return this._steps;
+    }
+    /** Whether the validity of previous steps should be checked or not. */
+    get linear() {
+        return this._linear;
+    }
+    set linear(value) {
+        this._linear = coerceBooleanProperty(value);
+    }
+    /** The index of the selected step. */
+    get selectedIndex() {
+        return this._selectedIndex;
+    }
+    set selectedIndex(index) {
+        const newIndex = coerceNumberProperty(index);
+        if (this.steps) {
+            // Ensure that the index can't be out of bounds.
+            if (newIndex < 0 || newIndex > this.steps.length - 1) {
+                throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');
             }
-            if (this.stepControl) {
-                this.stepControl.reset();
+            if (this._selectedIndex != newIndex && !this._anyControlsInvalidOrPending(newIndex) &&
+                (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) {
+                this._updateSelectedItemIndex(index);
             }
         }
-        ngOnChanges() {
-            // Since basically all inputs of the MatStep get proxied through the view down to the
-            // underlying MatStepHeader, we have to make sure that change detection runs correctly.
-            this._stepper._stateChanged();
+        else {
+            this._selectedIndex = newIndex;
         }
     }
-    CdkStep.decorators = [
-        { type: Component, args: [{
-                    selector: 'cdk-step',
-                    exportAs: 'cdkStep',
-                    template: '<ng-template><ng-content></ng-content></ng-template>',
-                    encapsulation: ViewEncapsulation.None,
-                    changeDetection: ChangeDetectionStrategy.OnPush
-                },] }
-    ];
-    CdkStep.ctorParameters = () => [
-        { type: CdkStepper, decorators: [{ type: Inject, args: [forwardRef(() => CdkStepper),] }] },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [STEPPER_GLOBAL_OPTIONS,] }] }
-    ];
-    CdkStep.propDecorators = {
-        stepLabel: [{ type: ContentChild, args: [CdkStepLabel,] }],
-        content: [{ type: ViewChild, args: [TemplateRef, { static: true },] }],
-        stepControl: [{ type: Input }],
-        label: [{ type: Input }],
-        errorMessage: [{ type: Input }],
-        ariaLabel: [{ type: Input, args: ['aria-label',] }],
-        ariaLabelledby: [{ type: Input, args: ['aria-labelledby',] }],
-        state: [{ type: Input }],
-        editable: [{ type: Input }],
-        optional: [{ type: Input }],
-        completed: [{ type: Input }],
-        hasError: [{ type: Input }]
-    };
-    return CdkStep;
-})();
-export { CdkStep };
-let CdkStepper = /** @class */ (() => {
-    class CdkStepper {
-        constructor(_dir, _changeDetectorRef, 
-        // @breaking-change 8.0.0 `_elementRef` and `_document` parameters to become required.
-        _elementRef, _document) {
-            this._dir = _dir;
-            this._changeDetectorRef = _changeDetectorRef;
-            this._elementRef = _elementRef;
-            /** Emits when the component is destroyed. */
-            this._destroyed = new Subject();
-            this._linear = false;
-            this._selectedIndex = 0;
-            /** Event emitted when the selected step has changed. */
-            this.selectionChange = new EventEmitter();
-            this._orientation = 'horizontal';
-            this._groupId = nextId++;
-            this._document = _document;
-        }
-        /** The list of step components that the stepper is holding. */
-        get steps() {
-            return this._steps;
-        }
-        /** Whether the validity of previous steps should be checked or not. */
-        get linear() {
-            return this._linear;
-        }
-        set linear(value) {
-            this._linear = coerceBooleanProperty(value);
-        }
-        /** The index of the selected step. */
-        get selectedIndex() {
-            return this._selectedIndex;
-        }
-        set selectedIndex(index) {
-            const newIndex = coerceNumberProperty(index);
-            if (this.steps) {
-                // Ensure that the index can't be out of bounds.
-                if (newIndex < 0 || newIndex > this.steps.length - 1) {
-                    throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');
-                }
-                if (this._selectedIndex != newIndex && !this._anyControlsInvalidOrPending(newIndex) &&
-                    (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) {
-                    this._updateSelectedItemIndex(index);
-                }
-            }
-            else {
-                this._selectedIndex = newIndex;
+    /** The step that is selected. */
+    get selected() {
+        // @breaking-change 8.0.0 Change return type to `CdkStep | undefined`.
+        return this.steps ? this.steps.toArray()[this.selectedIndex] : undefined;
+    }
+    set selected(step) {
+        this.selectedIndex = this.steps ? this.steps.toArray().indexOf(step) : -1;
+    }
+    ngAfterViewInit() {
+        // Note that while the step headers are content children by default, any components that
+        // extend this one might have them as view children. We initialize the keyboard handling in
+        // AfterViewInit so we're guaranteed for both view and content children to be defined.
+        this._keyManager = new FocusKeyManager(this._stepHeader)
+            .withWrap()
+            .withVerticalOrientation(this._orientation === 'vertical');
+        (this._dir ? this._dir.change : observableOf())
+            .pipe(startWith(this._layoutDirection()), takeUntil(this._destroyed))
+            .subscribe(direction => this._keyManager.withHorizontalOrientation(direction));
+        this._keyManager.updateActiveItem(this._selectedIndex);
+        this.steps.changes.pipe(takeUntil(this._destroyed)).subscribe(() => {
+            if (!this.selected) {
+                this._selectedIndex = Math.max(this._selectedIndex - 1, 0);
             }
+        });
+    }
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /** Selects and focuses the next step in list. */
+    next() {
+        this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);
+    }
+    /** Selects and focuses the previous step in list. */
+    previous() {
+        this.selectedIndex = Math.max(this._selectedIndex - 1, 0);
+    }
+    /** Resets the stepper to its initial state. Note that this includes clearing form data. */
+    reset() {
+        this._updateSelectedItemIndex(0);
+        this.steps.forEach(step => step.reset());
+        this._stateChanged();
+    }
+    /** Returns a unique id for each step label element. */
+    _getStepLabelId(i) {
+        return `cdk-step-label-${this._groupId}-${i}`;
+    }
+    /** Returns unique id for each step content element. */
+    _getStepContentId(i) {
+        return `cdk-step-content-${this._groupId}-${i}`;
+    }
+    /** Marks the component to be change detected. */
+    _stateChanged() {
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Returns position state of the step with the given index. */
+    _getAnimationDirection(index) {
+        const position = index - this._selectedIndex;
+        if (position < 0) {
+            return this._layoutDirection() === 'rtl' ? 'next' : 'previous';
         }
-        /** The step that is selected. */
-        get selected() {
-            // @breaking-change 8.0.0 Change return type to `CdkStep | undefined`.
-            return this.steps ? this.steps.toArray()[this.selectedIndex] : undefined;
-        }
-        set selected(step) {
-            this.selectedIndex = this.steps ? this.steps.toArray().indexOf(step) : -1;
-        }
-        ngAfterViewInit() {
-            // Note that while the step headers are content children by default, any components that
-            // extend this one might have them as view children. We initialize the keyboard handling in
-            // AfterViewInit so we're guaranteed for both view and content children to be defined.
-            this._keyManager = new FocusKeyManager(this._stepHeader)
-                .withWrap()
-                .withVerticalOrientation(this._orientation === 'vertical');
-            (this._dir ? this._dir.change : observableOf())
-                .pipe(startWith(this._layoutDirection()), takeUntil(this._destroyed))
-                .subscribe(direction => this._keyManager.withHorizontalOrientation(direction));
-            this._keyManager.updateActiveItem(this._selectedIndex);
-            this.steps.changes.pipe(takeUntil(this._destroyed)).subscribe(() => {
-                if (!this.selected) {
-                    this._selectedIndex = Math.max(this._selectedIndex - 1, 0);
-                }
-            });
-        }
-        ngOnDestroy() {
-            this._destroyed.next();
-            this._destroyed.complete();
-        }
-        /** Selects and focuses the next step in list. */
-        next() {
-            this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);
+        else if (position > 0) {
+            return this._layoutDirection() === 'rtl' ? 'previous' : 'next';
         }
-        /** Selects and focuses the previous step in list. */
-        previous() {
-            this.selectedIndex = Math.max(this._selectedIndex - 1, 0);
+        return 'current';
+    }
+    /** Returns the type of icon to be displayed. */
+    _getIndicatorType(index, state = STEP_STATE.NUMBER) {
+        const step = this.steps.toArray()[index];
+        const isCurrentStep = this._isCurrentStep(index);
+        return step._displayDefaultIndicatorType ? this._getDefaultIndicatorLogic(step, isCurrentStep) :
+            this._getGuidelineLogic(step, isCurrentStep, state);
+    }
+    _getDefaultIndicatorLogic(step, isCurrentStep) {
+        if (step._showError && step.hasError && !isCurrentStep) {
+            return STEP_STATE.ERROR;
         }
-        /** Resets the stepper to its initial state. Note that this includes clearing form data. */
-        reset() {
-            this._updateSelectedItemIndex(0);
-            this.steps.forEach(step => step.reset());
-            this._stateChanged();
+        else if (!step.completed || isCurrentStep) {
+            return STEP_STATE.NUMBER;
         }
-        /** Returns a unique id for each step label element. */
-        _getStepLabelId(i) {
-            return `cdk-step-label-${this._groupId}-${i}`;
+        else {
+            return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;
         }
-        /** Returns unique id for each step content element. */
-        _getStepContentId(i) {
-            return `cdk-step-content-${this._groupId}-${i}`;
+    }
+    _getGuidelineLogic(step, isCurrentStep, state = STEP_STATE.NUMBER) {
+        if (step._showError && step.hasError && !isCurrentStep) {
+            return STEP_STATE.ERROR;
         }
-        /** Marks the component to be change detected. */
-        _stateChanged() {
-            this._changeDetectorRef.markForCheck();
+        else if (step.completed && !isCurrentStep) {
+            return STEP_STATE.DONE;
         }
-        /** Returns position state of the step with the given index. */
-        _getAnimationDirection(index) {
-            const position = index - this._selectedIndex;
-            if (position < 0) {
-                return this._layoutDirection() === 'rtl' ? 'next' : 'previous';
-            }
-            else if (position > 0) {
-                return this._layoutDirection() === 'rtl' ? 'previous' : 'next';
-            }
-            return 'current';
+        else if (step.completed && isCurrentStep) {
+            return state;
         }
-        /** Returns the type of icon to be displayed. */
-        _getIndicatorType(index, state = STEP_STATE.NUMBER) {
-            const step = this.steps.toArray()[index];
-            const isCurrentStep = this._isCurrentStep(index);
-            return step._displayDefaultIndicatorType ? this._getDefaultIndicatorLogic(step, isCurrentStep) :
-                this._getGuidelineLogic(step, isCurrentStep, state);
+        else if (step.editable && isCurrentStep) {
+            return STEP_STATE.EDIT;
         }
-        _getDefaultIndicatorLogic(step, isCurrentStep) {
-            if (step._showError && step.hasError && !isCurrentStep) {
-                return STEP_STATE.ERROR;
-            }
-            else if (!step.completed || isCurrentStep) {
-                return STEP_STATE.NUMBER;
-            }
-            else {
-                return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;
-            }
+        else {
+            return state;
         }
-        _getGuidelineLogic(step, isCurrentStep, state = STEP_STATE.NUMBER) {
-            if (step._showError && step.hasError && !isCurrentStep) {
-                return STEP_STATE.ERROR;
-            }
-            else if (step.completed && !isCurrentStep) {
-                return STEP_STATE.DONE;
-            }
-            else if (step.completed && isCurrentStep) {
-                return state;
-            }
-            else if (step.editable && isCurrentStep) {
-                return STEP_STATE.EDIT;
-            }
-            else {
-                return state;
-            }
-        }
-        _isCurrentStep(index) {
-            return this._selectedIndex === index;
-        }
-        /** Returns the index of the currently-focused step header. */
-        _getFocusIndex() {
-            return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;
+    }
+    _isCurrentStep(index) {
+        return this._selectedIndex === index;
+    }
+    /** Returns the index of the currently-focused step header. */
+    _getFocusIndex() {
+        return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;
+    }
+    _updateSelectedItemIndex(newIndex) {
+        const stepsArray = this.steps.toArray();
+        this.selectionChange.emit({
+            selectedIndex: newIndex,
+            previouslySelectedIndex: this._selectedIndex,
+            selectedStep: stepsArray[newIndex],
+            previouslySelectedStep: stepsArray[this._selectedIndex],
+        });
+        // If focus is inside the stepper, move it to the next header, otherwise it may become
+        // lost when the active step content is hidden. We can't be more granular with the check
+        // (e.g. checking whether focus is inside the active step), because we don't have a
+        // reference to the elements that are rendering out the content.
+        this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :
+            this._keyManager.updateActiveItem(newIndex);
+        this._selectedIndex = newIndex;
+        this._stateChanged();
+    }
+    _onKeydown(event) {
+        const hasModifier = hasModifierKey(event);
+        const keyCode = event.keyCode;
+        const manager = this._keyManager;
+        if (manager.activeItemIndex != null && !hasModifier &&
+            (keyCode === SPACE || keyCode === ENTER)) {
+            this.selectedIndex = manager.activeItemIndex;
+            event.preventDefault();
+        }
+        else if (keyCode === HOME) {
+            manager.setFirstItemActive();
+            event.preventDefault();
+        }
+        else if (keyCode === END) {
+            manager.setLastItemActive();
+            event.preventDefault();
+        }
+        else {
+            manager.onKeydown(event);
         }
-        _updateSelectedItemIndex(newIndex) {
-            const stepsArray = this.steps.toArray();
-            this.selectionChange.emit({
-                selectedIndex: newIndex,
-                previouslySelectedIndex: this._selectedIndex,
-                selectedStep: stepsArray[newIndex],
-                previouslySelectedStep: stepsArray[this._selectedIndex],
+    }
+    _anyControlsInvalidOrPending(index) {
+        const steps = this.steps.toArray();
+        steps[this._selectedIndex].interacted = true;
+        if (this._linear && index >= 0) {
+            return steps.slice(0, index).some(step => {
+                const control = step.stepControl;
+                const isIncomplete = control ? (control.invalid || control.pending || !step.interacted) : !step.completed;
+                return isIncomplete && !step.optional && !step._completedOverride;
             });
-            // If focus is inside the stepper, move it to the next header, otherwise it may become
-            // lost when the active step content is hidden. We can't be more granular with the check
-            // (e.g. checking whether focus is inside the active step), because we don't have a
-            // reference to the elements that are rendering out the content.
-            this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :
-                this._keyManager.updateActiveItem(newIndex);
-            this._selectedIndex = newIndex;
-            this._stateChanged();
         }
-        _onKeydown(event) {
-            const hasModifier = hasModifierKey(event);
-            const keyCode = event.keyCode;
-            const manager = this._keyManager;
-            if (manager.activeItemIndex != null && !hasModifier &&
-                (keyCode === SPACE || keyCode === ENTER)) {
-                this.selectedIndex = manager.activeItemIndex;
-                event.preventDefault();
-            }
-            else if (keyCode === HOME) {
-                manager.setFirstItemActive();
-                event.preventDefault();
-            }
-            else if (keyCode === END) {
-                manager.setLastItemActive();
-                event.preventDefault();
-            }
-            else {
-                manager.onKeydown(event);
-            }
-        }
-        _anyControlsInvalidOrPending(index) {
-            const steps = this.steps.toArray();
-            steps[this._selectedIndex].interacted = true;
-            if (this._linear && index >= 0) {
-                return steps.slice(0, index).some(step => {
-                    const control = step.stepControl;
-                    const isIncomplete = control ? (control.invalid || control.pending || !step.interacted) : !step.completed;
-                    return isIncomplete && !step.optional && !step._completedOverride;
-                });
-            }
+        return false;
+    }
+    _layoutDirection() {
+        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+    }
+    /** Checks whether the stepper contains the focused element. */
+    _containsFocus() {
+        if (!this._document || !this._elementRef) {
             return false;
         }
-        _layoutDirection() {
-            return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
-        }
-        /** Checks whether the stepper contains the focused element. */
-        _containsFocus() {
-            if (!this._document || !this._elementRef) {
-                return false;
-            }
-            const stepperElement = this._elementRef.nativeElement;
-            const focusedElement = this._document.activeElement;
-            return stepperElement === focusedElement || stepperElement.contains(focusedElement);
-        }
+        const stepperElement = this._elementRef.nativeElement;
+        const focusedElement = this._document.activeElement;
+        return stepperElement === focusedElement || stepperElement.contains(focusedElement);
     }
-    CdkStepper.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkStepper]',
-                    exportAs: 'cdkStepper',
-                },] }
-    ];
-    CdkStepper.ctorParameters = () => [
-        { type: Directionality, decorators: [{ type: Optional }] },
-        { type: ChangeDetectorRef },
-        { type: ElementRef },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-    ];
-    CdkStepper.propDecorators = {
-        _steps: [{ type: ContentChildren, args: [CdkStep, { descendants: true },] }],
-        _stepHeader: [{ type: ContentChildren, args: [CdkStepHeader, { descendants: true },] }],
-        linear: [{ type: Input }],
-        selectedIndex: [{ type: Input }],
-        selected: [{ type: Input }],
-        selectionChange: [{ type: Output }]
-    };
-    return CdkStepper;
-})();
-export { CdkStepper };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepper.js","sourceRoot":"","sources":["../../../../../../src/cdk/stepper/stepper.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, FocusKeyManager} from '@angular/cdk/a11y';\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {\n  BooleanInput,\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  NumberInput\n} from '@angular/cdk/coercion';\nimport {END, ENTER, hasModifierKey, HOME, SPACE} from '@angular/cdk/keycodes';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  InjectionToken,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  TemplateRef,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {Observable, of as observableOf, Subject} from 'rxjs';\nimport {startWith, takeUntil} from 'rxjs/operators';\n\nimport {CdkStepHeader} from './step-header';\nimport {CdkStepLabel} from './step-label';\n\n/** Used to generate unique ID for each stepper component. */\nlet nextId = 0;\n\n/**\n * Position state of the content of each step in stepper that is used for transitioning\n * the content into correct position upon step selection change.\n */\nexport type StepContentPositionState = 'previous'|'current'|'next';\n\n/** Possible orientation of a stepper. */\nexport type StepperOrientation = 'horizontal'|'vertical';\n\n/** Change event emitted on selection changes. */\nexport class StepperSelectionEvent {\n  /** Index of the step now selected. */\n  selectedIndex: number;\n\n  /** Index of the step previously selected. */\n  previouslySelectedIndex: number;\n\n  /** The step instance now selected. */\n  selectedStep: CdkStep;\n\n  /** The step instance previously selected. */\n  previouslySelectedStep: CdkStep;\n}\n\n/** The state of each step. */\nexport type StepState = 'number'|'edit'|'done'|'error'|string;\n\n/** Enum to represent the different states of the steps. */\nexport const STEP_STATE = {\n  NUMBER: 'number',\n  EDIT: 'edit',\n  DONE: 'done',\n  ERROR: 'error'\n};\n\n/** InjectionToken that can be used to specify the global stepper options. */\nexport const STEPPER_GLOBAL_OPTIONS = new InjectionToken<StepperOptions>('STEPPER_GLOBAL_OPTIONS');\n\n/**\n * InjectionToken that can be used to specify the global stepper options.\n * @deprecated Use `STEPPER_GLOBAL_OPTIONS` instead.\n * @breaking-change 8.0.0.\n */\nexport const MAT_STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS;\n\n/** Configurable options for stepper. */\nexport interface StepperOptions {\n  /**\n   * Whether the stepper should display an error state or not.\n   * Default behavior is assumed to be false.\n   */\n  showError?: boolean;\n\n  /**\n   * Whether the stepper should display the default indicator type\n   * or not.\n   * Default behavior is assumed to be true.\n   */\n  displayDefaultIndicatorType?: boolean;\n}\n\n@Component({\n  selector: 'cdk-step',\n  exportAs: 'cdkStep',\n  template: '<ng-template><ng-content></ng-content></ng-template>',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CdkStep implements OnChanges {\n  private _stepperOptions: StepperOptions;\n  _showError: boolean;\n  _displayDefaultIndicatorType: boolean;\n\n  /** Template for step label if it exists. */\n  @ContentChild(CdkStepLabel) stepLabel: CdkStepLabel;\n\n  /** Template for step content. */\n  @ViewChild(TemplateRef, {static: true}) content: TemplateRef<any>;\n\n  /** The top level abstract control of the step. */\n  @Input() stepControl: AbstractControlLike;\n\n  /** Whether user has seen the expanded step content or not. */\n  interacted = false;\n\n  /** Plain text label of the step. */\n  @Input() label: string;\n\n  /** Error message to display when there's an error. */\n  @Input() errorMessage: string;\n\n  /** Aria label for the tab. */\n  @Input('aria-label') ariaLabel: string;\n\n  /**\n   * Reference to the element that the tab is labelled by.\n   * Will be cleared if `aria-label` is set at the same time.\n   */\n  @Input('aria-labelledby') ariaLabelledby: string;\n\n  /** State of the step. */\n  @Input() state: StepState;\n\n  /** Whether the user can return to this step once it has been marked as completed. */\n  @Input()\n  get editable(): boolean {\n    return this._editable;\n  }\n  set editable(value: boolean) {\n    this._editable = coerceBooleanProperty(value);\n  }\n  private _editable = true;\n\n  /** Whether the completion of step is optional. */\n  @Input()\n  get optional(): boolean {\n    return this._optional;\n  }\n  set optional(value: boolean) {\n    this._optional = coerceBooleanProperty(value);\n  }\n  private _optional = false;\n\n  /** Whether step is marked as completed. */\n  @Input()\n  get completed(): boolean {\n    return this._completedOverride == null ? this._getDefaultCompleted() : this._completedOverride;\n  }\n  set completed(value: boolean) {\n    this._completedOverride = coerceBooleanProperty(value);\n  }\n  _completedOverride: boolean|null = null;\n\n  private _getDefaultCompleted() {\n    return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;\n  }\n\n  /** Whether step has an error. */\n  @Input()\n  get hasError(): boolean {\n    return this._customError == null ? this._getDefaultError() : this._customError;\n  }\n  set hasError(value: boolean) {\n    this._customError = coerceBooleanProperty(value);\n  }\n  private _customError: boolean|null = null;\n\n  private _getDefaultError() {\n    return this.stepControl && this.stepControl.invalid && this.interacted;\n  }\n\n  /** @breaking-change 8.0.0 remove the `?` after `stepperOptions` */\n  constructor(\n      @Inject(forwardRef(() => CdkStepper)) private _stepper: CdkStepper,\n      @Optional() @Inject(STEPPER_GLOBAL_OPTIONS) stepperOptions?: StepperOptions) {\n    this._stepperOptions = stepperOptions ? stepperOptions : {};\n    this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;\n    this._showError = !!this._stepperOptions.showError;\n  }\n\n  /** Selects this step component. */\n  select(): void {\n    this._stepper.selected = this;\n  }\n\n  /** Resets the step to its initial state. Note that this includes resetting form data. */\n  reset(): void {\n    this.interacted = false;\n\n    if (this._completedOverride != null) {\n      this._completedOverride = false;\n    }\n\n    if (this._customError != null) {\n      this._customError = false;\n    }\n\n    if (this.stepControl) {\n      this.stepControl.reset();\n    }\n  }\n\n  ngOnChanges() {\n    // Since basically all inputs of the MatStep get proxied through the view down to the\n    // underlying MatStepHeader, we have to make sure that change detection runs correctly.\n    this._stepper._stateChanged();\n  }\n\n  static ngAcceptInputType_editable: BooleanInput;\n  static ngAcceptInputType_hasError: BooleanInput;\n  static ngAcceptInputType_optional: BooleanInput;\n  static ngAcceptInputType_completed: BooleanInput;\n}\n\n@Directive({\n  selector: '[cdkStepper]',\n  exportAs: 'cdkStepper',\n})\nexport class CdkStepper implements AfterViewInit, OnDestroy {\n  /** Emits when the component is destroyed. */\n  protected _destroyed = new Subject<void>();\n\n  /** Used for managing keyboard focus. */\n  private _keyManager: FocusKeyManager<FocusableOption>;\n\n  /**\n   * @breaking-change 8.0.0 Remove `| undefined` once the `_document`\n   * constructor param is required.\n   */\n  private _document: Document|undefined;\n\n  /**\n   * The list of step components that the stepper is holding.\n   * @deprecated use `steps` instead\n   * @breaking-change 9.0.0 remove this property\n   */\n  @ContentChildren(CdkStep, {descendants: true}) _steps: QueryList<CdkStep>;\n\n  /** The list of step components that the stepper is holding. */\n  get steps(): QueryList<CdkStep> {\n    return this._steps;\n  }\n\n  /**\n   * The list of step headers of the steps in the stepper.\n   * @deprecated Type to be changed to `QueryList<CdkStepHeader>`.\n   * @breaking-change 8.0.0\n   */\n  @ContentChildren(CdkStepHeader, {descendants: true}) _stepHeader: QueryList<FocusableOption>;\n\n  /** Whether the validity of previous steps should be checked or not. */\n  @Input()\n  get linear(): boolean {\n    return this._linear;\n  }\n  set linear(value: boolean) {\n    this._linear = coerceBooleanProperty(value);\n  }\n  private _linear = false;\n\n  /** The index of the selected step. */\n  @Input()\n  get selectedIndex() {\n    return this._selectedIndex;\n  }\n  set selectedIndex(index: number) {\n    const newIndex = coerceNumberProperty(index);\n\n    if (this.steps) {\n      // Ensure that the index can't be out of bounds.\n      if (newIndex < 0 || newIndex > this.steps.length - 1) {\n        throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');\n      }\n\n      if (this._selectedIndex != newIndex && !this._anyControlsInvalidOrPending(newIndex) &&\n          (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) {\n        this._updateSelectedItemIndex(index);\n      }\n    } else {\n      this._selectedIndex = newIndex;\n    }\n  }\n  private _selectedIndex = 0;\n\n  /** The step that is selected. */\n  @Input()\n  get selected(): CdkStep {\n    // @breaking-change 8.0.0 Change return type to `CdkStep | undefined`.\n    return this.steps ? this.steps.toArray()[this.selectedIndex] : undefined!;\n  }\n  set selected(step: CdkStep) {\n    this.selectedIndex = this.steps ? this.steps.toArray().indexOf(step) : -1;\n  }\n\n  /** Event emitted when the selected step has changed. */\n  @Output()\n  selectionChange: EventEmitter<StepperSelectionEvent> = new EventEmitter<StepperSelectionEvent>();\n\n  /** Used to track unique ID for each stepper component. */\n  _groupId: number;\n\n  protected _orientation: StepperOrientation = 'horizontal';\n\n  constructor(\n      @Optional() private _dir: Directionality, private _changeDetectorRef: ChangeDetectorRef,\n      // @breaking-change 8.0.0 `_elementRef` and `_document` parameters to become required.\n      private _elementRef?: ElementRef<HTMLElement>, @Inject(DOCUMENT) _document?: any) {\n    this._groupId = nextId++;\n    this._document = _document;\n  }\n\n  ngAfterViewInit() {\n    // Note that while the step headers are content children by default, any components that\n    // extend this one might have them as view children. We initialize the keyboard handling in\n    // AfterViewInit so we're guaranteed for both view and content children to be defined.\n    this._keyManager = new FocusKeyManager<FocusableOption>(this._stepHeader)\n                           .withWrap()\n                           .withVerticalOrientation(this._orientation === 'vertical');\n\n    (this._dir ? (this._dir.change as Observable<Direction>) : observableOf<Direction>())\n        .pipe(startWith(this._layoutDirection()), takeUntil(this._destroyed))\n        .subscribe(direction => this._keyManager.withHorizontalOrientation(direction));\n\n    this._keyManager.updateActiveItem(this._selectedIndex);\n\n    this.steps.changes.pipe(takeUntil(this._destroyed)).subscribe(() => {\n      if (!this.selected) {\n        this._selectedIndex = Math.max(this._selectedIndex - 1, 0);\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /** Selects and focuses the next step in list. */\n  next(): void {\n    this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);\n  }\n\n  /** Selects and focuses the previous step in list. */\n  previous(): void {\n    this.selectedIndex = Math.max(this._selectedIndex - 1, 0);\n  }\n\n  /** Resets the stepper to its initial state. Note that this includes clearing form data. */\n  reset(): void {\n    this._updateSelectedItemIndex(0);\n    this.steps.forEach(step => step.reset());\n    this._stateChanged();\n  }\n\n  /** Returns a unique id for each step label element. */\n  _getStepLabelId(i: number): string {\n    return `cdk-step-label-${this._groupId}-${i}`;\n  }\n\n  /** Returns unique id for each step content element. */\n  _getStepContentId(i: number): string {\n    return `cdk-step-content-${this._groupId}-${i}`;\n  }\n\n  /** Marks the component to be change detected. */\n  _stateChanged() {\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Returns position state of the step with the given index. */\n  _getAnimationDirection(index: number): StepContentPositionState {\n    const position = index - this._selectedIndex;\n    if (position < 0) {\n      return this._layoutDirection() === 'rtl' ? 'next' : 'previous';\n    } else if (position > 0) {\n      return this._layoutDirection() === 'rtl' ? 'previous' : 'next';\n    }\n    return 'current';\n  }\n\n  /** Returns the type of icon to be displayed. */\n  _getIndicatorType(index: number, state: StepState = STEP_STATE.NUMBER): StepState {\n    const step = this.steps.toArray()[index];\n    const isCurrentStep = this._isCurrentStep(index);\n\n    return step._displayDefaultIndicatorType ? this._getDefaultIndicatorLogic(step, isCurrentStep) :\n                                               this._getGuidelineLogic(step, isCurrentStep, state);\n  }\n\n  private _getDefaultIndicatorLogic(step: CdkStep, isCurrentStep: boolean): StepState {\n    if (step._showError && step.hasError && !isCurrentStep) {\n      return STEP_STATE.ERROR;\n    } else if (!step.completed || isCurrentStep) {\n      return STEP_STATE.NUMBER;\n    } else {\n      return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;\n    }\n  }\n\n  private _getGuidelineLogic(\n      step: CdkStep, isCurrentStep: boolean, state: StepState = STEP_STATE.NUMBER): StepState {\n    if (step._showError && step.hasError && !isCurrentStep) {\n      return STEP_STATE.ERROR;\n    } else if (step.completed && !isCurrentStep) {\n      return STEP_STATE.DONE;\n    } else if (step.completed && isCurrentStep) {\n      return state;\n    } else if (step.editable && isCurrentStep) {\n      return STEP_STATE.EDIT;\n    } else {\n      return state;\n    }\n  }\n\n  private _isCurrentStep(index: number) {\n    return this._selectedIndex === index;\n  }\n\n  /** Returns the index of the currently-focused step header. */\n  _getFocusIndex() {\n    return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;\n  }\n\n  private _updateSelectedItemIndex(newIndex: number): void {\n    const stepsArray = this.steps.toArray();\n    this.selectionChange.emit({\n      selectedIndex: newIndex,\n      previouslySelectedIndex: this._selectedIndex,\n      selectedStep: stepsArray[newIndex],\n      previouslySelectedStep: stepsArray[this._selectedIndex],\n    });\n\n    // If focus is inside the stepper, move it to the next header, otherwise it may become\n    // lost when the active step content is hidden. We can't be more granular with the check\n    // (e.g. checking whether focus is inside the active step), because we don't have a\n    // reference to the elements that are rendering out the content.\n    this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :\n                            this._keyManager.updateActiveItem(newIndex);\n\n    this._selectedIndex = newIndex;\n    this._stateChanged();\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    const hasModifier = hasModifierKey(event);\n    const keyCode = event.keyCode;\n    const manager = this._keyManager;\n\n    if (manager.activeItemIndex != null && !hasModifier &&\n        (keyCode === SPACE || keyCode === ENTER)) {\n      this.selectedIndex = manager.activeItemIndex;\n      event.preventDefault();\n    } else if (keyCode === HOME) {\n      manager.setFirstItemActive();\n      event.preventDefault();\n    } else if (keyCode === END) {\n      manager.setLastItemActive();\n      event.preventDefault();\n    } else {\n      manager.onKeydown(event);\n    }\n  }\n\n  private _anyControlsInvalidOrPending(index: number): boolean {\n    const steps = this.steps.toArray();\n\n    steps[this._selectedIndex].interacted = true;\n\n    if (this._linear && index >= 0) {\n      return steps.slice(0, index).some(step => {\n        const control = step.stepControl;\n        const isIncomplete =\n            control ? (control.invalid || control.pending || !step.interacted) : !step.completed;\n        return isIncomplete && !step.optional && !step._completedOverride;\n      });\n    }\n\n    return false;\n  }\n\n  private _layoutDirection(): Direction {\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n  }\n\n  /** Checks whether the stepper contains the focused element. */\n  private _containsFocus(): boolean {\n    if (!this._document || !this._elementRef) {\n      return false;\n    }\n\n    const stepperElement = this._elementRef.nativeElement;\n    const focusedElement = this._document.activeElement;\n    return stepperElement === focusedElement || stepperElement.contains(focusedElement);\n  }\n\n  static ngAcceptInputType_editable: BooleanInput;\n  static ngAcceptInputType_optional: BooleanInput;\n  static ngAcceptInputType_completed: BooleanInput;\n  static ngAcceptInputType_hasError: BooleanInput;\n  static ngAcceptInputType_linear: BooleanInput;\n  static ngAcceptInputType_selectedIndex: NumberInput;\n}\n\n\n/**\n * Simplified representation of an \"AbstractControl\" from @angular/forms.\n * Used to avoid having to bring in @angular/forms for a single optional interface.\n * @docs-private\n */\ninterface AbstractControlLike {\n  asyncValidator: ((control: any) => any) | null;\n  dirty: boolean;\n  disabled: boolean;\n  enabled: boolean;\n  errors: {[key: string]: any} | null;\n  invalid: boolean;\n  parent: any;\n  pending: boolean;\n  pristine: boolean;\n  root: AbstractControlLike;\n  status: string;\n  statusChanges: Observable<any>;\n  touched: boolean;\n  untouched: boolean;\n  updateOn: any;\n  valid: boolean;\n  validator: ((control: any) => any) | null;\n  value: any;\n  valueChanges: Observable<any>;\n  clearAsyncValidators(): void;\n  clearValidators(): void;\n  disable(opts?: any): void;\n  enable(opts?: any): void;\n  get(path: (string | number)[] | string): AbstractControlLike | null;\n  getError(errorCode: string, path?: (string | number)[] | string): any;\n  hasError(errorCode: string, path?: (string | number)[] | string): boolean;\n  markAllAsTouched(): void;\n  markAsDirty(opts?: any): void;\n  markAsPending(opts?: any): void;\n  markAsPristine(opts?: any): void;\n  markAsTouched(opts?: any): void;\n  markAsUntouched(opts?: any): void;\n  patchValue(value: any, options?: Object): void;\n  reset(value?: any, options?: Object): void;\n  setAsyncValidators(newValidator: (control: any) => any |\n    ((control: any) => any)[] | null): void;\n  setErrors(errors: {[key: string]: any} | null, opts?: any): void;\n  setParent(parent: any): void;\n  setValidators(newValidator: (control: any) => any |\n    ((control: any) => any)[] | null): void;\n  setValue(value: any, options?: Object): void;\n  updateValueAndValidity(opts?: any): void;\n  patchValue(value: any, options?: any): void;\n  reset(formState?: any, options?: any): void;\n  setValue(value: any, options?: any): void;\n}\n"]}
+}
+CdkStepper.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkStepper]',
+                exportAs: 'cdkStepper',
+            },] }
+];
+CdkStepper.ctorParameters = () => [
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: ChangeDetectorRef },
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+CdkStepper.propDecorators = {
+    _steps: [{ type: ContentChildren, args: [CdkStep, { descendants: true },] }],
+    _stepHeader: [{ type: ContentChildren, args: [CdkStepHeader, { descendants: true },] }],
+    linear: [{ type: Input }],
+    selectedIndex: [{ type: Input }],
+    selected: [{ type: Input }],
+    selectionChange: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepper.js","sourceRoot":"","sources":["../../../../../../src/cdk/stepper/stepper.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAkB,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAY,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAEL,qBAAqB,EACrB,oBAAoB,EAErB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAC,GAAG,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAC,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAEL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,eAAe,EACf,SAAS,EACT,UAAU,EACV,YAAY,EACZ,UAAU,EACV,MAAM,EACN,cAAc,EACd,KAAK,EAGL,QAAQ,EACR,MAAM,EACN,SAAS,EACT,WAAW,EACX,SAAS,EACT,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAa,EAAE,IAAI,YAAY,EAAE,OAAO,EAAC,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAC,SAAS,EAAE,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAEpD,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAE1C,6DAA6D;AAC7D,IAAI,MAAM,GAAG,CAAC,CAAC;AAWf,iDAAiD;AACjD,MAAM,OAAO,qBAAqB;CAYjC;AAKD,2DAA2D;AAC3D,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;CACf,CAAC;AAEF,6EAA6E;AAC7E,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,cAAc,CAAiB,wBAAwB,CAAC,CAAC;AAEnG;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,sBAAsB,CAAC;AAyBjE,MAAM,OAAO,OAAO;IAmFlB,mEAAmE;IACnE,YACkD,QAAoB,EACtB,cAA+B;QAD7B,aAAQ,GAAR,QAAQ,CAAY;QAvEtE,8DAA8D;QAC9D,eAAU,GAAG,KAAK,CAAC;QA4BX,cAAS,GAAG,IAAI,CAAC;QAUjB,cAAS,GAAG,KAAK,CAAC;QAU1B,uBAAkB,GAAiB,IAAI,CAAC;QAchC,iBAAY,GAAiB,IAAI,CAAC;QAUxC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5D,IAAI,CAAC,4BAA4B,GAAG,IAAI,CAAC,eAAe,CAAC,2BAA2B,KAAK,KAAK,CAAC;QAC/F,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;IACrD,CAAC;IAvDD,qFAAqF;IACrF,IACI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QACzB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAGD,kDAAkD;IAClD,IACI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QACzB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAGD,2CAA2C;IAC3C,IACI,SAAS;QACX,OAAO,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC;IACjG,CAAC;IACD,IAAI,SAAS,CAAC,KAAc;QAC1B,IAAI,CAAC,kBAAkB,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACzD,CAAC;IAGO,oBAAoB;QAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;IACxF,CAAC;IAED,iCAAiC;IACjC,IACI,QAAQ;QACV,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;IACjF,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QACzB,IAAI,CAAC,YAAY,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;IAGO,gBAAgB;QACtB,OAAO,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC;IACzE,CAAC;IAWD,mCAAmC;IACnC,MAAM;QACJ,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,yFAAyF;IACzF,KAAK;QACH,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QAExB,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,EAAE;YACnC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;SACjC;QAED,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,EAAE;YAC7B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;SAC3B;QAED,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;SAC1B;IACH,CAAC;IAED,WAAW;QACT,qFAAqF;QACrF,uFAAuF;QACvF,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC;IAChC,CAAC;;;YA7HF,SAAS,SAAC;gBACT,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,sDAAsD;gBAChE,aAAa,EAAE,iBAAiB,CAAC,IAAI;gBACrC,eAAe,EAAE,uBAAuB,CAAC,MAAM;aAChD;;;YAsF6D,UAAU,uBAAjE,MAAM,SAAC,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC;4CACnC,QAAQ,YAAI,MAAM,SAAC,sBAAsB;;;wBAhF7C,YAAY,SAAC,YAAY;sBAGzB,SAAS,SAAC,WAAW,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;0BAGrC,KAAK;oBAML,KAAK;2BAGL,KAAK;wBAGL,KAAK,SAAC,YAAY;6BAMlB,KAAK,SAAC,iBAAiB;oBAGvB,KAAK;uBAGL,KAAK;uBAUL,KAAK;wBAUL,KAAK;uBAcL,KAAK;;AA4DR,MAAM,OAAO,UAAU;IAqFrB,YACwB,IAAoB,EAAU,kBAAqC;IACvF,sFAAsF;IAC9E,WAAqC,EAAoB,SAAe;QAF5D,SAAI,GAAJ,IAAI,CAAgB;QAAU,uBAAkB,GAAlB,kBAAkB,CAAmB;QAE/E,gBAAW,GAAX,WAAW,CAA0B;QAvFjD,6CAA6C;QACnC,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;QAsCnC,YAAO,GAAG,KAAK,CAAC;QAwBhB,mBAAc,GAAG,CAAC,CAAC;QAY3B,wDAAwD;QAExD,oBAAe,GAAwC,IAAI,YAAY,EAAyB,CAAC;QAKvF,iBAAY,GAAuB,YAAY,CAAC;QAMxD,IAAI,CAAC,QAAQ,GAAG,MAAM,EAAE,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAvED,+DAA+D;IAC/D,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IASD,uEAAuE;IACvE,IACI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAc;QACvB,IAAI,CAAC,OAAO,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAGD,sCAAsC;IACtC,IACI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAAa;QAC7B,MAAM,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAE7C,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,gDAAgD;YAChD,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;gBACpD,MAAM,KAAK,CAAC,mEAAmE,CAAC,CAAC;aAClF;YAED,IAAI,IAAI,CAAC,cAAc,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC;gBAC/E,CAAC,QAAQ,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,EAAE;gBAChF,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;aACtC;SACF;aAAM;YACL,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;SAChC;IACH,CAAC;IAGD,iCAAiC;IACjC,IACI,QAAQ;QACV,sEAAsE;QACtE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,SAAU,CAAC;IAC5E,CAAC;IACD,IAAI,QAAQ,CAAC,IAAa;QACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,CAAC;IAmBD,eAAe;QACb,wFAAwF;QACxF,2FAA2F;QAC3F,sFAAsF;QACtF,IAAI,CAAC,WAAW,GAAG,IAAI,eAAe,CAAkB,IAAI,CAAC,WAAW,CAAC;aACjD,QAAQ,EAAE;aACV,uBAAuB,CAAC,IAAI,CAAC,YAAY,KAAK,UAAU,CAAC,CAAC;QAElF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAE,IAAI,CAAC,IAAI,CAAC,MAAgC,CAAC,CAAC,CAAC,YAAY,EAAa,CAAC;aAChF,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACpE,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,yBAAyB,CAAC,SAAS,CAAC,CAAC,CAAC;QAEnF,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAEvD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACjE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;gBAClB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;aAC5D;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,iDAAiD;IACjD,IAAI;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChF,CAAC;IAED,qDAAqD;IACrD,QAAQ;QACN,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,2FAA2F;IAC3F,KAAK;QACH,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;QACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAED,uDAAuD;IACvD,eAAe,CAAC,CAAS;QACvB,OAAO,kBAAkB,IAAI,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;IAChD,CAAC;IAED,uDAAuD;IACvD,iBAAiB,CAAC,CAAS;QACzB,OAAO,oBAAoB,IAAI,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;IAClD,CAAC;IAED,iDAAiD;IACjD,aAAa;QACX,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,+DAA+D;IAC/D,sBAAsB,CAAC,KAAa;QAClC,MAAM,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC;QAC7C,IAAI,QAAQ,GAAG,CAAC,EAAE;YAChB,OAAO,IAAI,CAAC,gBAAgB,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC;SAChE;aAAM,IAAI,QAAQ,GAAG,CAAC,EAAE;YACvB,OAAO,IAAI,CAAC,gBAAgB,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;SAChE;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,gDAAgD;IAChD,iBAAiB,CAAC,KAAa,EAAE,QAAmB,UAAU,CAAC,MAAM;QACnE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACzC,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAEjD,OAAO,IAAI,CAAC,4BAA4B,CAAC,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC;YACrD,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IACjG,CAAC;IAEO,yBAAyB,CAAC,IAAa,EAAE,aAAsB;QACrE,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,aAAa,EAAE;YACtD,OAAO,UAAU,CAAC,KAAK,CAAC;SACzB;aAAM,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,aAAa,EAAE;YAC3C,OAAO,UAAU,CAAC,MAAM,CAAC;SAC1B;aAAM;YACL,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC;SAC1D;IACH,CAAC;IAEO,kBAAkB,CACtB,IAAa,EAAE,aAAsB,EAAE,QAAmB,UAAU,CAAC,MAAM;QAC7E,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,aAAa,EAAE;YACtD,OAAO,UAAU,CAAC,KAAK,CAAC;SACzB;aAAM,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,aAAa,EAAE;YAC3C,OAAO,UAAU,CAAC,IAAI,CAAC;SACxB;aAAM,IAAI,IAAI,CAAC,SAAS,IAAI,aAAa,EAAE;YAC1C,OAAO,KAAK,CAAC;SACd;aAAM,IAAI,IAAI,CAAC,QAAQ,IAAI,aAAa,EAAE;YACzC,OAAO,UAAU,CAAC,IAAI,CAAC;SACxB;aAAM;YACL,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAEO,cAAc,CAAC,KAAa;QAClC,OAAO,IAAI,CAAC,cAAc,KAAK,KAAK,CAAC;IACvC,CAAC;IAED,8DAA8D;IAC9D,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;IACnF,CAAC;IAEO,wBAAwB,CAAC,QAAgB;QAC/C,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACxC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,aAAa,EAAE,QAAQ;YACvB,uBAAuB,EAAE,IAAI,CAAC,cAAc;YAC5C,YAAY,EAAE,UAAU,CAAC,QAAQ,CAAC;YAClC,sBAAsB,EAAE,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC;SACxD,CAAC,CAAC;QAEH,sFAAsF;QACtF,wFAAwF;QACxF,mFAAmF;QACnF,gEAAgE;QAChE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC1C,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAEpE,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAED,UAAU,CAAC,KAAoB;QAC7B,MAAM,WAAW,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC9B,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC;QAEjC,IAAI,OAAO,CAAC,eAAe,IAAI,IAAI,IAAI,CAAC,WAAW;YAC/C,CAAC,OAAO,KAAK,KAAK,IAAI,OAAO,KAAK,KAAK,CAAC,EAAE;YAC5C,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;YAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;aAAM,IAAI,OAAO,KAAK,IAAI,EAAE;YAC3B,OAAO,CAAC,kBAAkB,EAAE,CAAC;YAC7B,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;aAAM,IAAI,OAAO,KAAK,GAAG,EAAE;YAC1B,OAAO,CAAC,iBAAiB,EAAE,CAAC;YAC5B,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;aAAM;YACL,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SAC1B;IACH,CAAC;IAEO,4BAA4B,CAAC,KAAa;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAEnC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,UAAU,GAAG,IAAI,CAAC;QAE7C,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,IAAI,CAAC,EAAE;YAC9B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACvC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC;gBACjC,MAAM,YAAY,GACd,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;gBACzF,OAAO,YAAY,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC;YACpE,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,gBAAgB;QACtB,OAAO,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAChE,CAAC;IAED,+DAA+D;IACvD,cAAc;QACpB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACxC,OAAO,KAAK,CAAC;SACd;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;QACtD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;QACpD,OAAO,cAAc,KAAK,cAAc,IAAI,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;IACtF,CAAC;;;YAvRF,SAAS,SAAC;gBACT,QAAQ,EAAE,cAAc;gBACxB,QAAQ,EAAE,YAAY;aACvB;;;YA9OkB,cAAc,uBAqU1B,QAAQ;YAzTb,iBAAiB;YAKjB,UAAU;4CAsT0C,MAAM,SAAC,QAAQ;;;qBAtElE,eAAe,SAAC,OAAO,EAAE,EAAC,WAAW,EAAE,IAAI,EAAC;0BAY5C,eAAe,SAAC,aAAa,EAAE,EAAC,WAAW,EAAE,IAAI,EAAC;qBAGlD,KAAK;4BAUL,KAAK;uBAwBL,KAAK;8BAUL,MAAM","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, FocusKeyManager} from '@angular/cdk/a11y';\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {\n  BooleanInput,\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  NumberInput\n} from '@angular/cdk/coercion';\nimport {END, ENTER, hasModifierKey, HOME, SPACE} from '@angular/cdk/keycodes';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  InjectionToken,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  TemplateRef,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {Observable, of as observableOf, Subject} from 'rxjs';\nimport {startWith, takeUntil} from 'rxjs/operators';\n\nimport {CdkStepHeader} from './step-header';\nimport {CdkStepLabel} from './step-label';\n\n/** Used to generate unique ID for each stepper component. */\nlet nextId = 0;\n\n/**\n * Position state of the content of each step in stepper that is used for transitioning\n * the content into correct position upon step selection change.\n */\nexport type StepContentPositionState = 'previous'|'current'|'next';\n\n/** Possible orientation of a stepper. */\nexport type StepperOrientation = 'horizontal'|'vertical';\n\n/** Change event emitted on selection changes. */\nexport class StepperSelectionEvent {\n  /** Index of the step now selected. */\n  selectedIndex: number;\n\n  /** Index of the step previously selected. */\n  previouslySelectedIndex: number;\n\n  /** The step instance now selected. */\n  selectedStep: CdkStep;\n\n  /** The step instance previously selected. */\n  previouslySelectedStep: CdkStep;\n}\n\n/** The state of each step. */\nexport type StepState = 'number'|'edit'|'done'|'error'|string;\n\n/** Enum to represent the different states of the steps. */\nexport const STEP_STATE = {\n  NUMBER: 'number',\n  EDIT: 'edit',\n  DONE: 'done',\n  ERROR: 'error'\n};\n\n/** InjectionToken that can be used to specify the global stepper options. */\nexport const STEPPER_GLOBAL_OPTIONS = new InjectionToken<StepperOptions>('STEPPER_GLOBAL_OPTIONS');\n\n/**\n * InjectionToken that can be used to specify the global stepper options.\n * @deprecated Use `STEPPER_GLOBAL_OPTIONS` instead.\n * @breaking-change 8.0.0.\n */\nexport const MAT_STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS;\n\n/** Configurable options for stepper. */\nexport interface StepperOptions {\n  /**\n   * Whether the stepper should display an error state or not.\n   * Default behavior is assumed to be false.\n   */\n  showError?: boolean;\n\n  /**\n   * Whether the stepper should display the default indicator type\n   * or not.\n   * Default behavior is assumed to be true.\n   */\n  displayDefaultIndicatorType?: boolean;\n}\n\n@Component({\n  selector: 'cdk-step',\n  exportAs: 'cdkStep',\n  template: '<ng-template><ng-content></ng-content></ng-template>',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CdkStep implements OnChanges {\n  private _stepperOptions: StepperOptions;\n  _showError: boolean;\n  _displayDefaultIndicatorType: boolean;\n\n  /** Template for step label if it exists. */\n  @ContentChild(CdkStepLabel) stepLabel: CdkStepLabel;\n\n  /** Template for step content. */\n  @ViewChild(TemplateRef, {static: true}) content: TemplateRef<any>;\n\n  /** The top level abstract control of the step. */\n  @Input() stepControl: AbstractControlLike;\n\n  /** Whether user has seen the expanded step content or not. */\n  interacted = false;\n\n  /** Plain text label of the step. */\n  @Input() label: string;\n\n  /** Error message to display when there's an error. */\n  @Input() errorMessage: string;\n\n  /** Aria label for the tab. */\n  @Input('aria-label') ariaLabel: string;\n\n  /**\n   * Reference to the element that the tab is labelled by.\n   * Will be cleared if `aria-label` is set at the same time.\n   */\n  @Input('aria-labelledby') ariaLabelledby: string;\n\n  /** State of the step. */\n  @Input() state: StepState;\n\n  /** Whether the user can return to this step once it has been marked as completed. */\n  @Input()\n  get editable(): boolean {\n    return this._editable;\n  }\n  set editable(value: boolean) {\n    this._editable = coerceBooleanProperty(value);\n  }\n  private _editable = true;\n\n  /** Whether the completion of step is optional. */\n  @Input()\n  get optional(): boolean {\n    return this._optional;\n  }\n  set optional(value: boolean) {\n    this._optional = coerceBooleanProperty(value);\n  }\n  private _optional = false;\n\n  /** Whether step is marked as completed. */\n  @Input()\n  get completed(): boolean {\n    return this._completedOverride == null ? this._getDefaultCompleted() : this._completedOverride;\n  }\n  set completed(value: boolean) {\n    this._completedOverride = coerceBooleanProperty(value);\n  }\n  _completedOverride: boolean|null = null;\n\n  private _getDefaultCompleted() {\n    return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;\n  }\n\n  /** Whether step has an error. */\n  @Input()\n  get hasError(): boolean {\n    return this._customError == null ? this._getDefaultError() : this._customError;\n  }\n  set hasError(value: boolean) {\n    this._customError = coerceBooleanProperty(value);\n  }\n  private _customError: boolean|null = null;\n\n  private _getDefaultError() {\n    return this.stepControl && this.stepControl.invalid && this.interacted;\n  }\n\n  /** @breaking-change 8.0.0 remove the `?` after `stepperOptions` */\n  constructor(\n      @Inject(forwardRef(() => CdkStepper)) private _stepper: CdkStepper,\n      @Optional() @Inject(STEPPER_GLOBAL_OPTIONS) stepperOptions?: StepperOptions) {\n    this._stepperOptions = stepperOptions ? stepperOptions : {};\n    this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;\n    this._showError = !!this._stepperOptions.showError;\n  }\n\n  /** Selects this step component. */\n  select(): void {\n    this._stepper.selected = this;\n  }\n\n  /** Resets the step to its initial state. Note that this includes resetting form data. */\n  reset(): void {\n    this.interacted = false;\n\n    if (this._completedOverride != null) {\n      this._completedOverride = false;\n    }\n\n    if (this._customError != null) {\n      this._customError = false;\n    }\n\n    if (this.stepControl) {\n      this.stepControl.reset();\n    }\n  }\n\n  ngOnChanges() {\n    // Since basically all inputs of the MatStep get proxied through the view down to the\n    // underlying MatStepHeader, we have to make sure that change detection runs correctly.\n    this._stepper._stateChanged();\n  }\n\n  static ngAcceptInputType_editable: BooleanInput;\n  static ngAcceptInputType_hasError: BooleanInput;\n  static ngAcceptInputType_optional: BooleanInput;\n  static ngAcceptInputType_completed: BooleanInput;\n}\n\n@Directive({\n  selector: '[cdkStepper]',\n  exportAs: 'cdkStepper',\n})\nexport class CdkStepper implements AfterViewInit, OnDestroy {\n  /** Emits when the component is destroyed. */\n  protected _destroyed = new Subject<void>();\n\n  /** Used for managing keyboard focus. */\n  private _keyManager: FocusKeyManager<FocusableOption>;\n\n  /**\n   * @breaking-change 8.0.0 Remove `| undefined` once the `_document`\n   * constructor param is required.\n   */\n  private _document: Document|undefined;\n\n  /**\n   * The list of step components that the stepper is holding.\n   * @deprecated use `steps` instead\n   * @breaking-change 9.0.0 remove this property\n   */\n  @ContentChildren(CdkStep, {descendants: true}) _steps: QueryList<CdkStep>;\n\n  /** The list of step components that the stepper is holding. */\n  get steps(): QueryList<CdkStep> {\n    return this._steps;\n  }\n\n  /**\n   * The list of step headers of the steps in the stepper.\n   * @deprecated Type to be changed to `QueryList<CdkStepHeader>`.\n   * @breaking-change 8.0.0\n   */\n  @ContentChildren(CdkStepHeader, {descendants: true}) _stepHeader: QueryList<FocusableOption>;\n\n  /** Whether the validity of previous steps should be checked or not. */\n  @Input()\n  get linear(): boolean {\n    return this._linear;\n  }\n  set linear(value: boolean) {\n    this._linear = coerceBooleanProperty(value);\n  }\n  private _linear = false;\n\n  /** The index of the selected step. */\n  @Input()\n  get selectedIndex() {\n    return this._selectedIndex;\n  }\n  set selectedIndex(index: number) {\n    const newIndex = coerceNumberProperty(index);\n\n    if (this.steps) {\n      // Ensure that the index can't be out of bounds.\n      if (newIndex < 0 || newIndex > this.steps.length - 1) {\n        throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');\n      }\n\n      if (this._selectedIndex != newIndex && !this._anyControlsInvalidOrPending(newIndex) &&\n          (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) {\n        this._updateSelectedItemIndex(index);\n      }\n    } else {\n      this._selectedIndex = newIndex;\n    }\n  }\n  private _selectedIndex = 0;\n\n  /** The step that is selected. */\n  @Input()\n  get selected(): CdkStep {\n    // @breaking-change 8.0.0 Change return type to `CdkStep | undefined`.\n    return this.steps ? this.steps.toArray()[this.selectedIndex] : undefined!;\n  }\n  set selected(step: CdkStep) {\n    this.selectedIndex = this.steps ? this.steps.toArray().indexOf(step) : -1;\n  }\n\n  /** Event emitted when the selected step has changed. */\n  @Output()\n  selectionChange: EventEmitter<StepperSelectionEvent> = new EventEmitter<StepperSelectionEvent>();\n\n  /** Used to track unique ID for each stepper component. */\n  _groupId: number;\n\n  protected _orientation: StepperOrientation = 'horizontal';\n\n  constructor(\n      @Optional() private _dir: Directionality, private _changeDetectorRef: ChangeDetectorRef,\n      // @breaking-change 8.0.0 `_elementRef` and `_document` parameters to become required.\n      private _elementRef?: ElementRef<HTMLElement>, @Inject(DOCUMENT) _document?: any) {\n    this._groupId = nextId++;\n    this._document = _document;\n  }\n\n  ngAfterViewInit() {\n    // Note that while the step headers are content children by default, any components that\n    // extend this one might have them as view children. We initialize the keyboard handling in\n    // AfterViewInit so we're guaranteed for both view and content children to be defined.\n    this._keyManager = new FocusKeyManager<FocusableOption>(this._stepHeader)\n                           .withWrap()\n                           .withVerticalOrientation(this._orientation === 'vertical');\n\n    (this._dir ? (this._dir.change as Observable<Direction>) : observableOf<Direction>())\n        .pipe(startWith(this._layoutDirection()), takeUntil(this._destroyed))\n        .subscribe(direction => this._keyManager.withHorizontalOrientation(direction));\n\n    this._keyManager.updateActiveItem(this._selectedIndex);\n\n    this.steps.changes.pipe(takeUntil(this._destroyed)).subscribe(() => {\n      if (!this.selected) {\n        this._selectedIndex = Math.max(this._selectedIndex - 1, 0);\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /** Selects and focuses the next step in list. */\n  next(): void {\n    this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);\n  }\n\n  /** Selects and focuses the previous step in list. */\n  previous(): void {\n    this.selectedIndex = Math.max(this._selectedIndex - 1, 0);\n  }\n\n  /** Resets the stepper to its initial state. Note that this includes clearing form data. */\n  reset(): void {\n    this._updateSelectedItemIndex(0);\n    this.steps.forEach(step => step.reset());\n    this._stateChanged();\n  }\n\n  /** Returns a unique id for each step label element. */\n  _getStepLabelId(i: number): string {\n    return `cdk-step-label-${this._groupId}-${i}`;\n  }\n\n  /** Returns unique id for each step content element. */\n  _getStepContentId(i: number): string {\n    return `cdk-step-content-${this._groupId}-${i}`;\n  }\n\n  /** Marks the component to be change detected. */\n  _stateChanged() {\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Returns position state of the step with the given index. */\n  _getAnimationDirection(index: number): StepContentPositionState {\n    const position = index - this._selectedIndex;\n    if (position < 0) {\n      return this._layoutDirection() === 'rtl' ? 'next' : 'previous';\n    } else if (position > 0) {\n      return this._layoutDirection() === 'rtl' ? 'previous' : 'next';\n    }\n    return 'current';\n  }\n\n  /** Returns the type of icon to be displayed. */\n  _getIndicatorType(index: number, state: StepState = STEP_STATE.NUMBER): StepState {\n    const step = this.steps.toArray()[index];\n    const isCurrentStep = this._isCurrentStep(index);\n\n    return step._displayDefaultIndicatorType ? this._getDefaultIndicatorLogic(step, isCurrentStep) :\n                                               this._getGuidelineLogic(step, isCurrentStep, state);\n  }\n\n  private _getDefaultIndicatorLogic(step: CdkStep, isCurrentStep: boolean): StepState {\n    if (step._showError && step.hasError && !isCurrentStep) {\n      return STEP_STATE.ERROR;\n    } else if (!step.completed || isCurrentStep) {\n      return STEP_STATE.NUMBER;\n    } else {\n      return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;\n    }\n  }\n\n  private _getGuidelineLogic(\n      step: CdkStep, isCurrentStep: boolean, state: StepState = STEP_STATE.NUMBER): StepState {\n    if (step._showError && step.hasError && !isCurrentStep) {\n      return STEP_STATE.ERROR;\n    } else if (step.completed && !isCurrentStep) {\n      return STEP_STATE.DONE;\n    } else if (step.completed && isCurrentStep) {\n      return state;\n    } else if (step.editable && isCurrentStep) {\n      return STEP_STATE.EDIT;\n    } else {\n      return state;\n    }\n  }\n\n  private _isCurrentStep(index: number) {\n    return this._selectedIndex === index;\n  }\n\n  /** Returns the index of the currently-focused step header. */\n  _getFocusIndex() {\n    return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;\n  }\n\n  private _updateSelectedItemIndex(newIndex: number): void {\n    const stepsArray = this.steps.toArray();\n    this.selectionChange.emit({\n      selectedIndex: newIndex,\n      previouslySelectedIndex: this._selectedIndex,\n      selectedStep: stepsArray[newIndex],\n      previouslySelectedStep: stepsArray[this._selectedIndex],\n    });\n\n    // If focus is inside the stepper, move it to the next header, otherwise it may become\n    // lost when the active step content is hidden. We can't be more granular with the check\n    // (e.g. checking whether focus is inside the active step), because we don't have a\n    // reference to the elements that are rendering out the content.\n    this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :\n                            this._keyManager.updateActiveItem(newIndex);\n\n    this._selectedIndex = newIndex;\n    this._stateChanged();\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    const hasModifier = hasModifierKey(event);\n    const keyCode = event.keyCode;\n    const manager = this._keyManager;\n\n    if (manager.activeItemIndex != null && !hasModifier &&\n        (keyCode === SPACE || keyCode === ENTER)) {\n      this.selectedIndex = manager.activeItemIndex;\n      event.preventDefault();\n    } else if (keyCode === HOME) {\n      manager.setFirstItemActive();\n      event.preventDefault();\n    } else if (keyCode === END) {\n      manager.setLastItemActive();\n      event.preventDefault();\n    } else {\n      manager.onKeydown(event);\n    }\n  }\n\n  private _anyControlsInvalidOrPending(index: number): boolean {\n    const steps = this.steps.toArray();\n\n    steps[this._selectedIndex].interacted = true;\n\n    if (this._linear && index >= 0) {\n      return steps.slice(0, index).some(step => {\n        const control = step.stepControl;\n        const isIncomplete =\n            control ? (control.invalid || control.pending || !step.interacted) : !step.completed;\n        return isIncomplete && !step.optional && !step._completedOverride;\n      });\n    }\n\n    return false;\n  }\n\n  private _layoutDirection(): Direction {\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n  }\n\n  /** Checks whether the stepper contains the focused element. */\n  private _containsFocus(): boolean {\n    if (!this._document || !this._elementRef) {\n      return false;\n    }\n\n    const stepperElement = this._elementRef.nativeElement;\n    const focusedElement = this._document.activeElement;\n    return stepperElement === focusedElement || stepperElement.contains(focusedElement);\n  }\n\n  static ngAcceptInputType_editable: BooleanInput;\n  static ngAcceptInputType_optional: BooleanInput;\n  static ngAcceptInputType_completed: BooleanInput;\n  static ngAcceptInputType_hasError: BooleanInput;\n  static ngAcceptInputType_linear: BooleanInput;\n  static ngAcceptInputType_selectedIndex: NumberInput;\n}\n\n\n/**\n * Simplified representation of an \"AbstractControl\" from @angular/forms.\n * Used to avoid having to bring in @angular/forms for a single optional interface.\n * @docs-private\n */\ninterface AbstractControlLike {\n  asyncValidator: ((control: any) => any) | null;\n  dirty: boolean;\n  disabled: boolean;\n  enabled: boolean;\n  errors: {[key: string]: any} | null;\n  invalid: boolean;\n  parent: any;\n  pending: boolean;\n  pristine: boolean;\n  root: AbstractControlLike;\n  status: string;\n  statusChanges: Observable<any>;\n  touched: boolean;\n  untouched: boolean;\n  updateOn: any;\n  valid: boolean;\n  validator: ((control: any) => any) | null;\n  value: any;\n  valueChanges: Observable<any>;\n  clearAsyncValidators(): void;\n  clearValidators(): void;\n  disable(opts?: any): void;\n  enable(opts?: any): void;\n  get(path: (string | number)[] | string): AbstractControlLike | null;\n  getError(errorCode: string, path?: (string | number)[] | string): any;\n  hasError(errorCode: string, path?: (string | number)[] | string): boolean;\n  markAllAsTouched(): void;\n  markAsDirty(opts?: any): void;\n  markAsPending(opts?: any): void;\n  markAsPristine(opts?: any): void;\n  markAsTouched(opts?: any): void;\n  markAsUntouched(opts?: any): void;\n  patchValue(value: any, options?: Object): void;\n  reset(value?: any, options?: Object): void;\n  setAsyncValidators(newValidator: (control: any) => any |\n    ((control: any) => any)[] | null): void;\n  setErrors(errors: {[key: string]: any} | null, opts?: any): void;\n  setParent(parent: any): void;\n  setValidators(newValidator: (control: any) => any |\n    ((control: any) => any)[] | null): void;\n  setValue(value: any, options?: Object): void;\n  updateValueAndValidity(opts?: any): void;\n  patchValue(value: any, options?: any): void;\n  reset(formState?: any, options?: any): void;\n  setValue(value: any, options?: any): void;\n}\n"]}