{"version":3,"sources":["node_modules/@angular/cdk/fesm2022/observers/private.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { inject, NgZone, RendererFactory2, Injectable } from '@angular/core';\nimport { Subject, Observable } from 'rxjs';\nimport { filter, shareReplay, takeUntil } from 'rxjs/operators';\n\n/**\n * Handler that logs \"ResizeObserver loop limit exceeded\" errors.\n * These errors are not shown in the Chrome console, so we log them to ensure developers are aware.\n * @param e The error\n */\nconst loopLimitExceededErrorHandler = e => {\n  if (e instanceof ErrorEvent && e.message === 'ResizeObserver loop limit exceeded') {\n    console.error(`${e.message}. This could indicate a performance issue with your app. See https://github.com/WICG/resize-observer/blob/master/explainer.md#error-handling`);\n  }\n};\n/**\n * A shared ResizeObserver to be used for a particular box type (content-box, border-box, or\n * device-pixel-content-box)\n */\nclass SingleBoxSharedResizeObserver {\n  _box;\n  /** Stream that emits when the shared observer is destroyed. */\n  _destroyed = /*#__PURE__*/new Subject();\n  /** Stream of all events from the ResizeObserver. */\n  _resizeSubject = /*#__PURE__*/new Subject();\n  /** ResizeObserver used to observe element resize events. */\n  _resizeObserver;\n  /** A map of elements to streams of their resize events. */\n  _elementObservables = /*#__PURE__*/new Map();\n  constructor(/** The box type to observe for resizes. */\n  _box) {\n    this._box = _box;\n    if (typeof ResizeObserver !== 'undefined') {\n      this._resizeObserver = new ResizeObserver(entries => this._resizeSubject.next(entries));\n    }\n  }\n  /**\n   * Gets a stream of resize events for the given element.\n   * @param target The element to observe.\n   * @return The stream of resize events for the element.\n   */\n  observe(target) {\n    if (!this._elementObservables.has(target)) {\n      this._elementObservables.set(target, new Observable(observer => {\n        const subscription = this._resizeSubject.subscribe(observer);\n        this._resizeObserver?.observe(target, {\n          box: this._box\n        });\n        return () => {\n          this._resizeObserver?.unobserve(target);\n          subscription.unsubscribe();\n          this._elementObservables.delete(target);\n        };\n      }).pipe(filter(entries => entries.some(entry => entry.target === target)),\n      // Share a replay of the last event so that subsequent calls to observe the same element\n      // receive initial sizing info like the first one. Also enable ref counting so the\n      // element will be automatically unobserved when there are no more subscriptions.\n      shareReplay({\n        bufferSize: 1,\n        refCount: true\n      }), takeUntil(this._destroyed)));\n    }\n    return this._elementObservables.get(target);\n  }\n  /** Destroys this instance. */\n  destroy() {\n    this._destroyed.next();\n    this._destroyed.complete();\n    this._resizeSubject.complete();\n    this._elementObservables.clear();\n  }\n}\n/**\n * Allows observing resize events on multiple elements using a shared set of ResizeObserver.\n * Sharing a ResizeObserver instance is recommended for better performance (see\n * https://github.com/WICG/resize-observer/issues/59).\n *\n * Rather than share a single `ResizeObserver`, this class creates one `ResizeObserver` per type\n * of observed box ('content-box', 'border-box', and 'device-pixel-content-box'). This avoids\n * later calls to `observe` with a different box type from influencing the events dispatched to\n * earlier calls.\n */\nlet SharedResizeObserver = /*#__PURE__*/(() => {\n  class SharedResizeObserver {\n    _cleanupErrorListener;\n    /** Map of box type to shared resize observer. */\n    _observers = new Map();\n    /** The Angular zone. */\n    _ngZone = inject(NgZone);\n    constructor() {\n      if (typeof ResizeObserver !== 'undefined' && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n        this._ngZone.runOutsideAngular(() => {\n          const renderer = inject(RendererFactory2).createRenderer(null, null);\n          this._cleanupErrorListener = renderer.listen('window', 'error', loopLimitExceededErrorHandler);\n        });\n      }\n    }\n    ngOnDestroy() {\n      for (const [, observer] of this._observers) {\n        observer.destroy();\n      }\n      this._observers.clear();\n      this._cleanupErrorListener?.();\n    }\n    /**\n     * Gets a stream of resize events for the given target element and box type.\n     * @param target The element to observe for resizes.\n     * @param options Options to pass to the `ResizeObserver`\n     * @return The stream of resize events for the element.\n     */\n    observe(target, options) {\n      const box = options?.box || 'content-box';\n      if (!this._observers.has(box)) {\n        this._observers.set(box, new SingleBoxSharedResizeObserver(box));\n      }\n      return this._observers.get(box).observe(target);\n    }\n    static ɵfac = function SharedResizeObserver_Factory(__ngFactoryType__) {\n      return new (__ngFactoryType__ || SharedResizeObserver)();\n    };\n    static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n      token: SharedResizeObserver,\n      factory: SharedResizeObserver.ɵfac,\n      providedIn: 'root'\n    });\n  }\n  return SharedResizeObserver;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { SharedResizeObserver };\n"],"mappings":"8JAAA,IAmBMA,EA+DFC,EAlFJC,EAAAC,EAAA,KAAAC,IACAA,IACAC,IACAC,IAgBMN,EAAN,KAAoC,CAClC,KAEA,WAA0B,IAAIO,EAE9B,eAA8B,IAAIA,EAElC,gBAEA,oBAAmC,IAAI,IACvC,YACAC,EAAM,CACJ,KAAK,KAAOA,EACR,OAAO,eAAmB,MAC5B,KAAK,gBAAkB,IAAI,eAAeC,GAAW,KAAK,eAAe,KAAKA,CAAO,CAAC,EAE1F,CAMA,QAAQC,EAAQ,CACd,OAAK,KAAK,oBAAoB,IAAIA,CAAM,GACtC,KAAK,oBAAoB,IAAIA,EAAQ,IAAIC,EAAWC,GAAY,CAC9D,IAAMC,EAAe,KAAK,eAAe,UAAUD,CAAQ,EAC3D,YAAK,iBAAiB,QAAQF,EAAQ,CACpC,IAAK,KAAK,IACZ,CAAC,EACM,IAAM,CACX,KAAK,iBAAiB,UAAUA,CAAM,EACtCG,EAAa,YAAY,EACzB,KAAK,oBAAoB,OAAOH,CAAM,CACxC,CACF,CAAC,EAAE,KAAKI,EAAOL,GAAWA,EAAQ,KAAKM,GAASA,EAAM,SAAWL,CAAM,CAAC,EAIxEM,EAAY,CACV,WAAY,EACZ,SAAU,EACZ,CAAC,EAAGC,EAAU,KAAK,UAAU,CAAC,CAAC,EAE1B,KAAK,oBAAoB,IAAIP,CAAM,CAC5C,CAEA,SAAU,CACR,KAAK,WAAW,KAAK,EACrB,KAAK,WAAW,SAAS,EACzB,KAAK,eAAe,SAAS,EAC7B,KAAK,oBAAoB,MAAM,CACjC,CACF,EAWIT,GAAqC,IAAM,CAC7C,MAAMA,CAAqB,CACzB,sBAEA,WAAa,IAAI,IAEjB,QAAUiB,EAAOC,CAAM,EACvB,aAAc,CACR,OAAO,eAAmB,GAMhC,CACA,aAAc,CACZ,OAAW,CAAC,CAAEP,CAAQ,IAAK,KAAK,WAC9BA,EAAS,QAAQ,EAEnB,KAAK,WAAW,MAAM,EACtB,KAAK,wBAAwB,CAC/B,CAOA,QAAQF,EAAQU,EAAS,CACvB,IAAMC,EAAMD,GAAS,KAAO,cAC5B,OAAK,KAAK,WAAW,IAAIC,CAAG,GAC1B,KAAK,WAAW,IAAIA,EAAK,IAAIrB,EAA8BqB,CAAG,CAAC,EAE1D,KAAK,WAAW,IAAIA,CAAG,EAAE,QAAQX,CAAM,CAChD,CACA,OAAO,UAAO,SAAsCY,EAAmB,CACrE,OAAO,IAAKA,GAAqBrB,EACnC,EACA,OAAO,WAA0BsB,EAAmB,CAClD,MAAOtB,EACP,QAASA,EAAqB,UAC9B,WAAY,MACd,CAAC,CACH,CACA,OAAOA,CACT,GAAG","names":["SingleBoxSharedResizeObserver","SharedResizeObserver","init_private","__esmMin","init_core","init_esm","init_operators","Subject","_box","entries","target","Observable","observer","subscription","filter","entry","shareReplay","takeUntil","inject","NgZone","options","box","__ngFactoryType__","ɵɵdefineInjectable"],"x_google_ignoreList":[0]}