{"version":3,"sources":["node_modules/@angular/cdk/fesm2022/coercion.mjs","node_modules/@angular/cdk/fesm2022/observers.mjs"],"sourcesContent":["import { ElementRef } from '@angular/core';\n\n/** Coerces a data-bound value (typically a string) to a boolean. */\nfunction coerceBooleanProperty(value) {\n  return value != null && `${value}` !== 'false';\n}\nfunction coerceNumberProperty(value, fallbackValue = 0) {\n  if (_isNumberValue(value)) {\n    return Number(value);\n  }\n  return arguments.length === 2 ? fallbackValue : 0;\n}\n/**\n * Whether the provided value is considered a number.\n * @docs-private\n */\nfunction _isNumberValue(value) {\n  // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,\n  // and other non-number values as NaN, where Number just uses 0) but it considers the string\n  // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.\n  return !isNaN(parseFloat(value)) && !isNaN(Number(value));\n}\nfunction coerceArray(value) {\n  return Array.isArray(value) ? value : [value];\n}\n\n/** Coerces a value to a CSS pixel value. */\nfunction coerceCssPixelValue(value) {\n  if (value == null) {\n    return '';\n  }\n  return typeof value === 'string' ? value : `${value}px`;\n}\n\n/**\n * Coerces an ElementRef or an Element into an element.\n * Useful for APIs that can accept either a ref or the native element itself.\n */\nfunction coerceElement(elementOrRef) {\n  return elementOrRef instanceof ElementRef ? elementOrRef.nativeElement : elementOrRef;\n}\n\n/**\n * Coerces a value to an array of trimmed non-empty strings.\n * Any input that is not an array, `null` or `undefined` will be turned into a string\n * via `toString()` and subsequently split with the given separator.\n * `null` and `undefined` will result in an empty array.\n * This results in the following outcomes:\n * - `null` -&gt; `[]`\n * - `[null]` -&gt; `[\"null\"]`\n * - `[\"a\", \"b \", \" \"]` -&gt; `[\"a\", \"b\"]`\n * - `[1, [2, 3]]` -&gt; `[\"1\", \"2,3\"]`\n * - `[{ a: 0 }]` -&gt; `[\"[object Object]\"]`\n * - `{ a: 0 }` -&gt; `[\"[object\", \"Object]\"]`\n *\n * Useful for defining CSS classes or table columns.\n * @param value the value to coerce into an array of strings\n * @param separator split-separator if value isn't an array\n */\nfunction coerceStringArray(value, separator = /\\s+/) {\n  const result = [];\n  if (value != null) {\n    const sourceValues = Array.isArray(value) ? value : `${value}`.split(separator);\n    for (const sourceValue of sourceValues) {\n      const trimmedString = `${sourceValue}`.trim();\n      if (trimmedString) {\n        result.push(trimmedString);\n      }\n    }\n  }\n  return result;\n}\nexport { _isNumberValue, coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceElement, coerceNumberProperty, coerceStringArray };\n","import { coerceElement, coerceNumberProperty } from '@angular/cdk/coercion';\nimport * as i0 from '@angular/core';\nimport { Injectable, inject, NgZone, EventEmitter, booleanAttribute, Directive, Output, Input, NgModule } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { map, filter, debounceTime } from 'rxjs/operators';\n\n// Angular may add, remove, or edit comment nodes during change detection. We don't care about\n// these changes because they don't affect the user-preceived content, and worse it can cause\n// infinite change detection cycles where the change detection updates a comment, triggering the\n// MutationObserver, triggering another change detection and kicking the cycle off again.\nfunction shouldIgnoreRecord(record) {\n  // Ignore changes to comment text.\n  if (record.type === 'characterData' && record.target instanceof Comment) {\n    return true;\n  }\n  // Ignore addition / removal of comments.\n  if (record.type === 'childList') {\n    for (let i = 0; i < record.addedNodes.length; i++) {\n      if (!(record.addedNodes[i] instanceof Comment)) {\n        return false;\n      }\n    }\n    for (let i = 0; i < record.removedNodes.length; i++) {\n      if (!(record.removedNodes[i] instanceof Comment)) {\n        return false;\n      }\n    }\n    return true;\n  }\n  // Observe everything else.\n  return false;\n}\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * @docs-private\n */\nlet MutationObserverFactory = /*#__PURE__*/(() => {\n  class MutationObserverFactory {\n    create(callback) {\n      return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n    }\n    static {\n      this.ɵfac = function MutationObserverFactory_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || MutationObserverFactory)();\n      };\n    }\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: MutationObserverFactory,\n        factory: MutationObserverFactory.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return MutationObserverFactory;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/** An injectable service that allows watching elements for changes to their content. */\nlet ContentObserver = /*#__PURE__*/(() => {\n  class ContentObserver {\n    constructor(_mutationObserverFactory) {\n      this._mutationObserverFactory = _mutationObserverFactory;\n      /** Keeps track of the existing MutationObservers so they can be reused. */\n      this._observedElements = new Map();\n      this._ngZone = inject(NgZone);\n    }\n    ngOnDestroy() {\n      this._observedElements.forEach((_, element) => this._cleanupObserver(element));\n    }\n    observe(elementOrRef) {\n      const element = coerceElement(elementOrRef);\n      return new Observable(observer => {\n        const stream = this._observeElement(element);\n        const subscription = stream.pipe(map(records => records.filter(record => !shouldIgnoreRecord(record))), filter(records => !!records.length)).subscribe(records => {\n          this._ngZone.run(() => {\n            observer.next(records);\n          });\n        });\n        return () => {\n          subscription.unsubscribe();\n          this._unobserveElement(element);\n        };\n      });\n    }\n    /**\n     * Observes the given element by using the existing MutationObserver if available, or creating a\n     * new one if not.\n     */\n    _observeElement(element) {\n      return this._ngZone.runOutsideAngular(() => {\n        if (!this._observedElements.has(element)) {\n          const stream = new Subject();\n          const observer = this._mutationObserverFactory.create(mutations => stream.next(mutations));\n          if (observer) {\n            observer.observe(element, {\n              characterData: true,\n              childList: true,\n              subtree: true\n            });\n          }\n          this._observedElements.set(element, {\n            observer,\n            stream,\n            count: 1\n          });\n        } else {\n          this._observedElements.get(element).count++;\n        }\n        return this._observedElements.get(element).stream;\n      });\n    }\n    /**\n     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is\n     * observing this element.\n     */\n    _unobserveElement(element) {\n      if (this._observedElements.has(element)) {\n        this._observedElements.get(element).count--;\n        if (!this._observedElements.get(element).count) {\n          this._cleanupObserver(element);\n        }\n      }\n    }\n    /** Clean up the underlying MutationObserver for the specified element. */\n    _cleanupObserver(element) {\n      if (this._observedElements.has(element)) {\n        const {\n          observer,\n          stream\n        } = this._observedElements.get(element);\n        if (observer) {\n          observer.disconnect();\n        }\n        stream.complete();\n        this._observedElements.delete(element);\n      }\n    }\n    static {\n      this.ɵfac = function ContentObserver_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || ContentObserver)(i0.ɵɵinject(MutationObserverFactory));\n      };\n    }\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: ContentObserver,\n        factory: ContentObserver.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return ContentObserver;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\nlet CdkObserveContent = /*#__PURE__*/(() => {\n  class CdkObserveContent {\n    /**\n     * Whether observing content is disabled. This option can be used\n     * to disconnect the underlying MutationObserver until it is needed.\n     */\n    get disabled() {\n      return this._disabled;\n    }\n    set disabled(value) {\n      this._disabled = value;\n      this._disabled ? this._unsubscribe() : this._subscribe();\n    }\n    /** Debounce interval for emitting the changes. */\n    get debounce() {\n      return this._debounce;\n    }\n    set debounce(value) {\n      this._debounce = coerceNumberProperty(value);\n      this._subscribe();\n    }\n    constructor(_contentObserver, _elementRef) {\n      this._contentObserver = _contentObserver;\n      this._elementRef = _elementRef;\n      /** Event emitted for each change in the element's content. */\n      this.event = new EventEmitter();\n      this._disabled = false;\n      this._currentSubscription = null;\n    }\n    ngAfterContentInit() {\n      if (!this._currentSubscription && !this.disabled) {\n        this._subscribe();\n      }\n    }\n    ngOnDestroy() {\n      this._unsubscribe();\n    }\n    _subscribe() {\n      this._unsubscribe();\n      const stream = this._contentObserver.observe(this._elementRef);\n      this._currentSubscription = (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);\n    }\n    _unsubscribe() {\n      this._currentSubscription?.unsubscribe();\n    }\n    static {\n      this.ɵfac = function CdkObserveContent_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || CdkObserveContent)(i0.ɵɵdirectiveInject(ContentObserver), i0.ɵɵdirectiveInject(i0.ElementRef));\n      };\n    }\n    static {\n      this.ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n        type: CdkObserveContent,\n        selectors: [[\"\", \"cdkObserveContent\", \"\"]],\n        inputs: {\n          disabled: [2, \"cdkObserveContentDisabled\", \"disabled\", booleanAttribute],\n          debounce: \"debounce\"\n        },\n        outputs: {\n          event: \"cdkObserveContent\"\n        },\n        exportAs: [\"cdkObserveContent\"],\n        standalone: true,\n        features: [i0.ɵɵInputTransformsFeature]\n      });\n    }\n  }\n  return CdkObserveContent;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet ObserversModule = /*#__PURE__*/(() => {\n  class ObserversModule {\n    static {\n      this.ɵfac = function ObserversModule_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || ObserversModule)();\n      };\n    }\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: ObserversModule\n      });\n    }\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({\n        providers: [MutationObserverFactory]\n      });\n    }\n  }\n  return ObserversModule;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { CdkObserveContent, ContentObserver, MutationObserverFactory, ObserversModule };\n"],"mappings":"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","names":["coerceBooleanProperty","value","coerceNumberProperty","fallbackValue","_isNumberValue","coerceArray","coerceCssPixelValue","coerceElement","elementOrRef","ElementRef","coerceStringArray","separator","result","sourceValues","sourceValue","trimmedString","shouldIgnoreRecord","record","i","MutationObserverFactory","callback","__ngFactoryType__","ɵɵdefineInjectable","ContentObserver","_mutationObserverFactory","inject","NgZone","_","element","elementOrRef","coerceElement","Observable","observer","subscription","map","records","filter","stream","Subject","mutations","ɵɵinject","CdkObserveContent","value","coerceNumberProperty","_contentObserver","_elementRef","EventEmitter","debounceTime","ɵɵdirectiveInject","ElementRef","ɵɵdefineDirective","booleanAttribute","ɵɵInputTransformsFeature","ObserversModule","ɵɵdefineNgModule","ɵɵdefineInjector"],"x_google_ignoreList":[0,1]}