{"version":3,"sources":["node_modules/@angular/cdk/fesm2022/text-field.mjs","node_modules/@angular/material/fesm2022/input.mjs"],"sourcesContent":["import { normalizePassiveListenerOptions, Platform } from '@angular/cdk/platform';\nimport * as i0 from '@angular/core';\nimport { Component, ChangeDetectionStrategy, ViewEncapsulation, inject, NgZone, Injectable, ElementRef, EventEmitter, Directive, Output, Renderer2, booleanAttribute, Input, NgModule } from '@angular/core';\nimport { _CdkPrivateStyleLoader } from '@angular/cdk/private';\nimport { coerceElement, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { EMPTY, Subject } from 'rxjs';\nimport { DOCUMENT } from '@angular/common';\nimport { auditTime } from 'rxjs/operators';\n\n/** Component used to load the structural styles of the text field. */\nlet _CdkTextFieldStyleLoader = /*#__PURE__*/(() => {\n  class _CdkTextFieldStyleLoader {\n    static ɵfac = function _CdkTextFieldStyleLoader_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || _CdkTextFieldStyleLoader)();\n    };\n    static ɵcmp = /* @__PURE__ */i0.ɵɵdefineComponent({\n      type: _CdkTextFieldStyleLoader,\n      selectors: [[\"ng-component\"]],\n      hostAttrs: [\"cdk-text-field-style-loader\", \"\"],\n      decls: 0,\n      vars: 0,\n      template: function _CdkTextFieldStyleLoader_Template(rf, ctx) {},\n      styles: [\"textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}\"],\n      encapsulation: 2,\n      changeDetection: 0\n    });\n  }\n  return _CdkTextFieldStyleLoader;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/** Options to pass to the animationstart listener. */\nconst listenerOptions = /*#__PURE__*/normalizePassiveListenerOptions({\n  passive: true\n});\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 */\nlet AutofillMonitor = /*#__PURE__*/(() => {\n  class AutofillMonitor {\n    _platform = inject(Platform);\n    _ngZone = inject(NgZone);\n    _styleLoader = inject(_CdkPrivateStyleLoader);\n    _monitoredElements = new Map();\n    constructor() {}\n    monitor(elementOrRef) {\n      if (!this._platform.isBrowser) {\n        return EMPTY;\n      }\n      this._styleLoader.load(_CdkTextFieldStyleLoader);\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' && !element.classList.contains(cssClass)) {\n          element.classList.add(cssClass);\n          this._ngZone.run(() => result.next({\n            target: event.target,\n            isAutofilled: true\n          }));\n        } else if (event.animationName === 'cdk-text-field-autofill-end' && element.classList.contains(cssClass)) {\n          element.classList.remove(cssClass);\n          this._ngZone.run(() => result.next({\n            target: event.target,\n            isAutofilled: false\n          }));\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    static ɵfac = function AutofillMonitor_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || AutofillMonitor)();\n    };\n    static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n      token: AutofillMonitor,\n      factory: AutofillMonitor.ɵfac,\n      providedIn: 'root'\n    });\n  }\n  return AutofillMonitor;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/** A directive that can be used to monitor the autofill state of an input. */\nlet CdkAutofill = /*#__PURE__*/(() => {\n  class CdkAutofill {\n    _elementRef = inject(ElementRef);\n    _autofillMonitor = inject(AutofillMonitor);\n    /** Emits when the autofill state of the element changes. */\n    cdkAutofill = new EventEmitter();\n    constructor() {}\n    ngOnInit() {\n      this._autofillMonitor.monitor(this._elementRef).subscribe(event => this.cdkAutofill.emit(event));\n    }\n    ngOnDestroy() {\n      this._autofillMonitor.stopMonitoring(this._elementRef);\n    }\n    static ɵfac = function CdkAutofill_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || CdkAutofill)();\n    };\n    static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n      type: CdkAutofill,\n      selectors: [[\"\", \"cdkAutofill\", \"\"]],\n      outputs: {\n        cdkAutofill: \"cdkAutofill\"\n      }\n    });\n  }\n  return CdkAutofill;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/** Directive to automatically resize a textarea to fit its content. */\nlet CdkTextareaAutosize = /*#__PURE__*/(() => {\n  class CdkTextareaAutosize {\n    _elementRef = inject(ElementRef);\n    _platform = inject(Platform);\n    _ngZone = inject(NgZone);\n    _renderer = inject(Renderer2);\n    _resizeEvents = new Subject();\n    /** Keep track of the previous textarea value to avoid resizing when the value hasn't changed. */\n    _previousValue;\n    _initialHeight;\n    _destroyed = new Subject();\n    _listenerCleanups;\n    _minRows;\n    _maxRows;\n    _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    _previousMinRows = -1;\n    _textareaElement;\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      // 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      } else {\n        this._textareaElement.removeAttribute('placeholder');\n      }\n      this._cacheTextareaPlaceholderHeight();\n    }\n    /** Cached height of a textarea with a single row. */\n    _cachedLineHeight;\n    /** Cached height of a textarea with only the placeholder. */\n    _cachedPlaceholderHeight;\n    /** Used to reference correct document/window */\n    _document = inject(DOCUMENT, {\n      optional: true\n    });\n    _hasFocus;\n    _isViewInited = false;\n    constructor() {\n      const styleLoader = inject(_CdkPrivateStyleLoader);\n      styleLoader.load(_CdkTextFieldStyleLoader);\n      this._textareaElement = this._elementRef.nativeElement;\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          this._listenerCleanups = [this._renderer.listen('window', 'resize', () => this._resizeEvents.next()), this._renderer.listen(this._textareaElement, 'focus', this._handleFocusEvent), this._renderer.listen(this._textareaElement, 'blur', this._handleFocusEvent)];\n          this._resizeEvents.pipe(auditTime(16)).subscribe(() => {\n            // Clear the cached heights since the styles can change\n            // when the window is resized (e.g. by media queries).\n            this._cachedLineHeight = this._cachedPlaceholderHeight = undefined;\n            this.resizeToFitContent(true);\n          });\n        });\n        this._isViewInited = true;\n        this.resizeToFitContent(true);\n      }\n    }\n    ngOnDestroy() {\n      this._listenerCleanups?.forEach(cleanup => cleanup());\n      this._resizeEvents.complete();\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      const textareaClone = this._textareaElement.cloneNode(false);\n      const cloneStyles = textareaClone.style;\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      cloneStyles.position = 'absolute';\n      cloneStyles.visibility = 'hidden';\n      cloneStyles.border = 'none';\n      cloneStyles.padding = '0';\n      cloneStyles.height = '';\n      cloneStyles.minHeight = '';\n      cloneStyles.maxHeight = '';\n      // App styles might be messing with the height through the positioning properties.\n      cloneStyles.top = cloneStyles.bottom = cloneStyles.left = cloneStyles.right = 'auto';\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      cloneStyles.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 ? 'cdk-textarea-autosize-measuring-firefox' : '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    /** Handles `focus` and `blur` events. */\n    _handleFocusEvent = event => {\n      this._hasFocus = event.type === 'focus';\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        } 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    /**\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 {\n        selectionStart,\n        selectionEnd\n      } = 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    static ɵfac = function CdkTextareaAutosize_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || CdkTextareaAutosize)();\n    };\n    static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n      type: CdkTextareaAutosize,\n      selectors: [[\"textarea\", \"cdkTextareaAutosize\", \"\"]],\n      hostAttrs: [\"rows\", \"1\", 1, \"cdk-textarea-autosize\"],\n      hostBindings: function CdkTextareaAutosize_HostBindings(rf, ctx) {\n        if (rf & 1) {\n          i0.ɵɵlistener(\"input\", function CdkTextareaAutosize_input_HostBindingHandler() {\n            return ctx._noopInputHandler();\n          });\n        }\n      },\n      inputs: {\n        minRows: [0, \"cdkAutosizeMinRows\", \"minRows\"],\n        maxRows: [0, \"cdkAutosizeMaxRows\", \"maxRows\"],\n        enabled: [2, \"cdkTextareaAutosize\", \"enabled\", booleanAttribute],\n        placeholder: \"placeholder\"\n      },\n      exportAs: [\"cdkTextareaAutosize\"],\n      features: [i0.ɵɵInputTransformsFeature]\n    });\n  }\n  return CdkTextareaAutosize;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet TextFieldModule = /*#__PURE__*/(() => {\n  class TextFieldModule {\n    static ɵfac = function TextFieldModule_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || TextFieldModule)();\n    };\n    static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n      type: TextFieldModule\n    });\n    static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n  }\n  return TextFieldModule;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\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 { Platform, getSupportedInputTypes } from '@angular/cdk/platform';\nimport { AutofillMonitor, TextFieldModule } from '@angular/cdk/text-field';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, inject, ElementRef, NgZone, Renderer2, isSignal, effect, booleanAttribute, Directive, Input, NgModule } from '@angular/core';\nimport { _IdGenerator } from '@angular/cdk/a11y';\nimport { NgControl, Validators, NgForm, FormGroupDirective } from '@angular/forms';\nimport { ErrorStateMatcher, _ErrorStateTracker, MatCommonModule } from '@angular/material/core';\nimport { MAT_FORM_FIELD, MatFormFieldControl, MatFormFieldModule } from '@angular/material/form-field';\nexport { MatError, MatFormField, MatHint, MatLabel, MatPrefix, MatSuffix } from '@angular/material/form-field';\nimport { Subject } from 'rxjs';\n\n/** @docs-private */\nfunction getMatInputUnsupportedTypeError(type) {\n  return Error(`Input type \"${type}\" isn't supported by matInput.`);\n}\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 = /*#__PURE__*/new InjectionToken('MAT_INPUT_VALUE_ACCESSOR');\n\n// Invalid input type. Using one of these will throw an MatInputUnsupportedTypeError.\nconst MAT_INPUT_INVALID_TYPES = ['button', 'checkbox', 'file', 'hidden', 'image', 'radio', 'range', 'reset', 'submit'];\n/** Injection token that can be used to provide the default options for the input. */\nconst MAT_INPUT_CONFIG = /*#__PURE__*/new InjectionToken('MAT_INPUT_CONFIG');\nlet MatInput = /*#__PURE__*/(() => {\n  class MatInput {\n    _elementRef = inject(ElementRef);\n    _platform = inject(Platform);\n    ngControl = inject(NgControl, {\n      optional: true,\n      self: true\n    });\n    _autofillMonitor = inject(AutofillMonitor);\n    _ngZone = inject(NgZone);\n    _formField = inject(MAT_FORM_FIELD, {\n      optional: true\n    });\n    _renderer = inject(Renderer2);\n    _uid = inject(_IdGenerator).getId('mat-input-');\n    _previousNativeValue;\n    _inputValueAccessor;\n    _signalBasedValueAccessor;\n    _previousPlaceholder;\n    _errorStateTracker;\n    _config = inject(MAT_INPUT_CONFIG, {\n      optional: true\n    });\n    _cleanupIosKeyup;\n    _cleanupWebkitWheel;\n    /** `aria-describedby` IDs assigned by the form field. */\n    _formFieldDescribedBy;\n    /** Whether the component is being rendered on the server. */\n    _isServer;\n    /** Whether the component is a native html select. */\n    _isNativeSelect;\n    /** Whether the component is a textarea. */\n    _isTextarea;\n    /** Whether the input is inside of a form field. */\n    _isInFormField;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    focused = false;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    stateChanges = new Subject();\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    controlType = 'mat-input';\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    autofilled = false;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get disabled() {\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    _disabled = false;\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    _id;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    placeholder;\n    /**\n     * Name of the input.\n     * @docs-private\n     */\n    name;\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    _required;\n    /** Input type of the element. */\n    get type() {\n      return this._type;\n    }\n    set type(value) {\n      const prevType = this._type;\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      if (this._type !== prevType) {\n        this._ensureWheelDefaultBehavior();\n      }\n    }\n    _type = 'text';\n    /** An object used to control when error messages are shown. */\n    get errorStateMatcher() {\n      return this._errorStateTracker.matcher;\n    }\n    set errorStateMatcher(value) {\n      this._errorStateTracker.matcher = value;\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    userAriaDescribedBy;\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    get value() {\n      return this._signalBasedValueAccessor ? this._signalBasedValueAccessor.value() : this._inputValueAccessor.value;\n    }\n    set value(value) {\n      if (value !== this.value) {\n        if (this._signalBasedValueAccessor) {\n          this._signalBasedValueAccessor.value.set(value);\n        } else {\n          this._inputValueAccessor.value = value;\n        }\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    _readonly = false;\n    /** Whether the input should remain interactive when it is disabled. */\n    disabledInteractive;\n    /** Whether the input is in an error state. */\n    get errorState() {\n      return this._errorStateTracker.errorState;\n    }\n    set errorState(value) {\n      this._errorStateTracker.errorState = value;\n    }\n    _neverEmptyInputTypes = ['date', 'datetime', 'datetime-local', 'month', 'time', 'week'].filter(t => getSupportedInputTypes().has(t));\n    constructor() {\n      const parentForm = inject(NgForm, {\n        optional: true\n      });\n      const parentFormGroup = inject(FormGroupDirective, {\n        optional: true\n      });\n      const defaultErrorStateMatcher = inject(ErrorStateMatcher);\n      const accessor = inject(MAT_INPUT_VALUE_ACCESSOR, {\n        optional: true,\n        self: true\n      });\n      const element = this._elementRef.nativeElement;\n      const nodeName = element.nodeName.toLowerCase();\n      if (accessor) {\n        if (isSignal(accessor.value)) {\n          this._signalBasedValueAccessor = accessor;\n        } else {\n          this._inputValueAccessor = accessor;\n        }\n      } else {\n        // If no input value accessor was explicitly specified, use the element as the input value\n        // accessor.\n        this._inputValueAccessor = element;\n      }\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 (this._platform.IOS) {\n        this._ngZone.runOutsideAngular(() => {\n          this._cleanupIosKeyup = this._renderer.listen(element, 'keyup', this._iOSKeyupListener);\n        });\n      }\n      this._errorStateTracker = new _ErrorStateTracker(defaultErrorStateMatcher, this.ngControl, parentFormGroup, parentForm, this.stateChanges);\n      this._isServer = !this._platform.isBrowser;\n      this._isNativeSelect = nodeName === 'select';\n      this._isTextarea = nodeName === 'textarea';\n      this._isInFormField = !!this._formField;\n      this.disabledInteractive = this._config?.disabledInteractive || false;\n      if (this._isNativeSelect) {\n        this.controlType = element.multiple ? 'mat-native-select-multiple' : 'mat-native-select';\n      }\n      if (this._signalBasedValueAccessor) {\n        effect(() => {\n          // Read the value so the effect can register the dependency.\n          this._signalBasedValueAccessor.value();\n          this.stateChanges.next();\n        });\n      }\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      this._cleanupIosKeyup?.();\n      this._cleanupWebkitWheel?.();\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        // Since the input isn't a `ControlValueAccessor`, we don't have a good way of knowing when\n        // the disabled state has changed. We can't use the `ngControl.statusChanges`, because it\n        // won't fire if the input is disabled with `emitEvents = false`, despite the input becoming\n        // disabled.\n        if (this.ngControl.disabled !== null && this.ngControl.disabled !== this.disabled) {\n          this.disabled = this.ngControl.disabled;\n          this.stateChanges.next();\n        }\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    /** Refreshes the error state of the input. */\n    updateErrorState() {\n      this._errorStateTracker.updateErrorState();\n    }\n    /** Callback for the cases where the focused state of the input changes. */\n    _focusChanged(isFocused) {\n      if (isFocused === this.focused) {\n        return;\n      }\n      if (!this._isNativeSelect && isFocused && this.disabled && this.disabledInteractive) {\n        const element = this._elementRef.nativeElement;\n        // Focusing an input that has text will cause all the text to be selected. Clear it since\n        // the user won't be able to change it. This is based on the internal implementation.\n        if (element.type === 'number') {\n          // setSelectionRange doesn't work on number inputs so it needs to be set briefly to text.\n          element.type = 'text';\n          element.setSelectionRange(0, 0);\n          element.type = 'number';\n        } else {\n          element.setSelectionRange(0, 0);\n        }\n      }\n      this.focused = isFocused;\n      this.stateChanges.next();\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 `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    /** Does some manual dirty checking on the native input `placeholder` attribute. */\n    _dirtyCheckPlaceholder() {\n      const placeholder = this._getPlaceholder();\n      if (placeholder !== this._previousPlaceholder) {\n        const element = this._elementRef.nativeElement;\n        this._previousPlaceholder = placeholder;\n        placeholder ? element.setAttribute('placeholder', placeholder) : element.removeAttribute('placeholder');\n      }\n    }\n    /** Gets the current placeholder of the form field. */\n    _getPlaceholder() {\n      return this.placeholder || null;\n    }\n    /** Make sure the input is a supported type. */\n    _validateType() {\n      if (MAT_INPUT_INVALID_TYPES.indexOf(this._type) > -1 && (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() && !this._elementRef.nativeElement.value && !this._isBadInput() && !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 || selectElement.multiple || !this.empty || !!(selectElement.selectedIndex > -1 && firstOption && firstOption.label);\n      } else {\n        return this.focused && !this.disabled || !this.empty;\n      }\n    }\n    /**\n     * Implemented as part of MatFormFieldControl.\n     * @docs-private\n     */\n    setDescribedByIds(ids) {\n      const element = this._elementRef.nativeElement;\n      const existingDescribedBy = element.getAttribute('aria-describedby');\n      let toAssign;\n      // In some cases there might be some `aria-describedby` IDs that were assigned directly,\n      // like by the `AriaDescriber` (see #30011). Attempt to preserve them by taking the previous\n      // attribute value and filtering out the IDs that came from the previous `setDescribedByIds`\n      // call. Note the `|| ids` here allows us to avoid duplicating IDs on the first render.\n      if (existingDescribedBy) {\n        const exclude = this._formFieldDescribedBy || ids;\n        toAssign = ids.concat(existingDescribedBy.split(' ').filter(id => id && !exclude.includes(id)));\n      } else {\n        toAssign = ids;\n      }\n      this._formFieldDescribedBy = ids;\n      if (toAssign.length) {\n        element.setAttribute('aria-describedby', toAssign.join(' '));\n      } else {\n        element.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    _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    _webkitBlinkWheelListener = () => {\n      // This is a noop function and is used to enable mouse wheel input\n      // on number inputs\n      // on blink and webkit browsers.\n    };\n    /**\n     * In blink and webkit browsers a focused number input does not increment or decrement its value\n     * on mouse wheel interaction unless a wheel event listener is attached to it or one of its\n     * ancestors or a passive wheel listener is attached somewhere in the DOM. For example: Hitting\n     * a tooltip once enables the mouse wheel input for all number inputs as long as it exists. In\n     * order to get reliable and intuitive behavior we apply a wheel event on our own thus making\n     * sure increment and decrement by mouse wheel works every time.\n     * @docs-private\n     */\n    _ensureWheelDefaultBehavior() {\n      this._cleanupWebkitWheel?.();\n      if (this._type === 'number' && (this._platform.BLINK || this._platform.WEBKIT)) {\n        this._cleanupWebkitWheel = this._renderer.listen(this._elementRef.nativeElement, 'wheel', this._webkitBlinkWheelListener);\n      }\n    }\n    /** Gets the value to set on the `readonly` attribute. */\n    _getReadonlyAttribute() {\n      if (this._isNativeSelect) {\n        return null;\n      }\n      if (this.readonly || this.disabled && this.disabledInteractive) {\n        return 'true';\n      }\n      return null;\n    }\n    static ɵfac = function MatInput_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || MatInput)();\n    };\n    static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n      type: MatInput,\n      selectors: [[\"input\", \"matInput\", \"\"], [\"textarea\", \"matInput\", \"\"], [\"select\", \"matNativeControl\", \"\"], [\"input\", \"matNativeControl\", \"\"], [\"textarea\", \"matNativeControl\", \"\"]],\n      hostAttrs: [1, \"mat-mdc-input-element\"],\n      hostVars: 21,\n      hostBindings: function MatInput_HostBindings(rf, ctx) {\n        if (rf & 1) {\n          i0.ɵɵlistener(\"focus\", function MatInput_focus_HostBindingHandler() {\n            return ctx._focusChanged(true);\n          })(\"blur\", function MatInput_blur_HostBindingHandler() {\n            return ctx._focusChanged(false);\n          })(\"input\", function MatInput_input_HostBindingHandler() {\n            return ctx._onInput();\n          });\n        }\n        if (rf & 2) {\n          i0.ɵɵhostProperty(\"id\", ctx.id)(\"disabled\", ctx.disabled && !ctx.disabledInteractive)(\"required\", ctx.required);\n          i0.ɵɵattribute(\"name\", ctx.name || null)(\"readonly\", ctx._getReadonlyAttribute())(\"aria-disabled\", ctx.disabled && ctx.disabledInteractive ? \"true\" : null)(\"aria-invalid\", ctx.empty && ctx.required ? null : ctx.errorState)(\"aria-required\", ctx.required)(\"id\", ctx.id);\n          i0.ɵɵclassProp(\"mat-input-server\", ctx._isServer)(\"mat-mdc-form-field-textarea-control\", ctx._isInFormField && ctx._isTextarea)(\"mat-mdc-form-field-input-control\", ctx._isInFormField)(\"mat-mdc-input-disabled-interactive\", ctx.disabledInteractive)(\"mdc-text-field__input\", ctx._isInFormField)(\"mat-mdc-native-select-inline\", ctx._isInlineSelect());\n        }\n      },\n      inputs: {\n        disabled: \"disabled\",\n        id: \"id\",\n        placeholder: \"placeholder\",\n        name: \"name\",\n        required: \"required\",\n        type: \"type\",\n        errorStateMatcher: \"errorStateMatcher\",\n        userAriaDescribedBy: [0, \"aria-describedby\", \"userAriaDescribedBy\"],\n        value: \"value\",\n        readonly: \"readonly\",\n        disabledInteractive: [2, \"disabledInteractive\", \"disabledInteractive\", booleanAttribute]\n      },\n      exportAs: [\"matInput\"],\n      features: [i0.ɵɵProvidersFeature([{\n        provide: MatFormFieldControl,\n        useExisting: MatInput\n      }]), i0.ɵɵInputTransformsFeature, i0.ɵɵNgOnChangesFeature]\n    });\n  }\n  return MatInput;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet MatInputModule = /*#__PURE__*/(() => {\n  class MatInputModule {\n    static ɵfac = function MatInputModule_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || MatInputModule)();\n    };\n    static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n      type: MatInputModule\n    });\n    static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({\n      imports: [MatCommonModule, MatFormFieldModule, MatFormFieldModule, TextFieldModule, MatCommonModule]\n    });\n  }\n  return MatInputModule;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_INPUT_CONFIG, MAT_INPUT_VALUE_ACCESSOR, MatInput, MatInputModule, getMatInputUnsupportedTypeError };\n"],"mappings":"yaAUA,IAAIA,GAAyC,IAAM,CACjD,MAAMA,CAAyB,CAC7B,OAAO,UAAO,SAA0CC,EAAmB,CACzE,OAAO,IAAKA,GAAqBD,EACnC,EACA,OAAO,UAAyBE,EAAkB,CAChD,KAAMF,EACN,UAAW,CAAC,CAAC,cAAc,CAAC,EAC5B,UAAW,CAAC,8BAA+B,EAAE,EAC7C,MAAO,EACP,KAAM,EACN,SAAU,SAA2CG,EAAIC,EAAK,CAAC,EAC/D,OAAQ,CAAC,ymBAAymB,EAClnB,cAAe,EACf,gBAAiB,CACnB,CAAC,CACH,CACA,OAAOJ,CACT,GAAG,EAMGK,EAA+BC,EAAgC,CACnE,QAAS,EACX,CAAC,EAMGC,GAAgC,IAAM,CACxC,MAAMA,CAAgB,CACpB,UAAYC,EAAOC,CAAQ,EAC3B,QAAUD,EAAOE,CAAM,EACvB,aAAeF,EAAOG,CAAsB,EAC5C,mBAAqB,IAAI,IACzB,aAAc,CAAC,CACf,QAAQC,EAAc,CACpB,GAAI,CAAC,KAAK,UAAU,UAClB,OAAOC,EAET,KAAK,aAAa,KAAKb,CAAwB,EAC/C,IAAMc,EAAUC,EAAcH,CAAY,EACpCI,EAAO,KAAK,mBAAmB,IAAIF,CAAO,EAChD,GAAIE,EACF,OAAOA,EAAK,QAEd,IAAMC,EAAS,IAAIC,EACbC,EAAW,4BACXC,EAAWC,GAAS,CAIpBA,EAAM,gBAAkB,iCAAmC,CAACP,EAAQ,UAAU,SAASK,CAAQ,GACjGL,EAAQ,UAAU,IAAIK,CAAQ,EAC9B,KAAK,QAAQ,IAAI,IAAMF,EAAO,KAAK,CACjC,OAAQI,EAAM,OACd,aAAc,EAChB,CAAC,CAAC,GACOA,EAAM,gBAAkB,+BAAiCP,EAAQ,UAAU,SAASK,CAAQ,IACrGL,EAAQ,UAAU,OAAOK,CAAQ,EACjC,KAAK,QAAQ,IAAI,IAAMF,EAAO,KAAK,CACjC,OAAQI,EAAM,OACd,aAAc,EAChB,CAAC,CAAC,EAEN,EACA,YAAK,QAAQ,kBAAkB,IAAM,CACnCP,EAAQ,iBAAiB,iBAAkBM,EAAUf,CAAe,EACpES,EAAQ,UAAU,IAAI,mCAAmC,CAC3D,CAAC,EACD,KAAK,mBAAmB,IAAIA,EAAS,CACnC,QAASG,EACT,SAAU,IAAM,CACdH,EAAQ,oBAAoB,iBAAkBM,EAAUf,CAAe,CACzE,CACF,CAAC,EACMY,CACT,CACA,eAAeL,EAAc,CAC3B,IAAME,EAAUC,EAAcH,CAAY,EACpCI,EAAO,KAAK,mBAAmB,IAAIF,CAAO,EAC5CE,IACFA,EAAK,SAAS,EACdA,EAAK,QAAQ,SAAS,EACtBF,EAAQ,UAAU,OAAO,mCAAmC,EAC5DA,EAAQ,UAAU,OAAO,2BAA2B,EACpD,KAAK,mBAAmB,OAAOA,CAAO,EAE1C,CACA,aAAc,CACZ,KAAK,mBAAmB,QAAQ,CAACQ,EAAOR,IAAY,KAAK,eAAeA,CAAO,CAAC,CAClF,CACA,OAAO,UAAO,SAAiCb,EAAmB,CAChE,OAAO,IAAKA,GAAqBM,EACnC,EACA,OAAO,WAA0BgB,EAAmB,CAClD,MAAOhB,EACP,QAASA,EAAgB,UACzB,WAAY,MACd,CAAC,CACH,CACA,OAAOA,CACT,GAAG,EAoCH,IAAIiB,IAAoC,IAAM,CAC5C,MAAMA,CAAoB,CACxB,YAAcC,EAAOC,CAAU,EAC/B,UAAYD,EAAOE,CAAQ,EAC3B,QAAUF,EAAOG,CAAM,EACvB,UAAYH,EAAOI,CAAS,EAC5B,cAAgB,IAAIC,EAEpB,eACA,eACA,WAAa,IAAIA,EACjB,kBACA,SACA,SACA,SAAW,GAMX,iBAAmB,GACnB,iBAEA,IAAI,SAAU,CACZ,OAAO,KAAK,QACd,CACA,IAAI,QAAQC,EAAO,CACjB,KAAK,SAAWC,EAAqBD,CAAK,EAC1C,KAAK,cAAc,CACrB,CAEA,IAAI,SAAU,CACZ,OAAO,KAAK,QACd,CACA,IAAI,QAAQA,EAAO,CACjB,KAAK,SAAWC,EAAqBD,CAAK,EAC1C,KAAK,cAAc,CACrB,CAEA,IAAI,SAAU,CACZ,OAAO,KAAK,QACd,CACA,IAAI,QAAQA,EAAO,CAGb,KAAK,WAAaA,KACnB,KAAK,SAAWA,GAAS,KAAK,mBAAmB,EAAI,EAAI,KAAK,MAAM,EAEzE,CACA,IAAI,aAAc,CAChB,OAAO,KAAK,iBAAiB,WAC/B,CACA,IAAI,YAAYA,EAAO,CACrB,KAAK,yBAA2B,OAC5BA,EACF,KAAK,iBAAiB,aAAa,cAAeA,CAAK,EAEvD,KAAK,iBAAiB,gBAAgB,aAAa,EAErD,KAAK,gCAAgC,CACvC,CAEA,kBAEA,yBAEA,UAAYN,EAAOQ,EAAU,CAC3B,SAAU,EACZ,CAAC,EACD,UACA,cAAgB,GAChB,aAAc,CACQR,EAAOS,CAAsB,EACrC,KAAKC,CAAwB,EACzC,KAAK,iBAAmB,KAAK,YAAY,aAC3C,CAEA,eAAgB,CACd,IAAMC,EAAY,KAAK,SAAW,KAAK,kBAAoB,GAAG,KAAK,QAAU,KAAK,iBAAiB,KAAO,KACtGA,IACF,KAAK,iBAAiB,MAAM,UAAYA,EAE5C,CAEA,eAAgB,CACd,IAAMC,EAAY,KAAK,SAAW,KAAK,kBAAoB,GAAG,KAAK,QAAU,KAAK,iBAAiB,KAAO,KACtGA,IACF,KAAK,iBAAiB,MAAM,UAAYA,EAE5C,CACA,iBAAkB,CACZ,KAAK,UAAU,YAEjB,KAAK,eAAiB,KAAK,iBAAiB,MAAM,OAClD,KAAK,mBAAmB,EACxB,KAAK,QAAQ,kBAAkB,IAAM,CACnC,KAAK,kBAAoB,CAAC,KAAK,UAAU,OAAO,SAAU,SAAU,IAAM,KAAK,cAAc,KAAK,CAAC,EAAG,KAAK,UAAU,OAAO,KAAK,iBAAkB,QAAS,KAAK,iBAAiB,EAAG,KAAK,UAAU,OAAO,KAAK,iBAAkB,OAAQ,KAAK,iBAAiB,CAAC,EACjQ,KAAK,cAAc,KAAKC,EAAU,EAAE,CAAC,EAAE,UAAU,IAAM,CAGrD,KAAK,kBAAoB,KAAK,yBAA2B,OACzD,KAAK,mBAAmB,EAAI,CAC9B,CAAC,CACH,CAAC,EACD,KAAK,cAAgB,GACrB,KAAK,mBAAmB,EAAI,EAEhC,CACA,aAAc,CACZ,KAAK,mBAAmB,QAAQC,GAAWA,EAAQ,CAAC,EACpD,KAAK,cAAc,SAAS,EAC5B,KAAK,WAAW,KAAK,EACrB,KAAK,WAAW,SAAS,CAC3B,CAQA,0BAA2B,CACzB,GAAI,KAAK,kBACP,OAGF,IAAMC,EAAgB,KAAK,iBAAiB,UAAU,EAAK,EACrDC,EAAcD,EAAc,MAClCA,EAAc,KAAO,EAIrBC,EAAY,SAAW,WACvBA,EAAY,WAAa,SACzBA,EAAY,OAAS,OACrBA,EAAY,QAAU,IACtBA,EAAY,OAAS,GACrBA,EAAY,UAAY,GACxBA,EAAY,UAAY,GAExBA,EAAY,IAAMA,EAAY,OAASA,EAAY,KAAOA,EAAY,MAAQ,OAM9EA,EAAY,SAAW,SACvB,KAAK,iBAAiB,WAAW,YAAYD,CAAa,EAC1D,KAAK,kBAAoBA,EAAc,aACvCA,EAAc,OAAO,EAErB,KAAK,cAAc,EACnB,KAAK,cAAc,CACrB,CACA,sBAAuB,CACrB,IAAME,EAAU,KAAK,iBACfC,EAAiBD,EAAQ,MAAM,cAAgB,GAC/CE,EAAY,KAAK,UAAU,QAC3BC,EAAoBD,GAAa,KAAK,UACtCE,EAAiBF,EAAY,0CAA4C,kCAI3EC,IACFH,EAAQ,MAAM,aAAe,GAAGA,EAAQ,YAAY,MAItDA,EAAQ,UAAU,IAAII,CAAc,EAGpC,IAAMC,EAAeL,EAAQ,aAAe,EAC5C,OAAAA,EAAQ,UAAU,OAAOI,CAAc,EACnCD,IACFH,EAAQ,MAAM,aAAeC,GAExBI,CACT,CACA,iCAAkC,CAChC,GAAI,CAAC,KAAK,eAAiB,KAAK,0BAA4B,KAC1D,OAEF,GAAI,CAAC,KAAK,YAAa,CACrB,KAAK,yBAA2B,EAChC,MACF,CACA,IAAMhB,EAAQ,KAAK,iBAAiB,MACpC,KAAK,iBAAiB,MAAQ,KAAK,iBAAiB,YACpD,KAAK,yBAA2B,KAAK,qBAAqB,EAC1D,KAAK,iBAAiB,MAAQA,CAChC,CAEA,kBAAoBiB,GAAS,CAC3B,KAAK,UAAYA,EAAM,OAAS,OAClC,EACA,WAAY,CACN,KAAK,UAAU,WACjB,KAAK,mBAAmB,CAE5B,CAMA,mBAAmBC,EAAQ,GAAO,CAShC,GAPI,CAAC,KAAK,WAGV,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EAGjC,CAAC,KAAK,mBACR,OAEF,IAAMC,EAAW,KAAK,YAAY,cAC5BnB,EAAQmB,EAAS,MAEvB,GAAI,CAACD,GAAS,KAAK,WAAa,KAAK,kBAAoBlB,IAAU,KAAK,eACtE,OAEF,IAAMgB,EAAe,KAAK,qBAAqB,EACzCI,EAAS,KAAK,IAAIJ,EAAc,KAAK,0BAA4B,CAAC,EAExEG,EAAS,MAAM,OAAS,GAAGC,CAAM,KACjC,KAAK,QAAQ,kBAAkB,IAAM,CAC/B,OAAO,sBAA0B,IACnC,sBAAsB,IAAM,KAAK,uBAAuBD,CAAQ,CAAC,EAEjE,WAAW,IAAM,KAAK,uBAAuBA,CAAQ,CAAC,CAE1D,CAAC,EACD,KAAK,eAAiBnB,EACtB,KAAK,iBAAmB,KAAK,QAC/B,CAIA,OAAQ,CAGF,KAAK,iBAAmB,SAC1B,KAAK,iBAAiB,MAAM,OAAS,KAAK,eAE9C,CACA,mBAAoB,CAEpB,CAMA,uBAAuBmB,EAAU,CAC/B,GAAM,CACJ,eAAAE,EACA,aAAAC,CACF,EAAIH,EAOA,CAAC,KAAK,WAAW,WAAa,KAAK,WACrCA,EAAS,kBAAkBE,EAAgBC,CAAY,CAE3D,CACA,OAAO,UAAO,SAAqCC,EAAmB,CACpE,OAAO,IAAKA,GAAqB9B,EACnC,EACA,OAAO,UAAyB+B,EAAkB,CAChD,KAAM/B,EACN,UAAW,CAAC,CAAC,WAAY,sBAAuB,EAAE,CAAC,EACnD,UAAW,CAAC,OAAQ,IAAK,EAAG,uBAAuB,EACnD,aAAc,SAA0CgC,EAAIC,EAAK,CAC3DD,EAAK,GACJE,EAAW,QAAS,UAAwD,CAC7E,OAAOD,EAAI,kBAAkB,CAC/B,CAAC,CAEL,EACA,OAAQ,CACN,QAAS,CAAC,EAAG,qBAAsB,SAAS,EAC5C,QAAS,CAAC,EAAG,qBAAsB,SAAS,EAC5C,QAAS,CAAC,EAAG,sBAAuB,UAAWE,CAAgB,EAC/D,YAAa,aACf,EACA,SAAU,CAAC,qBAAqB,EAChC,SAAU,CAAIC,CAAwB,CACxC,CAAC,CACH,CACA,OAAOpC,CACT,GAAG,EAICqC,GAAgC,IAAM,CACxC,MAAMA,CAAgB,CACpB,OAAO,UAAO,SAAiCP,EAAmB,CAChE,OAAO,IAAKA,GAAqBO,EACnC,EACA,OAAO,UAAyBC,EAAiB,CAC/C,KAAMD,CACR,CAAC,EACD,OAAO,UAAyBE,EAAiB,CAAC,CAAC,CACrD,CACA,OAAOF,CACT,GAAG,ECtbH,IAAMG,GAAwC,IAAIC,EAAe,0BAA0B,EAGrFC,GAA0B,CAAC,SAAU,WAAY,OAAQ,SAAU,QAAS,QAAS,QAAS,QAAS,QAAQ,EAE/GC,GAAgC,IAAIF,EAAe,kBAAkB,EACvEG,IAAyB,IAAM,CACjC,MAAMA,CAAS,CACb,YAAcC,EAAOC,CAAU,EAC/B,UAAYD,EAAOE,CAAQ,EAC3B,UAAYF,EAAOG,EAAW,CAC5B,SAAU,GACV,KAAM,EACR,CAAC,EACD,iBAAmBH,EAAOI,CAAe,EACzC,QAAUJ,EAAOK,CAAM,EACvB,WAAaL,EAAOM,EAAgB,CAClC,SAAU,EACZ,CAAC,EACD,UAAYN,EAAOO,CAAS,EAC5B,KAAOP,EAAOQ,CAAY,EAAE,MAAM,YAAY,EAC9C,qBACA,oBACA,0BACA,qBACA,mBACA,QAAUR,EAAOF,GAAkB,CACjC,SAAU,EACZ,CAAC,EACD,iBACA,oBAEA,sBAEA,UAEA,gBAEA,YAEA,eAKA,QAAU,GAKV,aAAe,IAAIW,EAKnB,YAAc,YAKd,WAAa,GAKb,IAAI,UAAW,CACb,OAAO,KAAK,SACd,CACA,IAAI,SAASC,EAAO,CAClB,KAAK,UAAYC,EAAsBD,CAAK,EAGxC,KAAK,UACP,KAAK,QAAU,GACf,KAAK,aAAa,KAAK,EAE3B,CACA,UAAY,GAKZ,IAAI,IAAK,CACP,OAAO,KAAK,GACd,CACA,IAAI,GAAGA,EAAO,CACZ,KAAK,IAAMA,GAAS,KAAK,IAC3B,CACA,IAKA,YAKA,KAKA,IAAI,UAAW,CACb,OAAO,KAAK,WAAa,KAAK,WAAW,SAAS,aAAaE,EAAW,QAAQ,GAAK,EACzF,CACA,IAAI,SAASF,EAAO,CAClB,KAAK,UAAYC,EAAsBD,CAAK,CAC9C,CACA,UAEA,IAAI,MAAO,CACT,OAAO,KAAK,KACd,CACA,IAAI,KAAKA,EAAO,CACd,IAAMG,EAAW,KAAK,MACtB,KAAK,MAAQH,GAAS,OACtB,KAAK,cAAc,EAIf,CAAC,KAAK,aAAeI,EAAuB,EAAE,IAAI,KAAK,KAAK,IAC9D,KAAK,YAAY,cAAc,KAAO,KAAK,OAEzC,KAAK,QAAUD,GACjB,KAAK,4BAA4B,CAErC,CACA,MAAQ,OAER,IAAI,mBAAoB,CACtB,OAAO,KAAK,mBAAmB,OACjC,CACA,IAAI,kBAAkBH,EAAO,CAC3B,KAAK,mBAAmB,QAAUA,CACpC,CAKA,oBAKA,IAAI,OAAQ,CACV,OAAO,KAAK,0BAA4B,KAAK,0BAA0B,MAAM,EAAI,KAAK,oBAAoB,KAC5G,CACA,IAAI,MAAMA,EAAO,CACXA,IAAU,KAAK,QACb,KAAK,0BACP,KAAK,0BAA0B,MAAM,IAAIA,CAAK,EAE9C,KAAK,oBAAoB,MAAQA,EAEnC,KAAK,aAAa,KAAK,EAE3B,CAEA,IAAI,UAAW,CACb,OAAO,KAAK,SACd,CACA,IAAI,SAASA,EAAO,CAClB,KAAK,UAAYC,EAAsBD,CAAK,CAC9C,CACA,UAAY,GAEZ,oBAEA,IAAI,YAAa,CACf,OAAO,KAAK,mBAAmB,UACjC,CACA,IAAI,WAAWA,EAAO,CACpB,KAAK,mBAAmB,WAAaA,CACvC,CACA,sBAAwB,CAAC,OAAQ,WAAY,iBAAkB,QAAS,OAAQ,MAAM,EAAE,OAAOK,GAAKD,EAAuB,EAAE,IAAIC,CAAC,CAAC,EACnI,aAAc,CACZ,IAAMC,EAAahB,EAAOiB,EAAQ,CAChC,SAAU,EACZ,CAAC,EACKC,EAAkBlB,EAAOmB,EAAoB,CACjD,SAAU,EACZ,CAAC,EACKC,EAA2BpB,EAAOqB,CAAiB,EACnDC,EAAWtB,EAAOL,GAA0B,CAChD,SAAU,GACV,KAAM,EACR,CAAC,EACK4B,EAAU,KAAK,YAAY,cAC3BC,EAAWD,EAAQ,SAAS,YAAY,EAC1CD,EACEG,EAASH,EAAS,KAAK,EACzB,KAAK,0BAA4BA,EAEjC,KAAK,oBAAsBA,EAK7B,KAAK,oBAAsBC,EAE7B,KAAK,qBAAuB,KAAK,MAEjC,KAAK,GAAK,KAAK,GAIX,KAAK,UAAU,KACjB,KAAK,QAAQ,kBAAkB,IAAM,CACnC,KAAK,iBAAmB,KAAK,UAAU,OAAOA,EAAS,QAAS,KAAK,iBAAiB,CACxF,CAAC,EAEH,KAAK,mBAAqB,IAAIG,EAAmBN,EAA0B,KAAK,UAAWF,EAAiBF,EAAY,KAAK,YAAY,EACzI,KAAK,UAAY,CAAC,KAAK,UAAU,UACjC,KAAK,gBAAkBQ,IAAa,SACpC,KAAK,YAAcA,IAAa,WAChC,KAAK,eAAiB,CAAC,CAAC,KAAK,WAC7B,KAAK,oBAAsB,KAAK,SAAS,qBAAuB,GAC5D,KAAK,kBACP,KAAK,YAAcD,EAAQ,SAAW,6BAA+B,qBAEnE,KAAK,2BACPI,EAAO,IAAM,CAEX,KAAK,0BAA0B,MAAM,EACrC,KAAK,aAAa,KAAK,CACzB,CAAC,CAEL,CACA,iBAAkB,CACZ,KAAK,UAAU,WACjB,KAAK,iBAAiB,QAAQ,KAAK,YAAY,aAAa,EAAE,UAAUC,GAAS,CAC/E,KAAK,WAAaA,EAAM,aACxB,KAAK,aAAa,KAAK,CACzB,CAAC,CAEL,CACA,aAAc,CACZ,KAAK,aAAa,KAAK,CACzB,CACA,aAAc,CACZ,KAAK,aAAa,SAAS,EACvB,KAAK,UAAU,WACjB,KAAK,iBAAiB,eAAe,KAAK,YAAY,aAAa,EAErE,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,CAC7B,CACA,WAAY,CACN,KAAK,YAIP,KAAK,iBAAiB,EAKlB,KAAK,UAAU,WAAa,MAAQ,KAAK,UAAU,WAAa,KAAK,WACvE,KAAK,SAAW,KAAK,UAAU,SAC/B,KAAK,aAAa,KAAK,IAM3B,KAAK,uBAAuB,EAG5B,KAAK,uBAAuB,CAC9B,CAEA,MAAMC,EAAS,CACb,KAAK,YAAY,cAAc,MAAMA,CAAO,CAC9C,CAEA,kBAAmB,CACjB,KAAK,mBAAmB,iBAAiB,CAC3C,CAEA,cAAcC,EAAW,CACvB,GAAIA,IAAc,KAAK,QAGvB,IAAI,CAAC,KAAK,iBAAmBA,GAAa,KAAK,UAAY,KAAK,oBAAqB,CACnF,IAAMP,EAAU,KAAK,YAAY,cAG7BA,EAAQ,OAAS,UAEnBA,EAAQ,KAAO,OACfA,EAAQ,kBAAkB,EAAG,CAAC,EAC9BA,EAAQ,KAAO,UAEfA,EAAQ,kBAAkB,EAAG,CAAC,CAElC,CACA,KAAK,QAAUO,EACf,KAAK,aAAa,KAAK,EACzB,CACA,UAAW,CAQX,CAEA,wBAAyB,CACvB,IAAMC,EAAW,KAAK,YAAY,cAAc,MAC5C,KAAK,uBAAyBA,IAChC,KAAK,qBAAuBA,EAC5B,KAAK,aAAa,KAAK,EAE3B,CAEA,wBAAyB,CACvB,IAAMC,EAAc,KAAK,gBAAgB,EACzC,GAAIA,IAAgB,KAAK,qBAAsB,CAC7C,IAAMT,EAAU,KAAK,YAAY,cACjC,KAAK,qBAAuBS,EAC5BA,EAAcT,EAAQ,aAAa,cAAeS,CAAW,EAAIT,EAAQ,gBAAgB,aAAa,CACxG,CACF,CAEA,iBAAkB,CAChB,OAAO,KAAK,aAAe,IAC7B,CAEA,eAAgB,CACV1B,GAAwB,QAAQ,KAAK,KAAK,EAAI,EAGpD,CAEA,eAAgB,CACd,OAAO,KAAK,sBAAsB,QAAQ,KAAK,KAAK,EAAI,EAC1D,CAEA,aAAc,CAEZ,IAAIoC,EAAW,KAAK,YAAY,cAAc,SAC9C,OAAOA,GAAYA,EAAS,QAC9B,CAKA,IAAI,OAAQ,CACV,MAAO,CAAC,KAAK,cAAc,GAAK,CAAC,KAAK,YAAY,cAAc,OAAS,CAAC,KAAK,YAAY,GAAK,CAAC,KAAK,UACxG,CAKA,IAAI,kBAAmB,CACrB,GAAI,KAAK,gBAAiB,CAIxB,IAAMC,EAAgB,KAAK,YAAY,cACjCC,EAAcD,EAAc,QAAQ,CAAC,EAG3C,OAAO,KAAK,SAAWA,EAAc,UAAY,CAAC,KAAK,OAAS,CAAC,EAAEA,EAAc,cAAgB,IAAMC,GAAeA,EAAY,MACpI,KACE,QAAO,KAAK,SAAW,CAAC,KAAK,UAAY,CAAC,KAAK,KAEnD,CAKA,kBAAkBC,EAAK,CACrB,IAAMb,EAAU,KAAK,YAAY,cAC3Bc,EAAsBd,EAAQ,aAAa,kBAAkB,EAC/De,EAKJ,GAAID,EAAqB,CACvB,IAAME,EAAU,KAAK,uBAAyBH,EAC9CE,EAAWF,EAAI,OAAOC,EAAoB,MAAM,GAAG,EAAE,OAAOG,GAAMA,GAAM,CAACD,EAAQ,SAASC,CAAE,CAAC,CAAC,CAChG,MACEF,EAAWF,EAEb,KAAK,sBAAwBA,EACzBE,EAAS,OACXf,EAAQ,aAAa,mBAAoBe,EAAS,KAAK,GAAG,CAAC,EAE3Df,EAAQ,gBAAgB,kBAAkB,CAE9C,CAKA,kBAAmB,CAIZ,KAAK,SACR,KAAK,MAAM,CAEf,CAEA,iBAAkB,CAChB,IAAMA,EAAU,KAAK,YAAY,cACjC,OAAO,KAAK,kBAAoBA,EAAQ,UAAYA,EAAQ,KAAO,EACrE,CACA,kBAAoBK,GAAS,CAC3B,IAAMa,EAAKb,EAAM,OAOb,CAACa,EAAG,OAASA,EAAG,iBAAmB,GAAKA,EAAG,eAAiB,IAK9DA,EAAG,kBAAkB,EAAG,CAAC,EACzBA,EAAG,kBAAkB,EAAG,CAAC,EAE7B,EACA,0BAA4B,IAAM,CAIlC,EAUA,6BAA8B,CAC5B,KAAK,sBAAsB,EACvB,KAAK,QAAU,WAAa,KAAK,UAAU,OAAS,KAAK,UAAU,UACrE,KAAK,oBAAsB,KAAK,UAAU,OAAO,KAAK,YAAY,cAAe,QAAS,KAAK,yBAAyB,EAE5H,CAEA,uBAAwB,CACtB,OAAI,KAAK,gBACA,KAEL,KAAK,UAAY,KAAK,UAAY,KAAK,oBAClC,OAEF,IACT,CACA,OAAO,UAAO,SAA0BC,EAAmB,CACzD,OAAO,IAAKA,GAAqB3C,EACnC,EACA,OAAO,UAAyB4C,EAAkB,CAChD,KAAM5C,EACN,UAAW,CAAC,CAAC,QAAS,WAAY,EAAE,EAAG,CAAC,WAAY,WAAY,EAAE,EAAG,CAAC,SAAU,mBAAoB,EAAE,EAAG,CAAC,QAAS,mBAAoB,EAAE,EAAG,CAAC,WAAY,mBAAoB,EAAE,CAAC,EAChL,UAAW,CAAC,EAAG,uBAAuB,EACtC,SAAU,GACV,aAAc,SAA+B6C,EAAIC,EAAK,CAChDD,EAAK,GACJE,EAAW,QAAS,UAA6C,CAClE,OAAOD,EAAI,cAAc,EAAI,CAC/B,CAAC,EAAE,OAAQ,UAA4C,CACrD,OAAOA,EAAI,cAAc,EAAK,CAChC,CAAC,EAAE,QAAS,UAA6C,CACvD,OAAOA,EAAI,SAAS,CACtB,CAAC,EAECD,EAAK,IACJG,EAAe,KAAMF,EAAI,EAAE,EAAE,WAAYA,EAAI,UAAY,CAACA,EAAI,mBAAmB,EAAE,WAAYA,EAAI,QAAQ,EAC3GG,EAAY,OAAQH,EAAI,MAAQ,IAAI,EAAE,WAAYA,EAAI,sBAAsB,CAAC,EAAE,gBAAiBA,EAAI,UAAYA,EAAI,oBAAsB,OAAS,IAAI,EAAE,eAAgBA,EAAI,OAASA,EAAI,SAAW,KAAOA,EAAI,UAAU,EAAE,gBAAiBA,EAAI,QAAQ,EAAE,KAAMA,EAAI,EAAE,EACvQI,EAAY,mBAAoBJ,EAAI,SAAS,EAAE,sCAAuCA,EAAI,gBAAkBA,EAAI,WAAW,EAAE,mCAAoCA,EAAI,cAAc,EAAE,qCAAsCA,EAAI,mBAAmB,EAAE,wBAAyBA,EAAI,cAAc,EAAE,+BAAgCA,EAAI,gBAAgB,CAAC,EAE7V,EACA,OAAQ,CACN,SAAU,WACV,GAAI,KACJ,YAAa,cACb,KAAM,OACN,SAAU,WACV,KAAM,OACN,kBAAmB,oBACnB,oBAAqB,CAAC,EAAG,mBAAoB,qBAAqB,EAClE,MAAO,QACP,SAAU,WACV,oBAAqB,CAAC,EAAG,sBAAuB,sBAAuBK,CAAgB,CACzF,EACA,SAAU,CAAC,UAAU,EACrB,SAAU,CAAIC,EAAmB,CAAC,CAChC,QAASC,EACT,YAAarD,CACf,CAAC,CAAC,EAAMsD,EAA6BC,CAAoB,CAC3D,CAAC,CACH,CACA,OAAOvD,CACT,GAAG,EAICwD,IAA+B,IAAM,CACvC,MAAMA,CAAe,CACnB,OAAO,UAAO,SAAgCb,EAAmB,CAC/D,OAAO,IAAKA,GAAqBa,EACnC,EACA,OAAO,UAAyBC,EAAiB,CAC/C,KAAMD,CACR,CAAC,EACD,OAAO,UAAyBE,EAAiB,CAC/C,QAAS,CAACC,EAAiBC,EAAoBA,EAAoBC,EAAiBF,CAAe,CACrG,CAAC,CACH,CACA,OAAOH,CACT,GAAG","names":["_CdkTextFieldStyleLoader","__ngFactoryType__","ɵɵdefineComponent","rf","ctx","listenerOptions","normalizePassiveListenerOptions","AutofillMonitor","inject","Platform","NgZone","_CdkPrivateStyleLoader","elementOrRef","EMPTY","element","coerceElement","info","result","Subject","cssClass","listener","event","_info","ɵɵdefineInjectable","CdkTextareaAutosize","inject","ElementRef","Platform","NgZone","Renderer2","Subject","value","coerceNumberProperty","DOCUMENT","_CdkPrivateStyleLoader","_CdkTextFieldStyleLoader","minHeight","maxHeight","auditTime","cleanup","textareaClone","cloneStyles","element","previousMargin","isFirefox","needsMarginFiller","measuringClass","scrollHeight","event","force","textarea","height","selectionStart","selectionEnd","__ngFactoryType__","ɵɵdefineDirective","rf","ctx","ɵɵlistener","booleanAttribute","ɵɵInputTransformsFeature","TextFieldModule","ɵɵdefineNgModule","ɵɵdefineInjector","MAT_INPUT_VALUE_ACCESSOR","InjectionToken","MAT_INPUT_INVALID_TYPES","MAT_INPUT_CONFIG","MatInput","inject","ElementRef","Platform","NgControl","AutofillMonitor","NgZone","MAT_FORM_FIELD","Renderer2","_IdGenerator","Subject","value","coerceBooleanProperty","Validators","prevType","getSupportedInputTypes","t","parentForm","NgForm","parentFormGroup","FormGroupDirective","defaultErrorStateMatcher","ErrorStateMatcher","accessor","element","nodeName","isSignal","_ErrorStateTracker","effect","event","options","isFocused","newValue","placeholder","validity","selectElement","firstOption","ids","existingDescribedBy","toAssign","exclude","id","el","__ngFactoryType__","ɵɵdefineDirective","rf","ctx","ɵɵlistener","ɵɵhostProperty","ɵɵattribute","ɵɵclassProp","booleanAttribute","ɵɵProvidersFeature","MatFormFieldControl","ɵɵInputTransformsFeature","ɵɵNgOnChangesFeature","MatInputModule","ɵɵdefineNgModule","ɵɵdefineInjector","MatCommonModule","MatFormFieldModule","TextFieldModule"],"x_google_ignoreList":[0,1]}