text: import * as i0 from '@angular/core';
  import { Version, InjectionToken, isDevMode, NgModule, Optional, Inject, inject, LOCALE_ID, Injectable, Directive, ElementRef, NgZone, Input, Component, ViewEncapsulation, ChangeDetectionStrategy, EventEmitter, ChangeDetectorRef, Output } from '@angular/core';
  import { HighContrastModeDetector, isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from '@angular/cdk/a11y';
  import { BidiModule } from '@angular/cdk/bidi';
  import { VERSION as VERSION$2 } from '@angular/cdk';
  import { DOCUMENT, CommonModule } from '@angular/common';
  import { coerceBooleanProperty, coerceNumberProperty, coerceElement } from '@angular/cdk/coercion';
  import { Subject, Observable } from 'rxjs';
  import { Platform, PlatformModule, normalizePassiveListenerOptions } from '@angular/cdk/platform';
  import { startWith } from 'rxjs/operators';
  import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
  import { ENTER, SPACE, hasModifierKey } from '@angular/cdk/keycodes';
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /** Current version of Angular Material. */
  const VERSION$1 = new Version('12.2.6');
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /** @docs-private */
  class AnimationCurves {
  }
  AnimationCurves.STANDARD_CURVE = 'cubic-bezier(0.4,0.0,0.2,1)';
  AnimationCurves.DECELERATION_CURVE = 'cubic-bezier(0.0,0.0,0.2,1)';
  AnimationCurves.ACCELERATION_CURVE = 'cubic-bezier(0.4,0.0,1,1)';
  AnimationCurves.SHARP_CURVE = 'cubic-bezier(0.4,0.0,0.6,1)';
  /** @docs-private */
  class AnimationDurations {
  }
  AnimationDurations.COMPLEX = '375ms';
  AnimationDurations.ENTERING = '225ms';
  AnimationDurations.EXITING = '195ms';
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  // Private version constant to circumvent test/build issues,
  // i.e. avoid core to depend on the @angular/material primary entry-point
  // Can be removed once the Material primary entry-point no longer
  // re-exports all secondary entry-points
  const VERSION = new Version('12.2.6');
  /** @docs-private */
  function MATERIAL_SANITY_CHECKS_FACTORY() {
      return true;
  }
  /** Injection token that configures whether the Material sanity checks are enabled. */
  const MATERIAL_SANITY_CHECKS = new InjectionToken('mat-sanity-checks', {
      providedIn: 'root',
      factory: MATERIAL_SANITY_CHECKS_FACTORY,
  });
  /**
   * Module that captures anything that should be loaded and/or run for *all* Angular Material
   * components. This includes Bidi, etc.
   *
   * This module should be imported to each top-level component module (e.g., MatTabsModule).
   */
  class MatCommonModule {
      constructor(highContrastModeDetector, sanityChecks, document) {
          /** Whether we've done the global sanity checks (e.g. a theme is loaded, there is a doctype). */
          this._hasDoneGlobalChecks = false;
          this._document = document;
          // While A11yModule also does this, we repeat it here to avoid importing A11yModule
          // in MatCommonModule.
          highContrastModeDetector._applyBodyHighContrastModeCssClasses();
          // Note that `_sanityChecks` is typed to `any`, because AoT
          // throws an error if we use the `SanityChecks` type directly.
          this._sanityChecks = sanityChecks;
          if (!this._hasDoneGlobalChecks) {
              this._checkDoctypeIsDefined();
              this._checkThemeIsPresent();
              this._checkCdkVersionMatch();
              this._hasDoneGlobalChecks = true;
          }
      }
      /** Use defaultView of injected document if available or fallback to global window reference */
      _getWindow() {
          const win = this._document.defaultView || window;
          return typeof win === 'object' && win ? win : null;
      }
      /** Gets whether a specific sanity check is enabled. */
      _checkIsEnabled(name) {
          // TODO(crisbeto): we can't use `ngDevMode` here yet, because ViewEngine apps might not support
          // it. Since these checks can have performance implications and they aren't tree shakeable
          // in their current form, we can leave the `isDevMode` check in for now.
          // tslint:disable-next-line:ban
          if (!isDevMode() || this._isTestEnv()) {
              return false;
          }
          if (typeof this._sanityChecks === 'boolean') {
              return this._sanityChecks;
          }
          return !!this._sanityChecks[name];
      }
      /** Whether the code is running in tests. */
      _isTestEnv() {
          const window = this._getWindow();
          return window && (window.__karma__ || window.jasmine);
      }
      _checkDoctypeIsDefined() {
          if (this._checkIsEnabled('doctype') && !this._document.doctype) {
              console.warn('Current document does not have a doctype. This may cause ' +
                  'some Angular Material components not to behave as expected.');
          }
      }
      _checkThemeIsPresent() {
          // We need to assert that the `body` is defined, because these checks run very early
          // and the `body` won't be defined if the consumer put their scripts in the `head`.
          if (!this._checkIsEnabled('theme') || !this._document.body ||
              typeof getComputedStyle !== 'function') {
              return;
          }
          const testElement = this._document.createElement('div');
          testElement.classList.add('mat-theme-loaded-marker');
          this._document.body.appendChild(testElement);
          const computedStyle = getComputedStyle(testElement);
          // In some situations the computed style of the test element can be null. For example in
          // Firefox, the computed style is null if an application is running inside of a hidden iframe.
          // See: https://bugzilla.mozilla.org/show_bug.cgi?id=548397
          if (computedStyle && computedStyle.display !== 'none') {
              console.warn('Could not find Angular Material core theme. Most Material ' +
                  'components may not work as expected. For more info refer ' +
                  'to the theming guide: https://material.angular.io/guide/theming');
          }
          this._document.body.removeChild(testElement);
      }
      /** Checks whether the material version matches the cdk version */
      _checkCdkVersionMatch() {
          if (this._checkIsEnabled('version') && VERSION.full !== VERSION$2.full) {
              console.warn('The Angular Material version (' + VERSION.full + ') does not match ' +
                  'the Angular CDK version (' + VERSION$2.full + ').\n' +
                  'Please ensure the versions of these two packages exactly match.');
          }
      }
  }
  MatCommonModule.decorators = [
      { type: NgModule, args: [{
                  imports: [BidiModule],
                  exports: [BidiModule],
              },] }
  ];
  MatCommonModule.ctorParameters = () => [
      { type: HighContrastModeDetector },
      { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MATERIAL_SANITY_CHECKS,] }] },
      { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function mixinDisabled(base) {
      return class extends base {
          constructor(...args) {
              super(...args);
              this._disabled = false;
          }
          get disabled() { return this._disabled; }
          set disabled(value) { this._disabled = coerceBooleanProperty(value); }
      };
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function mixinColor(base, defaultColor) {
      return class extends base {
          constructor(...args) {
              super(...args);
              this.defaultColor = defaultColor;
              // Set the default color that can be specified from the mixin.
              this.color = defaultColor;
          }
          get color() { return this._color; }
          set color(value) {
              const colorPalette = value || this.defaultColor;
              if (colorPalette !== this._color) {
                  if (this._color) {
                      this._elementRef.nativeElement.classList.remove(`mat-${this._color}`);
                  }
                  if (colorPalette) {
                      this._elementRef.nativeElement.classList.add(`mat-${colorPalette}`);
                  }
                  this._color = colorPalette;
              }
          }
      };
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function mixinDisableRipple(base) {
      return class extends base {
          constructor(...args) {
              super(...args);
              this._disableRipple = false;
          }
          /** Whether the ripple effect is disabled or not. */
          get disableRipple() { return this._disableRipple; }
          set disableRipple(value) { this._disableRipple = coerceBooleanProperty(value); }
      };
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function mixinTabIndex(base, defaultTabIndex = 0) {
      return class extends base {
          constructor(...args) {
              super(...args);
              this._tabIndex = defaultTabIndex;
              this.defaultTabIndex = defaultTabIndex;
          }
          get tabIndex() { return this.disabled ? -1 : this._tabIndex; }
          set tabIndex(value) {
              // If the specified tabIndex value is null or undefined, fall back to the default value.
              this._tabIndex = value != null ? coerceNumberProperty(value) : this.defaultTabIndex;
          }
      };
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function mixinErrorState(base) {
      return class extends base {
          constructor(...args) {
              super(...args);
              // This class member exists as an interop with `MatFormFieldControl` which expects
              // a public `stateChanges` observable to emit whenever the form field should be updated.
              // The description is not specifically mentioning the error state, as classes using this
              // mixin can/should emit an event in other cases too.
              /** Emits whenever the component state changes. */
              this.stateChanges = new Subject();
              /** Whether the component is in an error state. */
              this.errorState = false;
          }
          /** Updates the error state based on the provided error state matcher. */
          updateErrorState() {
              const oldState = this.errorState;
              const parent = this._parentFormGroup || this._parentForm;
              const matcher = this.errorStateMatcher || this._defaultErrorStateMatcher;
              const control = this.ngControl ? this.ngControl.control : null;
              const newState = matcher.isErrorState(control, parent);
              if (newState !== oldState) {
                  this.errorState = newState;
                  this.stateChanges.next();
              }
          }
      };
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /** Mixin to augment a directive with an initialized property that will emits when ngOnInit ends. */
  function mixinInitialized(base) {
      return class extends base {
          constructor(...args) {
              super(...args);
              /** Whether this directive has been marked as initialized. */
              this._isInitialized = false;
              /**
               * List of subscribers that subscribed before the directive was initialized. Should be notified
               * during _markInitialized. Set to null after pending subscribers are notified, and should
               * not expect to be populated after.
               */
              this._pendingSubscribers = [];
              /**
               * Observable stream that emits when the directive initializes. If already initialized, the
               * subscriber is stored to be notified once _markInitialized is called.
               */
              this.initialized = new Observable(subscriber => {
                  // If initialized, immediately notify the subscriber. Otherwise store the subscriber to notify
                  // when _markInitialized is called.
                  if (this._isInitialized) {
                      this._notifySubscriber(subscriber);
                  }
                  else {
                      this._pendingSubscribers.push(subscriber);
                  }
              });
          }
          /**
           * Marks the state as initialized and notifies pending subscribers. Should be called at the end
           * of ngOnInit.
           * @docs-private
           */
          _markInitialized() {
              if (this._isInitialized && (typeof ngDevMode === 'undefined' || ngDevMode)) {
                  throw Error('This directive has already been marked as initialized and ' +
                      'should not be called twice.');
              }
              this._isInitialized = true;
              this._pendingSubscribers.forEach(this._notifySubscriber);
              this._pendingSubscribers = null;
          }
          /** Emits and completes the subscriber stream (should only emit once). */
          _notifySubscriber(subscriber) {
              subscriber.next();
              subscriber.complete();
          }
      };
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /** InjectionToken for datepicker that can be used to override default locale code. */
  const MAT_DATE_LOCALE = new InjectionToken('MAT_DATE_LOCALE', {
      providedIn: 'root',
      factory: MAT_DATE_LOCALE_FACTORY,
  });
  /** @docs-private */
  function MAT_DATE_LOCALE_FACTORY() {
      return inject(LOCALE_ID);
  }
  /** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */
  class DateAdapter {
      constructor() {
          this._localeChanges = new Subject();
          /** A stream that emits when the locale changes. */
          this.localeChanges = this._localeChanges;
      }
      /**
       * Given a potential date object, returns that same date object if it is
       * a valid date, or `null` if it's not a valid date.
       * @param obj The object to check.
       * @returns A date or `null`.
       */
      getValidDateOrNull(obj) {
          return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;
      }
      /**
       * Attempts to deserialize a value to a valid date object. This is different from parsing in that
       * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
       * string). The default implementation does not allow any deserialization, it simply checks that
       * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
       * method on all of its `@Input()` properties that accept dates. It is therefore possible to
       * support passing values from your backend directly to these properties by overriding this method
       * to also deserialize the format used by your backend.
       * @param value The value to be deserialized into a date object.
       * @returns The deserialized date object, either a valid date, null if the value can be
       *     deserialized into a null date (e.g. the empty string), or an invalid date.
       */
      deserialize(value) {
          if (value == null || this.isDateInstance(value) && this.isValid(value)) {
              return value;
          }
          return this.invalid();
      }
      /**
       * Sets the locale used for all dates.
       * @param locale The new locale.
       */
      setLocale(locale) {
          this.locale = locale;
          this._localeChanges.next();
      }
      /**
       * Compares two dates.
       * @param first The first date to compare.
       * @param second The second date to compare.
       * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
       *     a number greater than 0 if the first date is later.
       */
      compareDate(first, second) {
          return this.getYear(first) - this.getYear(second) ||
              this.getMonth(first) - this.getMonth(second) ||
              this.getDate(first) - this.getDate(second);
      }
      /**
       * Checks if two dates are equal.
       * @param first The first date to check.
       * @param second The second date to check.
       * @returns Whether the two dates are equal.
       *     Null dates are considered equal to other null dates.
       */
      sameDate(first, second) {
          if (first && second) {
              let firstValid = this.isValid(first);
              let secondValid = this.isValid(second);
              if (firstValid && secondValid) {
                  return !this.compareDate(first, second);
              }
              return firstValid == secondValid;
          }
          return first == second;
      }
      /**
       * Clamp the given date between min and max dates.
       * @param date The date to clamp.
       * @param min The minimum value to allow. If null or omitted no min is enforced.
       * @param max The maximum value to allow. If null or omitted no max is enforced.
       * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
       *     otherwise `date`.
       */
      clampDate(date, min, max) {
          if (min && this.compareDate(date, min) < 0) {
              return min;
          }
          if (max && this.compareDate(date, max) > 0) {
              return max;
          }
          return date;
      }
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  const MAT_DATE_FORMATS = new InjectionToken('mat-date-formats');
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  // TODO(mmalerba): Remove when we no longer support safari 9.
  /** Whether the browser supports the Intl API. */
  let SUPPORTS_INTL_API;
  // We need a try/catch around the reference to `Intl`, because accessing it in some cases can
  // cause IE to throw. These cases are tied to particular versions of Windows and can happen if
  // the consumer is providing a polyfilled `Map`. See:
  // https://github.com/Microsoft/ChakraCore/issues/3189
  // https://github.com/angular/components/issues/15687
  try {
      SUPPORTS_INTL_API = typeof Intl != 'undefined';
  }
  catch (_a) {
      SUPPORTS_INTL_API = false;
  }
  /** The default month names to use if Intl API is not available. */
  const DEFAULT_MONTH_NAMES = {
      'long': [
          'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
          'October', 'November', 'December'
      ],
      'short': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
      'narrow': ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']
  };
  const ɵ0$1 = i => String(i + 1);
  /** The default date names to use if Intl API is not available. */
  const DEFAULT_DATE_NAMES = range(31, ɵ0$1);
  /** The default day of the week names to use if Intl API is not available. */
  const DEFAULT_DAY_OF_WEEK_NAMES = {
      'long': ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
      'short': ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
      'narrow': ['S', 'M', 'T', 'W', 'T', 'F', 'S']
  };
  /**
   * Matches strings that have the form of a valid RFC 3339 string
   * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date
   * because the regex will match strings an with out of bounds month, date, etc.
   */
  const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
  /** Creates an array and fills it with values. */
  function range(length, valueFunction) {
      const valuesArray = Array(length);
      for (let i = 0; i < length; i++) {
          valuesArray[i] = valueFunction(i);
      }
      return valuesArray;
  }
  /** Adapts the native JS Date for use with cdk-based components that work with dates. */
  class NativeDateAdapter extends DateAdapter {
      constructor(matDateLocale, platform) {
          super();
          /**
           * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.
           * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off
           * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`
           * will produce `'8/13/1800'`.
           *
           * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now
           * getting the string representation of a Date object from its utc representation. We're keeping
           * it here for sometime, just for precaution, in case we decide to revert some of these changes
           * though.
           */
          this.useUtcForDisplay = true;
          super.setLocale(matDateLocale);
          // IE does its own time zone correction, so we disable this on IE.
          this.useUtcForDisplay = !platform.TRIDENT;
          this._clampDate = platform.TRIDENT || platform.EDGE;
      }
      getYear(date) {
          return date.getFullYear();
      }
      getMonth(date) {
          return date.getMonth();
      }
      getDate(date) {
          return date.getDate();
      }
      getDayOfWeek(date) {
          return date.getDay();
      }
      getMonthNames(style) {
          if (SUPPORTS_INTL_API) {
              const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });
              return range(12, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, i, 1))));
          }
          return DEFAULT_MONTH_NAMES[style];
      }
      getDateNames() {
          if (SUPPORTS_INTL_API) {
              const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });
              return range(31, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1))));
          }
          return DEFAULT_DATE_NAMES;
      }
      getDayOfWeekNames(style) {
          if (SUPPORTS_INTL_API) {
              const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });
              return range(7, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1))));
          }
          return DEFAULT_DAY_OF_WEEK_NAMES[style];
      }
      getYearName(date) {
          if (SUPPORTS_INTL_API) {
              const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });
              return this._stripDirectionalityCharacters(this._format(dtf, date));
          }
          return String(this.getYear(date));
      }
      getFirstDayOfWeek() {
          // We can't tell using native JS Date what the first day of the week is, we default to Sunday.
          return 0;
      }
      getNumDaysInMonth(date) {
          return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));
      }
      clone(date) {
          return new Date(date.getTime());
      }
      createDate(year, month, date) {
          if (typeof ngDevMode === 'undefined' || ngDevMode) {
              // Check for invalid month and date (except upper bound on date which we have to check after
              // creating the Date).
              if (month < 0 || month > 11) {
                  throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
              }
              if (date < 1) {
                  throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
              }
          }
          let result = this._createDateWithOverflow(year, month, date);
          // Check that the date wasn't above the upper bound for the month, causing the month to overflow
          if (result.getMonth() != month && (typeof ngDevMode === 'undefined' || ngDevMode)) {
              throw Error(`Invalid date "${date}" for month with index "${month}".`);
          }
          return result;
      }
      today() {
          return new Date();
      }
      parse(value) {
          // We have no way using the native JS Date to set the parse format or locale, so we ignore these
          // parameters.
          if (typeof value == 'number') {
              return new Date(value);
          }
          return value ? new Date(Date.parse(value)) : null;
      }
      format(date, displayFormat) {
          if (!this.isValid(date)) {
              throw Error('NativeDateAdapter: Cannot format invalid date.');
          }
          if (SUPPORTS_INTL_API) {
              // On IE and Edge the i18n API will throw a hard error that can crash the entire app
              // if we attempt to format a date whose year is less than 1 or greater than 9999.
              if (this._clampDate && (date.getFullYear() < 1 || date.getFullYear() > 9999)) {
                  date = this.clone(date);
                  date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));
              }
              displayFormat = Object.assign(Object.assign({}, displayFormat), { timeZone: 'utc' });
              const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);
              return this._stripDirectionalityCharacters(this._format(dtf, date));
          }
          return this._stripDirectionalityCharacters(date.toDateString());
      }
      addCalendarYears(date, years) {
          return this.addCalendarMonths(date, years * 12);
      }
      addCalendarMonths(date, months) {
          let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));
          // It's possible to wind up in the wrong month if the original month has more days than the new
          // month. In this case we want to go to the last day of the desired month.
          // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't
          // guarantee this.
          if (this.getMonth(newDate) != ((this.getMonth(date) + months) % 12 + 12) % 12) {
              newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);
          }
          return newDate;
      }
      addCalendarDays(date, days) {
          return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);
      }
      toIso8601(date) {
          return [
              date.getUTCFullYear(),
              this._2digit(date.getUTCMonth() + 1),
              this._2digit(date.getUTCDate())
          ].join('-');
      }
      /**
       * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
       * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
       * invalid date for all other values.
       */
      deserialize(value) {
          if (typeof value === 'string') {
              if (!value) {
                  return null;
              }
              // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the
              // string is the right format first.
              if (ISO_8601_REGEX.test(value)) {
                  let date = new Date(value);
                  if (this.isValid(date)) {
                      return date;
                  }
              }
          }
          return super.deserialize(value);
      }
      isDateInstance(obj) {
          return obj instanceof Date;
      }
      isValid(date) {
          return !isNaN(date.getTime());
      }
      invalid() {
          return new Date(NaN);
      }
      /** Creates a date but allows the month and date to overflow. */
      _createDateWithOverflow(year, month, date) {
          // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
          // To work around this we use `setFullYear` and `setHours` instead.
          const d = new Date();
          d.setFullYear(year, month, date);
          d.setHours(0, 0, 0, 0);
          return d;
      }
      /**
       * Pads a number to make it two digits.
       * @param n The number to pad.
       * @returns The padded number.
       */
      _2digit(n) {
          return ('00' + n).slice(-2);
      }
      /**
       * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
       * other browsers do not. We remove them to make output consistent and because they interfere with
       * date parsing.
       * @param str The string to strip direction characters from.
       * @returns The stripped string.
       */
      _stripDirectionalityCharacters(str) {
          return str.replace(/[\u200e\u200f]/g, '');
      }
      /**
       * When converting Date object to string, javascript built-in functions may return wrong
       * results because it applies its internal DST rules. The DST rules around the world change
       * very frequently, and the current valid rule is not always valid in previous years though.
       * We work around this problem building a new Date object which has its internal UTC
       * representation with the local date and time.
       * @param dtf Intl.DateTimeFormat object, containg the desired string format. It must have
       *    timeZone set to 'utc' to work fine.
       * @param date Date from which we want to get the string representation according to dtf
       * @returns A Date object with its UTC representation based on the passed in date info
       */
      _format(dtf, date) {
          // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
          // To work around this we use `setUTCFullYear` and `setUTCHours` instead.
          const d = new Date();
          d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());
          d.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
          return dtf.format(d);
      }
  }
  NativeDateAdapter.decorators = [
      { type: Injectable }
  ];
  NativeDateAdapter.ctorParameters = () => [
      { type: String, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_LOCALE,] }] },
      { type: Platform }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  const MAT_NATIVE_DATE_FORMATS = {
      parse: {
          dateInput: null,
      },
      display: {
          dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },
          monthYearLabel: { year: 'numeric', month: 'short' },
          dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
          monthYearA11yLabel: { year: 'numeric', month: 'long' },
      }
  };
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  class NativeDateModule {
  }
  NativeDateModule.decorators = [
      { type: NgModule, args: [{
                  imports: [PlatformModule],
                  providers: [
                      { provide: DateAdapter, useClass: NativeDateAdapter },
                  ],
              },] }
  ];
  const ɵ0 = MAT_NATIVE_DATE_FORMATS;
  class MatNativeDateModule {
  }
  MatNativeDateModule.decorators = [
      { type: NgModule, args: [{
                  imports: [NativeDateModule],
                  providers: [{ provide: MAT_DATE_FORMATS, useValue: ɵ0 }],
              },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /** Error state matcher that matches when a control is invalid and dirty. */
  class ShowOnDirtyErrorStateMatcher {
      isErrorState(control, form) {
          return !!(control && control.invalid && (control.dirty || (form && form.submitted)));
      }
  }
  ShowOnDirtyErrorStateMatcher.decorators = [
      { type: Injectable }
  ];
  /** Provider that defines how form controls behave with regards to displaying error messages. */
  class ErrorStateMatcher {
      isErrorState(control, form) {
          return !!(control && control.invalid && (control.touched || (form && form.submitted)));
      }
  }
  ErrorStateMatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function ErrorStateMatcher_Factory() { return new ErrorStateMatcher(); }, token: ErrorStateMatcher, providedIn: "root" });
  ErrorStateMatcher.decorators = [
      { type: Injectable, args: [{ providedIn: 'root' },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Shared directive to count lines inside a text area, such as a list item.
   * Line elements can be extracted with a @ContentChildren(MatLine) query, then
   * counted by checking the query list's length.
   */
  class MatLine {
  }
  MatLine.decorators = [
      { type: Directive, args: [{
                  selector: '[mat-line], [matLine]',
                  host: { 'class': 'mat-line' }
              },] }
  ];
  /**
   * Helper that takes a query list of lines and sets the correct class on the host.
   * @docs-private
   */
  function setLines(lines, element, prefix = 'mat') {
      // Note: doesn't need to unsubscribe, because `changes`
      // gets completed by Angular when the view is destroyed.
      lines.changes.pipe(startWith(lines)).subscribe(({ length }) => {
          setClass(element, `${prefix}-2-line`, false);
          setClass(element, `${prefix}-3-line`, false);
          setClass(element, `${prefix}-multi-line`, false);
          if (length === 2 || length === 3) {
              setClass(element, `${prefix}-${length}-line`, true);
          }
          else if (length > 3) {
              setClass(element, `${prefix}-multi-line`, true);
          }
      });
  }
  /** Adds or removes a class from an element. */
  function setClass(element, className, isAdd) {
      const classList = element.nativeElement.classList;
      isAdd ? classList.add(className) : classList.remove(className);
  }
  class MatLineModule {
  }
  MatLineModule.decorators = [
      { type: NgModule, args: [{
                  imports: [MatCommonModule],
                  exports: [MatLine, MatCommonModule],
                  declarations: [MatLine],
              },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Reference to a previously launched ripple element.
   */
  class RippleRef {
      constructor(_renderer, 
      /** Reference to the ripple HTML element. */
      element, 
      /** Ripple configuration used for the ripple. */
      config) {
          this._renderer = _renderer;
          this.element = element;
          this.config = config;
          /** Current state of the ripple. */
          this.state = 3 /* HIDDEN */;
      }
      /** Fades out the ripple element. */
      fadeOut() {
          this._renderer.fadeOutRipple(this);
      }
  }
  
  // TODO: import these values from `@material/ripple` eventually.
  /**
   * Default ripple animation configuration for ripples without an explicit
   * animation config specified.
   */
  const defaultRippleAnimationConfig = {
      enterDuration: 225,
      exitDuration: 150
  };
  /**
   * Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch
   * events to avoid synthetic mouse events.
   */
  const ignoreMouseEventsTimeout = 800;
  /** Options that apply to all the event listeners that are bound by the ripple renderer. */
  const passiveEventOptions = normalizePassiveListenerOptions({ passive: true });
  /** Events that signal that the pointer is down. */
  const pointerDownEvents = ['mousedown', 'touchstart'];
  /** Events that signal that the pointer is up. */
  const pointerUpEvents = ['mouseup', 'mouseleave', 'touchend', 'touchcancel'];
  /**
   * Helper service that performs DOM manipulations. Not intended to be used outside this module.
   * The constructor takes a reference to the ripple directive's host element and a map of DOM
   * event handlers to be installed on the element that triggers ripple animations.
   * This will eventually become a custom renderer once Angular support exists.
   * @docs-private
   */
  class RippleRenderer {
      constructor(_target, _ngZone, elementOrElementRef, platform) {
          this._target = _target;
          this._ngZone = _ngZone;
          /** Whether the pointer is currently down or not. */
          this._isPointerDown = false;
          /** Set of currently active ripple references. */
          this._activeRipples = new Set();
          /** Whether pointer-up event listeners have been registered. */
          this._pointerUpEventsRegistered = false;
          // Only do anything if we're on the browser.
          if (platform.isBrowser) {
              this._containerElement = coerceElement(elementOrElementRef);
          }
      }
      /**
       * Fades in a ripple at the given coordinates.
       * @param x Coordinate within the element, along the X axis at which to start the ripple.
       * @param y Coordinate within the element, along the Y axis at which to start the ripple.
       * @param config Extra ripple options.
       */
      fadeInRipple(x, y, config = {}) {
          const containerRect = this._containerRect =
              this._containerRect || this._containerElement.getBoundingClientRect();
          const animationConfig = Object.assign(Object.assign({}, defaultRippleAnimationConfig), config.animation);
          if (config.centered) {
              x = containerRect.left + containerRect.width / 2;
              y = containerRect.top + containerRect.height / 2;
          }
          const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);
          const offsetX = x - containerRect.left;
          const offsetY = y - containerRect.top;
          const duration = animationConfig.enterDuration;
          const ripple = document.createElement('div');
          ripple.classList.add('mat-ripple-element');
          ripple.style.left = `${offsetX - radius}px`;
          ripple.style.top = `${offsetY - radius}px`;
          ripple.style.height = `${radius * 2}px`;
          ripple.style.width = `${radius * 2}px`;
          // If a custom color has been specified, set it as inline style. If no color is
          // set, the default color will be applied through the ripple theme styles.
          if (config.color != null) {
              ripple.style.backgroundColor = config.color;
          }
          ripple.style.transitionDuration = `${duration}ms`;
          this._containerElement.appendChild(ripple);
          // By default the browser does not recalculate the styles of dynamically created
          // ripple elements. This is critical because then the `scale` would not animate properly.
          enforceStyleRecalculation(ripple);
          ripple.style.transform = 'scale(1)';
          // Exposed reference to the ripple that will be returned.
          const rippleRef = new RippleRef(this, ripple, config);
          rippleRef.state = 0 /* FADING_IN */;
          // Add the ripple reference to the list of all active ripples.
          this._activeRipples.add(rippleRef);
          if (!config.persistent) {
              this._mostRecentTransientRipple = rippleRef;
          }
          // Wait for the ripple element to be completely faded in.
          // Once it's faded in, the ripple can be hidden immediately if the mouse is released.
          this._runTimeoutOutsideZone(() => {
              const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;
              rippleRef.state = 1 /* VISIBLE */;
              // When the timer runs out while the user has kept their pointer down, we want to
              // keep only the persistent ripples and the latest transient ripple. We do this,
              // because we don't want stacked transient ripples to appear after their enter
              // animation has finished.
              if (!config.persistent && (!isMostRecentTransientRipple || !this._isPointerDown)) {
                  rippleRef.fadeOut();
              }
          }, duration);
          return rippleRef;
      }
      /** Fades out a ripple reference. */
      fadeOutRipple(rippleRef) {
          const wasActive = this._activeRipples.delete(rippleRef);
          if (rippleRef === this._mostRecentTransientRipple) {
              this._mostRecentTransientRipple = null;
          }
          // Clear out the cached bounding rect if we have no more ripples.
          if (!this._activeRipples.size) {
              this._containerRect = null;
          }
          // For ripples that are not active anymore, don't re-run the fade-out animation.
          if (!wasActive) {
              return;
          }
          const rippleEl = rippleRef.element;
          const animationConfig = Object.assign(Object.assign({}, defaultRippleAnimationConfig), rippleRef.config.animation);
          rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;
          rippleEl.style.opacity = '0';
          rippleRef.state = 2 /* FADING_OUT */;
          // Once the ripple faded out, the ripple can be safely removed from the DOM.
          this._runTimeoutOutsideZone(() => {
              rippleRef.state = 3 /* HIDDEN */;
              rippleEl.parentNode.removeChild(rippleEl);
          }, animationConfig.exitDuration);
      }
      /** Fades out all currently active ripples. */
      fadeOutAll() {
          this._activeRipples.forEach(ripple => ripple.fadeOut());
      }
      /** Fades out all currently active non-persistent ripples. */
      fadeOutAllNonPersistent() {
          this._activeRipples.forEach(ripple => {
              if (!ripple.config.persistent) {
                  ripple.fadeOut();
              }
          });
      }
      /** Sets up the trigger event listeners */
      setupTriggerEvents(elementOrElementRef) {
          const element = coerceElement(elementOrElementRef);
          if (!element || element === this._triggerElement) {
              return;
          }
          // Remove all previously registered event listeners from the trigger element.
          this._removeTriggerEvents();
          this._triggerElement = element;
          this._registerEvents(pointerDownEvents);
      }
      /**
       * Handles all registered events.
       * @docs-private
       */
      handleEvent(event) {
          if (event.type === 'mousedown') {
              this._onMousedown(event);
          }
          else if (event.type === 'touchstart') {
              this._onTouchStart(event);
          }
          else {
              this._onPointerUp();
          }
          // If pointer-up events haven't been registered yet, do so now.
          // We do this on-demand in order to reduce the total number of event listeners
          // registered by the ripples, which speeds up the rendering time for large UIs.
          if (!this._pointerUpEventsRegistered) {
              this._registerEvents(pointerUpEvents);
              this._pointerUpEventsRegistered = true;
          }
      }
      /** Function being called whenever the trigger is being pressed using mouse. */
      _onMousedown(event) {
          // Screen readers will fire fake mouse events for space/enter. Skip launching a
          // ripple in this case for consistency with the non-screen-reader experience.
          const isFakeMousedown = isFakeMousedownFromScreenReader(event);
          const isSyntheticEvent = this._lastTouchStartEvent &&
              Date.now() < this._lastTouchStartEvent + ignoreMouseEventsTimeout;
          if (!this._target.rippleDisabled && !isFakeMousedown && !isSyntheticEvent) {
              this._isPointerDown = true;
              this.fadeInRipple(event.clientX, event.clientY, this._target.rippleConfig);
          }
      }
      /** Function being called whenever the trigger is being pressed using touch. */
      _onTouchStart(event) {
          if (!this._target.rippleDisabled && !isFakeTouchstartFromScreenReader(event)) {
              // Some browsers fire mouse events after a `touchstart` event. Those synthetic mouse
              // events will launch a second ripple if we don't ignore mouse events for a specific
              // time after a touchstart event.
              this._lastTouchStartEvent = Date.now();
              this._isPointerDown = true;
              // Use `changedTouches` so we skip any touches where the user put
              // their finger down, but used another finger to tap the element again.
              const touches = event.changedTouches;
              for (let i = 0; i < touches.length; i++) {
                  this.fadeInRipple(touches[i].clientX, touches[i].clientY, this._target.rippleConfig);
              }
          }
      }
      /** Function being called whenever the trigger is being released. */
      _onPointerUp() {
          if (!this._isPointerDown) {
              return;
          }
          this._isPointerDown = false;
          // Fade-out all ripples that are visible and not persistent.
          this._activeRipples.forEach(ripple => {
              // By default, only ripples that are completely visible will fade out on pointer release.
              // If the `terminateOnPointerUp` option is set, ripples that still fade in will also fade out.
              const isVisible = ripple.state === 1 /* VISIBLE */ ||
                  ripple.config.terminateOnPointerUp && ripple.state === 0 /* FADING_IN */;
              if (!ripple.config.persistent && isVisible) {
                  ripple.fadeOut();
              }
          });
      }
      /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
      _runTimeoutOutsideZone(fn, delay = 0) {
          this._ngZone.runOutsideAngular(() => setTimeout(fn, delay));
      }
      /** Registers event listeners for a given list of events. */
      _registerEvents(eventTypes) {
          this._ngZone.runOutsideAngular(() => {
              eventTypes.forEach((type) => {
                  this._triggerElement.addEventListener(type, this, passiveEventOptions);
              });
          });
      }
      /** Removes previously registered event listeners from the trigger element. */
      _removeTriggerEvents() {
          if (this._triggerElement) {
              pointerDownEvents.forEach((type) => {
                  this._triggerElement.removeEventListener(type, this, passiveEventOptions);
              });
              if (this._pointerUpEventsRegistered) {
                  pointerUpEvents.forEach((type) => {
                      this._triggerElement.removeEventListener(type, this, passiveEventOptions);
                  });
              }
          }
      }
  }
  /** Enforces a style recalculation of a DOM element by computing its styles. */
  function enforceStyleRecalculation(element) {
      // Enforce a style recalculation by calling `getComputedStyle` and accessing any property.
      // Calling `getPropertyValue` is important to let optimizers know that this is not a noop.
      // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a
      window.getComputedStyle(element).getPropertyValue('opacity');
  }
  /**
   * Returns the distance from the point (x, y) to the furthest corner of a rectangle.
   */
  function distanceToFurthestCorner(x, y, rect) {
      const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));
      const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));
      return Math.sqrt(distX * distX + distY * distY);
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /** Injection token that can be used to specify the global ripple options. */
  const MAT_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('mat-ripple-global-options');
  class MatRipple {
      constructor(_elementRef, ngZone, platform, globalOptions, _animationMode) {
          this._elementRef = _elementRef;
          this._animationMode = _animationMode;
          /**
           * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
           * will be the distance from the center of the ripple to the furthest corner of the host element's
           * bounding rectangle.
           */
          this.radius = 0;
          this._disabled = false;
          /** Whether ripple directive is initialized and the input bindings are set. */
          this._isInitialized = false;
          this._globalOptions = globalOptions || {};
          this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);
      }
      /**
       * Whether click events will not trigger the ripple. Ripples can be still launched manually
       * by using the `launch()` method.
       */
      get disabled() { return this._disabled; }
      set disabled(value) {
          if (value) {
              this.fadeOutAllNonPersistent();
          }
          this._disabled = value;
          this._setupTriggerEventsIfEnabled();
      }
      /**
       * The element that triggers the ripple when click events are received.
       * Defaults to the directive's host element.
       */
      get trigger() { return this._trigger || this._elementRef.nativeElement; }
      set trigger(trigger) {
          this._trigger = trigger;
          this._setupTriggerEventsIfEnabled();
      }
      ngOnInit() {
          this._isInitialized = true;
          this._setupTriggerEventsIfEnabled();
      }
      ngOnDestroy() {
          this._rippleRenderer._removeTriggerEvents();
      }
      /** Fades out all currently showing ripple elements. */
      fadeOutAll() {
          this._rippleRenderer.fadeOutAll();
      }
      /** Fades out all currently showing non-persistent ripple elements. */
      fadeOutAllNonPersistent() {
          this._rippleRenderer.fadeOutAllNonPersistent();
      }
      /**
       * Ripple configuration from the directive's input values.
       * @docs-private Implemented as part of RippleTarget
       */
      get rippleConfig() {
          return {
              centered: this.centered,
              radius: this.radius,
              color: this.color,
              animation: Object.assign(Object.assign(Object.assign({}, this._globalOptions.animation), (this._animationMode === 'NoopAnimations' ? { enterDuration: 0, exitDuration: 0 } : {})), this.animation),
              terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,
          };
      }
      /**
       * Whether ripples on pointer-down are disabled or not.
       * @docs-private Implemented as part of RippleTarget
       */
      get rippleDisabled() {
          return this.disabled || !!this._globalOptions.disabled;
      }
      /** Sets up the trigger event listeners if ripples are enabled. */
      _setupTriggerEventsIfEnabled() {
          if (!this.disabled && this._isInitialized) {
              this._rippleRenderer.setupTriggerEvents(this.trigger);
          }
      }
      /** Launches a manual ripple at the specified coordinated or just by the ripple config. */
      launch(configOrX, y = 0, config) {
          if (typeof configOrX === 'number') {
              return this._rippleRenderer.fadeInRipple(configOrX, y, Object.assign(Object.assign({}, this.rippleConfig), config));
          }
          else {
              return this._rippleRenderer.fadeInRipple(0, 0, Object.assign(Object.assign({}, this.rippleConfig), configOrX));
          }
      }
  }
  MatRipple.decorators = [
      { type: Directive, args: [{
                  selector: '[mat-ripple], [matRipple]',
                  exportAs: 'matRipple',
                  host: {
                      'class': 'mat-ripple',
                      '[class.mat-ripple-unbounded]': 'unbounded'
                  }
              },] }
  ];
  MatRipple.ctorParameters = () => [
      { type: ElementRef },
      { type: NgZone },
      { type: Platform },
      { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_RIPPLE_GLOBAL_OPTIONS,] }] },
      { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }
  ];
  MatRipple.propDecorators = {
      color: [{ type: Input, args: ['matRippleColor',] }],
      unbounded: [{ type: Input, args: ['matRippleUnbounded',] }],
      centered: [{ type: Input, args: ['matRippleCentered',] }],
      radius: [{ type: Input, args: ['matRippleRadius',] }],
      animation: [{ type: Input, args: ['matRippleAnimation',] }],
      disabled: [{ type: Input, args: ['matRippleDisabled',] }],
      trigger: [{ type: Input, args: ['matRippleTrigger',] }]
  };
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  class MatRippleModule {
  }
  MatRippleModule.decorators = [
      { type: NgModule, args: [{
                  imports: [MatCommonModule, PlatformModule],
                  exports: [MatRipple, MatCommonModule],
                  declarations: [MatRipple],
              },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Component that shows a simplified checkbox without including any kind of "real" checkbox.
   * Meant to be used when the checkbox is purely decorative and a large number of them will be
   * included, such as for the options in a multi-select. Uses no SVGs or complex animations.
   * Note that theming is meant to be handled by the parent element, e.g.
   * `mat-primary .mat-pseudo-checkbox`.
   *
   * Note that this component will be completely invisible to screen-reader users. This is *not*
   * interchangeable with `<mat-checkbox>` and should *not* be used if the user would directly
   * interact with the checkbox. The pseudo-checkbox should only be used as an implementation detail
   * of more complex components that appropriately handle selected / checked state.
   * @docs-private
   */
  class MatPseudoCheckbox {
      constructor(_animationMode) {
          this._animationMode = _animationMode;
          /** Display state of the checkbox. */
          this.state = 'unchecked';
          /** Whether the checkbox is disabled. */
          this.disabled = false;
      }
  }
  MatPseudoCheckbox.decorators = [
      { type: Component, args: [{
                  encapsulation: ViewEncapsulation.None,
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  selector: 'mat-pseudo-checkbox',
                  template: '',
                  host: {
                      'class': 'mat-pseudo-checkbox',
                      '[class.mat-pseudo-checkbox-indeterminate]': 'state === "indeterminate"',
                      '[class.mat-pseudo-checkbox-checked]': 'state === "checked"',
                      '[class.mat-pseudo-checkbox-disabled]': 'disabled',
                      '[class._mat-animation-noopable]': '_animationMode === "NoopAnimations"',
                  },
                  styles: [".mat-pseudo-checkbox{width:16px;height:16px;border:2px solid;border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:\"\";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox.mat-pseudo-checkbox-indeterminate{border-color:transparent}._mat-animation-noopable.mat-pseudo-checkbox{transition:none;animation:none}._mat-animation-noopable.mat-pseudo-checkbox::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{top:5px;left:1px;width:10px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{top:2.4px;left:1px;width:8px;height:3px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}\n"]
              },] }
  ];
  MatPseudoCheckbox.ctorParameters = () => [
      { type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }
  ];
  MatPseudoCheckbox.propDecorators = {
      state: [{ type: Input }],
      disabled: [{ type: Input }]
  };
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  class MatPseudoCheckboxModule {
  }
  MatPseudoCheckboxModule.decorators = [
      { type: NgModule, args: [{
                  imports: [MatCommonModule],
                  exports: [MatPseudoCheckbox],
                  declarations: [MatPseudoCheckbox]
              },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Injection token used to provide the parent component to options.
   */
  const MAT_OPTION_PARENT_COMPONENT = new InjectionToken('MAT_OPTION_PARENT_COMPONENT');
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  // Notes on the accessibility pattern used for `mat-optgroup`.
  // The option group has two different "modes": regular and inert. The regular mode uses the
  // recommended a11y pattern which has `role="group"` on the group element with `aria-labelledby`
  // pointing to the label. This works for `mat-select`, but it seems to hit a bug for autocomplete
  // under VoiceOver where the group doesn't get read out at all. The bug appears to be that if
  // there's __any__ a11y-related attribute on the group (e.g. `role` or `aria-labelledby`),
  // VoiceOver on Safari won't read it out.
  // We've introduced the `inert` mode as a workaround. Under this mode, all a11y attributes are
  // removed from the group, and we get the screen reader to read out the group label by mirroring it
  // inside an invisible element in the option. This is sub-optimal, because the screen reader will
  // repeat the group label on each navigation, whereas the default pattern only reads the group when
  // the user enters a new group. The following alternate approaches were considered:
  // 1. Reading out the group label using the `LiveAnnouncer` solves the problem, but we can't control
  //    when the text will be read out so sometimes it comes in too late or never if the user
  //    navigates quickly.
  // 2. `<mat-option aria-describedby="groupLabel"` - This works on Safari, but VoiceOver in Chrome
  //    won't read out the description at all.
  // 3. `<mat-option aria-labelledby="optionLabel groupLabel"` - This works on Chrome, but Safari
  //     doesn't read out the text at all. Furthermore, on
  // Boilerplate for applying mixins to MatOptgroup.
  /** @docs-private */
  const _MatOptgroupMixinBase = mixinDisabled(class {
  });
  // Counter for unique group ids.
  let _uniqueOptgroupIdCounter = 0;
  class _MatOptgroupBase extends _MatOptgroupMixinBase {
      constructor(parent) {
          var _a;
          super();
          /** Unique id for the underlying label. */
          this._labelId = `mat-optgroup-label-${_uniqueOptgroupIdCounter++}`;
          this._inert = (_a = parent === null || parent === void 0 ? void 0 : parent.inertGroups) !== null && _a !== void 0 ? _a : false;
      }
  }
  _MatOptgroupBase.decorators = [
      { type: Directive }
  ];
  _MatOptgroupBase.ctorParameters = () => [
      { type: undefined, decorators: [{ type: Inject, args: [MAT_OPTION_PARENT_COMPONENT,] }, { type: Optional }] }
  ];
  _MatOptgroupBase.propDecorators = {
      label: [{ type: Input }]
  };
  /**
   * Injection token that can be used to reference instances of `MatOptgroup`. It serves as
   * alternative token to the actual `MatOptgroup` class which could cause unnecessary
   * retention of the class and its component metadata.
   */
  const MAT_OPTGROUP = new InjectionToken('MatOptgroup');
  /**
   * Component that is used to group instances of `mat-option`.
   */
  class MatOptgroup extends _MatOptgroupBase {
  }
  MatOptgroup.decorators = [
      { type: Component, args: [{
                  selector: 'mat-optgroup',
                  exportAs: 'matOptgroup',
                  template: "<span class=\"mat-optgroup-label\" aria-hidden=\"true\" [id]=\"_labelId\">{{ label }} <ng-content></ng-content></span>\n<ng-content select=\"mat-option, ng-container\"></ng-content>\n",
                  encapsulation: ViewEncapsulation.None,
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  inputs: ['disabled'],
                  host: {
                      'class': 'mat-optgroup',
                      '[attr.role]': '_inert ? null : "group"',
                      '[attr.aria-disabled]': '_inert ? null : disabled.toString()',
                      '[attr.aria-labelledby]': '_inert ? null : _labelId',
                      '[class.mat-optgroup-disabled]': 'disabled',
                  },
                  providers: [{ provide: MAT_OPTGROUP, useExisting: MatOptgroup }],
                  styles: [".mat-optgroup-label{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup-label[disabled]{cursor:default}[dir=rtl] .mat-optgroup-label{text-align:right}.mat-optgroup-label .mat-icon{margin-right:16px;vertical-align:middle}.mat-optgroup-label .mat-icon svg{vertical-align:top}[dir=rtl] .mat-optgroup-label .mat-icon{margin-left:16px;margin-right:0}\n"]
              },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Option IDs need to be unique across components, so this counter exists outside of
   * the component definition.
   */
  let _uniqueIdCounter = 0;
  /** Event object emitted by MatOption when selected or deselected. */
  class MatOptionSelectionChange {
      constructor(
      /** Reference to the option that emitted the event. */
      source, 
      /** Whether the change in the option's value was a result of a user action. */
      isUserInput = false) {
          this.source = source;
          this.isUserInput = isUserInput;
      }
  }
  class _MatOptionBase {
      constructor(_element, _changeDetectorRef, _parent, group) {
          this._element = _element;
          this._changeDetectorRef = _changeDetectorRef;
          this._parent = _parent;
          this.group = group;
          this._selected = false;
          this._active = false;
          this._disabled = false;
          this._mostRecentViewValue = '';
          /** The unique ID of the option. */
          this.id = `mat-option-${_uniqueIdCounter++}`;
          /** Event emitted when the option is selected or deselected. */
          // tslint:disable-next-line:no-output-on-prefix
          this.onSelectionChange = new EventEmitter();
          /** Emits when the state of the option changes and any parents have to be notified. */
          this._stateChanges = new Subject();
      }
      /** Whether the wrapping component is in multiple selection mode. */
      get multiple() { return this._parent && this._parent.multiple; }
      /** Whether or not the option is currently selected. */
      get selected() { return this._selected; }
      /** Whether the option is disabled. */
      get disabled() { return (this.group && this.group.disabled) || this._disabled; }
      set disabled(value) { this._disabled = coerceBooleanProperty(value); }
      /** Whether ripples for the option are disabled. */
      get disableRipple() { return this._parent && this._parent.disableRipple; }
      /**
       * Whether or not the option is currently active and ready to be selected.
       * An active option displays styles as if it is focused, but the
       * focus is actually retained somewhere else. This comes in handy
       * for components like autocomplete where focus must remain on the input.
       */
      get active() {
          return this._active;
      }
      /**
       * The displayed value of the option. It is necessary to show the selected option in the
       * select's trigger.
       */
      get viewValue() {
          // TODO(kara): Add input property alternative for node envs.
          return (this._getHostElement().textContent || '').trim();
      }
      /** Selects the option. */
      select() {
          if (!this._selected) {
              this._selected = true;
              this._changeDetectorRef.markForCheck();
              this._emitSelectionChangeEvent();
          }
      }
      /** Deselects the option. */
      deselect() {
          if (this._selected) {
              this._selected = false;
              this._changeDetectorRef.markForCheck();
              this._emitSelectionChangeEvent();
          }
      }
      /** Sets focus onto this option. */
      focus(_origin, options) {
          // Note that we aren't using `_origin`, but we need to keep it because some internal consumers
          // use `MatOption` in a `FocusKeyManager` and we need it to match `FocusableOption`.
          const element = this._getHostElement();
          if (typeof element.focus === 'function') {
              element.focus(options);
          }
      }
      /**
       * This method sets display styles on the option to make it appear
       * active. This is used by the ActiveDescendantKeyManager so key
       * events will display the proper options as active on arrow key events.
       */
      setActiveStyles() {
          if (!this._active) {
              this._active = true;
              this._changeDetectorRef.markForCheck();
          }
      }
      /**
       * This method removes display styles on the option that made it appear
       * active. This is used by the ActiveDescendantKeyManager so key
       * events will display the proper options as active on arrow key events.
       */
      setInactiveStyles() {
          if (this._active) {
              this._active = false;
              this._changeDetectorRef.markForCheck();
          }
      }
      /** Gets the label to be used when determining whether the option should be focused. */
      getLabel() {
          return this.viewValue;
      }
      /** Ensures the option is selected when activated from the keyboard. */
      _handleKeydown(event) {
          if ((event.keyCode === ENTER || event.keyCode === SPACE) && !hasModifierKey(event)) {
              this._selectViaInteraction();
              // Prevent the page from scrolling down and form submits.
              event.preventDefault();
          }
      }
      /**
       * `Selects the option while indicating the selection came from the user. Used to
       * determine if the select's view -> model callback should be invoked.`
       */
      _selectViaInteraction() {
          if (!this.disabled) {
              this._selected = this.multiple ? !this._selected : true;
              this._changeDetectorRef.markForCheck();
              this._emitSelectionChangeEvent(true);
          }
      }
      /**
       * Gets the `aria-selected` value for the option. We explicitly omit the `aria-selected`
       * attribute from single-selection, unselected options. Including the `aria-selected="false"`
       * attributes adds a significant amount of noise to screen-reader users without providing useful
       * information.
       */
      _getAriaSelected() {
          return this.selected || (this.multiple ? false : null);
      }
      /** Returns the correct tabindex for the option depending on disabled state. */
      _getTabIndex() {
          return this.disabled ? '-1' : '0';
      }
      /** Gets the host DOM element. */
      _getHostElement() {
          return this._element.nativeElement;
      }
      ngAfterViewChecked() {
          // Since parent components could be using the option's label to display the selected values
          // (e.g. `mat-select`) and they don't have a way of knowing if the option's label has changed
          // we have to check for changes in the DOM ourselves and dispatch an event. These checks are
          // relatively cheap, however we still limit them only to selected options in order to avoid
          // hitting the DOM too often.
          if (this._selected) {
              const viewValue = this.viewValue;
              if (viewValue !== this._mostRecentViewValue) {
                  this._mostRecentViewValue = viewValue;
                  this._stateChanges.next();
              }
          }
      }
      ngOnDestroy() {
          this._stateChanges.complete();
      }
      /** Emits the selection change event. */
      _emitSelectionChangeEvent(isUserInput = false) {
          this.onSelectionChange.emit(new MatOptionSelectionChange(this, isUserInput));
      }
  }
  _MatOptionBase.decorators = [
      { type: Directive }
  ];
  _MatOptionBase.ctorParameters = () => [
      { type: ElementRef },
      { type: ChangeDetectorRef },
      { type: undefined },
      { type: _MatOptgroupBase }
  ];
  _MatOptionBase.propDecorators = {
      value: [{ type: Input }],
      id: [{ type: Input }],
      disabled: [{ type: Input }],
      onSelectionChange: [{ type: Output }]
  };
  /**
   * Single option inside of a `<mat-select>` element.
   */
  class MatOption extends _MatOptionBase {
      constructor(element, changeDetectorRef, parent, group) {
          super(element, changeDetectorRef, parent, group);
      }
  }
  MatOption.decorators = [
      { type: Component, args: [{
                  selector: 'mat-option',
                  exportAs: 'matOption',
                  host: {
                      'role': 'option',
                      '[attr.tabindex]': '_getTabIndex()',
                      '[class.mat-selected]': 'selected',
                      '[class.mat-option-multiple]': 'multiple',
                      '[class.mat-active]': 'active',
                      '[id]': 'id',
                      '[attr.aria-selected]': '_getAriaSelected()',
                      '[attr.aria-disabled]': 'disabled.toString()',
                      '[class.mat-option-disabled]': 'disabled',
                      '(click)': '_selectViaInteraction()',
                      '(keydown)': '_handleKeydown($event)',
                      'class': 'mat-option mat-focus-indicator',
                  },
                  template: "<mat-pseudo-checkbox *ngIf=\"multiple\" class=\"mat-option-pseudo-checkbox\"\n    [state]=\"selected ? 'checked' : 'unchecked'\" [disabled]=\"disabled\"></mat-pseudo-checkbox>\n\n<span class=\"mat-option-text\"><ng-content></ng-content></span>\n\n<!-- See a11y notes inside optgroup.ts for context behind this element. -->\n<span class=\"cdk-visually-hidden\" *ngIf=\"group && group._inert\">({{ group.label }})</span>\n\n<div class=\"mat-option-ripple\" mat-ripple\n     [matRippleTrigger]=\"_getHostElement()\"\n     [matRippleDisabled]=\"disabled || disableRipple\">\n</div>\n",
                  encapsulation: ViewEncapsulation.None,
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  styles: [".mat-option{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative;cursor:pointer;outline:none;display:flex;flex-direction:row;max-width:100%;box-sizing:border-box;align-items:center;-webkit-tap-highlight-color:transparent}.mat-option[disabled]{cursor:default}[dir=rtl] .mat-option{text-align:right}.mat-option .mat-icon{margin-right:16px;vertical-align:middle}.mat-option .mat-icon svg{vertical-align:top}[dir=rtl] .mat-option .mat-icon{margin-left:16px;margin-right:0}.mat-option[aria-disabled=true]{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:32px}[dir=rtl] .mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:16px;padding-right:32px}.cdk-high-contrast-active .mat-option{margin:0 1px}.cdk-high-contrast-active .mat-option.mat-active{border:solid 1px currentColor;margin:0}.cdk-high-contrast-active .mat-option[aria-disabled=true]{opacity:.5}.mat-option-text{display:inline-block;flex-grow:1;overflow:hidden;text-overflow:ellipsis}.mat-option .mat-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-option-pseudo-checkbox{margin-right:8px}[dir=rtl] .mat-option-pseudo-checkbox{margin-left:8px;margin-right:0}\n"]
              },] }
  ];
  MatOption.ctorParameters = () => [
      { type: ElementRef },
      { type: ChangeDetectorRef },
      { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_OPTION_PARENT_COMPONENT,] }] },
      { type: MatOptgroup, decorators: [{ type: Optional }, { type: Inject, args: [MAT_OPTGROUP,] }] }
  ];
  /**
   * Counts the amount of option group labels that precede the specified option.
   * @param optionIndex Index of the option at which to start counting.
   * @param options Flat list of all of the options.
   * @param optionGroups Flat list of all of the option groups.
   * @docs-private
   */
  function _countGroupLabelsBeforeOption(optionIndex, options, optionGroups) {
      if (optionGroups.length) {
          let optionsArray = options.toArray();
          let groups = optionGroups.toArray();
          let groupCounter = 0;
          for (let i = 0; i < optionIndex + 1; i++) {
              if (optionsArray[i].group && optionsArray[i].group === groups[groupCounter]) {
                  groupCounter++;
              }
          }
          return groupCounter;
      }
      return 0;
  }
  /**
   * Determines the position to which to scroll a panel in order for an option to be into view.
   * @param optionOffset Offset of the option from the top of the panel.
   * @param optionHeight Height of the options.
   * @param currentScrollPosition Current scroll position of the panel.
   * @param panelHeight Height of the panel.
   * @docs-private
   */
  function _getOptionScrollPosition(optionOffset, optionHeight, currentScrollPosition, panelHeight) {
      if (optionOffset < currentScrollPosition) {
          return optionOffset;
      }
      if (optionOffset + optionHeight > currentScrollPosition + panelHeight) {
          return Math.max(0, optionOffset - panelHeight + optionHeight);
      }
      return currentScrollPosition;
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  class MatOptionModule {
  }
  MatOptionModule.decorators = [
      { type: NgModule, args: [{
                  imports: [MatRippleModule, CommonModule, MatCommonModule, MatPseudoCheckboxModule],
                  exports: [MatOption, MatOptgroup],
                  declarations: [MatOption, MatOptgroup]
              },] }
  ];
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  
  /**
   * Generated bundle index. Do not edit.
   */
  
  export { AnimationCurves, AnimationDurations, DateAdapter, ErrorStateMatcher, MATERIAL_SANITY_CHECKS, MAT_DATE_FORMATS, MAT_DATE_LOCALE, MAT_DATE_LOCALE_FACTORY, MAT_NATIVE_DATE_FORMATS, MAT_OPTGROUP, MAT_OPTION_PARENT_COMPONENT, MAT_RIPPLE_GLOBAL_OPTIONS, MatCommonModule, MatLine, MatLineModule, MatNativeDateModule, MatOptgroup, MatOption, MatOptionModule, MatOptionSelectionChange, MatPseudoCheckbox, MatPseudoCheckboxModule, MatRipple, MatRippleModule, NativeDateAdapter, NativeDateModule, RippleRef, RippleRenderer, ShowOnDirtyErrorStateMatcher, VERSION$1 as VERSION, _MatOptgroupBase, _MatOptionBase, _countGroupLabelsBeforeOption, _getOptionScrollPosition, defaultRippleAnimationConfig, mixinColor, mixinDisableRipple, mixinDisabled, mixinErrorState, mixinInitialized, mixinTabIndex, setLines, ɵ0, MATERIAL_SANITY_CHECKS_FACTORY as ɵangular_material_src_material_core_core_a };
  //# sourceMappingURL=core.js.map
  