@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/datepicker/date-range-input-parts.js

@@ -19,245 +19,230 @@ export const MAT_DATE_RANGE_INPUT_PARENT = new InjectionToken('MAT_DATE_RANGE_IN
 /**
  * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.
  */
-let MatDateRangeInputPartBase = /** @class */ (() => {
-    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;
-            this._outsideValueChanged = () => {
-                // Whenever the value changes outside the input we need to revalidate, because
-                // the validation state of each of the inputs depends on the other one.
-                this._validatorOnChange();
-            };
-        }
-        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.
-            const ngControl = this._injector.get(NgControl, null, InjectFlags.Self);
-            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;
+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;
+        this._outsideValueChanged = () => {
+            // Whenever the value changes outside the input we need to revalidate, because
+            // the validation state of each of the inputs depends on the other one.
+            this._validatorOnChange();
+        };
+    }
+    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.
+        const ngControl = this._injector.get(NgControl, null, InjectFlags.Self);
+        if (ngControl) {
+            this.ngControl = ngControl;
         }
-        _parentDisabled() {
-            return this._rangeInput._groupDisabled;
+    }
+    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();
         }
     }
-    MatDateRangeInputPartBase.decorators = [
-        { type: Directive }
-    ];
-    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,] }] }
-    ];
-    return MatDateRangeInputPartBase;
-})();
+    /** 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;
+    }
+}
+MatDateRangeInputPartBase.decorators = [
+    { type: Directive }
+];
+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,] }] }
+];
 const _MatDateRangeInputBase = 
 // Needs to be `as any`, because the base class is abstract.
 mixinErrorState(MatDateRangeInputPartBase);
 /** Input for entering the start date in a `mat-date-range-input`. */
-let MatStartDate = /** @class */ (() => {
-    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._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;
-        }
-        _assignValueToModel(value) {
-            if (this._model) {
-                const range = new DateRange(value, this._model.selection.end);
-                this._model.updateSelection(range, this);
-                this._cvaOnChange(value);
-            }
-        }
-        _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;
+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._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;
+    }
+    _assignValueToModel(value) {
+        if (this._model) {
+            const range = new DateRange(value, this._model.selection.end);
+            this._model.updateSelection(range, this);
+            this._cvaOnChange(value);
         }
     }
-    MatStartDate.decorators = [
-        { type: Directive, args: [{
-                    selector: 'input[matStartDate]',
-                    host: {
-                        'class': 'mat-date-range-input-inner',
-                        '[disabled]': 'disabled',
-                        '(input)': '_onInput($event.target.value)',
-                        '(change)': '_onChange()',
-                        '(keydown)': '_onKeydown($event)',
-                        '[attr.id]': '_rangeInput.id',
-                        '[attr.aria-labelledby]': '_rangeInput._ariaLabelledBy',
-                        '[attr.aria-describedby]': '_rangeInput._ariaDescribedBy',
-                        '[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 }
-                    ]
-                },] }
-    ];
-    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,] }] }
-    ];
-    return MatStartDate;
-})();
-export { MatStartDate };
+    _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.decorators = [
+    { type: Directive, args: [{
+                selector: 'input[matStartDate]',
+                host: {
+                    'class': '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 }
+                ]
+            },] }
+];
+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,] }] }
+];
 /** Input for entering the end date in a `mat-date-range-input`. */
