ahcdashboardui/node_modules/@angular/material/esm2015/datepicker/date-range-input-parts.js

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Directive, ElementRef, Optional, InjectionToken, Inject, Injector, InjectFlags, } from '@angular/core';
import { NG_VALUE_ACCESSOR, NG_VALIDATORS, NgForm, FormGroupDirective, NgControl, Validators, } from '@angular/forms';
import { mixinErrorState, MAT_DATE_FORMATS, DateAdapter, ErrorStateMatcher, } from '@angular/material/core';
import { BACKSPACE } from '@angular/cdk/keycodes';
import { MatDatepickerInputBase } from './datepicker-input-base';
import { DateRange } from './date-selection-model';
/**
 * Used to provide the date range input wrapper component
 * to the parts without circular dependencies.
 */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from '@angular/material/core';
import * as ɵngcc2 from '@angular/forms';
export const MAT_DATE_RANGE_INPUT_PARENT = new InjectionToken('MAT_DATE_RANGE_INPUT_PARENT');
/**
 * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.
 */
class MatDateRangeInputPartBase extends MatDatepickerInputBase {
    constructor(_rangeInput, elementRef, _defaultErrorStateMatcher, _injector, _parentForm, _parentFormGroup, dateAdapter, dateFormats) {
        super(elementRef, dateAdapter, dateFormats);
        this._rangeInput = _rangeInput;
        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
        this._injector = _injector;
        this._parentForm = _parentForm;
        this._parentFormGroup = _parentFormGroup;
    }
    ngOnInit() {
        // We need the date input to provide itself as a `ControlValueAccessor` and a `Validator`, while
        // injecting its `NgControl` so that the error state is handled correctly. This introduces a
        // circular dependency, because both `ControlValueAccessor` and `Validator` depend on the input
        // itself. Usually we can work around it for the CVA, but there's no API to do it for the
        // validator. We work around it here by injecting the `NgControl` in `ngOnInit`, after
        // everything has been resolved.
        // tslint:disable-next-line:no-bitwise
        const ngControl = this._injector.get(NgControl, null, InjectFlags.Self | InjectFlags.Optional);
        if (ngControl) {
            this.ngControl = ngControl;
        }
    }
    ngDoCheck() {
        if (this.ngControl) {
            // We need to re-evaluate this on every change detection cycle, because there are some
            // error triggers that we can't subscribe to (e.g. parent form submissions). This means
            // that whatever logic is in here has to be super lean or we risk destroying the performance.
            this.updateErrorState();
        }
    }
    /** Gets whether the input is empty. */
    isEmpty() {
        return this._elementRef.nativeElement.value.length === 0;
    }
    /** Gets the placeholder of the input. */
    _getPlaceholder() {
        return this._elementRef.nativeElement.placeholder;
    }
    /** Focuses the input. */
    focus() {
        this._elementRef.nativeElement.focus();
    }
    /** Handles `input` events on the input element. */
    _onInput(value) {
        super._onInput(value);
        this._rangeInput._handleChildValueChange();
    }
    /** Opens the datepicker associated with the input. */
    _openPopup() {
        this._rangeInput._openDatepicker();
    }
    /** Gets the minimum date from the range input. */
    _getMinDate() {
        return this._rangeInput.min;
    }
    /** Gets the maximum date from the range input. */
    _getMaxDate() {
        return this._rangeInput.max;
    }
    /** Gets the date filter function from the range input. */
    _getDateFilter() {
        return this._rangeInput.dateFilter;
    }
    _parentDisabled() {
        return this._rangeInput._groupDisabled;
    }
    _shouldHandleChangeEvent({ source }) {
        return source !== this._rangeInput._startInput && source !== this._rangeInput._endInput;
    }
    _assignValueProgrammatically(value) {
        super._assignValueProgrammatically(value);
        const opposite = (this === this._rangeInput._startInput ? this._rangeInput._endInput :
            this._rangeInput._startInput);
        opposite === null || opposite === void 0 ? void 0 : opposite._validatorOnChange();
    }
}
MatDateRangeInputPartBase.ɵfac = function MatDateRangeInputPartBase_Factory(t) { return new (t || MatDateRangeInputPartBase)(ɵngcc0.ɵɵdirectiveInject(MAT_DATE_RANGE_INPUT_PARENT), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.ErrorStateMatcher), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgForm, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.FormGroupDirective, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8)); };
MatDateRangeInputPartBase.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: MatDateRangeInputPartBase, features: [ɵngcc0.ɵɵInheritDefinitionFeature] });
MatDateRangeInputPartBase.ctorParameters = () => [
    { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_INPUT_PARENT,] }] },
    { type: ElementRef },
    { type: ErrorStateMatcher },
    { type: Injector },
    { type: NgForm, decorators: [{ type: Optional }] },
    { type: FormGroupDirective, decorators: [{ type: Optional }] },
    { type: DateAdapter, decorators: [{ type: Optional }] },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] }
];
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatDateRangeInputPartBase, [{
        type: Directive
    }], function () { return [{ type: undefined, decorators: [{
                type: Inject,
                args: [MAT_DATE_RANGE_INPUT_PARENT]
            }] }, { type: ɵngcc0.ElementRef }, { type: ɵngcc1.ErrorStateMatcher }, { type: ɵngcc0.Injector }, { type: ɵngcc2.NgForm, decorators: [{
                type: Optional
            }] }, { type: ɵngcc2.FormGroupDirective, decorators: [{
                type: Optional
            }] }, { type: ɵngcc1.DateAdapter, decorators: [{
                type: Optional
            }] }, { type: undefined, decorators: [{
                type: Optional
            }, {
                type: Inject,
                args: [MAT_DATE_FORMATS]
            }] }]; }, null); })();
