/**
 * @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, inject, InjectionToken, Inject, Injector, } 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 { Directionality } from '@angular/cdk/bidi';
import { BACKSPACE, LEFT_ARROW, RIGHT_ARROW } from '@angular/cdk/keycodes';
import { MatDatepickerInputBase } from './datepicker-input-base';
import { DateRange } from './date-selection-model';
import { _computeAriaAccessibleName } from './aria-accessible-name';
import * as i0 from "@angular/core";
import * as i1 from "@angular/material/core";
import * as i2 from "@angular/forms";
/**
 * Used to provide the date range input wrapper component
 * to the parts without circular dependencies.
 */
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._elementRef = _elementRef;
        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
        this._injector = _injector;
        this._parentForm = _parentForm;
        this._parentFormGroup = _parentFormGroup;
        this._dir = inject(Directionality, { optional: true });
    }
    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, { optional: true, self: true });
        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();
    }
    /** 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;
    }
    /** 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?._validatorOnChange();
    }
    /** return the ARIA accessible name of the input element */
    _getAccessibleName() {
        return _computeAriaAccessibleName(this._elementRef.nativeElement);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatDateRangeInputPartBase, deps: [{ token: MAT_DATE_RANGE_INPUT_PARENT }, { token: i0.ElementRef }, { token: i1.ErrorStateMatcher }, { token: i0.Injector }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.1", type: MatDateRangeInputPartBase, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatDateRangeInputPartBase, decorators: [{
            type: Directive
        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                    type: Inject,
                    args: [MAT_DATE_RANGE_INPUT_PARENT]
                }] }, { type: i0.ElementRef }, { type: i1.ErrorStateMatcher }, { type: i0.Injector }, { type: i2.NgForm, decorators: [{
                    type: Optional
                }] }, { type: i2.FormGroupDirective, decorators: [{
                    type: Optional
                }] }, { type: i1.DateAdapter, decorators: [{
                    type: Optional
                }] }, { type: undefined, decorators: [{
                    type: Optional
                }, {
                    type: Inject,
                    args: [MAT_DATE_FORMATS]
                }] }]; } });
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) {
        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]);
    }
    _getValueFromModel(modelValue) {
        return modelValue.start;
    }
    _shouldHandleChangeEvent(change) {
        if (!super._shouldHandleChangeEvent(change)) {
            return false;
        }
        else {
            return !change.oldValue?.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();
    }
    _onKeydown(event) {
        const endInput = this._rangeInput._endInput;
        const element = this._elementRef.nativeElement;
        const isLtr = this._dir?.value !== 'rtl';
        // If the user hits RIGHT (LTR) when at the end of the input (and no
        // selection), move the cursor to the start of the end input.
        if (((event.keyCode === RIGHT_ARROW && isLtr) || (event.keyCode === LEFT_ARROW && !isLtr)) &&
            element.selectionStart === element.value.length &&
            element.selectionEnd === element.value.length) {
            event.preventDefault();
            endInput._elementRef.nativeElement.setSelectionRange(0, 0);
            endInput.focus();
        }
        else {
            super._onKeydown(event);
        }
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatStartDate, deps: [{ token: MAT_DATE_RANGE_INPUT_PARENT }, { token: i0.ElementRef }, { token: i1.ErrorStateMatcher }, { token: i0.Injector }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.1", type: MatStartDate, selector: "input[matStartDate]", inputs: { errorStateMatcher: "errorStateMatcher" }, outputs: { dateChange: "dateChange", dateInput: "dateInput" }, host: { attributes: { "type": "text" }, listeners: { "input": "_onInput($event.target.value)", "change": "_onChange()", "keydown": "_onKeydown($event)", "blur": "_onBlur()" }, properties: { "disabled": "disabled", "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" }, classAttribute: "mat-start-date mat-date-range-input-inner" }, providers: [
            { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true },
            { provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true },
        ], usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatStartDate, decorators: [{
            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.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'],
                }]
        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                    type: Inject,
                    args: [MAT_DATE_RANGE_INPUT_PARENT]
                }] }, { type: i0.ElementRef }, { type: i1.ErrorStateMatcher }, { type: i0.Injector }, { type: i2.NgForm, decorators: [{
                    type: Optional
                }] }, { type: i2.FormGroupDirective, decorators: [{
                    type: Optional
                }] }, { type: i1.DateAdapter, decorators: [{
                    type: Optional
                }] }, { type: undefined, decorators: [{
                    type: Optional
                }, {
                    type: Inject,
                    args: [MAT_DATE_FORMATS]
                }] }]; } });
