{"version":3,"file":"default-node_modules_angular_material_fesm2020_input_mjs.6a1d3cb7aa164fd5.js","mappings":"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","names":["listenerOptions","normalizePassiveListenerOptions","passive","AutofillMonitor","constructor","_platform","_ngZone","this","_monitoredElements","Map","monitor","elementOrRef","isBrowser","EMPTY","element","coerceElement","info","get","subject","result","Subject","cssClass","listener","event","animationName","classList","contains","remove","run","next","target","isAutofilled","add","runOutsideAngular","addEventListener","set","unlisten","removeEventListener","stopMonitoring","complete","delete","ngOnDestroy","forEach","_info","ɵfac","i0","i1","ɵprov","factory","CdkTextareaAutosize","_elementRef","document","_destroyed","_enabled","_previousMinRows","_isViewInited","_handleFocusEvent","_hasFocus","type","_document","_textareaElement","nativeElement","minRows","_minRows","value","coerceNumberProperty","_setMinHeight","maxRows","_maxRows","_setMaxHeight","enabled","coerceBooleanProperty","resizeToFitContent","reset","placeholder","_cachedPlaceholderHeight","undefined","setAttribute","removeAttribute","_cacheTextareaPlaceholderHeight","minHeight","_cachedLineHeight","style","maxHeight","ngAfterViewInit","_initialHeight","height","window","_getWindow","fromEvent","pipe","auditTime","takeUntil","subscribe","_cacheTextareaLineHeight","textareaClone","cloneNode","rows","position","visibility","border","padding","overflow","parentNode","appendChild","clientHeight","_measureScrollHeight","previousMargin","marginBottom","isFirefox","FIREFOX","needsMarginFiller","measuringClass","scrollHeight","ngDoCheck","force","textarea","_previousValue","Math","max","requestAnimationFrame","_scrollToCaretPosition","setTimeout","_noopInputHandler","_getDocument","defaultView","selectionStart","selectionEnd","isStopped","setSelectionRange","DOCUMENT","ɵdir","selectors","ctx","TextFieldModule","ɵmod","ɵinj","MAT_INPUT_VALUE_ACCESSOR","InjectionToken","MAT_INPUT_INVALID_TYPES","nextUniqueId","_MatInputBase","mixinErrorState","_defaultErrorStateMatcher","_parentForm","_parentFormGroup","ngControl","stateChanges","MatInput","inputValueAccessor","_autofillMonitor","ngZone","_formField","super","_uid","focused","controlType","autofilled","_disabled","_type","_readonly","_neverEmptyInputTypes","filter","t","getSupportedInputTypes","has","_iOSKeyupListener","el","nodeName","toLowerCase","_inputValueAccessor","_previousNativeValue","id","IOS","_isServer","_isNativeSelect","_isTextarea","_isInFormField","multiple","disabled","_id","required","_required","control","hasValidator","Validators","_validateType","readonly","ngOnChanges","updateErrorState","_dirtyCheckNativeValue","_dirtyCheckPlaceholder","focus","options","_focusChanged","isFocused","_onInput","formField","appearance","_hasLabel","_previousPlaceholder","newValue","indexOf","_isNeverEmpty","_isBadInput","validity","badInput","empty","shouldLabelFloat","selectElement","firstOption","selectedIndex","label","setDescribedByIds","ids","length","join","onContainerClick","_isInlineSelect","size","i2","i3","i4","MAT_FORM_FIELD","provide","MatFormFieldControl","useExisting","MatInputModule","ErrorStateMatcher","imports","MatFormFieldModule","MatCommonModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/cdk/fesm2020/text-field.mjs","./node_modules/@angular/material/fesm2020/input.mjs"],"sourcesContent":["import * as i1 from '@angular/cdk/platform';\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform';\nimport * as i0 from '@angular/core';\nimport { Injectable, EventEmitter, Directive, Output, Optional, Inject, Input, NgModule } from '@angular/core';\nimport { coerceElement, coerceNumberProperty, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { EMPTY, Subject, fromEvent } from 'rxjs';\nimport { auditTime, takeUntil } from 'rxjs/operators';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Options to pass to the animationstart listener. */\nconst listenerOptions = normalizePassiveListenerOptions({ passive: true });\n/**\n * An injectable service that can be used to monitor the autofill state of an input.\n * Based on the following blog post:\n * https://medium.com/@brunn/detecting-autofilled-fields-in-javascript-aed598d25da7\n */\nclass AutofillMonitor {\n    constructor(_platform, _ngZone) {\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        this._monitoredElements = new Map();\n    }\n    monitor(elementOrRef) {\n        if (!this._platform.isBrowser) {\n            return EMPTY;\n        }\n        const element = coerceElement(elementOrRef);\n        const info = this._monitoredElements.get(element);\n        if (info) {\n            return info.subject;\n        }\n        const result = new Subject();\n        const cssClass = 'cdk-text-field-autofilled';\n        const listener = ((event) => {\n            // Animation events fire on initial element render, we check for the presence of the autofill\n            // CSS class to make sure this is a real change in state, not just the initial render before\n            // we fire off events.\n            if (event.animationName === 'cdk-text-field-autofill-start' &&\n                !element.classList.contains(cssClass)) {\n                element.classList.add(cssClass);\n                this._ngZone.run(() => result.next({ target: event.target, isAutofilled: true }));\n            }\n            else if (event.animationName === 'cdk-text-field-autofill-end' &&\n                element.classList.contains(cssClass)) {\n                element.classList.remove(cssClass);\n                this._ngZone.run(() => result.next({ target: event.target, isAutofilled: false }));\n            }\n        });\n        this._ngZone.runOutsideAngular(() => {\n            element.addEventListener('animationstart', listener, listenerOptions);\n            element.classList.add('cdk-text-field-autofill-monitored');\n        });\n        this._monitoredElements.set(element, {\n            subject: result,\n            unlisten: () => {\n                element.removeEventListener('animationstart', listener, listenerOptions);\n            },\n        });\n        return result;\n    }\n    stopMonitoring(elementOrRef) {\n        const element = coerceElement(elementOrRef);\n        const info = this._monitoredElements.get(element);\n        if (info) {\n            info.unlisten();\n            info.subject.complete();\n            element.classList.remove('cdk-text-field-autofill-monitored');\n            element.classList.remove('cdk-text-field-autofilled');\n            this._monitoredElements.delete(element);\n        }\n    }\n    ngOnDestroy() {\n        this._monitoredElements.forEach((_info, element) => this.stopMonitoring(element));\n    }\n}\nAutofillMonitor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: AutofillMonitor, deps: [{ token: i1.Platform }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });\nAutofillMonitor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: AutofillMonitor, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: AutofillMonitor, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i0.NgZone }]; } });\n/** A directive that can be used to monitor the autofill state of an input. */\nclass CdkAutofill {\n    constructor(_elementRef, _autofillMonitor) {\n        this._elementRef = _elementRef;\n        this._autofillMonitor = _autofillMonitor;\n        /** Emits when the autofill state of the element changes. */\n        this.cdkAutofill = new EventEmitter();\n    }\n    ngOnInit() {\n        this._autofillMonitor\n            .monitor(this._elementRef)\n            .subscribe(event => this.cdkAutofill.emit(event));\n    }\n    ngOnDestroy() {\n        this._autofillMonitor.stopMonitoring(this._elementRef);\n    }\n}\nCdkAutofill.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: CdkAutofill, deps: [{ token: i0.ElementRef }, { token: AutofillMonitor }], target: i0.ɵɵFactoryTarget.Directive });\nCdkAutofill.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", type: CdkAutofill, selector: \"[cdkAutofill]\", outputs: { cdkAutofill: \"cdkAutofill\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: CdkAutofill, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: '[cdkAutofill]',\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: AutofillMonitor }]; }, propDecorators: { cdkAutofill: [{\n                type: Output\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** Directive to automatically resize a textarea to fit its content. */\nclass CdkTextareaAutosize {\n    constructor(_elementRef, _platform, _ngZone, \n    /** @breaking-change 11.0.0 make document required */\n    document) {\n        this._elementRef = _elementRef;\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        this._destroyed = new Subject();\n        this._enabled = true;\n        /**\n         * Value of minRows as of last resize. If the minRows has decreased, the\n         * height of the textarea needs to be recomputed to reflect the new minimum. The maxHeight\n         * does not have the same problem because it does not affect the textarea's scrollHeight.\n         */\n        this._previousMinRows = -1;\n        this._isViewInited = false;\n        /** Handles `focus` and `blur` events. */\n        this._handleFocusEvent = (event) => {\n            this._hasFocus = event.type === 'focus';\n        };\n        this._document = document;\n        this._textareaElement = this._elementRef.nativeElement;\n    }\n    /** Minimum amount of rows in the textarea. */\n    get minRows() {\n        return this._minRows;\n    }\n    set minRows(value) {\n        this._minRows = coerceNumberProperty(value);\n        this._setMinHeight();\n    }\n    /** Maximum amount of rows in the textarea. */\n    get maxRows() {\n        return this._maxRows;\n    }\n    set maxRows(value) {\n        this._maxRows = coerceNumberProperty(value);\n        this._setMaxHeight();\n    }\n    /** Whether autosizing is enabled or not */\n    get enabled() {\n        return this._enabled;\n    }\n    set enabled(value) {\n        value = coerceBooleanProperty(value);\n        // Only act if the actual value changed. This specifically helps to not run\n        // resizeToFitContent too early (i.e. before ngAfterViewInit)\n        if (this._enabled !== value) {\n            (this._enabled = value) ? this.resizeToFitContent(true) : this.reset();\n        }\n    }\n    get placeholder() {\n        return this._textareaElement.placeholder;\n    }\n    set placeholder(value) {\n        this._cachedPlaceholderHeight = undefined;\n        if (value) {\n            this._textareaElement.setAttribute('placeholder', value);\n        }\n        else {\n            this._textareaElement.removeAttribute('placeholder');\n        }\n        this._cacheTextareaPlaceholderHeight();\n    }\n    /** Sets the minimum height of the textarea as determined by minRows. */\n    _setMinHeight() {\n        const minHeight = this.minRows && this._cachedLineHeight ? `${this.minRows * this._cachedLineHeight}px` : null;\n        if (minHeight) {\n            this._textareaElement.style.minHeight = minHeight;\n        }\n    }\n    /** Sets the maximum height of the textarea as determined by maxRows. */\n    _setMaxHeight() {\n        const maxHeight = this.maxRows && this._cachedLineHeight ? `${this.maxRows * this._cachedLineHeight}px` : null;\n        if (maxHeight) {\n            this._textareaElement.style.maxHeight = maxHeight;\n        }\n    }\n    ngAfterViewInit() {\n        if (this._platform.isBrowser) {\n            // Remember the height which we started with in case autosizing is disabled\n            this._initialHeight = this._textareaElement.style.height;\n            this.resizeToFitContent();\n            this._ngZone.runOutsideAngular(() => {\n                const window = this._getWindow();\n                fromEvent(window, 'resize')\n                    .pipe(auditTime(16), takeUntil(this._destroyed))\n                    .subscribe(() => this.resizeToFitContent(true));\n                this._textareaElement.addEventListener('focus', this._handleFocusEvent);\n                this._textareaElement.addEventListener('blur', this._handleFocusEvent);\n            });\n            this._isViewInited = true;\n            this.resizeToFitContent(true);\n        }\n    }\n    ngOnDestroy() {\n        this._textareaElement.removeEventListener('focus', this._handleFocusEvent);\n        this._textareaElement.removeEventListener('blur', this._handleFocusEvent);\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /**\n     * Cache the height of a single-row textarea if it has not already been cached.\n     *\n     * We need to know how large a single \"row\" of a textarea is in order to apply minRows and\n     * maxRows. For the initial version, we will assume that the height of a single line in the\n     * textarea does not ever change.\n     */\n    _cacheTextareaLineHeight() {\n        if (this._cachedLineHeight) {\n            return;\n        }\n        // Use a clone element because we have to override some styles.\n        let textareaClone = this._textareaElement.cloneNode(false);\n        textareaClone.rows = 1;\n        // Use `position: absolute` so that this doesn't cause a browser layout and use\n        // `visibility: hidden` so that nothing is rendered. Clear any other styles that\n        // would affect the height.\n        textareaClone.style.position = 'absolute';\n        textareaClone.style.visibility = 'hidden';\n        textareaClone.style.border = 'none';\n        textareaClone.style.padding = '0';\n        textareaClone.style.height = '';\n        textareaClone.style.minHeight = '';\n        textareaClone.style.maxHeight = '';\n        // In Firefox it happens that textarea elements are always bigger than the specified amount\n        // of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.\n        // As a workaround that removes the extra space for the scrollbar, we can just set overflow\n        // to hidden. This ensures that there is no invalid calculation of the line height.\n        // See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654\n        textareaClone.style.overflow = 'hidden';\n        this._textareaElement.parentNode.appendChild(textareaClone);\n        this._cachedLineHeight = textareaClone.clientHeight;\n        textareaClone.remove();\n        // Min and max heights have to be re-calculated if the cached line height changes\n        this._setMinHeight();\n        this._setMaxHeight();\n    }\n    _measureScrollHeight() {\n        const element = this._textareaElement;\n        const previousMargin = element.style.marginBottom || '';\n        const isFirefox = this._platform.FIREFOX;\n        const needsMarginFiller = isFirefox && this._hasFocus;\n        const measuringClass = isFirefox\n            ? 'cdk-textarea-autosize-measuring-firefox'\n            : 'cdk-textarea-autosize-measuring';\n        // In some cases the page might move around while we're measuring the `textarea` on Firefox. We\n        // work around it by assigning a temporary margin with the same height as the `textarea` so that\n        // it occupies the same amount of space. See #23233.\n        if (needsMarginFiller) {\n            element.style.marginBottom = `${element.clientHeight}px`;\n        }\n        // Reset the textarea height to auto in order to shrink back to its default size.\n        // Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.\n        element.classList.add(measuringClass);\n        // The measuring class includes a 2px padding to workaround an issue with Chrome,\n        // so we account for that extra space here by subtracting 4 (2px top + 2px bottom).\n        const scrollHeight = element.scrollHeight - 4;\n        element.classList.remove(measuringClass);\n        if (needsMarginFiller) {\n            element.style.marginBottom = previousMargin;\n        }\n        return scrollHeight;\n    }\n    _cacheTextareaPlaceholderHeight() {\n        if (!this._isViewInited || this._cachedPlaceholderHeight != undefined) {\n            return;\n        }\n        if (!this.placeholder) {\n            this._cachedPlaceholderHeight = 0;\n            return;\n        }\n        const value = this._textareaElement.value;\n        this._textareaElement.value = this._textareaElement.placeholder;\n        this._cachedPlaceholderHeight = this._measureScrollHeight();\n        this._textareaElement.value = value;\n    }\n    ngDoCheck() {\n        if (this._platform.isBrowser) {\n            this.resizeToFitContent();\n        }\n    }\n    /**\n     * Resize the textarea to fit its content.\n     * @param force Whether to force a height recalculation. By default the height will be\n     *    recalculated only if the value changed since the last call.\n     */\n    resizeToFitContent(force = false) {\n        // If autosizing is disabled, just skip everything else\n        if (!this._enabled) {\n            return;\n        }\n        this._cacheTextareaLineHeight();\n        this._cacheTextareaPlaceholderHeight();\n        // If we haven't determined the line-height yet, we know we're still hidden and there's no point\n        // in checking the height of the textarea.\n        if (!this._cachedLineHeight) {\n            return;\n        }\n        const textarea = this._elementRef.nativeElement;\n        const value = textarea.value;\n        // Only resize if the value or minRows have changed since these calculations can be expensive.\n        if (!force && this._minRows === this._previousMinRows && value === this._previousValue) {\n            return;\n        }\n        const scrollHeight = this._measureScrollHeight();\n        const height = Math.max(scrollHeight, this._cachedPlaceholderHeight || 0);\n        // Use the scrollHeight to know how large the textarea *would* be if fit its entire value.\n        textarea.style.height = `${height}px`;\n        this._ngZone.runOutsideAngular(() => {\n            if (typeof requestAnimationFrame !== 'undefined') {\n                requestAnimationFrame(() => this._scrollToCaretPosition(textarea));\n            }\n            else {\n                setTimeout(() => this._scrollToCaretPosition(textarea));\n            }\n        });\n        this._previousValue = value;\n        this._previousMinRows = this._minRows;\n    }\n    /**\n     * Resets the textarea to its original size\n     */\n    reset() {\n        // Do not try to change the textarea, if the initialHeight has not been determined yet\n        // This might potentially remove styles when reset() is called before ngAfterViewInit\n        if (this._initialHeight !== undefined) {\n            this._textareaElement.style.height = this._initialHeight;\n        }\n    }\n    _noopInputHandler() {\n        // no-op handler that ensures we're running change detection on input events.\n    }\n    /** Access injected document if available or fallback to global document reference */\n    _getDocument() {\n        return this._document || document;\n    }\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    _getWindow() {\n        const doc = this._getDocument();\n        return doc.defaultView || window;\n    }\n    /**\n     * Scrolls a textarea to the caret position. On Firefox resizing the textarea will\n     * prevent it from scrolling to the caret position. We need to re-set the selection\n     * in order for it to scroll to the proper position.\n     */\n    _scrollToCaretPosition(textarea) {\n        const { selectionStart, selectionEnd } = textarea;\n        // IE will throw an \"Unspecified error\" if we try to set the selection range after the\n        // element has been removed from the DOM. Assert that the directive hasn't been destroyed\n        // between the time we requested the animation frame and when it was executed.\n        // Also note that we have to assert that the textarea is focused before we set the\n        // selection range. Setting the selection range on a non-focused textarea will cause\n        // it to receive focus on IE and Edge.\n        if (!this._destroyed.isStopped && this._hasFocus) {\n            textarea.setSelectionRange(selectionStart, selectionEnd);\n        }\n    }\n}\nCdkTextareaAutosize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: CdkTextareaAutosize, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: i0.NgZone }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nCdkTextareaAutosize.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", type: CdkTextareaAutosize, selector: \"textarea[cdkTextareaAutosize]\", inputs: { minRows: [\"cdkAutosizeMinRows\", \"minRows\"], maxRows: [\"cdkAutosizeMaxRows\", \"maxRows\"], enabled: [\"cdkTextareaAutosize\", \"enabled\"], placeholder: \"placeholder\" }, host: { attributes: { \"rows\": \"1\" }, listeners: { \"input\": \"_noopInputHandler()\" }, classAttribute: \"cdk-textarea-autosize\" }, exportAs: [\"cdkTextareaAutosize\"], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: CdkTextareaAutosize, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'textarea[cdkTextareaAutosize]',\n                    exportAs: 'cdkTextareaAutosize',\n                    host: {\n                        'class': 'cdk-textarea-autosize',\n                        // Textarea elements that have the directive applied should have a single row by default.\n                        // Browsers normally show two rows by default and therefore this limits the minRows binding.\n                        'rows': '1',\n                        '(input)': '_noopInputHandler()',\n                    },\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }]; }, propDecorators: { minRows: [{\n                type: Input,\n                args: ['cdkAutosizeMinRows']\n            }], maxRows: [{\n                type: Input,\n                args: ['cdkAutosizeMaxRows']\n            }], enabled: [{\n                type: Input,\n                args: ['cdkTextareaAutosize']\n            }], placeholder: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass TextFieldModule {\n}\nTextFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: TextFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nTextFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: TextFieldModule, declarations: [CdkAutofill, CdkTextareaAutosize], exports: [CdkAutofill, CdkTextareaAutosize] });\nTextFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: TextFieldModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: TextFieldModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: [CdkAutofill, CdkTextareaAutosize],\n                    exports: [CdkAutofill, CdkTextareaAutosize],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AutofillMonitor, CdkAutofill, CdkTextareaAutosize, TextFieldModule };\n","import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport * as i1 from '@angular/cdk/platform';\nimport { getSupportedInputTypes } from '@angular/cdk/platform';\nimport * as i4 from '@angular/cdk/text-field';\nimport { TextFieldModule } from '@angular/cdk/text-field';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Directive, Optional, Self, Inject, Input, NgModule } from '@angular/core';\nimport * as i2 from '@angular/forms';\nimport { Validators } from '@angular/forms';\nimport * as i3 from '@angular/material/core';\nimport { mixinErrorState, MatCommonModule, ErrorStateMatcher } from '@angular/material/core';\nimport * as i5 from '@angular/material/form-field';\nimport { MAT_FORM_FIELD, MatFormFieldControl, MatFormFieldModule } from '@angular/material/form-field';\nimport { Subject } from 'rxjs';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @docs-private */\nfunction getMatInputUnsupportedTypeError(type) {\n    return Error(`Input type \"${type}\" isn't supported by matInput.`);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This token is used to inject the object whose value should be set into `MatInput`. If none is\n * provided, the native `HTMLInputElement` is used. Directives like `MatDatepickerInput` can provide\n * themselves for this token, in order to make `MatInput` delegate the getting and setting of the\n * value to them.\n */\nconst MAT_INPUT_VALUE_ACCESSOR = new InjectionToken('MAT_INPUT_VALUE_ACCESSOR');\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Invalid input type. Using one of these will throw an MatInputUnsupportedTypeError.\nconst MAT_INPUT_INVALID_TYPES = [\n    'button',\n    'checkbox',\n    'file',\n    'hidden',\n    'image',\n    'radio',\n    'range',\n    'reset',\n    'submit',\n];\nlet nextUniqueId = 0;\n// Boilerplate for applying mixins to MatInput.\n/** @docs-private */\nconst _MatInputBase = mixinErrorState(class {\n    constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, \n    /**\n     * Form control bound to the component.\n     * Implemented as part of `MatFormFieldControl`.\n     * @docs-private\n     */\n    ngControl) {\n        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;\n        this._parentForm = _parentForm;\n        this._parentFormGroup = _parentFormGroup;\n        this.ngControl = ngControl;\n        /**\n         * Emits whenever the component state changes and should cause the parent\n         * form field to update. Implemented as part of `MatFormFieldControl`.\n         * @docs-private\n         */\n        this.stateChanges = new Subject();\n    }\n});\n/** Directive that allows a native input to work inside a `MatFormField`. */\nclass MatInput extends _MatInputBase {\n    constructor(_elementRef, _platform, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher, inputValueAccessor, _autofillMonitor, ngZone, \n    // TODO: Remove this once the legacy appearance has been removed. We only need\n    // to inject the form field for determining whether the placeholder has been promoted.\n    _formField) {\n        super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n        this._elementRef = _elementRef;\n        this._platform = _platform;\n        this._autofillMonitor = _autofillMonitor;\n        this._formField = _formField;\n        this._uid = `mat-input-${nextUniqueId++}`;\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * @docs-private\n         */\n        this.focused = false;\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * @docs-private\n         */\n        this.stateChanges = new Subject();\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * @docs-private\n         */\n        this.controlType = 'mat-input';\n        /**\n         * Implemented as part of MatFormFieldControl.\n         * @docs-private\n         */\n        this.autofilled = false;\n        this._disabled = false;\n        this._type = 'text';\n        this._readonly = false;\n        this._neverEmptyInputTypes = [\n            'date',\n            'datetime',\n            'datetime-local',\n            'month',\n            'time',\n            'week',\n        ].filter(t => getSupportedInputTypes().has(t));\n        this._iOSKeyupListener = (event) => {\n            const el = event.target;\n            // Note: We specifically check for 0, rather than `!el.selectionStart`, because the two\n            // indicate different things. If the value is 0, it means that the caret is at the start\n            // of the input, whereas a value of `null` means that the input doesn't support\n            // manipulating the selection range. Inputs that don't support setting the selection range\n            // will throw an error so we want to avoid calling `setSelectionRange` on them. See:\n            // https://html.spec.whatwg.org/multipage/input.html#do-not-apply\n            if (!el.value && el.selectionStart === 0 && el.selectionEnd === 0) {\n                // Note: Just setting `0, 0` doesn't fix the issue. Setting\n                // `1, 1` fixes it for the first time that you type text and\n                // then hold delete. Toggling to `1, 1` and then back to\n                // `0, 0` seems to completely fix it.\n                el.setSelectionRange(1, 1);\n                el.setSelectionRange(0, 0);\n            }\n        };\n        const element = this._elementRef.nativeElement;\n        const nodeName = element.nodeName.toLowerCase();\n        // If no input value accessor was explicitly specified, use the element as the input value\n        // accessor.\n        this._inputValueAccessor = inputValueAccessor || element;\n        this._previousNativeValue = this.value;\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n        // On some versions of iOS the caret gets stuck in the wrong place when holding down the delete\n        // key. In order to get around this we need to \"jiggle\" the caret loose. Since this bug only\n        // exists on iOS, we only bother to install the listener on iOS.\n        if (_platform.IOS) {\n            ngZone.runOutsideAngular(() => {\n                _elementRef.nativeElement.addEventListener('keyup', this._iOSKeyupListener);\n            });\n        }\n        this._isServer = !this._platform.isBrowser;\n        this._isNativeSelect = nodeName === 'select';\n        this._isTextarea = nodeName === 'textarea';\n        this._isInFormField = !!_formField;\n        if (this._isNativeSelect) {\n            this.controlType = element.multiple\n                ? 'mat-native-select-multiple'\n                : 'mat-native-select';\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get disabled() {\n        if (this.ngControl && this.ngControl.disabled !== null) {\n            return this.ngControl.disabled;\n        }\n        return this._disabled;\n    }\n    set disabled(value) {\n        this._disabled = coerceBooleanProperty(value);\n        // Browsers may not fire the blur event if the input is disabled too quickly.\n        // Reset from here to ensure that the element doesn't become stuck.\n        if (this.focused) {\n            this.focused = false;\n            this.stateChanges.next();\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get id() {\n        return this._id;\n    }\n    set id(value) {\n        this._id = value || this._uid;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get required() {\n        return this._required ?? this.ngControl?.control?.hasValidator(Validators.required) ?? false;\n    }\n    set required(value) {\n        this._required = coerceBooleanProperty(value);\n    }\n    /** Input type of the element. */\n    get type() {\n        return this._type;\n    }\n    set type(value) {\n        this._type = value || 'text';\n        this._validateType();\n        // When using Angular inputs, developers are no longer able to set the properties on the native\n        // input element. To ensure that bindings for `type` work, we need to sync the setter\n        // with the native property. Textarea elements don't support the type property or attribute.\n        if (!this._isTextarea && getSupportedInputTypes().has(this._type)) {\n            this._elementRef.nativeElement.type = this._type;\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get value() {\n        return this._inputValueAccessor.value;\n    }\n    set value(value) {\n        if (value !== this.value) {\n            this._inputValueAccessor.value = value;\n            this.stateChanges.next();\n        }\n    }\n    /** Whether the element is readonly. */\n    get readonly() {\n        return this._readonly;\n    }\n    set readonly(value) {\n        this._readonly = coerceBooleanProperty(value);\n    }\n    ngAfterViewInit() {\n        if (this._platform.isBrowser) {\n            this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(event => {\n                this.autofilled = event.isAutofilled;\n                this.stateChanges.next();\n            });\n        }\n    }\n    ngOnChanges() {\n        this.stateChanges.next();\n    }\n    ngOnDestroy() {\n        this.stateChanges.complete();\n        if (this._platform.isBrowser) {\n            this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement);\n        }\n        if (this._platform.IOS) {\n            this._elementRef.nativeElement.removeEventListener('keyup', this._iOSKeyupListener);\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        // We need to dirty-check the native element's value, because there are some cases where\n        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're\n        // updating the value using `emitEvent: false`).\n        this._dirtyCheckNativeValue();\n        // We need to dirty-check and set the placeholder attribute ourselves, because whether it's\n        // present or not depends on a query which is prone to \"changed after checked\" errors.\n        this._dirtyCheckPlaceholder();\n    }\n    /** Focuses the input. */\n    focus(options) {\n        this._elementRef.nativeElement.focus(options);\n    }\n    /** Callback for the cases where the focused state of the input changes. */\n    _focusChanged(isFocused) {\n        if (isFocused !== this.focused) {\n            this.focused = isFocused;\n            this.stateChanges.next();\n        }\n    }\n    _onInput() {\n        // This is a noop function and is used to let Angular know whenever the value changes.\n        // Angular will run a new change detection each time the `input` event has been dispatched.\n        // It's necessary that Angular recognizes the value change, because when floatingLabel\n        // is set to false and Angular forms aren't used, the placeholder won't recognize the\n        // value changes and will not disappear.\n        // Listening to the input event wouldn't be necessary when the input is using the\n        // FormsModule or ReactiveFormsModule, because Angular forms also listens to input events.\n    }\n    /** Does some manual dirty checking on the native input `placeholder` attribute. */\n    _dirtyCheckPlaceholder() {\n        // If we're hiding the native placeholder, it should also be cleared from the DOM, otherwise\n        // screen readers will read it out twice: once from the label and once from the attribute.\n        // TODO: can be removed once we get rid of the `legacy` style for the form field, because it's\n        // the only one that supports promoting the placeholder to a label.\n        const formField = this._formField;\n        const placeholder = formField && formField.appearance === 'legacy' && !formField._hasLabel?.()\n            ? null\n            : this.placeholder;\n        if (placeholder !== this._previousPlaceholder) {\n            const element = this._elementRef.nativeElement;\n            this._previousPlaceholder = placeholder;\n            placeholder\n                ? element.setAttribute('placeholder', placeholder)\n                : element.removeAttribute('placeholder');\n        }\n    }\n    /** Does some manual dirty checking on the native input `value` property. */\n    _dirtyCheckNativeValue() {\n        const newValue = this._elementRef.nativeElement.value;\n        if (this._previousNativeValue !== newValue) {\n            this._previousNativeValue = newValue;\n            this.stateChanges.next();\n        }\n    }\n    /** Make sure the input is a supported type. */\n    _validateType() {\n        if (MAT_INPUT_INVALID_TYPES.indexOf(this._type) > -1 &&\n            (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMatInputUnsupportedTypeError(this._type);\n        }\n    }\n    /** Checks whether the input type is one of the types that are never empty. */\n    _isNeverEmpty() {\n        return this._neverEmptyInputTypes.indexOf(this._type) > -1;\n    }\n    /** Checks whether the input is invalid based on the native validation. */\n    _isBadInput() {\n        // The `validity` property won't be present on platform-server.\n        let validity = this._elementRef.nativeElement.validity;\n        return validity && validity.badInput;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get empty() {\n        return (!this._isNeverEmpty() &&\n            !this._elementRef.nativeElement.value &&\n            !this._isBadInput() &&\n            !this.autofilled);\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get shouldLabelFloat() {\n        if (this._isNativeSelect) {\n            // For a single-selection `<select>`, the label should float when the selected option has\n            // a non-empty display value. For a `<select multiple>`, the label *always* floats to avoid\n            // overlapping the label with the options.\n            const selectElement = this._elementRef.nativeElement;\n            const firstOption = selectElement.options[0];\n            // On most browsers the `selectedIndex` will always be 0, however on IE and Edge it'll be\n            // -1 if the `value` is set to something, that isn't in the list of options, at a later point.\n            return (this.focused ||\n                selectElement.multiple ||\n                !this.empty ||\n                !!(selectElement.selectedIndex > -1 && firstOption && firstOption.label));\n        }\n        else {\n            return this.focused || !this.empty;\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    setDescribedByIds(ids) {\n        if (ids.length) {\n            this._elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));\n        }\n        else {\n            this._elementRef.nativeElement.removeAttribute('aria-describedby');\n        }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick() {\n        // Do not re-focus the input element if the element is already focused. Otherwise it can happen\n        // that someone clicks on a time input and the cursor resets to the \"hours\" field while the\n        // \"minutes\" field was actually clicked. See: https://github.com/angular/components/issues/12849\n        if (!this.focused) {\n            this.focus();\n        }\n    }\n    /** Whether the form control is a native select that is displayed inline. */\n    _isInlineSelect() {\n        const element = this._elementRef.nativeElement;\n        return this._isNativeSelect && (element.multiple || element.size > 1);\n    }\n}\nMatInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatInput, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: i2.NgControl, optional: true, self: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i3.ErrorStateMatcher }, { token: MAT_INPUT_VALUE_ACCESSOR, optional: true, self: true }, { token: i4.AutofillMonitor }, { token: i0.NgZone }, { token: MAT_FORM_FIELD, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nMatInput.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", type: MatInput, selector: \"input[matInput], textarea[matInput], select[matNativeControl],\\n      input[matNativeControl], textarea[matNativeControl]\", inputs: { disabled: \"disabled\", id: \"id\", placeholder: \"placeholder\", name: \"name\", required: \"required\", type: \"type\", errorStateMatcher: \"errorStateMatcher\", userAriaDescribedBy: [\"aria-describedby\", \"userAriaDescribedBy\"], value: \"value\", readonly: \"readonly\" }, host: { listeners: { \"focus\": \"_focusChanged(true)\", \"blur\": \"_focusChanged(false)\", \"input\": \"_onInput()\" }, properties: { \"class.mat-input-server\": \"_isServer\", \"attr.id\": \"id\", \"attr.data-placeholder\": \"placeholder\", \"disabled\": \"disabled\", \"required\": \"required\", \"attr.name\": \"name || null\", \"attr.readonly\": \"readonly && !_isNativeSelect || null\", \"class.mat-native-select-inline\": \"_isInlineSelect()\", \"attr.aria-invalid\": \"(empty && required) ? null : errorState\", \"attr.aria-required\": \"required\" }, classAttribute: \"mat-input-element mat-form-field-autofill-control\" }, providers: [{ provide: MatFormFieldControl, useExisting: MatInput }], exportAs: [\"matInput\"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatInput, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: `input[matInput], textarea[matInput], select[matNativeControl],\n      input[matNativeControl], textarea[matNativeControl]`,\n                    exportAs: 'matInput',\n                    host: {\n                        /**\n                         * @breaking-change 8.0.0 remove .mat-form-field-autofill-control in favor of AutofillMonitor.\n                         */\n                        'class': 'mat-input-element mat-form-field-autofill-control',\n                        '[class.mat-input-server]': '_isServer',\n                        // Native input properties that are overwritten by Angular inputs need to be synced with\n                        // the native input element. Otherwise property bindings for those don't work.\n                        '[attr.id]': 'id',\n                        // At the time of writing, we have a lot of customer tests that look up the input based on its\n                        // placeholder. Since we sometimes omit the placeholder attribute from the DOM to prevent screen\n                        // readers from reading it twice, we have to keep it somewhere in the DOM for the lookup.\n                        '[attr.data-placeholder]': 'placeholder',\n                        '[disabled]': 'disabled',\n                        '[required]': 'required',\n                        '[attr.name]': 'name || null',\n                        '[attr.readonly]': 'readonly && !_isNativeSelect || null',\n                        '[class.mat-native-select-inline]': '_isInlineSelect()',\n                        // Only mark the input as invalid for assistive technology if it has a value since the\n                        // state usually overlaps with `aria-required` when the input is empty and can be redundant.\n                        '[attr.aria-invalid]': '(empty && required) ? null : errorState',\n                        '[attr.aria-required]': 'required',\n                        '(focus)': '_focusChanged(true)',\n                        '(blur)': '_focusChanged(false)',\n                        '(input)': '_onInput()',\n                    },\n                    providers: [{ provide: MatFormFieldControl, useExisting: MatInput }],\n                }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i2.NgControl, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }] }, { type: i2.NgForm, decorators: [{\n                    type: Optional\n                }] }, { type: i2.FormGroupDirective, decorators: [{\n                    type: Optional\n                }] }, { type: i3.ErrorStateMatcher }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Self\n                }, {\n                    type: Inject,\n                    args: [MAT_INPUT_VALUE_ACCESSOR]\n                }] }, { type: i4.AutofillMonitor }, { type: i0.NgZone }, { type: i5.MatFormField, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_FORM_FIELD]\n                }] }]; }, propDecorators: { disabled: [{\n                type: Input\n            }], id: [{\n                type: Input\n            }], placeholder: [{\n                type: Input\n            }], name: [{\n                type: Input\n            }], required: [{\n                type: Input\n            }], type: [{\n                type: Input\n            }], errorStateMatcher: [{\n                type: Input\n            }], userAriaDescribedBy: [{\n                type: Input,\n                args: ['aria-describedby']\n            }], value: [{\n                type: Input\n            }], readonly: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatInputModule {\n}\nMatInputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatInputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatInputModule, declarations: [MatInput], imports: [TextFieldModule, MatFormFieldModule, MatCommonModule], exports: [TextFieldModule,\n        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n        // be used together with `MatFormField`.\n        MatFormFieldModule,\n        MatInput] });\nMatInputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatInputModule, providers: [ErrorStateMatcher], imports: [TextFieldModule, MatFormFieldModule, MatCommonModule, TextFieldModule,\n        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n        // be used together with `MatFormField`.\n        MatFormFieldModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0-rc.0\", ngImport: i0, type: MatInputModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    declarations: [MatInput],\n                    imports: [TextFieldModule, MatFormFieldModule, MatCommonModule],\n                    exports: [\n                        TextFieldModule,\n                        // We re-export the `MatFormFieldModule` since `MatInput` will almost always\n                        // be used together with `MatFormField`.\n                        MatFormFieldModule,\n                        MatInput,\n                    ],\n                    providers: [ErrorStateMatcher],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_INPUT_VALUE_ACCESSOR, MatInput, MatInputModule, getMatInputUnsupportedTypeError };\n"],"x_google_ignoreList":[0,1]}