const _MatDateRangeInputBase = mixinErrorState(MatDateRangeInputPartBase);
/** Input for entering the start date in a `mat-date-range-input`. */
export class MatStartDate extends _MatDateRangeInputBase {
    constructor(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) {
        // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to
        // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this
        // constructor once ViewEngine is removed.
        super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats);
        /** Validator that checks that the start date isn't after the end date. */
        this._startValidator = (control) => {
            const start = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
            const end = this._model ? this._model.selection.end : null;
            return (!start || !end ||
                this._dateAdapter.compareDate(start, end) <= 0) ?
                null : { 'matStartDateInvalid': { 'end': end, 'actual': start } };
        };
        this._validator = Validators.compose([...super._getValidators(), this._startValidator]);
    }
    ngOnInit() {
        // Normally this happens automatically, but it seems to break if not added explicitly when all
        // of the criteria below are met:
        // 1) The class extends a TS mixin.
        // 2) The application is running in ViewEngine.
        // 3) The application is being transpiled through tsickle.
        // This can be removed once google3 is completely migrated to Ivy.
        super.ngOnInit();
    }
    ngDoCheck() {
        // Normally this happens automatically, but it seems to break if not added explicitly when all
        // of the criteria below are met:
        // 1) The class extends a TS mixin.
        // 2) The application is running in ViewEngine.
        // 3) The application is being transpiled through tsickle.
        // This can be removed once google3 is completely migrated to Ivy.
        super.ngDoCheck();
    }
    _getValueFromModel(modelValue) {
        return modelValue.start;
    }
    _shouldHandleChangeEvent(change) {
        var _a;
        if (!super._shouldHandleChangeEvent(change)) {
            return false;
        }
        else {
            return !((_a = change.oldValue) === null || _a === void 0 ? void 0 : _a.start) ? !!change.selection.start :
                !change.selection.start ||
                    !!this._dateAdapter.compareDate(change.oldValue.start, change.selection.start);
        }
    }
    _assignValueToModel(value) {
        if (this._model) {
            const range = new DateRange(value, this._model.selection.end);
            this._model.updateSelection(range, this);
        }
    }
    _formatValue(value) {
        super._formatValue(value);
        // Any time the input value is reformatted we need to tell the parent.
        this._rangeInput._handleChildValueChange();
    }
    /** Gets the value that should be used when mirroring the input's size. */
    getMirrorValue() {
        const element = this._elementRef.nativeElement;
        const value = element.value;
        return value.length > 0 ? value : element.placeholder;
    }
}
MatStartDate.ɵfac = function MatStartDate_Factory(t) { return new (t || MatStartDate)(ɵngcc0.ɵɵdirectiveInject(MAT_DATE_RANGE_INPUT_PARENT), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.ErrorStateMatcher), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgForm, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.FormGroupDirective, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8)); };
MatStartDate.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: MatStartDate, selectors: [["input", "matStartDate", ""]], hostAttrs: ["type", "text", 1, "mat-start-date", "mat-date-range-input-inner"], hostVars: 6, hostBindings: function MatStartDate_HostBindings(rf, ctx) { if (rf & 1) {
        ɵngcc0.ɵɵlistener("input", function MatStartDate_input_HostBindingHandler($event) { return ctx._onInput($event.target.value); })("change", function MatStartDate_change_HostBindingHandler() { return ctx._onChange(); })("keydown", function MatStartDate_keydown_HostBindingHandler($event) { return ctx._onKeydown($event); })("blur", function MatStartDate_blur_HostBindingHandler() { return ctx._onBlur(); });
    } if (rf & 2) {
        ɵngcc0.ɵɵhostProperty("disabled", ctx.disabled);
        ɵngcc0.ɵɵattribute("id", ctx._rangeInput.id)("aria-haspopup", ctx._rangeInput.rangePicker ? "dialog" : null)("aria-owns", (ctx._rangeInput.rangePicker == null ? null : ctx._rangeInput.rangePicker.opened) && ctx._rangeInput.rangePicker.id || null)("min", ctx._getMinDate() ? ctx._dateAdapter.toIso8601(ctx._getMinDate()) : null)("max", ctx._getMaxDate() ? ctx._dateAdapter.toIso8601(ctx._getMaxDate()) : null);
    } }, inputs: { errorStateMatcher: "errorStateMatcher" }, outputs: { dateChange: "dateChange", dateInput: "dateInput" }, features: [ɵngcc0.ɵɵProvidersFeature([
            { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true },
            { provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true }
        ]), ɵngcc0.ɵɵInheritDefinitionFeature] });
MatStartDate.ctorParameters = () => [
    { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_INPUT_PARENT,] }] },
    { type: ElementRef },
    { type: ErrorStateMatcher },
    { type: Injector },
    { type: NgForm, decorators: [{ type: Optional }] },
    { type: FormGroupDirective, decorators: [{ type: Optional }] },
    { type: DateAdapter, decorators: [{ type: Optional }] },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] }
];
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatStartDate, [{
        type: Directive,
        args: [{
                selector: 'input[matStartDate]',
                host: {
                    'class': 'mat-start-date mat-date-range-input-inner',
                    '[disabled]': 'disabled',
                    '(input)': '_onInput($event.target.value)',
                    '(change)': '_onChange()',
                    '(keydown)': '_onKeydown($event)',
                    '[attr.id]': '_rangeInput.id',
                    '[attr.aria-haspopup]': '_rangeInput.rangePicker ? "dialog" : null',
                    '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',
                    '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',
                    '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',
                    '(blur)': '_onBlur()',
                    'type': 'text'
                },
                providers: [
                    { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true },
                    { provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true }
                ],
                // These need to be specified explicitly, because some tooling doesn't
                // seem to pick them up from the base class. See #20932.
                outputs: ['dateChange', 'dateInput'],
                inputs: ['errorStateMatcher']
            }]
    }], function () { return [{ type: undefined, decorators: [{
                type: Inject,
                args: [MAT_DATE_RANGE_INPUT_PARENT]
            }] }, { type: ɵngcc0.ElementRef }, { type: ɵngcc1.ErrorStateMatcher }, { type: ɵngcc0.Injector }, { type: ɵngcc2.NgForm, decorators: [{
                type: Optional
            }] }, { type: ɵngcc2.FormGroupDirective, decorators: [{
                type: Optional
            }] }, { type: ɵngcc1.DateAdapter, decorators: [{
                type: Optional
            }] }, { type: undefined, decorators: [{
                type: Optional
            }, {
                type: Inject,
                args: [MAT_DATE_FORMATS]
            }] }]; }, null); })();