/** 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) {
        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]);
    }
    _getValueFromModel(modelValue) {
        return modelValue.end;
    }
    _shouldHandleChangeEvent(change) {
        if (!super._shouldHandleChangeEvent(change)) {
            return false;
        }
        else {
            return !change.oldValue?.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) {
        const startInput = this._rangeInput._startInput;
        const element = this._elementRef.nativeElement;
        const isLtr = this._dir?.value !== 'rtl';
        // If the user is pressing backspace on an empty end input, move focus back to the start.
        if (event.keyCode === BACKSPACE && !element.value) {
            startInput.focus();
        }
        // If the user hits LEFT (LTR) when at the start of the input (and no
        // selection), move the cursor to the end of the start input.
        else if (((event.keyCode === LEFT_ARROW && isLtr) || (event.keyCode === RIGHT_ARROW && !isLtr)) &&
            element.selectionStart === 0 &&
            element.selectionEnd === 0) {
            event.preventDefault();
            const endPosition = startInput._elementRef.nativeElement.value.length;
            startInput._elementRef.nativeElement.setSelectionRange(endPosition, endPosition);
            startInput.focus();
        }
        else {
            super._onKeydown(event);
        }
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatEndDate, deps: [{ token: MAT_DATE_RANGE_INPUT_PARENT }, { token: i0.ElementRef }, { token: i1.ErrorStateMatcher }, { token: i0.Injector }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i1.DateAdapter, optional: true }, { token: MAT_DATE_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.1", type: MatEndDate, selector: "input[matEndDate]", inputs: { errorStateMatcher: "errorStateMatcher" }, outputs: { dateChange: "dateChange", dateInput: "dateInput" }, host: { attributes: { "type": "text" }, listeners: { "input": "_onInput($event.target.value)", "change": "_onChange()", "keydown": "_onKeydown($event)", "blur": "_onBlur()" }, properties: { "disabled": "disabled", "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" }, classAttribute: "mat-end-date mat-date-range-input-inner" }, providers: [
            { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true },
            { provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true },
        ], usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatEndDate, decorators: [{
            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'],
                }]
        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                    type: Inject,
                    args: [MAT_DATE_RANGE_INPUT_PARENT]
                }] }, { type: i0.ElementRef }, { type: i1.ErrorStateMatcher }, { type: i0.Injector }, { type: i2.NgForm, decorators: [{
                    type: Optional
                }] }, { type: i2.FormGroupDirective, decorators: [{
                    type: Optional
                }] }, { type: i1.DateAdapter, decorators: [{
                    type: Optional
                }] }, { type: undefined, decorators: [{
                    type: Optional
                }, {
                    type: Inject,
                    args: [MAT_DATE_FORMATS]
                }] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-input-parts.js","sourceRoot":"","sources":["../../../../../../src/material/datepicker/date-range-input-parts.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Directive,\n  ElementRef,\n  Optional,\n  inject,\n  InjectionToken,\n  Inject,\n  OnInit,\n  Injector,\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 {Directionality} from '@angular/cdk/bidi';\nimport {BACKSPACE, LEFT_ARROW, RIGHT_ARROW} from '@angular/cdk/keycodes';\nimport {MatDatepickerInputBase, DateFilterFn} from './datepicker-input-base';\nimport {DateRange, DateSelectionModelChange} from './date-selection-model';\nimport {_computeAriaAccessibleName} from './aria-accessible-name';\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 = new InjectionToken<MatDateRangeInputParent<unknown>>(\n  'MAT_DATE_RANGE_INPUT_PARENT',\n);\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>>\n  implements OnInit, DoCheck\n{\n  /**\n   * Form control bound to this input part.\n   * @docs-private\n   */\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  protected readonly _dir = inject(Directionality, {optional: true});\n\n  constructor(\n    @Inject(MAT_DATE_RANGE_INPUT_PARENT) public _rangeInput: MatDateRangeInputParent<D>,\n    public override _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  ) {\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, {optional: true, self: true});\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  /** 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  /** 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 = (\n      this === this._rangeInput._startInput\n        ? this._rangeInput._endInput\n        : this._rangeInput._startInput\n    ) as MatDateRangeInputPartBase<D> | undefined;\n    opposite?._validatorOnChange();\n  }\n\n  /** return the ARIA accessible name of the input element */\n  _getAccessibleName(): string {\n    return _computeAriaAccessibleName(this._elementRef.nativeElement);\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.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 CanUpdateErrorState {\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    );\n    const end = this._model ? this._model.selection.end : null;\n    return !start || !end || this._dateAdapter.compareDate(start, end) <= 0\n      ? null\n      : {'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    super(\n      rangeInput,\n      elementRef,\n      defaultErrorStateMatcher,\n      injector,\n      parentForm,\n      parentFormGroup,\n      dateAdapter,\n      dateFormats,\n    );\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>>,\n  ): boolean {\n    if (!super._shouldHandleChangeEvent(change)) {\n      return false;\n    } else {\n      return !change.oldValue?.start\n        ? !!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  override _onKeydown(event: KeyboardEvent) {\n    const endInput = this._rangeInput._endInput;\n    const element = this._elementRef.nativeElement;\n    const isLtr = this._dir?.value !== 'rtl';\n\n    // If the user hits RIGHT (LTR) when at the end of the input (and no\n    // selection), move the cursor to the start of the end input.\n    if (\n      ((event.keyCode === RIGHT_ARROW && isLtr) || (event.keyCode === LEFT_ARROW && !isLtr)) &&\n      element.selectionStart === element.value.length &&\n      element.selectionEnd === element.value.length\n    ) {\n      event.preventDefault();\n      endInput._elementRef.nativeElement.setSelectionRange(0, 0);\n      endInput.focus();\n    } else {\n      super._onKeydown(event);\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 CanUpdateErrorState {\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 || this._dateAdapter.compareDate(end, start) >= 0\n      ? null\n      : {'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    super(\n      rangeInput,\n      elementRef,\n      defaultErrorStateMatcher,\n      injector,\n      parentForm,\n      parentFormGroup,\n      dateAdapter,\n      dateFormats,\n    );\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>>,\n  ): boolean {\n    if (!super._shouldHandleChangeEvent(change)) {\n      return false;\n    } else {\n      return !change.oldValue?.end\n        ? !!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    const startInput = this._rangeInput._startInput;\n    const element = this._elementRef.nativeElement;\n    const isLtr = this._dir?.value !== 'rtl';\n\n    // If the user is pressing backspace on an empty end input, move focus back to the start.\n    if (event.keyCode === BACKSPACE && !element.value) {\n      startInput.focus();\n    }\n    // If the user hits LEFT (LTR) when at the start of the input (and no\n    // selection), move the cursor to the end of the start input.\n    else if (\n      ((event.keyCode === LEFT_ARROW && isLtr) || (event.keyCode === RIGHT_ARROW && !isLtr)) &&\n      element.selectionStart === 0 &&\n      element.selectionEnd === 0\n    ) {\n      event.preventDefault();\n      const endPosition = startInput._elementRef.nativeElement.value.length;\n      startInput._elementRef.nativeElement.setSelectionRange(endPosition, endPosition);\n      startInput.focus();\n    } else {\n      super._onKeydown(event);\n    }\n  }\n}\n"]}