{"version":3,"sources":["node_modules/@angular/material/fesm2022/ripple-5bdada85.mjs","node_modules/@angular/material/fesm2022/ripple-loader-dabcd93d.mjs","node_modules/@angular/material/fesm2022/structural-styles-326dcb39.mjs"],"sourcesContent":["import { normalizePassiveListenerOptions, _getEventTarget, Platform } from '@angular/cdk/platform';\nimport * as i0 from '@angular/core';\nimport { Component, ChangeDetectionStrategy, ViewEncapsulation, InjectionToken, inject, ElementRef, ANIMATION_MODULE_TYPE, NgZone, Injector, Directive, Input } from '@angular/core';\nimport { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from '@angular/cdk/a11y';\nimport { coerceElement } from '@angular/cdk/coercion';\nimport { _CdkPrivateStyleLoader } from '@angular/cdk/private';\n\n/** Possible states for a ripple element. */\nvar RippleState = /*#__PURE__*/function (RippleState) {\n  RippleState[RippleState[\"FADING_IN\"] = 0] = \"FADING_IN\";\n  RippleState[RippleState[\"VISIBLE\"] = 1] = \"VISIBLE\";\n  RippleState[RippleState[\"FADING_OUT\"] = 2] = \"FADING_OUT\";\n  RippleState[RippleState[\"HIDDEN\"] = 3] = \"HIDDEN\";\n  return RippleState;\n}(RippleState || {});\n/**\n * Reference to a previously launched ripple element.\n */\nclass RippleRef {\n  _renderer;\n  element;\n  config;\n  _animationForciblyDisabledThroughCss;\n  /** Current state of the ripple. */\n  state = RippleState.HIDDEN;\n  constructor(_renderer, /** Reference to the ripple HTML element. */\n  element, /** Ripple configuration used for the ripple. */\n  config, /* Whether animations are forcibly disabled for ripples through CSS. */\n  _animationForciblyDisabledThroughCss = false) {\n    this._renderer = _renderer;\n    this.element = element;\n    this.config = config;\n    this._animationForciblyDisabledThroughCss = _animationForciblyDisabledThroughCss;\n  }\n  /** Fades out the ripple element. */\n  fadeOut() {\n    this._renderer.fadeOutRipple(this);\n  }\n}\n\n/** Options used to bind a passive capturing event. */\nconst passiveCapturingEventOptions$1 = /*#__PURE__*/normalizePassiveListenerOptions({\n  passive: true,\n  capture: true\n});\n/** Manages events through delegation so that as few event handlers as possible are bound. */\nclass RippleEventManager {\n  _events = /*#__PURE__*/new Map();\n  /** Adds an event handler. */\n  addHandler(ngZone, name, element, handler) {\n    const handlersForEvent = this._events.get(name);\n    if (handlersForEvent) {\n      const handlersForElement = handlersForEvent.get(element);\n      if (handlersForElement) {\n        handlersForElement.add(handler);\n      } else {\n        handlersForEvent.set(element, new Set([handler]));\n      }\n    } else {\n      this._events.set(name, new Map([[element, new Set([handler])]]));\n      ngZone.runOutsideAngular(() => {\n        document.addEventListener(name, this._delegateEventHandler, passiveCapturingEventOptions$1);\n      });\n    }\n  }\n  /** Removes an event handler. */\n  removeHandler(name, element, handler) {\n    const handlersForEvent = this._events.get(name);\n    if (!handlersForEvent) {\n      return;\n    }\n    const handlersForElement = handlersForEvent.get(element);\n    if (!handlersForElement) {\n      return;\n    }\n    handlersForElement.delete(handler);\n    if (handlersForElement.size === 0) {\n      handlersForEvent.delete(element);\n    }\n    if (handlersForEvent.size === 0) {\n      this._events.delete(name);\n      document.removeEventListener(name, this._delegateEventHandler, passiveCapturingEventOptions$1);\n    }\n  }\n  /** Event handler that is bound and which dispatches the events to the different targets. */\n  _delegateEventHandler = event => {\n    const target = _getEventTarget(event);\n    if (target) {\n      this._events.get(event.type)?.forEach((handlers, element) => {\n        if (element === target || element.contains(target)) {\n          handlers.forEach(handler => handler.handleEvent(event));\n        }\n      });\n    }\n  };\n}\n\n/**\n * Default ripple animation configuration for ripples without an explicit\n * animation config specified.\n */\nconst defaultRippleAnimationConfig = {\n  enterDuration: 225,\n  exitDuration: 150\n};\n/**\n * Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch\n * events to avoid synthetic mouse events.\n */\nconst ignoreMouseEventsTimeout = 800;\n/** Options used to bind a passive capturing event. */\nconst passiveCapturingEventOptions = /*#__PURE__*/normalizePassiveListenerOptions({\n  passive: true,\n  capture: true\n});\n/** Events that signal that the pointer is down. */\nconst pointerDownEvents = ['mousedown', 'touchstart'];\n/** Events that signal that the pointer is up. */\nconst pointerUpEvents = ['mouseup', 'mouseleave', 'touchend', 'touchcancel'];\nlet _MatRippleStylesLoader = /*#__PURE__*/(() => {\n  class _MatRippleStylesLoader {\n    static ɵfac = function _MatRippleStylesLoader_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || _MatRippleStylesLoader)();\n    };\n    static ɵcmp = /* @__PURE__ */i0.ɵɵdefineComponent({\n      type: _MatRippleStylesLoader,\n      selectors: [[\"ng-component\"]],\n      hostAttrs: [\"mat-ripple-style-loader\", \"\"],\n      decls: 0,\n      vars: 0,\n      template: function _MatRippleStylesLoader_Template(rf, ctx) {},\n      styles: [\".mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale3d(0, 0, 0);background-color:var(--mat-ripple-color, color-mix(in srgb, var(--mat-sys-on-surface) 10%, transparent))}@media(forced-colors: active){.mat-ripple-element{display:none}}.cdk-drag-preview .mat-ripple-element,.cdk-drag-placeholder .mat-ripple-element{display:none}\"],\n      encapsulation: 2,\n      changeDetection: 0\n    });\n  }\n  return _MatRippleStylesLoader;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Helper service that performs DOM manipulations. Not intended to be used outside this module.\n * The constructor takes a reference to the ripple directive's host element and a map of DOM\n * event handlers to be installed on the element that triggers ripple animations.\n * This will eventually become a custom renderer once Angular support exists.\n * @docs-private\n */\nclass RippleRenderer {\n  _target;\n  _ngZone;\n  _platform;\n  /** Element where the ripples are being added to. */\n  _containerElement;\n  /** Element which triggers the ripple elements on mouse events. */\n  _triggerElement;\n  /** Whether the pointer is currently down or not. */\n  _isPointerDown = false;\n  /**\n   * Map of currently active ripple references.\n   * The ripple reference is mapped to its element event listeners.\n   * The reason why `| null` is used is that event listeners are added only\n   * when the condition is truthy (see the `_startFadeOutTransition` method).\n   */\n  _activeRipples = /*#__PURE__*/new Map();\n  /** Latest non-persistent ripple that was triggered. */\n  _mostRecentTransientRipple;\n  /** Time in milliseconds when the last touchstart event happened. */\n  _lastTouchStartEvent;\n  /** Whether pointer-up event listeners have been registered. */\n  _pointerUpEventsRegistered = false;\n  /**\n   * Cached dimensions of the ripple container. Set when the first\n   * ripple is shown and cleared once no more ripples are visible.\n   */\n  _containerRect;\n  static _eventManager = /*#__PURE__*/new RippleEventManager();\n  constructor(_target, _ngZone, elementOrElementRef, _platform, injector) {\n    this._target = _target;\n    this._ngZone = _ngZone;\n    this._platform = _platform;\n    // Only do anything if we're on the browser.\n    if (_platform.isBrowser) {\n      this._containerElement = coerceElement(elementOrElementRef);\n    }\n    if (injector) {\n      injector.get(_CdkPrivateStyleLoader).load(_MatRippleStylesLoader);\n    }\n  }\n  /**\n   * Fades in a ripple at the given coordinates.\n   * @param x Coordinate within the element, along the X axis at which to start the ripple.\n   * @param y Coordinate within the element, along the Y axis at which to start the ripple.\n   * @param config Extra ripple options.\n   */\n  fadeInRipple(x, y, config = {}) {\n    const containerRect = this._containerRect = this._containerRect || this._containerElement.getBoundingClientRect();\n    const animationConfig = {\n      ...defaultRippleAnimationConfig,\n      ...config.animation\n    };\n    if (config.centered) {\n      x = containerRect.left + containerRect.width / 2;\n      y = containerRect.top + containerRect.height / 2;\n    }\n    const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);\n    const offsetX = x - containerRect.left;\n    const offsetY = y - containerRect.top;\n    const enterDuration = animationConfig.enterDuration;\n    const ripple = document.createElement('div');\n    ripple.classList.add('mat-ripple-element');\n    ripple.style.left = `${offsetX - radius}px`;\n    ripple.style.top = `${offsetY - radius}px`;\n    ripple.style.height = `${radius * 2}px`;\n    ripple.style.width = `${radius * 2}px`;\n    // If a custom color has been specified, set it as inline style. If no color is\n    // set, the default color will be applied through the ripple theme styles.\n    if (config.color != null) {\n      ripple.style.backgroundColor = config.color;\n    }\n    ripple.style.transitionDuration = `${enterDuration}ms`;\n    this._containerElement.appendChild(ripple);\n    // By default the browser does not recalculate the styles of dynamically created\n    // ripple elements. This is critical to ensure that the `scale` animates properly.\n    // We enforce a style recalculation by calling `getComputedStyle` and *accessing* a property.\n    // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a\n    const computedStyles = window.getComputedStyle(ripple);\n    const userTransitionProperty = computedStyles.transitionProperty;\n    const userTransitionDuration = computedStyles.transitionDuration;\n    // Note: We detect whether animation is forcibly disabled through CSS (e.g. through\n    // `transition: none` or `display: none`). This is technically unexpected since animations are\n    // controlled through the animation config, but this exists for backwards compatibility. This\n    // logic does not need to be super accurate since it covers some edge cases which can be easily\n    // avoided by users.\n    const animationForciblyDisabledThroughCss = userTransitionProperty === 'none' ||\n    // Note: The canonical unit for serialized CSS `<time>` properties is seconds. Additionally\n    // some browsers expand the duration for every property (in our case `opacity` and `transform`).\n    userTransitionDuration === '0s' || userTransitionDuration === '0s, 0s' ||\n    // If the container is 0x0, it's likely `display: none`.\n    containerRect.width === 0 && containerRect.height === 0;\n    // Exposed reference to the ripple that will be returned.\n    const rippleRef = new RippleRef(this, ripple, config, animationForciblyDisabledThroughCss);\n    // Start the enter animation by setting the transform/scale to 100%. The animation will\n    // execute as part of this statement because we forced a style recalculation before.\n    // Note: We use a 3d transform here in order to avoid an issue in Safari where\n    // the ripples aren't clipped when inside the shadow DOM (see #24028).\n    ripple.style.transform = 'scale3d(1, 1, 1)';\n    rippleRef.state = RippleState.FADING_IN;\n    if (!config.persistent) {\n      this._mostRecentTransientRipple = rippleRef;\n    }\n    let eventListeners = null;\n    // Do not register the `transition` event listener if fade-in and fade-out duration\n    // are set to zero. The events won't fire anyway and we can save resources here.\n    if (!animationForciblyDisabledThroughCss && (enterDuration || animationConfig.exitDuration)) {\n      this._ngZone.runOutsideAngular(() => {\n        const onTransitionEnd = () => {\n          // Clear the fallback timer since the transition fired correctly.\n          if (eventListeners) {\n            eventListeners.fallbackTimer = null;\n          }\n          clearTimeout(fallbackTimer);\n          this._finishRippleTransition(rippleRef);\n        };\n        const onTransitionCancel = () => this._destroyRipple(rippleRef);\n        // In some cases where there's a higher load on the browser, it can choose not to dispatch\n        // neither `transitionend` nor `transitioncancel` (see b/227356674). This timer serves as a\n        // fallback for such cases so that the ripple doesn't become stuck. We add a 100ms buffer\n        // because timers aren't precise. Note that another approach can be to transition the ripple\n        // to the `VISIBLE` state immediately above and to `FADING_IN` afterwards inside\n        // `transitionstart`. We go with the timer because it's one less event listener and\n        // it's less likely to break existing tests.\n        const fallbackTimer = setTimeout(onTransitionCancel, enterDuration + 100);\n        ripple.addEventListener('transitionend', onTransitionEnd);\n        // If the transition is cancelled (e.g. due to DOM removal), we destroy the ripple\n        // directly as otherwise we would keep it part of the ripple container forever.\n        // https://www.w3.org/TR/css-transitions-1/#:~:text=no%20longer%20in%20the%20document.\n        ripple.addEventListener('transitioncancel', onTransitionCancel);\n        eventListeners = {\n          onTransitionEnd,\n          onTransitionCancel,\n          fallbackTimer\n        };\n      });\n    }\n    // Add the ripple reference to the list of all active ripples.\n    this._activeRipples.set(rippleRef, eventListeners);\n    // In case there is no fade-in transition duration, we need to manually call the transition\n    // end listener because `transitionend` doesn't fire if there is no transition.\n    if (animationForciblyDisabledThroughCss || !enterDuration) {\n      this._finishRippleTransition(rippleRef);\n    }\n    return rippleRef;\n  }\n  /** Fades out a ripple reference. */\n  fadeOutRipple(rippleRef) {\n    // For ripples already fading out or hidden, this should be a noop.\n    if (rippleRef.state === RippleState.FADING_OUT || rippleRef.state === RippleState.HIDDEN) {\n      return;\n    }\n    const rippleEl = rippleRef.element;\n    const animationConfig = {\n      ...defaultRippleAnimationConfig,\n      ...rippleRef.config.animation\n    };\n    // This starts the fade-out transition and will fire the transition end listener that\n    // removes the ripple element from the DOM.\n    rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;\n    rippleEl.style.opacity = '0';\n    rippleRef.state = RippleState.FADING_OUT;\n    // In case there is no fade-out transition duration, we need to manually call the\n    // transition end listener because `transitionend` doesn't fire if there is no transition.\n    if (rippleRef._animationForciblyDisabledThroughCss || !animationConfig.exitDuration) {\n      this._finishRippleTransition(rippleRef);\n    }\n  }\n  /** Fades out all currently active ripples. */\n  fadeOutAll() {\n    this._getActiveRipples().forEach(ripple => ripple.fadeOut());\n  }\n  /** Fades out all currently active non-persistent ripples. */\n  fadeOutAllNonPersistent() {\n    this._getActiveRipples().forEach(ripple => {\n      if (!ripple.config.persistent) {\n        ripple.fadeOut();\n      }\n    });\n  }\n  /** Sets up the trigger event listeners */\n  setupTriggerEvents(elementOrElementRef) {\n    const element = coerceElement(elementOrElementRef);\n    if (!this._platform.isBrowser || !element || element === this._triggerElement) {\n      return;\n    }\n    // Remove all previously registered event listeners from the trigger element.\n    this._removeTriggerEvents();\n    this._triggerElement = element;\n    // Use event delegation for the trigger events since they're\n    // set up during creation and are performance-sensitive.\n    pointerDownEvents.forEach(type => {\n      RippleRenderer._eventManager.addHandler(this._ngZone, type, element, this);\n    });\n  }\n  /**\n   * Handles all registered events.\n   * @docs-private\n   */\n  handleEvent(event) {\n    if (event.type === 'mousedown') {\n      this._onMousedown(event);\n    } else if (event.type === 'touchstart') {\n      this._onTouchStart(event);\n    } else {\n      this._onPointerUp();\n    }\n    // If pointer-up events haven't been registered yet, do so now.\n    // We do this on-demand in order to reduce the total number of event listeners\n    // registered by the ripples, which speeds up the rendering time for large UIs.\n    if (!this._pointerUpEventsRegistered) {\n      // The events for hiding the ripple are bound directly on the trigger, because:\n      // 1. Some of them occur frequently (e.g. `mouseleave`) and any advantage we get from\n      // delegation will be diminished by having to look through all the data structures often.\n      // 2. They aren't as performance-sensitive, because they're bound only after the user\n      // has interacted with an element.\n      this._ngZone.runOutsideAngular(() => {\n        pointerUpEvents.forEach(type => {\n          this._triggerElement.addEventListener(type, this, passiveCapturingEventOptions);\n        });\n      });\n      this._pointerUpEventsRegistered = true;\n    }\n  }\n  /** Method that will be called if the fade-in or fade-in transition completed. */\n  _finishRippleTransition(rippleRef) {\n    if (rippleRef.state === RippleState.FADING_IN) {\n      this._startFadeOutTransition(rippleRef);\n    } else if (rippleRef.state === RippleState.FADING_OUT) {\n      this._destroyRipple(rippleRef);\n    }\n  }\n  /**\n   * Starts the fade-out transition of the given ripple if it's not persistent and the pointer\n   * is not held down anymore.\n   */\n  _startFadeOutTransition(rippleRef) {\n    const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;\n    const {\n      persistent\n    } = rippleRef.config;\n    rippleRef.state = RippleState.VISIBLE;\n    // When the timer runs out while the user has kept their pointer down, we want to\n    // keep only the persistent ripples and the latest transient ripple. We do this,\n    // because we don't want stacked transient ripples to appear after their enter\n    // animation has finished.\n    if (!persistent && (!isMostRecentTransientRipple || !this._isPointerDown)) {\n      rippleRef.fadeOut();\n    }\n  }\n  /** Destroys the given ripple by removing it from the DOM and updating its state. */\n  _destroyRipple(rippleRef) {\n    const eventListeners = this._activeRipples.get(rippleRef) ?? null;\n    this._activeRipples.delete(rippleRef);\n    // Clear out the cached bounding rect if we have no more ripples.\n    if (!this._activeRipples.size) {\n      this._containerRect = null;\n    }\n    // If the current ref is the most recent transient ripple, unset it\n    // avoid memory leaks.\n    if (rippleRef === this._mostRecentTransientRipple) {\n      this._mostRecentTransientRipple = null;\n    }\n    rippleRef.state = RippleState.HIDDEN;\n    if (eventListeners !== null) {\n      rippleRef.element.removeEventListener('transitionend', eventListeners.onTransitionEnd);\n      rippleRef.element.removeEventListener('transitioncancel', eventListeners.onTransitionCancel);\n      if (eventListeners.fallbackTimer !== null) {\n        clearTimeout(eventListeners.fallbackTimer);\n      }\n    }\n    rippleRef.element.remove();\n  }\n  /** Function being called whenever the trigger is being pressed using mouse. */\n  _onMousedown(event) {\n    // Screen readers will fire fake mouse events for space/enter. Skip launching a\n    // ripple in this case for consistency with the non-screen-reader experience.\n    const isFakeMousedown = isFakeMousedownFromScreenReader(event);\n    const isSyntheticEvent = this._lastTouchStartEvent && Date.now() < this._lastTouchStartEvent + ignoreMouseEventsTimeout;\n    if (!this._target.rippleDisabled && !isFakeMousedown && !isSyntheticEvent) {\n      this._isPointerDown = true;\n      this.fadeInRipple(event.clientX, event.clientY, this._target.rippleConfig);\n    }\n  }\n  /** Function being called whenever the trigger is being pressed using touch. */\n  _onTouchStart(event) {\n    if (!this._target.rippleDisabled && !isFakeTouchstartFromScreenReader(event)) {\n      // Some browsers fire mouse events after a `touchstart` event. Those synthetic mouse\n      // events will launch a second ripple if we don't ignore mouse events for a specific\n      // time after a touchstart event.\n      this._lastTouchStartEvent = Date.now();\n      this._isPointerDown = true;\n      // Use `changedTouches` so we skip any touches where the user put\n      // their finger down, but used another finger to tap the element again.\n      const touches = event.changedTouches;\n      // According to the typings the touches should always be defined, but in some cases\n      // the browser appears to not assign them in tests which leads to flakes.\n      if (touches) {\n        for (let i = 0; i < touches.length; i++) {\n          this.fadeInRipple(touches[i].clientX, touches[i].clientY, this._target.rippleConfig);\n        }\n      }\n    }\n  }\n  /** Function being called whenever the trigger is being released. */\n  _onPointerUp() {\n    if (!this._isPointerDown) {\n      return;\n    }\n    this._isPointerDown = false;\n    // Fade-out all ripples that are visible and not persistent.\n    this._getActiveRipples().forEach(ripple => {\n      // By default, only ripples that are completely visible will fade out on pointer release.\n      // If the `terminateOnPointerUp` option is set, ripples that still fade in will also fade out.\n      const isVisible = ripple.state === RippleState.VISIBLE || ripple.config.terminateOnPointerUp && ripple.state === RippleState.FADING_IN;\n      if (!ripple.config.persistent && isVisible) {\n        ripple.fadeOut();\n      }\n    });\n  }\n  _getActiveRipples() {\n    return Array.from(this._activeRipples.keys());\n  }\n  /** Removes previously registered event listeners from the trigger element. */\n  _removeTriggerEvents() {\n    const trigger = this._triggerElement;\n    if (trigger) {\n      pointerDownEvents.forEach(type => RippleRenderer._eventManager.removeHandler(type, trigger, this));\n      if (this._pointerUpEventsRegistered) {\n        pointerUpEvents.forEach(type => trigger.removeEventListener(type, this, passiveCapturingEventOptions));\n        this._pointerUpEventsRegistered = false;\n      }\n    }\n  }\n}\n/**\n * Returns the distance from the point (x, y) to the furthest corner of a rectangle.\n */\nfunction distanceToFurthestCorner(x, y, rect) {\n  const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));\n  const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));\n  return Math.sqrt(distX * distX + distY * distY);\n}\n\n/** Injection token that can be used to specify the global ripple options. */\nconst MAT_RIPPLE_GLOBAL_OPTIONS = /*#__PURE__*/new InjectionToken('mat-ripple-global-options');\nlet MatRipple = /*#__PURE__*/(() => {\n  class MatRipple {\n    _elementRef = inject(ElementRef);\n    _animationMode = inject(ANIMATION_MODULE_TYPE, {\n      optional: true\n    });\n    /** Custom color for all ripples. */\n    color;\n    /** Whether the ripples should be visible outside the component's bounds. */\n    unbounded;\n    /**\n     * Whether the ripple always originates from the center of the host element's bounds, rather\n     * than originating from the location of the click event.\n     */\n    centered;\n    /**\n     * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n     * will be the distance from the center of the ripple to the furthest corner of the host element's\n     * bounding rectangle.\n     */\n    radius = 0;\n    /**\n     * Configuration for the ripple animation. Allows modifying the enter and exit animation\n     * duration of the ripples. The animation durations will be overwritten if the\n     * `NoopAnimationsModule` is being used.\n     */\n    animation;\n    /**\n     * Whether click events will not trigger the ripple. Ripples can be still launched manually\n     * by using the `launch()` method.\n     */\n    get disabled() {\n      return this._disabled;\n    }\n    set disabled(value) {\n      if (value) {\n        this.fadeOutAllNonPersistent();\n      }\n      this._disabled = value;\n      this._setupTriggerEventsIfEnabled();\n    }\n    _disabled = false;\n    /**\n     * The element that triggers the ripple when click events are received.\n     * Defaults to the directive's host element.\n     */\n    get trigger() {\n      return this._trigger || this._elementRef.nativeElement;\n    }\n    set trigger(trigger) {\n      this._trigger = trigger;\n      this._setupTriggerEventsIfEnabled();\n    }\n    _trigger;\n    /** Renderer for the ripple DOM manipulations. */\n    _rippleRenderer;\n    /** Options that are set globally for all ripples. */\n    _globalOptions;\n    /** @docs-private Whether ripple directive is initialized and the input bindings are set. */\n    _isInitialized = false;\n    constructor() {\n      const ngZone = inject(NgZone);\n      const platform = inject(Platform);\n      const globalOptions = inject(MAT_RIPPLE_GLOBAL_OPTIONS, {\n        optional: true\n      });\n      const injector = inject(Injector);\n      // Note: cannot use `inject()` here, because this class\n      // gets instantiated manually in the ripple loader.\n      this._globalOptions = globalOptions || {};\n      this._rippleRenderer = new RippleRenderer(this, ngZone, this._elementRef, platform, injector);\n    }\n    ngOnInit() {\n      this._isInitialized = true;\n      this._setupTriggerEventsIfEnabled();\n    }\n    ngOnDestroy() {\n      this._rippleRenderer._removeTriggerEvents();\n    }\n    /** Fades out all currently showing ripple elements. */\n    fadeOutAll() {\n      this._rippleRenderer.fadeOutAll();\n    }\n    /** Fades out all currently showing non-persistent ripple elements. */\n    fadeOutAllNonPersistent() {\n      this._rippleRenderer.fadeOutAllNonPersistent();\n    }\n    /**\n     * Ripple configuration from the directive's input values.\n     * @docs-private Implemented as part of RippleTarget\n     */\n    get rippleConfig() {\n      return {\n        centered: this.centered,\n        radius: this.radius,\n        color: this.color,\n        animation: {\n          ...this._globalOptions.animation,\n          ...(this._animationMode === 'NoopAnimations' ? {\n            enterDuration: 0,\n            exitDuration: 0\n          } : {}),\n          ...this.animation\n        },\n        terminateOnPointerUp: this._globalOptions.terminateOnPointerUp\n      };\n    }\n    /**\n     * Whether ripples on pointer-down are disabled or not.\n     * @docs-private Implemented as part of RippleTarget\n     */\n    get rippleDisabled() {\n      return this.disabled || !!this._globalOptions.disabled;\n    }\n    /** Sets up the trigger event listeners if ripples are enabled. */\n    _setupTriggerEventsIfEnabled() {\n      if (!this.disabled && this._isInitialized) {\n        this._rippleRenderer.setupTriggerEvents(this.trigger);\n      }\n    }\n    /** Launches a manual ripple at the specified coordinated or just by the ripple config. */\n    launch(configOrX, y = 0, config) {\n      if (typeof configOrX === 'number') {\n        return this._rippleRenderer.fadeInRipple(configOrX, y, {\n          ...this.rippleConfig,\n          ...config\n        });\n      } else {\n        return this._rippleRenderer.fadeInRipple(0, 0, {\n          ...this.rippleConfig,\n          ...configOrX\n        });\n      }\n    }\n    static ɵfac = function MatRipple_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || MatRipple)();\n    };\n    static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n      type: MatRipple,\n      selectors: [[\"\", \"mat-ripple\", \"\"], [\"\", \"matRipple\", \"\"]],\n      hostAttrs: [1, \"mat-ripple\"],\n      hostVars: 2,\n      hostBindings: function MatRipple_HostBindings(rf, ctx) {\n        if (rf & 2) {\n          i0.ɵɵclassProp(\"mat-ripple-unbounded\", ctx.unbounded);\n        }\n      },\n      inputs: {\n        color: [0, \"matRippleColor\", \"color\"],\n        unbounded: [0, \"matRippleUnbounded\", \"unbounded\"],\n        centered: [0, \"matRippleCentered\", \"centered\"],\n        radius: [0, \"matRippleRadius\", \"radius\"],\n        animation: [0, \"matRippleAnimation\", \"animation\"],\n        disabled: [0, \"matRippleDisabled\", \"disabled\"],\n        trigger: [0, \"matRippleTrigger\", \"trigger\"]\n      },\n      exportAs: [\"matRipple\"]\n    });\n  }\n  return MatRipple;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nexport { MatRipple as M, RippleRenderer as R, MAT_RIPPLE_GLOBAL_OPTIONS as a, RippleState as b, RippleRef as c, defaultRippleAnimationConfig as d };\n","import { DOCUMENT } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { inject, ANIMATION_MODULE_TYPE, NgZone, Injector, RendererFactory2, Injectable } from '@angular/core';\nimport { Platform, _bindEventWithOptions, _getEventTarget } from '@angular/cdk/platform';\nimport { a as MAT_RIPPLE_GLOBAL_OPTIONS, R as RippleRenderer, d as defaultRippleAnimationConfig } from './ripple-5bdada85.mjs';\n\n/** The options for the MatRippleLoader's event listeners. */\nconst eventListenerOptions = {\n  capture: true\n};\n/**\n * The events that should trigger the initialization of the ripple.\n * Note that we use `mousedown`, rather than `click`, for mouse devices because\n * we can't rely on `mouseenter` in the shadow DOM and `click` happens too late.\n */\nconst rippleInteractionEvents = ['focus', 'mousedown', 'mouseenter', 'touchstart'];\n/** The attribute attached to a component whose ripple has not yet been initialized. */\nconst matRippleUninitialized = 'mat-ripple-loader-uninitialized';\n/** Additional classes that should be added to the ripple when it is rendered. */\nconst matRippleClassName = 'mat-ripple-loader-class-name';\n/** Whether the ripple should be centered. */\nconst matRippleCentered = 'mat-ripple-loader-centered';\n/** Whether the ripple should be disabled. */\nconst matRippleDisabled = 'mat-ripple-loader-disabled';\n/**\n * Handles attaching ripples on demand.\n *\n * This service allows us to avoid eagerly creating & attaching MatRipples.\n * It works by creating & attaching a ripple only when a component is first interacted with.\n *\n * @docs-private\n */\nlet MatRippleLoader = /*#__PURE__*/(() => {\n  class MatRippleLoader {\n    _document = inject(DOCUMENT);\n    _animationMode = inject(ANIMATION_MODULE_TYPE, {\n      optional: true\n    });\n    _globalRippleOptions = inject(MAT_RIPPLE_GLOBAL_OPTIONS, {\n      optional: true\n    });\n    _platform = inject(Platform);\n    _ngZone = inject(NgZone);\n    _injector = inject(Injector);\n    _eventCleanups;\n    _hosts = new Map();\n    constructor() {\n      const renderer = inject(RendererFactory2).createRenderer(null, null);\n      this._eventCleanups = this._ngZone.runOutsideAngular(() => {\n        return rippleInteractionEvents.map(name => _bindEventWithOptions(renderer, this._document, name, this._onInteraction, eventListenerOptions));\n      });\n    }\n    ngOnDestroy() {\n      const hosts = this._hosts.keys();\n      for (const host of hosts) {\n        this.destroyRipple(host);\n      }\n      this._eventCleanups.forEach(cleanup => cleanup());\n    }\n    /**\n     * Configures the ripple that will be rendered by the ripple loader.\n     *\n     * Stores the given information about how the ripple should be configured on the host\n     * element so that it can later be retrived & used when the ripple is actually created.\n     */\n    configureRipple(host, config) {\n      // Indicates that the ripple has not yet been rendered for this component.\n      host.setAttribute(matRippleUninitialized, this._globalRippleOptions?.namespace ?? '');\n      // Store the additional class name(s) that should be added to the ripple element.\n      if (config.className || !host.hasAttribute(matRippleClassName)) {\n        host.setAttribute(matRippleClassName, config.className || '');\n      }\n      // Store whether the ripple should be centered.\n      if (config.centered) {\n        host.setAttribute(matRippleCentered, '');\n      }\n      if (config.disabled) {\n        host.setAttribute(matRippleDisabled, '');\n      }\n    }\n    /** Sets the disabled state on the ripple instance corresponding to the given host element. */\n    setDisabled(host, disabled) {\n      const ripple = this._hosts.get(host);\n      // If the ripple has already been instantiated, just disable it.\n      if (ripple) {\n        ripple.target.rippleDisabled = disabled;\n        if (!disabled && !ripple.hasSetUpEvents) {\n          ripple.hasSetUpEvents = true;\n          ripple.renderer.setupTriggerEvents(host);\n        }\n      } else if (disabled) {\n        // Otherwise, set an attribute so we know what the\n        // disabled state should be when the ripple is initialized.\n        host.setAttribute(matRippleDisabled, '');\n      } else {\n        host.removeAttribute(matRippleDisabled);\n      }\n    }\n    /**\n     * Handles creating and attaching component internals\n     * when a component is initially interacted with.\n     */\n    _onInteraction = event => {\n      const eventTarget = _getEventTarget(event);\n      if (eventTarget instanceof HTMLElement) {\n        // TODO(wagnermaciel): Consider batching these events to improve runtime performance.\n        const element = eventTarget.closest(`[${matRippleUninitialized}=\"${this._globalRippleOptions?.namespace ?? ''}\"]`);\n        if (element) {\n          this._createRipple(element);\n        }\n      }\n    };\n    /** Creates a MatRipple and appends it to the given element. */\n    _createRipple(host) {\n      if (!this._document || this._hosts.has(host)) {\n        return;\n      }\n      // Create the ripple element.\n      host.querySelector('.mat-ripple')?.remove();\n      const rippleEl = this._document.createElement('span');\n      rippleEl.classList.add('mat-ripple', host.getAttribute(matRippleClassName));\n      host.append(rippleEl);\n      const isNoopAnimations = this._animationMode === 'NoopAnimations';\n      const globalOptions = this._globalRippleOptions;\n      const enterDuration = isNoopAnimations ? 0 : globalOptions?.animation?.enterDuration ?? defaultRippleAnimationConfig.enterDuration;\n      const exitDuration = isNoopAnimations ? 0 : globalOptions?.animation?.exitDuration ?? defaultRippleAnimationConfig.exitDuration;\n      const target = {\n        rippleDisabled: isNoopAnimations || globalOptions?.disabled || host.hasAttribute(matRippleDisabled),\n        rippleConfig: {\n          centered: host.hasAttribute(matRippleCentered),\n          terminateOnPointerUp: globalOptions?.terminateOnPointerUp,\n          animation: {\n            enterDuration,\n            exitDuration\n          }\n        }\n      };\n      const renderer = new RippleRenderer(target, this._ngZone, rippleEl, this._platform, this._injector);\n      const hasSetUpEvents = !target.rippleDisabled;\n      if (hasSetUpEvents) {\n        renderer.setupTriggerEvents(host);\n      }\n      this._hosts.set(host, {\n        target,\n        renderer,\n        hasSetUpEvents\n      });\n      host.removeAttribute(matRippleUninitialized);\n    }\n    destroyRipple(host) {\n      const ripple = this._hosts.get(host);\n      if (ripple) {\n        ripple.renderer._removeTriggerEvents();\n        this._hosts.delete(host);\n      }\n    }\n    static ɵfac = function MatRippleLoader_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || MatRippleLoader)();\n    };\n    static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n      token: MatRippleLoader,\n      factory: MatRippleLoader.ɵfac,\n      providedIn: 'root'\n    });\n  }\n  return MatRippleLoader;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nexport { MatRippleLoader as M };\n","import * as i0 from '@angular/core';\nimport { Component, ViewEncapsulation, ChangeDetectionStrategy } from '@angular/core';\n\n/**\n * Component used to load structural styles for focus indicators.\n * @docs-private\n */\nlet _StructuralStylesLoader = /*#__PURE__*/(() => {\n  class _StructuralStylesLoader {\n    static ɵfac = function _StructuralStylesLoader_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || _StructuralStylesLoader)();\n    };\n    static ɵcmp = /* @__PURE__ */i0.ɵɵdefineComponent({\n      type: _StructuralStylesLoader,\n      selectors: [[\"structural-styles\"]],\n      decls: 0,\n      vars: 0,\n      template: function _StructuralStylesLoader_Template(rf, ctx) {},\n      styles: [\".mat-focus-indicator{position:relative}.mat-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border-width:var(--mat-focus-indicator-border-width, 3px);border-style:var(--mat-focus-indicator-border-style, solid);border-color:var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus::before{content:\\\"\\\"}@media(forced-colors: active){html{--mat-focus-indicator-display: block}}\"],\n      encapsulation: 2,\n      changeDetection: 0\n    });\n  }\n  return _StructuralStylesLoader;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nexport { _StructuralStylesLoader as _ };\n"],"mappings":"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","names":["RippleState","RippleRef","_renderer","element","config","_animationForciblyDisabledThroughCss","passiveCapturingEventOptions$1","normalizePassiveListenerOptions","RippleEventManager","ngZone","name","handler","handlersForEvent","handlersForElement","event","target","_getEventTarget","handlers","defaultRippleAnimationConfig","ignoreMouseEventsTimeout","passiveCapturingEventOptions","pointerDownEvents","pointerUpEvents","_MatRippleStylesLoader","__ngFactoryType__","ɵɵdefineComponent","rf","ctx","RippleRenderer","_RippleRenderer","_target","_ngZone","elementOrElementRef","_platform","injector","coerceElement","_CdkPrivateStyleLoader","x","y","containerRect","animationConfig","__spreadValues","radius","distanceToFurthestCorner","offsetX","offsetY","enterDuration","ripple","computedStyles","userTransitionProperty","userTransitionDuration","animationForciblyDisabledThroughCss","rippleRef","eventListeners","onTransitionEnd","fallbackTimer","onTransitionCancel","rippleEl","type","isMostRecentTransientRipple","persistent","isFakeMousedown","isFakeMousedownFromScreenReader","isSyntheticEvent","isFakeTouchstartFromScreenReader","touches","isVisible","trigger","rect","distX","distY","MAT_RIPPLE_GLOBAL_OPTIONS","InjectionToken","eventListenerOptions","rippleInteractionEvents","matRippleUninitialized","matRippleClassName","matRippleCentered","matRippleDisabled","MatRippleLoader","inject","DOCUMENT","ANIMATION_MODULE_TYPE","MAT_RIPPLE_GLOBAL_OPTIONS","Platform","NgZone","Injector","renderer","RendererFactory2","name","_bindEventWithOptions","hosts","host","cleanup","config","disabled","ripple","event","eventTarget","_getEventTarget","element","rippleEl","isNoopAnimations","globalOptions","enterDuration","defaultRippleAnimationConfig","exitDuration","target","RippleRenderer","hasSetUpEvents","__ngFactoryType__","ɵɵdefineInjectable","_StructuralStylesLoader","__ngFactoryType__","ɵɵdefineComponent","rf","ctx"],"x_google_ignoreList":[0,1,2]}