/** Input for entering the end date in a `mat-date-range-input`. */
export class MatEndDate extends _MatDateRangeInputBase {
    constructor(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) {
        // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to
        // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this
        // constructor once ViewEngine is removed.
        super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats);
        /** Validator that checks that the end date isn't before the start date. */
        this._endValidator = (control) => {
            const end = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
            const start = this._model ? this._model.selection.start : null;
            return (!end || !start ||
                this._dateAdapter.compareDate(end, start) >= 0) ?
                null : { 'matEndDateInvalid': { 'start': start, 'actual': end } };
        };
        this._validator = Validators.compose([...super._getValidators(), this._endValidator]);
    }
    ngOnInit() {
        // Normally this happens automatically, but it seems to break if not added explicitly when all
        // of the criteria below are met:
        // 1) The class extends a TS mixin.
        // 2) The application is running in ViewEngine.
        // 3) The application is being transpiled through tsickle.
        // This can be removed once google3 is completely migrated to Ivy.
        super.ngOnInit();
    }
    ngDoCheck() {
        // Normally this happens automatically, but it seems to break if not added explicitly when all
        // of the criteria below are met:
        // 1) The class extends a TS mixin.
        // 2) The application is running in ViewEngine.
        // 3) The application is being transpiled through tsickle.
        // This can be removed once google3 is completely migrated to Ivy.
        super.ngDoCheck();
    }
    _getValueFromModel(modelValue) {
        return modelValue.end;
    }
    _shouldHandleChangeEvent(change) {
        var _a;
        if (!super._shouldHandleChangeEvent(change)) {
            return false;
        }
        else {
            return !((_a = change.oldValue) === null || _a === void 0 ? void 0 : _a.end) ? !!change.selection.end :
                !change.selection.end ||
                    !!this._dateAdapter.compareDate(change.oldValue.end, change.selection.end);
        }
    }
    _assignValueToModel(value) {
        if (this._model) {
            const range = new DateRange(this._model.selection.start, value);
            this._model.updateSelection(range, this);
        }
    }
    _onKeydown(event) {
        // If the user is pressing backspace on an empty end input, move focus back to the start.
        if (event.keyCode === BACKSPACE && !this._elementRef.nativeElement.value) {
            this._rangeInput._startInput.focus();
        }
        super._onKeydown(event);
    }
}
MatEndDate.ɵfac = function MatEndDate_Factory(t) { return new (t || MatEndDate)(ɵngcc0.ɵɵdirectiveInject(MAT_DATE_RANGE_INPUT_PARENT), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.ErrorStateMatcher), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgForm, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.FormGroupDirective, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(MAT_DATE_FORMATS, 8)); };
MatEndDate.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: MatEndDate, selectors: [["input", "matEndDate", ""]], hostAttrs: ["type", "text", 1, "mat-end-date", "mat-date-range-input-inner"], hostVars: 5, hostBindings: function MatEndDate_HostBindings(rf, ctx) { if (rf & 1) {
        ɵngcc0.ɵɵlistener("input", function MatEndDate_input_HostBindingHandler($event) { return ctx._onInput($event.target.value); })("change", function MatEndDate_change_HostBindingHandler() { return ctx._onChange(); })("keydown", function MatEndDate_keydown_HostBindingHandler($event) { return ctx._onKeydown($event); })("blur", function MatEndDate_blur_HostBindingHandler() { return ctx._onBlur(); });
    } if (rf & 2) {
        ɵngcc0.ɵɵhostProperty("disabled", ctx.disabled);
        ɵngcc0.ɵɵattribute("aria-haspopup", ctx._rangeInput.rangePicker ? "dialog" : null)("aria-owns", (ctx._rangeInput.rangePicker == null ? null : ctx._rangeInput.rangePicker.opened) && ctx._rangeInput.rangePicker.id || null)("min", ctx._getMinDate() ? ctx._dateAdapter.toIso8601(ctx._getMinDate()) : null)("max", ctx._getMaxDate() ? ctx._dateAdapter.toIso8601(ctx._getMaxDate()) : null);
    } }, inputs: { errorStateMatcher: "errorStateMatcher" }, outputs: { dateChange: "dateChange", dateInput: "dateInput" }, features: [ɵngcc0.ɵɵProvidersFeature([
            { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true },
            { provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true }
        ]), ɵngcc0.ɵɵInheritDefinitionFeature] });