-let MatEndDate = /** @class */ (() => {
-    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._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;
-        }
-        _assignValueToModel(value) {
-            if (this._model) {
-                const range = new DateRange(this._model.selection.start, value);
-                this._model.updateSelection(range, this);
-                this._cvaOnChange(value);
-            }
+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._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;
+    }
+    _assignValueToModel(value) {
+        if (this._model) {
+            const range = new DateRange(this._model.selection.start, value);
+            this._model.updateSelection(range, this);
+            this._cvaOnChange(value);
         }
-        _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);
+    }
+    _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.decorators = [
-        { type: Directive, args: [{
-                    selector: 'input[matEndDate]',
-                    host: {
-                        'class': 'mat-date-range-input-inner',
-                        '[disabled]': 'disabled',
-                        '(input)': '_onInput($event.target.value)',
-                        '(change)': '_onChange()',
-                        '(keydown)': '_onKeydown($event)',
-                        '[attr.aria-labelledby]': '_rangeInput._ariaLabelledBy',
-                        '[attr.aria-describedby]': '_rangeInput._ariaDescribedBy',
-                        '[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 }
-                    ]
-                },] }
-    ];
-    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,] }] }
-    ];
-    return MatEndDate;
-})();
-export { MatEndDate };
-//# 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  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  CanUpdateErrorStateCtor,\n  mixinErrorState,\n  MAT_DATE_FORMATS,\n  DateAdapter,\n  MatDateFormats,\n  ErrorStateMatcher,\n} from '@angular/material/core';\nimport {BooleanInput} from '@angular/cdk/coercion';\nimport {BACKSPACE} from '@angular/cdk/keycodes';\nimport {MatDatepickerInputBase, DateFilterFn} from './datepicker-input-base';\nimport {DateRange} 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  _ariaDescribedBy: string | null;\n  _ariaLabelledBy: string | null;\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 _validator: ValidatorFn | null;\n  protected abstract _assignValueToModel(value: D | null): void;\n  protected abstract _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    const ngControl = this._injector.get(NgControl, null, InjectFlags.Self);\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  _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 _outsideValueChanged = () => {\n    // Whenever the value changes outside the input we need to revalidate, because\n    // the validation state of each of the inputs depends on the other one.\n    this._validatorOnChange();\n  }\n\n  protected _parentDisabled() {\n    return this._rangeInput._groupDisabled;\n  }\n}\n\nconst _MatDateRangeInputBase:\n    CanUpdateErrorStateCtor & typeof MatDateRangeInputPartBase =\n    // Needs to be `as any`, because the base class is abstract.\n    mixinErrorState(MatDateRangeInputPartBase as any);\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-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-labelledby]': '_rangeInput._ariaLabelledBy',\n    '[attr.aria-describedby]': '_rangeInput._ariaDescribedBy',\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})\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._getValidDateOrNull(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  protected _validator = Validators.compose([...super._getValidators(), this._startValidator]);\n\n  protected _getValueFromModel(modelValue: DateRange<D>) {\n    return modelValue.start;\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      this._cvaOnChange(value);\n    }\n  }\n\n  protected _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  static ngAcceptInputType_disabled: BooleanInput;\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-date-range-input-inner',\n    '[disabled]': 'disabled',\n    '(input)': '_onInput($event.target.value)',\n    '(change)': '_onChange()',\n    '(keydown)': '_onKeydown($event)',\n    '[attr.aria-labelledby]': '_rangeInput._ariaLabelledBy',\n    '[attr.aria-describedby]': '_rangeInput._ariaDescribedBy',\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})\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._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  protected _validator = Validators.compose([...super._getValidators(), this._endValidator]);\n\n  protected _getValueFromModel(modelValue: DateRange<D>) {\n    return modelValue.end;\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      this._cvaOnChange(value);\n    }\n  }\n\n  _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  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}
+}
+MatEndDate.decorators = [
+    { type: Directive, args: [{
+                selector: 'input[matEndDate]',
+                host: {
+                    'class': '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 }
+                ]
+            },] }
+];
+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,] }] }
+];
+//# 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  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  CanUpdateErrorStateCtor,\n  mixinErrorState,\n  MAT_DATE_FORMATS,\n  DateAdapter,\n  MatDateFormats,\n  ErrorStateMatcher,\n} from '@angular/material/core';\nimport {BooleanInput} from '@angular/cdk/coercion';\nimport {BACKSPACE} from '@angular/cdk/keycodes';\nimport {MatDatepickerInputBase, DateFilterFn} from './datepicker-input-base';\nimport {DateRange} 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 _validator: ValidatorFn | null;\n  protected abstract _assignValueToModel(value: D | null): void;\n  protected abstract _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    const ngControl = this._injector.get(NgControl, null, InjectFlags.Self);\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  _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 _outsideValueChanged = () => {\n    // Whenever the value changes outside the input we need to revalidate, because\n    // the validation state of each of the inputs depends on the other one.\n    this._validatorOnChange();\n  }\n\n  protected _parentDisabled() {\n    return this._rangeInput._groupDisabled;\n  }\n}\n\nconst _MatDateRangeInputBase:\n    CanUpdateErrorStateCtor & typeof MatDateRangeInputPartBase =\n    // Needs to be `as any`, because the base class is abstract.\n    mixinErrorState(MatDateRangeInputPartBase as any);\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-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})\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._getValidDateOrNull(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  protected _validator = Validators.compose([...super._getValidators(), this._startValidator]);\n\n  protected _getValueFromModel(modelValue: DateRange<D>) {\n    return modelValue.start;\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      this._cvaOnChange(value);\n    }\n  }\n\n  protected _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  static ngAcceptInputType_disabled: BooleanInput;\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-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})\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._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  protected _validator = Validators.compose([...super._getValidators(), this._endValidator]);\n\n  protected _getValueFromModel(modelValue: DateRange<D>) {\n    return modelValue.end;\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      this._cvaOnChange(value);\n    }\n  }\n\n  _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  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}