{"version":3,"file":"197.f66aabf154390112.js","mappings":"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","names":["i0","_r2","ctx_r1","ctx_r3","MAT_SORT_DEFAULT_OPTIONS","InjectionToken","_MatSortBase","mixinInitialized","mixinDisabled","MatSort","direction","this","_direction","disableClear","_disableClear","v","coerceBooleanProperty","constructor","_defaultOptions","super","sortables","Map","_stateChanges","Subject","start","sortChange","EventEmitter","register","sortable","set","id","deregister","delete","sort","active","getNextSortDirection","emit","sortDirectionCycle","getSortDirectionCycle","sortOrder","reverse","push","nextDirectionIndex","indexOf","length","ngOnInit","_markInitialized","ngOnChanges","next","ngOnDestroy","complete","ɵfac","ɵdir","selectors","SORT_ANIMATION_TRANSITION","AnimationDurations","AnimationCurves","matSortAnimations","indicator","trigger","state","style","transform","transition","animate","leftPointer","rightPointer","arrowOpacity","opacity","arrowPosition","keyframes","allowChildren","query","animateChild","optional","MatSortHeaderIntl","changes","ɵprov","factory","MAT_SORT_HEADER_INTL_PROVIDER","provide","deps","Optional","SkipSelf","useFactory","MAT_SORT_HEADER_INTL_PROVIDER_FACTORY","parentIntl","_MatSortHeaderBase","MatSortHeader","sortActionDescription","_sortActionDescription","value","_updateSortActionDescription","_intl","_changeDetectorRef","_sort","_columnDef","_focusMonitor","_elementRef","_ariaDescriber","defaultOptions","_showIndicatorHint","_viewState","_arrowDirection","_disableViewStateAnimation","_handleStateChanges","name","_updateArrowDirection","_setAnimationTransitionState","toState","_isSorted","_sortButton","nativeElement","querySelector","ngAfterViewInit","monitor","subscribe","origin","newState","_setIndicatorHintVisible","markForCheck","stopMonitoring","_rerenderSubscription","unsubscribe","visible","_isDisabled","fromState","viewState","_toggleOnInteraction","_handleClick","_handleKeydown","event","keyCode","SPACE","ENTER","preventDefault","_getArrowDirectionState","_getArrowViewState","disabled","_getAriaSortAttribute","_renderArrow","newDescription","removeDescription","describe","merge","i3","ɵcmp","ctx","attrs","i4","styles","changeDetection","MatSortModule","ɵmod","ɵinj","imports","CommonModule","MatCommonModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/material/fesm2020/sort.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { InjectionToken, EventEmitter, Directive, Optional, Inject, Input, Output, Injectable, SkipSelf, Component, ViewEncapsulation, ChangeDetectionStrategy, NgModule } from '@angular/core';\nimport * as i3 from '@angular/cdk/a11y';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { SPACE, ENTER } from '@angular/cdk/keycodes';\nimport { mixinInitialized, mixinDisabled, AnimationDurations, AnimationCurves, MatCommonModule } from '@angular/material/core';\nimport { Subject, merge } from 'rxjs';\nimport { trigger, state, style, transition, animate, keyframes, query, animateChild } from '@angular/animations';\nimport * as i4 from '@angular/common';\nimport { CommonModule } from '@angular/common';\n\n/**\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/** @docs-private */\nfunction getSortDuplicateSortableIdError(id) {\n    return Error(`Cannot have two MatSortables with the same id (${id}).`);\n}\n/** @docs-private */\nfunction getSortHeaderNotContainedWithinSortError() {\n    return Error(`MatSortHeader must be placed within a parent element with the MatSort directive.`);\n}\n/** @docs-private */\nfunction getSortHeaderMissingIdError() {\n    return Error(`MatSortHeader must be provided with a unique id.`);\n}\n/** @docs-private */\nfunction getSortInvalidDirectionError(direction) {\n    return Error(`${direction} is not a valid sort direction ('asc' or 'desc').`);\n}\n\n/**\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/** Injection token to be used to override the default options for `mat-sort`. */\nconst MAT_SORT_DEFAULT_OPTIONS = new InjectionToken('MAT_SORT_DEFAULT_OPTIONS');\n// Boilerplate for applying mixins to MatSort.\n/** @docs-private */\nconst _MatSortBase = mixinInitialized(mixinDisabled(class {\n}));\n/** Container for MatSortables to manage the sort state and provide default sort parameters. */\nclass MatSort extends _MatSortBase {\n    /** The sort direction of the currently active MatSortable. */\n    get direction() {\n        return this._direction;\n    }\n    set direction(direction) {\n        if (direction &&\n            direction !== 'asc' &&\n            direction !== 'desc' &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getSortInvalidDirectionError(direction);\n        }\n        this._direction = direction;\n    }\n    /**\n     * Whether to disable the user from clearing the sort by finishing the sort direction cycle.\n     * May be overridden by the MatSortable's disable clear input.\n     */\n    get disableClear() {\n        return this._disableClear;\n    }\n    set disableClear(v) {\n        this._disableClear = coerceBooleanProperty(v);\n    }\n    constructor(_defaultOptions) {\n        super();\n        this._defaultOptions = _defaultOptions;\n        /** Collection of all registered sortables that this directive manages. */\n        this.sortables = new Map();\n        /** Used to notify any child components listening to state changes. */\n        this._stateChanges = new Subject();\n        /**\n         * The direction to set when an MatSortable is initially sorted.\n         * May be overridden by the MatSortable's sort start.\n         */\n        this.start = 'asc';\n        this._direction = '';\n        /** Event emitted when the user changes either the active sort or sort direction. */\n        this.sortChange = new EventEmitter();\n    }\n    /**\n     * Register function to be used by the contained MatSortables. Adds the MatSortable to the\n     * collection of MatSortables.\n     */\n    register(sortable) {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            if (!sortable.id) {\n                throw getSortHeaderMissingIdError();\n            }\n            if (this.sortables.has(sortable.id)) {\n                throw getSortDuplicateSortableIdError(sortable.id);\n            }\n        }\n        this.sortables.set(sortable.id, sortable);\n    }\n    /**\n     * Unregister function to be used by the contained MatSortables. Removes the MatSortable from the\n     * collection of contained MatSortables.\n     */\n    deregister(sortable) {\n        this.sortables.delete(sortable.id);\n    }\n    /** Sets the active sort id and determines the new sort direction. */\n    sort(sortable) {\n        if (this.active != sortable.id) {\n            this.active = sortable.id;\n            this.direction = sortable.start ? sortable.start : this.start;\n        }\n        else {\n            this.direction = this.getNextSortDirection(sortable);\n        }\n        this.sortChange.emit({ active: this.active, direction: this.direction });\n    }\n    /** Returns the next sort direction of the active sortable, checking for potential overrides. */\n    getNextSortDirection(sortable) {\n        if (!sortable) {\n            return '';\n        }\n        // Get the sort direction cycle with the potential sortable overrides.\n        const disableClear = sortable?.disableClear ?? this.disableClear ?? !!this._defaultOptions?.disableClear;\n        let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);\n        // Get and return the next direction in the cycle\n        let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;\n        if (nextDirectionIndex >= sortDirectionCycle.length) {\n            nextDirectionIndex = 0;\n        }\n        return sortDirectionCycle[nextDirectionIndex];\n    }\n    ngOnInit() {\n        this._markInitialized();\n    }\n    ngOnChanges() {\n        this._stateChanges.next();\n    }\n    ngOnDestroy() {\n        this._stateChanges.complete();\n    }\n}\nMatSort.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSort, deps: [{ token: MAT_SORT_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatSort.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatSort, selector: \"[matSort]\", inputs: { disabled: [\"matSortDisabled\", \"disabled\"], active: [\"matSortActive\", \"active\"], start: [\"matSortStart\", \"start\"], direction: [\"matSortDirection\", \"direction\"], disableClear: [\"matSortDisableClear\", \"disableClear\"] }, outputs: { sortChange: \"matSortChange\" }, host: { classAttribute: \"mat-sort\" }, exportAs: [\"matSort\"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSort, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[matSort]',\n                    exportAs: 'matSort',\n                    host: { 'class': 'mat-sort' },\n                    inputs: ['disabled: matSortDisabled'],\n                }]\n        }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_SORT_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { active: [{\n                type: Input,\n                args: ['matSortActive']\n            }], start: [{\n                type: Input,\n                args: ['matSortStart']\n            }], direction: [{\n                type: Input,\n                args: ['matSortDirection']\n            }], disableClear: [{\n                type: Input,\n                args: ['matSortDisableClear']\n            }], sortChange: [{\n                type: Output,\n                args: ['matSortChange']\n            }] } });\n/** Returns the sort direction cycle to use given the provided parameters of order and clear. */\nfunction getSortDirectionCycle(start, disableClear) {\n    let sortOrder = ['asc', 'desc'];\n    if (start == 'desc') {\n        sortOrder.reverse();\n    }\n    if (!disableClear) {\n        sortOrder.push('');\n    }\n    return sortOrder;\n}\n\n/**\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 */\nconst SORT_ANIMATION_TRANSITION = AnimationDurations.ENTERING + ' ' + AnimationCurves.STANDARD_CURVE;\n/**\n * Animations used by MatSort.\n * @docs-private\n */\nconst matSortAnimations = {\n    /** Animation that moves the sort indicator. */\n    indicator: trigger('indicator', [\n        state('active-asc, asc', style({ transform: 'translateY(0px)' })),\n        // 10px is the height of the sort indicator, minus the width of the pointers\n        state('active-desc, desc', style({ transform: 'translateY(10px)' })),\n        transition('active-asc <=> active-desc', animate(SORT_ANIMATION_TRANSITION)),\n    ]),\n    /** Animation that rotates the left pointer of the indicator based on the sorting direction. */\n    leftPointer: trigger('leftPointer', [\n        state('active-asc, asc', style({ transform: 'rotate(-45deg)' })),\n        state('active-desc, desc', style({ transform: 'rotate(45deg)' })),\n        transition('active-asc <=> active-desc', animate(SORT_ANIMATION_TRANSITION)),\n    ]),\n    /** Animation that rotates the right pointer of the indicator based on the sorting direction. */\n    rightPointer: trigger('rightPointer', [\n        state('active-asc, asc', style({ transform: 'rotate(45deg)' })),\n        state('active-desc, desc', style({ transform: 'rotate(-45deg)' })),\n        transition('active-asc <=> active-desc', animate(SORT_ANIMATION_TRANSITION)),\n    ]),\n    /** Animation that controls the arrow opacity. */\n    arrowOpacity: trigger('arrowOpacity', [\n        state('desc-to-active, asc-to-active, active', style({ opacity: 1 })),\n        state('desc-to-hint, asc-to-hint, hint', style({ opacity: 0.54 })),\n        state('hint-to-desc, active-to-desc, desc, hint-to-asc, active-to-asc, asc, void', style({ opacity: 0 })),\n        // Transition between all states except for immediate transitions\n        transition('* => asc, * => desc, * => active, * => hint, * => void', animate('0ms')),\n        transition('* <=> *', animate(SORT_ANIMATION_TRANSITION)),\n    ]),\n    /**\n     * Animation for the translation of the arrow as a whole. States are separated into two\n     * groups: ones with animations and others that are immediate. Immediate states are asc, desc,\n     * peek, and active. The other states define a specific animation (source-to-destination)\n     * and are determined as a function of their prev user-perceived state and what the next state\n     * should be.\n     */\n    arrowPosition: trigger('arrowPosition', [\n        // Hidden Above => Hint Center\n        transition('* => desc-to-hint, * => desc-to-active', animate(SORT_ANIMATION_TRANSITION, keyframes([style({ transform: 'translateY(-25%)' }), style({ transform: 'translateY(0)' })]))),\n        // Hint Center => Hidden Below\n        transition('* => hint-to-desc, * => active-to-desc', animate(SORT_ANIMATION_TRANSITION, keyframes([style({ transform: 'translateY(0)' }), style({ transform: 'translateY(25%)' })]))),\n        // Hidden Below => Hint Center\n        transition('* => asc-to-hint, * => asc-to-active', animate(SORT_ANIMATION_TRANSITION, keyframes([style({ transform: 'translateY(25%)' }), style({ transform: 'translateY(0)' })]))),\n        // Hint Center => Hidden Above\n        transition('* => hint-to-asc, * => active-to-asc', animate(SORT_ANIMATION_TRANSITION, keyframes([style({ transform: 'translateY(0)' }), style({ transform: 'translateY(-25%)' })]))),\n        state('desc-to-hint, asc-to-hint, hint, desc-to-active, asc-to-active, active', style({ transform: 'translateY(0)' })),\n        state('hint-to-desc, active-to-desc, desc', style({ transform: 'translateY(-25%)' })),\n        state('hint-to-asc, active-to-asc, asc', style({ transform: 'translateY(25%)' })),\n    ]),\n    /** Necessary trigger that calls animate on children animations. */\n    allowChildren: trigger('allowChildren', [\n        transition('* <=> *', [query('@*', animateChild(), { optional: true })]),\n    ]),\n};\n\n/**\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/**\n * To modify the labels and text displayed, create a new instance of MatSortHeaderIntl and\n * include it in a custom provider.\n */\nclass MatSortHeaderIntl {\n    constructor() {\n        /**\n         * Stream that emits whenever the labels here are changed. Use this to notify\n         * components if the labels have changed after initialization.\n         */\n        this.changes = new Subject();\n    }\n}\nMatSortHeaderIntl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortHeaderIntl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nMatSortHeaderIntl.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortHeaderIntl, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortHeaderIntl, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }] });\n/** @docs-private */\nfunction MAT_SORT_HEADER_INTL_PROVIDER_FACTORY(parentIntl) {\n    return parentIntl || new MatSortHeaderIntl();\n}\n/** @docs-private */\nconst MAT_SORT_HEADER_INTL_PROVIDER = {\n    // If there is already an MatSortHeaderIntl available, use that. Otherwise, provide a new one.\n    provide: MatSortHeaderIntl,\n    deps: [[new Optional(), new SkipSelf(), MatSortHeaderIntl]],\n    useFactory: MAT_SORT_HEADER_INTL_PROVIDER_FACTORY,\n};\n\n/**\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// Boilerplate for applying mixins to the sort header.\n/** @docs-private */\nconst _MatSortHeaderBase = mixinDisabled(class {\n});\n/**\n * Applies sorting behavior (click to change sort) and styles to an element, including an\n * arrow to display the current sort direction.\n *\n * Must be provided with an id and contained within a parent MatSort directive.\n *\n * If used on header cells in a CdkTable, it will automatically default its id from its containing\n * column definition.\n */\nclass MatSortHeader extends _MatSortHeaderBase {\n    /**\n     * Description applied to MatSortHeader's button element with aria-describedby. This text should\n     * describe the action that will occur when the user clicks the sort header.\n     */\n    get sortActionDescription() {\n        return this._sortActionDescription;\n    }\n    set sortActionDescription(value) {\n        this._updateSortActionDescription(value);\n    }\n    /** Overrides the disable clear value of the containing MatSort for this MatSortable. */\n    get disableClear() {\n        return this._disableClear;\n    }\n    set disableClear(v) {\n        this._disableClear = coerceBooleanProperty(v);\n    }\n    constructor(\n    /**\n     * @deprecated `_intl` parameter isn't being used anymore and it'll be removed.\n     * @breaking-change 13.0.0\n     */\n    _intl, _changeDetectorRef, \n    // `MatSort` is not optionally injected, but just asserted manually w/ better error.\n    // tslint:disable-next-line: lightweight-tokens\n    _sort, _columnDef, _focusMonitor, _elementRef, \n    /** @breaking-change 14.0.0 _ariaDescriber will be required. */\n    _ariaDescriber, defaultOptions) {\n        // Note that we use a string token for the `_columnDef`, because the value is provided both by\n        // `material/table` and `cdk/table` and we can't have the CDK depending on Material,\n        // and we want to avoid having the sort header depending on the CDK table because\n        // of this single reference.\n        super();\n        this._intl = _intl;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._sort = _sort;\n        this._columnDef = _columnDef;\n        this._focusMonitor = _focusMonitor;\n        this._elementRef = _elementRef;\n        this._ariaDescriber = _ariaDescriber;\n        /**\n         * Flag set to true when the indicator should be displayed while the sort is not active. Used to\n         * provide an affordance that the header is sortable by showing on focus and hover.\n         */\n        this._showIndicatorHint = false;\n        /**\n         * The view transition state of the arrow (translation/ opacity) - indicates its `from` and `to`\n         * position through the animation. If animations are currently disabled, the fromState is removed\n         * so that there is no animation displayed.\n         */\n        this._viewState = {};\n        /** The direction the arrow should be facing according to the current state. */\n        this._arrowDirection = '';\n        /**\n         * Whether the view state animation should show the transition between the `from` and `to` states.\n         */\n        this._disableViewStateAnimation = false;\n        /** Sets the position of the arrow that displays when sorted. */\n        this.arrowPosition = 'after';\n        // Default the action description to \"Sort\" because it's better than nothing.\n        // Without a description, the button's label comes from the sort header text content,\n        // which doesn't give any indication that it performs a sorting operation.\n        this._sortActionDescription = 'Sort';\n        if (!_sort && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getSortHeaderNotContainedWithinSortError();\n        }\n        if (defaultOptions?.arrowPosition) {\n            this.arrowPosition = defaultOptions?.arrowPosition;\n        }\n        this._handleStateChanges();\n    }\n    ngOnInit() {\n        if (!this.id && this._columnDef) {\n            this.id = this._columnDef.name;\n        }\n        // Initialize the direction of the arrow and set the view state to be immediately that state.\n        this._updateArrowDirection();\n        this._setAnimationTransitionState({\n            toState: this._isSorted() ? 'active' : this._arrowDirection,\n        });\n        this._sort.register(this);\n        this._sortButton = this._elementRef.nativeElement.querySelector('.mat-sort-header-container');\n        this._updateSortActionDescription(this._sortActionDescription);\n    }\n    ngAfterViewInit() {\n        // We use the focus monitor because we also want to style\n        // things differently based on the focus origin.\n        this._focusMonitor.monitor(this._elementRef, true).subscribe(origin => {\n            const newState = !!origin;\n            if (newState !== this._showIndicatorHint) {\n                this._setIndicatorHintVisible(newState);\n                this._changeDetectorRef.markForCheck();\n            }\n        });\n    }\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef);\n        this._sort.deregister(this);\n        this._rerenderSubscription.unsubscribe();\n    }\n    /**\n     * Sets the \"hint\" state such that the arrow will be semi-transparently displayed as a hint to the\n     * user showing what the active sort will become. If set to false, the arrow will fade away.\n     */\n    _setIndicatorHintVisible(visible) {\n        // No-op if the sort header is disabled - should not make the hint visible.\n        if (this._isDisabled() && visible) {\n            return;\n        }\n        this._showIndicatorHint = visible;\n        if (!this._isSorted()) {\n            this._updateArrowDirection();\n            if (this._showIndicatorHint) {\n                this._setAnimationTransitionState({ fromState: this._arrowDirection, toState: 'hint' });\n            }\n            else {\n                this._setAnimationTransitionState({ fromState: 'hint', toState: this._arrowDirection });\n            }\n        }\n    }\n    /**\n     * Sets the animation transition view state for the arrow's position and opacity. If the\n     * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that\n     * no animation appears.\n     */\n    _setAnimationTransitionState(viewState) {\n        this._viewState = viewState || {};\n        // If the animation for arrow position state (opacity/translation) should be disabled,\n        // remove the fromState so that it jumps right to the toState.\n        if (this._disableViewStateAnimation) {\n            this._viewState = { toState: viewState.toState };\n        }\n    }\n    /** Triggers the sort on this sort header and removes the indicator hint. */\n    _toggleOnInteraction() {\n        this._sort.sort(this);\n        // Do not show the animation if the header was already shown in the right position.\n        if (this._viewState.toState === 'hint' || this._viewState.toState === 'active') {\n            this._disableViewStateAnimation = true;\n        }\n    }\n    _handleClick() {\n        if (!this._isDisabled()) {\n            this._sort.sort(this);\n        }\n    }\n    _handleKeydown(event) {\n        if (!this._isDisabled() && (event.keyCode === SPACE || event.keyCode === ENTER)) {\n            event.preventDefault();\n            this._toggleOnInteraction();\n        }\n    }\n    /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */\n    _isSorted() {\n        return (this._sort.active == this.id &&\n            (this._sort.direction === 'asc' || this._sort.direction === 'desc'));\n    }\n    /** Returns the animation state for the arrow direction (indicator and pointers). */\n    _getArrowDirectionState() {\n        return `${this._isSorted() ? 'active-' : ''}${this._arrowDirection}`;\n    }\n    /** Returns the arrow position state (opacity, translation). */\n    _getArrowViewState() {\n        const fromState = this._viewState.fromState;\n        return (fromState ? `${fromState}-to-` : '') + this._viewState.toState;\n    }\n    /**\n     * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be\n     * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently\n     * active sorted direction. The reason this is updated through a function is because the direction\n     * should only be changed at specific times - when deactivated but the hint is displayed and when\n     * the sort is active and the direction changes. Otherwise the arrow's direction should linger\n     * in cases such as the sort becoming deactivated but we want to animate the arrow away while\n     * preserving its direction, even though the next sort direction is actually different and should\n     * only be changed once the arrow displays again (hint or activation).\n     */\n    _updateArrowDirection() {\n        this._arrowDirection = this._isSorted() ? this._sort.direction : this.start || this._sort.start;\n    }\n    _isDisabled() {\n        return this._sort.disabled || this.disabled;\n    }\n    /**\n     * Gets the aria-sort attribute that should be applied to this sort header. If this header\n     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec\n     * says that the aria-sort property should only be present on one header at a time, so removing\n     * ensures this is true.\n     */\n    _getAriaSortAttribute() {\n        if (!this._isSorted()) {\n            return 'none';\n        }\n        return this._sort.direction == 'asc' ? 'ascending' : 'descending';\n    }\n    /** Whether the arrow inside the sort header should be rendered. */\n    _renderArrow() {\n        return !this._isDisabled() || this._isSorted();\n    }\n    _updateSortActionDescription(newDescription) {\n        // We use AriaDescriber for the sort button instead of setting an `aria-label` because some\n        // screen readers (notably VoiceOver) will read both the column header *and* the button's label\n        // for every *cell* in the table, creating a lot of unnecessary noise.\n        // If _sortButton is undefined, the component hasn't been initialized yet so there's\n        // nothing to update in the DOM.\n        if (this._sortButton) {\n            // removeDescription will no-op if there is no existing message.\n            // TODO(jelbourn): remove optional chaining when AriaDescriber is required.\n            this._ariaDescriber?.removeDescription(this._sortButton, this._sortActionDescription);\n            this._ariaDescriber?.describe(this._sortButton, newDescription);\n        }\n        this._sortActionDescription = newDescription;\n    }\n    /** Handles changes in the sorting state. */\n    _handleStateChanges() {\n        this._rerenderSubscription = merge(this._sort.sortChange, this._sort._stateChanges, this._intl.changes).subscribe(() => {\n            if (this._isSorted()) {\n                this._updateArrowDirection();\n                // Do not show the animation if the header was already shown in the right position.\n                if (this._viewState.toState === 'hint' || this._viewState.toState === 'active') {\n                    this._disableViewStateAnimation = true;\n                }\n                this._setAnimationTransitionState({ fromState: this._arrowDirection, toState: 'active' });\n                this._showIndicatorHint = false;\n            }\n            // If this header was recently active and now no longer sorted, animate away the arrow.\n            if (!this._isSorted() && this._viewState && this._viewState.toState === 'active') {\n                this._disableViewStateAnimation = false;\n                this._setAnimationTransitionState({ fromState: 'active', toState: this._arrowDirection });\n            }\n            this._changeDetectorRef.markForCheck();\n        });\n    }\n}\nMatSortHeader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortHeader, deps: [{ token: MatSortHeaderIntl }, { token: i0.ChangeDetectorRef }, { token: MatSort, optional: true }, { token: 'MAT_SORT_HEADER_COLUMN_DEF', optional: true }, { token: i3.FocusMonitor }, { token: i0.ElementRef }, { token: i3.AriaDescriber, optional: true }, { token: MAT_SORT_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatSortHeader.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", type: MatSortHeader, selector: \"[mat-sort-header]\", inputs: { disabled: \"disabled\", id: [\"mat-sort-header\", \"id\"], arrowPosition: \"arrowPosition\", start: \"start\", sortActionDescription: \"sortActionDescription\", disableClear: \"disableClear\" }, host: { listeners: { \"click\": \"_handleClick()\", \"keydown\": \"_handleKeydown($event)\", \"mouseenter\": \"_setIndicatorHintVisible(true)\", \"mouseleave\": \"_setIndicatorHintVisible(false)\" }, properties: { \"attr.aria-sort\": \"_getAriaSortAttribute()\", \"class.mat-sort-header-disabled\": \"_isDisabled()\" }, classAttribute: \"mat-sort-header\" }, exportAs: [\"matSortHeader\"], usesInheritance: true, ngImport: i0, template: \"<!--\\n  We set the `tabindex` on an element inside the table header, rather than the header itself,\\n  because of a bug in NVDA where having a `tabindex` on a `th` breaks keyboard navigation in the\\n  table (see https://github.com/nvaccess/nvda/issues/7718). This allows for the header to both\\n  be focusable, and have screen readers read out its `aria-sort` state. We prefer this approach\\n  over having a button with an `aria-label` inside the header, because the button's `aria-label`\\n  will be read out as the user is navigating the table's cell (see #13012).\\n\\n  The approach is based off of: https://dequeuniversity.com/library/aria/tables/sf-sortable-grid\\n-->\\n<div class=\\\"mat-sort-header-container mat-focus-indicator\\\"\\n     [class.mat-sort-header-sorted]=\\\"_isSorted()\\\"\\n     [class.mat-sort-header-position-before]=\\\"arrowPosition === 'before'\\\"\\n     [attr.tabindex]=\\\"_isDisabled() ? null : 0\\\"\\n     [attr.role]=\\\"_isDisabled() ? null : 'button'\\\">\\n\\n  <!--\\n    TODO(crisbeto): this div isn't strictly necessary, but we have to keep it due to a large\\n    number of screenshot diff failures. It should be removed eventually. Note that the difference\\n    isn't visible with a shorter header, but once it breaks up into multiple lines, this element\\n    causes it to be center-aligned, whereas removing it will keep the text to the left.\\n  -->\\n  <div class=\\\"mat-sort-header-content\\\">\\n    <ng-content></ng-content>\\n  </div>\\n\\n  <!-- Disable animations while a current animation is running -->\\n  <div class=\\\"mat-sort-header-arrow\\\"\\n       *ngIf=\\\"_renderArrow()\\\"\\n       [@arrowOpacity]=\\\"_getArrowViewState()\\\"\\n       [@arrowPosition]=\\\"_getArrowViewState()\\\"\\n       [@allowChildren]=\\\"_getArrowDirectionState()\\\"\\n       (@arrowPosition.start)=\\\"_disableViewStateAnimation = true\\\"\\n       (@arrowPosition.done)=\\\"_disableViewStateAnimation = false\\\">\\n    <div class=\\\"mat-sort-header-stem\\\"></div>\\n    <div class=\\\"mat-sort-header-indicator\\\" [@indicator]=\\\"_getArrowDirectionState()\\\">\\n      <div class=\\\"mat-sort-header-pointer-left\\\" [@leftPointer]=\\\"_getArrowDirectionState()\\\"></div>\\n      <div class=\\\"mat-sort-header-pointer-right\\\" [@rightPointer]=\\\"_getArrowDirectionState()\\\"></div>\\n      <div class=\\\"mat-sort-header-pointer-middle\\\"></div>\\n    </div>\\n  </div>\\n</div>\\n\", styles: [\".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-container::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}\"], dependencies: [{ kind: \"directive\", type: i4.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }], animations: [\n        matSortAnimations.indicator,\n        matSortAnimations.leftPointer,\n        matSortAnimations.rightPointer,\n        matSortAnimations.arrowOpacity,\n        matSortAnimations.arrowPosition,\n        matSortAnimations.allowChildren,\n    ], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortHeader, decorators: [{\n            type: Component,\n            args: [{ selector: '[mat-sort-header]', exportAs: 'matSortHeader', host: {\n                        'class': 'mat-sort-header',\n                        '(click)': '_handleClick()',\n                        '(keydown)': '_handleKeydown($event)',\n                        '(mouseenter)': '_setIndicatorHintVisible(true)',\n                        '(mouseleave)': '_setIndicatorHintVisible(false)',\n                        '[attr.aria-sort]': '_getAriaSortAttribute()',\n                        '[class.mat-sort-header-disabled]': '_isDisabled()',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, inputs: ['disabled'], animations: [\n                        matSortAnimations.indicator,\n                        matSortAnimations.leftPointer,\n                        matSortAnimations.rightPointer,\n                        matSortAnimations.arrowOpacity,\n                        matSortAnimations.arrowPosition,\n                        matSortAnimations.allowChildren,\n                    ], template: \"<!--\\n  We set the `tabindex` on an element inside the table header, rather than the header itself,\\n  because of a bug in NVDA where having a `tabindex` on a `th` breaks keyboard navigation in the\\n  table (see https://github.com/nvaccess/nvda/issues/7718). This allows for the header to both\\n  be focusable, and have screen readers read out its `aria-sort` state. We prefer this approach\\n  over having a button with an `aria-label` inside the header, because the button's `aria-label`\\n  will be read out as the user is navigating the table's cell (see #13012).\\n\\n  The approach is based off of: https://dequeuniversity.com/library/aria/tables/sf-sortable-grid\\n-->\\n<div class=\\\"mat-sort-header-container mat-focus-indicator\\\"\\n     [class.mat-sort-header-sorted]=\\\"_isSorted()\\\"\\n     [class.mat-sort-header-position-before]=\\\"arrowPosition === 'before'\\\"\\n     [attr.tabindex]=\\\"_isDisabled() ? null : 0\\\"\\n     [attr.role]=\\\"_isDisabled() ? null : 'button'\\\">\\n\\n  <!--\\n    TODO(crisbeto): this div isn't strictly necessary, but we have to keep it due to a large\\n    number of screenshot diff failures. It should be removed eventually. Note that the difference\\n    isn't visible with a shorter header, but once it breaks up into multiple lines, this element\\n    causes it to be center-aligned, whereas removing it will keep the text to the left.\\n  -->\\n  <div class=\\\"mat-sort-header-content\\\">\\n    <ng-content></ng-content>\\n  </div>\\n\\n  <!-- Disable animations while a current animation is running -->\\n  <div class=\\\"mat-sort-header-arrow\\\"\\n       *ngIf=\\\"_renderArrow()\\\"\\n       [@arrowOpacity]=\\\"_getArrowViewState()\\\"\\n       [@arrowPosition]=\\\"_getArrowViewState()\\\"\\n       [@allowChildren]=\\\"_getArrowDirectionState()\\\"\\n       (@arrowPosition.start)=\\\"_disableViewStateAnimation = true\\\"\\n       (@arrowPosition.done)=\\\"_disableViewStateAnimation = false\\\">\\n    <div class=\\\"mat-sort-header-stem\\\"></div>\\n    <div class=\\\"mat-sort-header-indicator\\\" [@indicator]=\\\"_getArrowDirectionState()\\\">\\n      <div class=\\\"mat-sort-header-pointer-left\\\" [@leftPointer]=\\\"_getArrowDirectionState()\\\"></div>\\n      <div class=\\\"mat-sort-header-pointer-right\\\" [@rightPointer]=\\\"_getArrowDirectionState()\\\"></div>\\n      <div class=\\\"mat-sort-header-pointer-middle\\\"></div>\\n    </div>\\n  </div>\\n</div>\\n\", styles: [\".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-container::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}\"] }]\n        }], ctorParameters: function () { return [{ type: MatSortHeaderIntl }, { type: i0.ChangeDetectorRef }, { type: MatSort, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: ['MAT_SORT_HEADER_COLUMN_DEF']\n                }, {\n                    type: Optional\n                }] }, { type: i3.FocusMonitor }, { type: i0.ElementRef }, { type: i3.AriaDescriber, decorators: [{\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_SORT_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { id: [{\n                type: Input,\n                args: ['mat-sort-header']\n            }], arrowPosition: [{\n                type: Input\n            }], start: [{\n                type: Input\n            }], sortActionDescription: [{\n                type: Input\n            }], disableClear: [{\n                type: Input\n            }] } });\n\n/**\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 */\nclass MatSortModule {\n}\nMatSortModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatSortModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortModule, declarations: [MatSort, MatSortHeader], imports: [CommonModule, MatCommonModule], exports: [MatSort, MatSortHeader] });\nMatSortModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortModule, providers: [MAT_SORT_HEADER_INTL_PROVIDER], imports: [CommonModule, MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"15.2.0-rc.0\", ngImport: i0, type: MatSortModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, MatCommonModule],\n                    exports: [MatSort, MatSortHeader],\n                    declarations: [MatSort, MatSortHeader],\n                    providers: [MAT_SORT_HEADER_INTL_PROVIDER],\n                }]\n        }] });\n\n/**\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\n/**\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\n/**\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\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_SORT_DEFAULT_OPTIONS, MAT_SORT_HEADER_INTL_PROVIDER, MAT_SORT_HEADER_INTL_PROVIDER_FACTORY, MatSort, MatSortHeader, MatSortHeaderIntl, MatSortModule, matSortAnimations };\n"],"x_google_ignoreList":[0]}