MatEndDate.ctorParameters = () => [
    { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_INPUT_PARENT,] }] },
    { type: ElementRef },
    { type: ErrorStateMatcher },
    { type: Injector },
    { type: NgForm, decorators: [{ type: Optional }] },
    { type: FormGroupDirective, decorators: [{ type: Optional }] },
    { type: DateAdapter, decorators: [{ type: Optional }] },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] }
];
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatEndDate, [{
        type: Directive,
        args: [{
                selector: 'input[matEndDate]',
                host: {
                    'class': 'mat-end-date mat-date-range-input-inner',
                    '[disabled]': 'disabled',
                    '(input)': '_onInput($event.target.value)',
                    '(change)': '_onChange()',
                    '(keydown)': '_onKeydown($event)',
                    '[attr.aria-haspopup]': '_rangeInput.rangePicker ? "dialog" : null',
                    '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',
                    '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',
                    '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',
                    '(blur)': '_onBlur()',
                    'type': 'text'
                },
                providers: [
                    { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true },
                    { provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true }
                ],
                // These need to be specified explicitly, because some tooling doesn't
                // seem to pick them up from the base class. See #20932.
                outputs: ['dateChange', 'dateInput'],
                inputs: ['errorStateMatcher']
            }]
    }], function () { return [{ type: undefined, decorators: [{
                type: Inject,
                args: [MAT_DATE_RANGE_INPUT_PARENT]
            }] }, { type: ɵngcc0.ElementRef }, { type: ɵngcc1.ErrorStateMatcher }, { type: ɵngcc0.Injector }, { type: ɵngcc2.NgForm, decorators: [{
                type: Optional
            }] }, { type: ɵngcc2.FormGroupDirective, decorators: [{
                type: Optional
            }] }, { type: ɵngcc1.DateAdapter, decorators: [{
                type: Optional
            }] }, { type: undefined, decorators: [{
                type: Optional
            }, {
                type: Inject,
                args: [MAT_DATE_FORMATS]
            }] }]; }, null); })();

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"date-range-input-parts.js","sources":["../../../../../../src/material/datepicker/date-range-input-parts.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AAEH,OAAO,EACL,SAAS,EACT,UAAU,EACV,QAAQ,EACR,cAAc,EACd,MAAM,EAEN,QAAQ,EACR,WAAW,GAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,MAAM,EACN,kBAAkB,EAClB,SAAS,EAET,UAAU,GAGX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,eAAe,EACf,gBAAgB,EAChB,WAAW,EAEX,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAC,sBAAsB,EAAe,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAC,SAAS,EAA2B,MAAM,wBAAwB,CAAC;AAmB3E;AACA;AACA;AACA,GAAG;;;;AACH,MAAM,CAAC,MAAM,2BAA2B,GACpC,IAAI,cAAc,CAAmC,6BAA6B,CAAC,CAAC;AAExF;AACA;AACA,GAAG;AACH,MACe,yBACb,SAAQ,sBAAoC;AAAG,IAY/C,YAC8C,WAAuC,EACnF,UAAwC,EACjC,yBAA4C,EAC3C,SAAmB,EACR,WAAmB,EACnB,gBAAoC,EAC3C,WAA2B,EACD,WAA2B;AACrE,QAAI,KAAK,CAAC,UAAU,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;AAChD,QATgD,gBAAW,GAAX,WAAW,CAA4B;AAAC,QAE7E,8BAAyB,GAAzB,yBAAyB,CAAmB;AAAC,QAC5C,cAAS,GAAT,SAAS,CAAU;AAAC,QACT,gBAAW,GAAX,WAAW,CAAQ;AAAC,QACpB,qBAAgB,GAAhB,gBAAgB,CAAoB;AAAC,IAI1D,CAAC;AACH,IACE,QAAQ;AACV,QAAI,gGAAgG;AACpG,QAAI,4FAA4F;AAChG,QAAI,+FAA+F;AACnG,QAAI,yFAAyF;AAC7F,QAAI,sFAAsF;AAC1F,QAAI,gCAAgC;AACpC,QAAI,sCAAsC;AAC1C,QAAI,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AACnG,QACI,IAAI,SAAS,EAAE;AACnB,YAAM,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;AACjC,SAAK;AACL,IAAE,CAAC;AACH,IACE,SAAS;AACX,QAAI,IAAI,IAAI,CAAC,SAAS,EAAE;AACxB,YAAM,sFAAsF;AAC5F,YAAM,uFAAuF;AAC7F,YAAM,6FAA6F;AACnG,YAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;AAC9B,SAAK;AACL,IAAE,CAAC;AACH,IACE,uCAAuC;AACzC,IAAE,OAAO;AAAK,QACV,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7D,IAAE,CAAC;AACH,IACE,yCAAyC;AAC3C,IAAE,eAAe;AACjB,QAAI,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC;AACtD,IAAE,CAAC;AACH,IACE,yBAAyB;AAC3B,IAAE,KAAK;AAAK,QACR,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;AAC3C,IAAE,CAAC;AACH,IACE,mDAAmD;AACrD,IAAW,QAAQ,CAAC,KAAa;AACjC,QAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC1B,QAAI,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,CAAC;AAC/C,IAAE,CAAC;AACH,IACE,sDAAsD;AACxD,IAAY,UAAU;AAAK,QACvB,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;AACvC,IAAE,CAAC;AACH,IACE,kDAAkD;AACpD,IAAE,WAAW;AACb,QAAI,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;AAChC,IAAE,CAAC;AACH,IACE,kDAAkD;AACpD,IAAE,WAAW;AACb,QAAI,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;AAChC,IAAE,CAAC;AACH,IACE,0DAA0D;AAC5D,IAAY,cAAc;AAC1B,QAAI,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC;AACvC,IAAE,CAAC;AACH,IACqB,eAAe;AACpC,QAAI,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC;AAC3C,IAAE,CAAC;AACH,IACY,wBAAwB,CAAC,EAAC,MAAM,EAAyC;AAAI,QACrF,OAAO,MAAM,KAAK,IAAI,CAAC,WAAW,CAAC,WAAW,IAAI,MAAM,KAAK,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;AAC5F,IAAE,CAAC;AACH,IACqB,4BAA4B,CAAC,KAAe;AACjE,QAAI,KAAK,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC;AAC9C,QAAI,MAAM,QAAQ,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;AAC1F,YAAQ,IAAI,CAAC,WAAW,CAAC,WAAW,CAA6C,CAAC;AAClF,QAAI,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,kBAAkB,EAAE,CAAC;AACnC,IAAE,CAAC;AACH;qDAzGC,SAAS;4JACR;AAAC;AACO,4CAaL,MAAM,SAAC,2BAA2B;AAAS,YA1E9C,UAAU;AACV,YAyBA,iBAAiB;AACjB,YAtBA,QAAQ;AACR,YAMA,MAAM,uBAkEH,QAAQ;AAAO,YAjElB,kBAAkB,uBAkEf,QAAQ;AAAO,YAvDlB,WAAW,uBAwDR,QAAQ;AAAO,4CACf,QAAQ,YAAI,MAAM,SAAC,gBAAgB;AAAQ;;;;;;;;;;;;;;;;;kCAAE;AAqFlD,MAAM,sBAAsB,GAAG,eAAe,CAAC,yBAAyB,CAAC,CAAC;AAE1E,qEAAqE;AA0BrE,MAAM,OAAO,YAAgB,SAAQ,sBAAyB;AAAG,IAY/D,YACuC,UAAsC,EAC3E,UAAwC,EACxC,wBAA2C,EAC3C,QAAkB,EACN,UAAkB,EAClB,eAAmC,EACnC,WAA2B,EACD,WAA2B;AACrE,QACI,0FAA0F;AAC9F,QAAI,8FAA8F;AAClG,QAAI,0CAA0C;AAC9C,QAAI,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,wBAAwB,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EACzF,WAAW,EAAE,WAAW,CAAC,CAAC;AAClC,QAzBE,0EAA0E;AAC5E,QAAU,oBAAe,GAAgB,CAAC,OAAwB,EAA2B,EAAE;AAC/F,YAAI,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAChD,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACpD,YAAI,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/D,YAAI,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC,GAAG;AAC1B,gBAAQ,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACzD,gBAAQ,IAAI,CAAC,CAAC,CAAC,EAAC,qBAAqB,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAC,EAAC,CAAC;AACtE,QAAE,CAAC,CAAA;AACH,QAsCY,eAAU,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;AAC/F,IAvBE,CAAC;AACH,IACW,QAAQ;AACnB,QAAI,8FAA8F;AAClG,QAAI,iCAAiC;AACrC,QAAI,mCAAmC;AACvC,QAAI,+CAA+C;AACnD,QAAI,0DAA0D;AAC9D,QAAI,kEAAkE;AACtE,QAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;AACrB,IAAE,CAAC;AACH,IACW,SAAS;AACpB,QAAI,8FAA8F;AAClG,QAAI,iCAAiC;AACrC,QAAI,mCAAmC;AACvC,QAAI,+CAA+C;AACnD,QAAI,0DAA0D;AAC9D,QAAI,kEAAkE;AACtE,QAAI,KAAK,CAAC,SAAS,EAAE,CAAC;AACtB,IAAE,CAAC;AACH,IAGY,kBAAkB,CAAC,UAAwB;AACvD,QAAI,OAAO,UAAU,CAAC,KAAK,CAAC;AAC5B,IAAE,CAAC;AACH,IACqB,wBAAwB,CACvC,MAA8C;AAAI;AACjD,QAAH,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE;AACjD,YAAM,OAAO,KAAK,CAAC;AACnB,SAAK;AAAC,aAAK;AACX,YAAM,OAAO,CAAC,CAAA,MAAA,MAAM,CAAC,QAAQ,0CAAE,KAAK,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AACjE,gBAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK;AAC/B,oBAAQ,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AACvF,SAAK;AACL,IAAE,CAAC;AACH,IACY,mBAAmB,CAAC,KAAe;AAC/C,QAAI,IAAI,IAAI,CAAC,MAAM,EAAE;AACrB,YAAM,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;AACpE,YAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AAC/C,SAAK;AACL,IAAE,CAAC;AACH,IACqB,YAAY,CAAC,KAAe;AACjD,QAAI,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAC9B,QACI,sEAAsE;AAC1E,QAAI,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,CAAC;AAC/C,IAAE,CAAC;AACH,IACE,0EAA0E;AAC5E,IAAE,cAAc;AAAK,QACjB,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;AACnD,QAAI,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;AAChC,QAAI,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;AAC1D,IAAE,CAAC;AACH;wCA/GC,SAAS,SAAC,kBACT,QAAQ,EAAE,qBAAqB,kBAC/B,IAAI,EAAE,sBACJ,OAAO,EAAE,2CAA2C,sBACpD,YAAY,EAAE,UAAU,sBACxB,SAAS,EAAE,+BAA+B,sBAC1C,UAAU,EAAE,aAAa,sBACzB,WAAW,EAAE,oBAAoB,sBACjC,WAAW,EAAE,gBAAgB;SAC7B,sBAAsB,EAAE,2CAA2C,sBACnE,kBAAkB,EAAE,yEAAyE,sBAC7F,YAAY,EAAE,8DAA8D;mBAC5E,YAAY,EAAE,8DAA8D,sBAC5E,QAAQ,EAAE,WAAW,sBACrB,MAAM,EAAE,MAAM,mBACf,kBACD,SAAS,EAAE,sBACT,EAAC,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAC,sBACpE,EAAC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAC;MACjE;IACD;iBAAsE,iBACtE,wDAAwD,iBACxD,OAAO,EAAE,CAAC,YAAY,EAAE,WAAW,CAAC,kBACpC,MAAM,EAAE,CAAC,mBAAmB,CAAC,cAC9B;;;;kDACI;AAAC;AAAsC,4CAavC,MAAM,SAAC,2BAA2B;AAAS,YA/M9C,UAAU;AACV,YAyBA,iBAAiB;AACjB,YAtBA,QAAQ;AACR,YAMA,MAAM,uBAuMH,QAAQ;AAAO,YAtMlB,kBAAkB,uBAuMf,QAAQ;AAAO,YA5LlB,WAAW,uBA6LR,QAAQ;AAAO,4CACf,QAAQ,YAAI,MAAM,SAAC,gBAAgB;AAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAE;AAqElD,mEAAmE;AAyBnE,MAAM,OAAO,UAAc,SAAQ,sBAAyB;AAAG,IAW7D,YACuC,UAAsC,EAC3E,UAAwC,EACxC,wBAA2C,EAC3C,QAAkB,EACN,UAAkB,EAClB,eAAmC,EACnC,WAA2B,EACD,WAA2B;AACrE,QACI,0FAA0F;AAC9F,QAAI,8FAA8F;AAClG,QAAI,0CAA0C;AAC9C,QAAI,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,wBAAwB,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EACzF,WAAW,EAAE,WAAW,CAAC,CAAC;AAClC,QAxBE,2EAA2E;AAC7E,QAAU,kBAAa,GAAgB,CAAC,OAAwB,EAA2B,EAAE;AAC7F,YAAI,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACnG,YAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACnE,YAAI,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK;AAC1B,gBAAQ,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACzD,gBAAQ,IAAI,CAAC,CAAC,CAAC,EAAC,mBAAmB,EAAE,EAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAC,EAAC,CAAC;AACtE,QAAE,CAAC,CAAA;AACH,QAsCY,eAAU,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;AAC7F,IAvBE,CAAC;AACH,IACW,QAAQ;AACnB,QAAI,8FAA8F;AAClG,QAAI,iCAAiC;AACrC,QAAI,mCAAmC;AACvC,QAAI,+CAA+C;AACnD,QAAI,0DAA0D;AAC9D,QAAI,kEAAkE;AACtE,QAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;AACrB,IAAE,CAAC;AACH,IACW,SAAS;AACpB,QAAI,8FAA8F;AAClG,QAAI,iCAAiC;AACrC,QAAI,mCAAmC;AACvC,QAAI,+CAA+C;AACnD,QAAI,0DAA0D;AAC9D,QAAI,kEAAkE;AACtE,QAAI,KAAK,CAAC,SAAS,EAAE,CAAC;AACtB,IAAE,CAAC;AACH,IAGY,kBAAkB,CAAC,UAAwB;AACvD,QAAI,OAAO,UAAU,CAAC,GAAG,CAAC;AAC1B,IAAE,CAAC;AACH,IACqB,wBAAwB,CACvC,MAA8C;AAAI;AACjD,QAAH,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE;AACjD,YAAM,OAAO,KAAK,CAAC;AACnB,SAAK;AAAC,aAAK;AACX,YAAM,OAAO,CAAC,CAAA,MAAA,MAAM,CAAC,QAAQ,0CAAE,GAAG,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;AAC7D,gBAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG;AAC7B,oBAAQ,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;AACnF,SAAK;AACL,IAAE,CAAC;AACH,IACY,mBAAmB,CAAC,KAAe;AAC/C,QAAI,IAAI,IAAI,CAAC,MAAM,EAAE;AACrB,YAAM,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AACtE,YAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AAC/C,SAAK;AACL,IAAE,CAAC;AACH,IACW,UAAU,CAAC,KAAoB;AAC1C,QAAI,yFAAyF;AAC7F,QAAI,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE;AAC9E,YAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;AAC3C,SAAK;AACL,QACI,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;AAC5B,IAAE,CAAC;AACH;sCAxGC,SAAS,SAAC,kBACT,QAAQ,EAAE,mBAAmB,kBAC7B,IAAI,EAAE,sBACJ,OAAO,EAAE,yCAAyC,sBAClD,YAAY,EAAE,UAAU,sBACxB,SAAS,EAAE,+BAA+B,sBAC1C,UAAU,EAAE,aAAa,sBACzB,WAAW,EAAE,oBAAoB,sBACjC,sBAAsB,EAAE;yBAA2C,sBACnE,kBAAkB,EAAE,yEAAyE,sBAC7F,YAAY,EAAE,8DAA8D,sBAC5E,YAAY,EAAE;sDAA8D,sBAC5E,QAAQ,EAAE,WAAW,sBACrB,MAAM,EAAE,MAAM,mBACf,kBACD,SAAS,EAAE,sBACT,EAAC,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAC,sBAClE,EAAC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAC,kBAC/D,kBACD;;qCAAsE,iBACtE;qDAAwD,iBACxD,OAAO,EAAE,CAAC,YAAY,EAAE,WAAW,CAAC,kBACpC,MAAM,EAAE,CAAC,mBAAmB,CAAC,cAC9B;;;;kDACI;AAAC;AAAoC,4CAYrC,MAAM,SAAC,2BAA2B;AAAS,YAhU9C,UAAU;AACV,YAyBA,iBAAiB;AACjB,YAtBA,QAAQ;AACR,YAMA,MAAM,uBAwTH,QAAQ;AAAO,YAvTlB,kBAAkB,uBAwTf,QAAQ;AAAO,YA7SlB,WAAW,uBA8SR,QAAQ;AAAO,4CACf,QAAQ,YAAI,MAAM,SAAC,gBAAgB;AAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAE;AAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Directive,\n  ElementRef,\n  Optional,\n  InjectionToken,\n  Inject,\n  OnInit,\n  Injector,\n  InjectFlags,\n  DoCheck,\n} from '@angular/core';\nimport {\n  NG_VALUE_ACCESSOR,\n  NG_VALIDATORS,\n  NgForm,\n  FormGroupDirective,\n  NgControl,\n  ValidatorFn,\n  Validators,\n  AbstractControl,\n  ValidationErrors,\n} from '@angular/forms';\nimport {\n  CanUpdateErrorState,\n  mixinErrorState,\n  MAT_DATE_FORMATS,\n  DateAdapter,\n  MatDateFormats,\n  ErrorStateMatcher,\n} from '@angular/material/core';\nimport {BACKSPACE} from '@angular/cdk/keycodes';\nimport {MatDatepickerInputBase, DateFilterFn} from './datepicker-input-base';\nimport {DateRange, DateSelectionModelChange} from './date-selection-model';\n\n/** Parent component that should be wrapped around `MatStartDate` and `MatEndDate`. */\nexport interface MatDateRangeInputParent<D> {\n  id: string;\n  min: D | null;\n  max: D | null;\n  dateFilter: DateFilterFn<D>;\n  rangePicker: {\n    opened: boolean;\n    id: string;\n  };\n  _startInput: MatDateRangeInputPartBase<D>;\n  _endInput: MatDateRangeInputPartBase<D>;\n  _groupDisabled: boolean;\n  _handleChildValueChange(): void;\n  _openDatepicker(): void;\n}\n\n/**\n * Used to provide the date range input wrapper component\n * to the parts without circular dependencies.\n */\nexport const MAT_DATE_RANGE_INPUT_PARENT =\n    new InjectionToken<MatDateRangeInputParent<unknown>>('MAT_DATE_RANGE_INPUT_PARENT');\n\n/**\n * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.\n */\n@Directive()\nabstract class MatDateRangeInputPartBase<D>\n  extends MatDatepickerInputBase<DateRange<D>> implements OnInit, DoCheck {\n\n  /** @docs-private */\n  ngControl: NgControl;\n\n  /** @docs-private */\n  abstract updateErrorState(): void;\n\n  protected abstract override _validator: ValidatorFn | null;\n  protected abstract override _assignValueToModel(value: D | null): void;\n  protected abstract override _getValueFromModel(modelValue: DateRange<D>): D | null;\n\n  constructor(\n    @Inject(MAT_DATE_RANGE_INPUT_PARENT) public _rangeInput: MatDateRangeInputParent<D>,\n    elementRef: ElementRef<HTMLInputElement>,\n    public _defaultErrorStateMatcher: ErrorStateMatcher,\n    private _injector: Injector,\n    @Optional() public _parentForm: NgForm,\n    @Optional() public _parentFormGroup: FormGroupDirective,\n    @Optional() dateAdapter: DateAdapter<D>,\n    @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats) {\n    super(elementRef, dateAdapter, dateFormats);\n  }\n\n  ngOnInit() {\n    // We need the date input to provide itself as a `ControlValueAccessor` and a `Validator`, while\n    // injecting its `NgControl` so that the error state is handled correctly. This introduces a\n    // circular dependency, because both `ControlValueAccessor` and `Validator` depend on the input\n    // itself. Usually we can work around it for the CVA, but there's no API to do it for the\n    // validator. We work around it here by injecting the `NgControl` in `ngOnInit`, after\n    // everything has been resolved.\n    // tslint:disable-next-line:no-bitwise\n    const ngControl = this._injector.get(NgControl, null, InjectFlags.Self | InjectFlags.Optional);\n\n    if (ngControl) {\n      this.ngControl = ngControl;\n    }\n  }\n\n  ngDoCheck() {\n    if (this.ngControl) {\n      // We need to re-evaluate this on every change detection cycle, because there are some\n      // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n      // that whatever logic is in here has to be super lean or we risk destroying the performance.\n      this.updateErrorState();\n    }\n  }\n\n  /** Gets whether the input is empty. */\n  isEmpty(): boolean {\n    return this._elementRef.nativeElement.value.length === 0;\n  }\n\n  /** Gets the placeholder of the input. */\n  _getPlaceholder() {\n    return this._elementRef.nativeElement.placeholder;\n  }\n\n  /** Focuses the input. */\n  focus(): void {\n    this._elementRef.nativeElement.focus();\n  }\n\n  /** Handles `input` events on the input element. */\n  override _onInput(value: string) {\n    super._onInput(value);\n    this._rangeInput._handleChildValueChange();\n  }\n\n  /** Opens the datepicker associated with the input. */\n  protected _openPopup(): void {\n    this._rangeInput._openDatepicker();\n  }\n\n  /** Gets the minimum date from the range input. */\n  _getMinDate() {\n    return this._rangeInput.min;\n  }\n\n  /** Gets the maximum date from the range input. */\n  _getMaxDate() {\n    return this._rangeInput.max;\n  }\n\n  /** Gets the date filter function from the range input. */\n  protected _getDateFilter() {\n    return this._rangeInput.dateFilter;\n  }\n\n  protected override _parentDisabled() {\n    return this._rangeInput._groupDisabled;\n  }\n\n  protected _shouldHandleChangeEvent({source}: DateSelectionModelChange<DateRange<D>>): boolean {\n    return source !== this._rangeInput._startInput && source !== this._rangeInput._endInput;\n  }\n\n  protected override _assignValueProgrammatically(value: D | null) {\n    super._assignValueProgrammatically(value);\n    const opposite = (this === this._rangeInput._startInput ? this._rangeInput._endInput :\n        this._rangeInput._startInput) as MatDateRangeInputPartBase<D> | undefined;\n    opposite?._validatorOnChange();\n  }\n}\n\nconst _MatDateRangeInputBase = mixinErrorState(MatDateRangeInputPartBase);\n\n/** Input for entering the start date in a `mat-date-range-input`. */\n@Directive({\n  selector: 'input[matStartDate]',\n  host: {\n    'class': 'mat-start-date mat-date-range-input-inner',\n    '[disabled]': 'disabled',\n    '(input)': '_onInput($event.target.value)',\n    '(change)': '_onChange()',\n    '(keydown)': '_onKeydown($event)',\n    '[attr.id]': '_rangeInput.id',\n    '[attr.aria-haspopup]': '_rangeInput.rangePicker ? \"dialog\" : null',\n    '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',\n    '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',\n    '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',\n    '(blur)': '_onBlur()',\n    'type': 'text',\n  },\n  providers: [\n    {provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true},\n    {provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true}\n  ],\n  // These need to be specified explicitly, because some tooling doesn't\n  // seem to pick them up from the base class. See #20932.\n  outputs: ['dateChange', 'dateInput'],\n  inputs: ['errorStateMatcher']\n})\nexport class MatStartDate<D> extends _MatDateRangeInputBase<D> implements\n    CanUpdateErrorState, DoCheck, OnInit {\n  /** Validator that checks that the start date isn't after the end date. */\n  private _startValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n    const start = this._dateAdapter.getValidDateOrNull(\n      this._dateAdapter.deserialize(control.value));\n    const end = this._model ? this._model.selection.end : null;\n    return (!start || !end ||\n        this._dateAdapter.compareDate(start, end) <= 0) ?\n        null : {'matStartDateInvalid': {'end': end, 'actual': start}};\n  }\n\n  constructor(\n    @Inject(MAT_DATE_RANGE_INPUT_PARENT) rangeInput: MatDateRangeInputParent<D>,\n    elementRef: ElementRef<HTMLInputElement>,\n    defaultErrorStateMatcher: ErrorStateMatcher,\n    injector: Injector,\n    @Optional() parentForm: NgForm,\n    @Optional() parentFormGroup: FormGroupDirective,\n    @Optional() dateAdapter: DateAdapter<D>,\n    @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats) {\n\n    // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to\n    // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this\n    // constructor once ViewEngine is removed.\n    super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup,\n        dateAdapter, dateFormats);\n  }\n\n  override ngOnInit() {\n    // Normally this happens automatically, but it seems to break if not added explicitly when all\n    // of the criteria below are met:\n    // 1) The class extends a TS mixin.\n    // 2) The application is running in ViewEngine.\n    // 3) The application is being transpiled through tsickle.\n    // This can be removed once google3 is completely migrated to Ivy.\n    super.ngOnInit();\n  }\n\n  override ngDoCheck() {\n    // Normally this happens automatically, but it seems to break if not added explicitly when all\n    // of the criteria below are met:\n    // 1) The class extends a TS mixin.\n    // 2) The application is running in ViewEngine.\n    // 3) The application is being transpiled through tsickle.\n    // This can be removed once google3 is completely migrated to Ivy.\n    super.ngDoCheck();\n  }\n\n  protected _validator = Validators.compose([...super._getValidators(), this._startValidator]);\n\n  protected _getValueFromModel(modelValue: DateRange<D>) {\n    return modelValue.start;\n  }\n\n  protected override _shouldHandleChangeEvent(\n      change: DateSelectionModelChange<DateRange<D>>): boolean {\n    if (!super._shouldHandleChangeEvent(change)) {\n      return false;\n    } else {\n      return !change.oldValue?.start ? !!change.selection.start :\n        !change.selection.start ||\n        !!this._dateAdapter.compareDate(change.oldValue.start, change.selection.start);\n    }\n  }\n\n  protected _assignValueToModel(value: D | null) {\n    if (this._model) {\n      const range = new DateRange(value, this._model.selection.end);\n      this._model.updateSelection(range, this);\n    }\n  }\n\n  protected override _formatValue(value: D | null) {\n    super._formatValue(value);\n\n    // Any time the input value is reformatted we need to tell the parent.\n    this._rangeInput._handleChildValueChange();\n  }\n\n  /** Gets the value that should be used when mirroring the input's size. */\n  getMirrorValue(): string {\n    const element = this._elementRef.nativeElement;\n    const value = element.value;\n    return value.length > 0 ? value : element.placeholder;\n  }\n}\n\n\n/** Input for entering the end date in a `mat-date-range-input`. */\n@Directive({\n  selector: 'input[matEndDate]',\n  host: {\n    'class': 'mat-end-date mat-date-range-input-inner',\n    '[disabled]': 'disabled',\n    '(input)': '_onInput($event.target.value)',\n    '(change)': '_onChange()',\n    '(keydown)': '_onKeydown($event)',\n    '[attr.aria-haspopup]': '_rangeInput.rangePicker ? \"dialog\" : null',\n    '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',\n    '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',\n    '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',\n    '(blur)': '_onBlur()',\n    'type': 'text',\n  },\n  providers: [\n    {provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true},\n    {provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true}\n  ],\n  // These need to be specified explicitly, because some tooling doesn't\n  // seem to pick them up from the base class. See #20932.\n  outputs: ['dateChange', 'dateInput'],\n  inputs: ['errorStateMatcher']\n})\nexport class MatEndDate<D> extends _MatDateRangeInputBase<D> implements\n    CanUpdateErrorState, DoCheck, OnInit {\n  /** Validator that checks that the end date isn't before the start date. */\n  private _endValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n    const end = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n    const start = this._model ? this._model.selection.start : null;\n    return (!end || !start ||\n        this._dateAdapter.compareDate(end, start) >= 0) ?\n        null : {'matEndDateInvalid': {'start': start, 'actual': end}};\n  }\n\n  constructor(\n    @Inject(MAT_DATE_RANGE_INPUT_PARENT) rangeInput: MatDateRangeInputParent<D>,\n    elementRef: ElementRef<HTMLInputElement>,\n    defaultErrorStateMatcher: ErrorStateMatcher,\n    injector: Injector,\n    @Optional() parentForm: NgForm,\n    @Optional() parentFormGroup: FormGroupDirective,\n    @Optional() dateAdapter: DateAdapter<D>,\n    @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats) {\n\n    // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to\n    // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this\n    // constructor once ViewEngine is removed.\n    super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup,\n        dateAdapter, dateFormats);\n  }\n\n  override ngOnInit() {\n    // Normally this happens automatically, but it seems to break if not added explicitly when all\n    // of the criteria below are met:\n    // 1) The class extends a TS mixin.\n    // 2) The application is running in ViewEngine.\n    // 3) The application is being transpiled through tsickle.\n    // This can be removed once google3 is completely migrated to Ivy.\n    super.ngOnInit();\n  }\n\n  override ngDoCheck() {\n    // Normally this happens automatically, but it seems to break if not added explicitly when all\n    // of the criteria below are met:\n    // 1) The class extends a TS mixin.\n    // 2) The application is running in ViewEngine.\n    // 3) The application is being transpiled through tsickle.\n    // This can be removed once google3 is completely migrated to Ivy.\n    super.ngDoCheck();\n  }\n\n  protected _validator = Validators.compose([...super._getValidators(), this._endValidator]);\n\n  protected _getValueFromModel(modelValue: DateRange<D>) {\n    return modelValue.end;\n  }\n\n  protected override _shouldHandleChangeEvent(\n      change: DateSelectionModelChange<DateRange<D>>): boolean {\n    if (!super._shouldHandleChangeEvent(change)) {\n      return false;\n    } else {\n      return !change.oldValue?.end ? !!change.selection.end :\n        !change.selection.end ||\n        !!this._dateAdapter.compareDate(change.oldValue.end, change.selection.end);\n    }\n  }\n\n  protected _assignValueToModel(value: D | null) {\n    if (this._model) {\n      const range = new DateRange(this._model.selection.start, value);\n      this._model.updateSelection(range, this);\n    }\n  }\n\n  override _onKeydown(event: KeyboardEvent) {\n    // If the user is pressing backspace on an empty end input, move focus back to the start.\n    if (event.keyCode === BACKSPACE && !this._elementRef.nativeElement.value) {\n      this._rangeInput._startInput.focus();\n    }\n\n    super._onKeydown(event);\n  }\n}\n"]}