{"version":3,"sources":["node_modules/@angular/cdk/fesm2022/text-field.mjs","node_modules/@angular/material/fesm2022/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, booleanAttribute, Optional, Inject, Input, NgModule } from '@angular/core';\nimport { coerceElement, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { EMPTY, Subject, fromEvent } from 'rxjs';\nimport { auditTime, takeUntil } from 'rxjs/operators';\nimport { DOCUMENT } from '@angular/common';\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    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' && !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 {\n      this.ɵfac = function AutofillMonitor_Factory(t) {\n        return new (t || AutofillMonitor)(i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i0.NgZone));\n      };\n    }\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: AutofillMonitor,\n        factory: AutofillMonitor.ɵfac,\n        providedIn: 'root'\n      });\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    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.monitor(this._elementRef).subscribe(event => this.cdkAutofill.emit(event));\n    }\n    ngOnDestroy() {\n      this._autofillMonitor.stopMonitoring(this._elementRef);\n    }\n    static {\n      this.ɵfac = function CdkAutofill_Factory(t) {\n        return new (t || CdkAutofill)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(AutofillMonitor));\n      };\n    }\n    static {\n      this.ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n        type: CdkAutofill,\n        selectors: [[\"\", \"cdkAutofill\", \"\"]],\n        outputs: {\n          cdkAutofill: \"cdkAutofill\"\n        },\n        standalone: true\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    /** 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    constructor(_elementRef, _platform, _ngZone, /** @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    /** 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').pipe(auditTime(16), takeUntil(this._destroyed)).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 ? '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    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    /** 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 {\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 {\n      this.ɵfac = function CdkTextareaAutosize_Factory(t) {\n        return new (t || CdkTextareaAutosize)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.Platform), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(DOCUMENT, 8));\n      };\n    }\n    static {\n      this.ɵ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: [i0.ɵɵInputFlags.None, \"cdkAutosizeMinRows\", \"minRows\"],\n          maxRows: [i0.ɵɵInputFlags.None, \"cdkAutosizeMaxRows\", \"maxRows\"],\n          enabled: [i0.ɵɵInputFlags.HasDecoratorInputTransform, \"cdkTextareaAutosize\", \"enabled\", booleanAttribute],\n          placeholder: \"placeholder\"\n        },\n        exportAs: [\"cdkTextareaAutosize\"],\n        standalone: true,\n        features: [i0.ɵɵInputTransformsFeature]\n      });\n    }\n  }\n  return CdkTextareaAutosize;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet TextFieldModule = /*#__PURE__*/(() => {\n  class TextFieldModule {\n    static {\n      this.ɵfac = function TextFieldModule_Factory(t) {\n        return new (t || TextFieldModule)();\n      };\n    }\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: TextFieldModule\n      });\n    }\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n    }\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 * 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 { _ErrorStateTracker, MatCommonModule } from '@angular/material/core';\nimport * as i5 from '@angular/material/form-field';\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'];\nlet nextUniqueId = 0;\nlet MatInput = /*#__PURE__*/(() => {\n  class MatInput {\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    /**\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    /** 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    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    /** 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    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      this._elementRef = _elementRef;\n      this._platform = _platform;\n      this.ngControl = ngControl;\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 = ['date', 'datetime', 'datetime-local', 'month', 'time', 'week'].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._errorStateTracker = new _ErrorStateTracker(defaultErrorStateMatcher, ngControl, parentFormGroup, parentForm, this.stateChanges);\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 ? 'mat-native-select-multiple' : 'mat-native-select';\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      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        // 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        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 `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.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      } 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    static {\n      this.ɵfac = function MatInput_Factory(t) {\n        return new (t || MatInput)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.Platform), i0.ɵɵdirectiveInject(i2.NgControl, 10), i0.ɵɵdirectiveInject(i2.NgForm, 8), i0.ɵɵdirectiveInject(i2.FormGroupDirective, 8), i0.ɵɵdirectiveInject(i3.ErrorStateMatcher), i0.ɵɵdirectiveInject(MAT_INPUT_VALUE_ACCESSOR, 10), i0.ɵɵdirectiveInject(i4.AutofillMonitor), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(MAT_FORM_FIELD, 8));\n      };\n    }\n    static {\n      this.ɵ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: 18,\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)(\"required\", ctx.required);\n            i0.ɵɵattribute(\"name\", ctx.name || null)(\"readonly\", ctx.readonly && !ctx._isNativeSelect || 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)(\"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: [i0.ɵɵInputFlags.None, \"aria-describedby\", \"userAriaDescribedBy\"],\n          value: \"value\",\n          readonly: \"readonly\"\n        },\n        exportAs: [\"matInput\"],\n        standalone: true,\n        features: [i0.ɵɵProvidersFeature([{\n          provide: MatFormFieldControl,\n          useExisting: MatInput\n        }]), i0.ɵɵNgOnChangesFeature]\n      });\n    }\n  }\n  return MatInput;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet MatInputModule = /*#__PURE__*/(() => {\n  class MatInputModule {\n    static {\n      this.ɵfac = function MatInputModule_Factory(t) {\n        return new (t || MatInputModule)();\n      };\n    }\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: MatInputModule\n      });\n    }\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({\n        imports: [MatCommonModule, MatFormFieldModule, MatFormFieldModule, TextFieldModule, MatCommonModule]\n      });\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_VALUE_ACCESSOR, MatInput, MatInputModule, getMatInputUnsupportedTypeError };\n"],"mappings":"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","names":["listenerOptions","normalizePassiveListenerOptions","AutofillMonitor","_AutofillMonitor","_platform","_ngZone","elementOrRef","EMPTY","element","coerceElement","info","result","Subject","cssClass","listener","event","_info","ɵɵinject","Platform","NgZone","ɵɵdefineInjectable","TextFieldModule","_TextFieldModule","ɵɵdefineNgModule","ɵɵdefineInjector","MAT_INPUT_VALUE_ACCESSOR","InjectionToken","MAT_INPUT_INVALID_TYPES","nextUniqueId","MatInput","_MatInput","value","coerceBooleanProperty","Validators","getSupportedInputTypes","_elementRef","_platform","ngControl","parentForm","parentFormGroup","defaultErrorStateMatcher","inputValueAccessor","_autofillMonitor","ngZone","_formField","Subject","t","event","el","element","nodeName","_ErrorStateTracker","options","isFocused","newValue","placeholder","validity","selectElement","firstOption","ids","ɵɵdirectiveInject","ElementRef","Platform","NgControl","NgForm","FormGroupDirective","ErrorStateMatcher","AutofillMonitor","NgZone","MAT_FORM_FIELD","ɵɵdefineDirective","rf","ctx","ɵɵlistener","ɵɵhostProperty","ɵɵattribute","ɵɵclassProp","InputFlags","ɵɵProvidersFeature","MatFormFieldControl","ɵɵNgOnChangesFeature","MatInputModule","_MatInputModule","ɵɵdefineNgModule","ɵɵdefineInjector","MatCommonModule","MatFormFieldModule","TextFieldModule"],"x_google_ignoreList":[0,1]}