{"version":3,"sources":["node_modules/@ngrx/component/fesm2022/ngrx-component.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { NgZone, inject, Injectable, ChangeDetectorRef, untracked, Directive, Input, Pipe } from '@angular/core';\nimport { isObservable, combineLatest, from, Observable, ReplaySubject, pipe, Subscription } from 'rxjs';\nimport { distinctUntilChanged, tap, switchMap } from 'rxjs/operators';\nfunction isNgZone(zone) {\n  return zone instanceof NgZone;\n}\nlet TickScheduler = /*#__PURE__*/(() => {\n  class TickScheduler {\n    /** @nocollapse */static {\n      this.ɵfac = function TickScheduler_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || TickScheduler)();\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: TickScheduler,\n        factory: () => (() => {\n          const zone = inject(NgZone);\n          return isNgZone(zone) ? new NoopTickScheduler() : inject(AnimationFrameTickScheduler);\n        })(),\n        providedIn: 'root'\n      });\n    }\n  }\n  return TickScheduler;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet AnimationFrameTickScheduler = /*#__PURE__*/(() => {\n  class AnimationFrameTickScheduler extends TickScheduler {\n    constructor(appRef) {\n      super();\n      this.appRef = appRef;\n      this.isScheduled = false;\n    }\n    schedule() {\n      if (!this.isScheduled) {\n        this.isScheduled = true;\n        requestAnimationFrame(() => {\n          this.appRef.tick();\n          this.isScheduled = false;\n        });\n      }\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function AnimationFrameTickScheduler_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || AnimationFrameTickScheduler)(i0.ɵɵinject(i0.ApplicationRef));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: AnimationFrameTickScheduler,\n        factory: AnimationFrameTickScheduler.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return AnimationFrameTickScheduler;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nclass NoopTickScheduler extends TickScheduler {\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  schedule() {}\n}\n\n/**\n * Provides rendering functionality regardless of whether `zone.js` is present\n * or not. It must be provided at the component/directive level.\n *\n * @usageNotes\n *\n * ### Rerender zone-less app on route changes\n *\n * ```ts\n * @Component({\n *   selector: 'app-root',\n *   template: '<router-outlet>',\n *   // 👇 `RenderScheduler` is provided at the component level\n *   providers: [RenderScheduler],\n *   changeDetection: ChangeDetectionStrategy.OnPush,\n * })\n * export class AppComponent implements OnInit {\n *   constructor(\n *     private readonly router: Router,\n *     private readonly renderScheduler: RenderScheduler\n *   ) {}\n *\n *   ngOnInit(): void {\n *     this.router.events\n *       .pipe(filter((e) => e instanceof NavigationEnd))\n *       .subscribe(() => this.renderScheduler.schedule());\n *   }\n * }\n * ```\n *\n * ### Rerender component on interval\n *\n * ```ts\n * @Component({\n *   selector: 'app-interval',\n *   template: '{{ elapsedTime }}ms',\n *   // 👇 `RenderScheduler` is provided at the component level\n *   providers: [RenderScheduler],\n *   changeDetection: ChangeDetectionStrategy.OnPush,\n * })\n * export class IntervalComponent implements OnInit {\n *   elapsedTime = 0;\n *\n *   constructor(private readonly renderScheduler: RenderScheduler) {}\n *\n *   ngOnInit(): void {\n *     setInterval(() => {\n *       this.elapsedTime += 1000;\n *       this.renderScheduler.schedule();\n *     }, 1000);\n *   }\n * }\n * ```\n */\nlet RenderScheduler = /*#__PURE__*/(() => {\n  class RenderScheduler {\n    constructor(cdRef, tickScheduler) {\n      this.cdRef = cdRef;\n      this.tickScheduler = tickScheduler;\n    }\n    /**\n     * Marks component and its ancestors as dirty.\n     * It also schedules a new change detection cycle in zone-less mode.\n     */\n    schedule() {\n      this.cdRef.markForCheck();\n      this.tickScheduler.schedule();\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function RenderScheduler_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || RenderScheduler)(i0.ɵɵinject(i0.ChangeDetectorRef), i0.ɵɵinject(TickScheduler));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: RenderScheduler,\n        factory: RenderScheduler.ɵfac\n      });\n    }\n  }\n  return RenderScheduler;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction createRenderScheduler() {\n  return new RenderScheduler(inject(ChangeDetectorRef), inject(TickScheduler));\n}\nfunction combineRenderEventHandlers(handlers) {\n  return event => handlers[event.type]?.(event);\n}\nfunction fromPotentialObservable(potentialObservable) {\n  if (isObservable(potentialObservable)) {\n    return potentialObservable;\n  }\n  if (isObservableDictionary(potentialObservable)) {\n    return combineLatest(toDistinctObsDictionary(potentialObservable));\n  }\n  if (isPromiseLike(potentialObservable)) {\n    return from(potentialObservable);\n  }\n  return new Observable(subscriber => {\n    subscriber.next(potentialObservable);\n  });\n}\nfunction isPromiseLike(value) {\n  return typeof value?.then === 'function';\n}\nfunction isObservableDictionary(value) {\n  return isDictionary(value) && Object.keys(value).length > 0 && Object.values(value).every(isObservable);\n}\nfunction isDictionary(value) {\n  return !!value && typeof value === 'object' && !Array.isArray(value);\n}\nfunction toDistinctObsDictionary(obsDictionary) {\n  return Object.keys(obsDictionary).reduce((acc, key) => ({\n    ...acc,\n    [key]: obsDictionary[key].pipe(distinctUntilChanged())\n  }), {});\n}\nfunction createRenderEventManager(handlers) {\n  const handleRenderEvent = combineRenderEventHandlers(handlers);\n  const potentialObservable$ = new ReplaySubject(1);\n  return {\n    nextPotentialObservable(potentialObservable) {\n      potentialObservable$.next(potentialObservable);\n    },\n    handlePotentialObservableChanges() {\n      return potentialObservable$.pipe(distinctUntilChanged(), switchMapToRenderEvent(), distinctUntilChanged(renderEventComparator), tap(handleRenderEvent));\n    }\n  };\n}\nfunction switchMapToRenderEvent() {\n  return pipe(switchMap(potentialObservable => {\n    const observable$ = fromPotentialObservable(potentialObservable);\n    let reset = true;\n    let synchronous = true;\n    return new Observable(subscriber => {\n      const subscription = untracked(() => observable$.subscribe({\n        next(value) {\n          subscriber.next({\n            type: 'next',\n            value,\n            reset,\n            synchronous\n          });\n          reset = false;\n        },\n        error(error) {\n          subscriber.next({\n            type: 'error',\n            error,\n            reset,\n            synchronous\n          });\n          reset = false;\n        },\n        complete() {\n          subscriber.next({\n            type: 'complete',\n            reset,\n            synchronous\n          });\n          reset = false;\n        }\n      }));\n      if (reset) {\n        subscriber.next({\n          type: 'suspense',\n          reset,\n          synchronous: true\n        });\n        reset = false;\n      }\n      synchronous = false;\n      return subscription;\n    });\n  }));\n}\nfunction renderEventComparator(previous, current) {\n  if (previous.type !== current.type || previous.reset !== current.reset) {\n    return false;\n  }\n  if (current.type === 'next') {\n    return previous.value === current.value;\n  }\n  if (current.type === 'error') {\n    return previous.error === current.error;\n  }\n  return true;\n}\n\n/**\n *\n * @description\n *\n * The `*ngrxLet` directive serves a convenient way of binding observables to a view context\n * (DOM element's scope). It also helps with several internal processing under the hood.\n *\n * @usageNotes\n *\n * ### Displaying Observable Values\n *\n * ```html\n * <ng-container *ngrxLet=\"number$ as n\">\n *   <app-number [number]=\"n\"></app-number>\n * </ng-container>\n *\n * <ng-container *ngrxLet=\"number$; let n\">\n *   <app-number [number]=\"n\"></app-number>\n * </ng-container>\n * ```\n *\n * ### Tracking Different Observable Events\n *\n * ```html\n * <ng-container *ngrxLet=\"number$ as n; error as e; complete as c\">\n *   <app-number [number]=\"n\" *ngIf=\"!e && !c\">\n *   </app-number>\n *\n *   <p *ngIf=\"e\">There is an error: {{ e }}</p>\n *   <p *ngIf=\"c\">Observable is completed.</p>\n * </ng-container>\n * ```\n *\n * ### Combining Multiple Observables\n *\n * ```html\n * <ng-container *ngrxLet=\"{ users: users$, query: query$ } as vm\">\n *   <app-search-bar [query]=\"vm.query\"></app-search-bar>\n *   <app-user-list [users]=\"vm.users\"></app-user-list>\n * </ng-container>\n * ```\n *\n * ### Using Suspense Template\n *\n * ```html\n * <ng-container *ngrxLet=\"number$ as n; suspenseTpl: loading\">\n *   <app-number [number]=\"n\"></app-number>\n * </ng-container>\n *\n * <ng-template #loading>\n *   <p>Loading...</p>\n * </ng-template>\n * ```\n *\n * ### Using Aliases for Non-Observable Values\n *\n * ```html\n * <ng-container *ngrxLet=\"userForm.controls.email as email\">\n *   <input type=\"text\" [formControl]=\"email\" />\n *\n *   <ng-container *ngIf=\"email.errors && (email.touched || email.dirty)\">\n *     <p *ngIf=\"email.errors.required\">This field is required.</p>\n *     <p *ngIf=\"email.errors.email\">This field must be an email.</p>\n *   </ng-container>\n * </ng-container>\n * ```\n *\n * @publicApi\n */\nlet LetDirective = /*#__PURE__*/(() => {\n  class LetDirective {\n    set ngrxLet(potentialObservable) {\n      this.renderEventManager.nextPotentialObservable(potentialObservable);\n    }\n    constructor(mainTemplateRef, viewContainerRef, errorHandler, renderScheduler) {\n      this.mainTemplateRef = mainTemplateRef;\n      this.viewContainerRef = viewContainerRef;\n      this.errorHandler = errorHandler;\n      this.renderScheduler = renderScheduler;\n      this.isMainViewCreated = false;\n      this.isSuspenseViewCreated = false;\n      this.viewContext = {\n        $implicit: undefined,\n        ngrxLet: undefined,\n        error: undefined,\n        complete: false\n      };\n      this.renderEventManager = createRenderEventManager({\n        suspense: () => {\n          this.viewContext.$implicit = undefined;\n          this.viewContext.ngrxLet = undefined;\n          this.viewContext.error = undefined;\n          this.viewContext.complete = false;\n          this.renderSuspenseView();\n        },\n        next: event => {\n          this.viewContext.$implicit = event.value;\n          this.viewContext.ngrxLet = event.value;\n          if (event.reset) {\n            this.viewContext.error = undefined;\n            this.viewContext.complete = false;\n          }\n          this.renderMainView(event.synchronous);\n        },\n        error: event => {\n          this.viewContext.error = event.error;\n          if (event.reset) {\n            this.viewContext.$implicit = undefined;\n            this.viewContext.ngrxLet = undefined;\n            this.viewContext.complete = false;\n          }\n          this.renderMainView(event.synchronous);\n          this.errorHandler.handleError(event.error);\n        },\n        complete: event => {\n          this.viewContext.complete = true;\n          if (event.reset) {\n            this.viewContext.$implicit = undefined;\n            this.viewContext.ngrxLet = undefined;\n            this.viewContext.error = undefined;\n          }\n          this.renderMainView(event.synchronous);\n        }\n      });\n      this.subscription = new Subscription();\n    }\n    static ngTemplateContextGuard(dir, ctx) {\n      return true;\n    }\n    ngOnInit() {\n      this.subscription.add(this.renderEventManager.handlePotentialObservableChanges().subscribe());\n    }\n    ngOnDestroy() {\n      this.subscription.unsubscribe();\n    }\n    renderMainView(isSyncEvent) {\n      if (this.isSuspenseViewCreated) {\n        this.isSuspenseViewCreated = false;\n        this.viewContainerRef.clear();\n      }\n      if (!this.isMainViewCreated) {\n        this.isMainViewCreated = true;\n        this.viewContainerRef.createEmbeddedView(this.mainTemplateRef, this.viewContext);\n      }\n      if (!isSyncEvent) {\n        this.renderScheduler.schedule();\n      }\n    }\n    renderSuspenseView() {\n      if (this.isMainViewCreated) {\n        this.isMainViewCreated = false;\n        this.viewContainerRef.clear();\n      }\n      if (this.suspenseTemplateRef && !this.isSuspenseViewCreated) {\n        this.isSuspenseViewCreated = true;\n        this.viewContainerRef.createEmbeddedView(this.suspenseTemplateRef);\n      }\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function LetDirective_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || LetDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i0.ErrorHandler), i0.ɵɵdirectiveInject(RenderScheduler));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n        type: LetDirective,\n        selectors: [[\"\", \"ngrxLet\", \"\"]],\n        inputs: {\n          ngrxLet: \"ngrxLet\",\n          suspenseTemplateRef: [0, \"ngrxLetSuspenseTpl\", \"suspenseTemplateRef\"]\n        },\n        standalone: true,\n        features: [i0.ɵɵProvidersFeature([RenderScheduler])]\n      });\n    }\n  }\n  return LetDirective;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * @description\n *\n * The `ngrxPush` pipe serves as a drop-in replacement for the `async` pipe.\n * It contains intelligent handling of change detection to enable us\n * running in zone-full as well as zone-less mode without any changes to the code.\n *\n * @usageNotes\n *\n * ### Displaying Observable Values\n *\n * ```html\n * <p>{{ number$ | ngrxPush }}</p>\n *\n * <ng-container *ngIf=\"number$ | ngrxPush as n\">{{ n }}</ng-container>\n *\n * <app-number [number]=\"number$ | ngrxPush\"></app-number>\n * ```\n *\n * ### Combining Multiple Observables\n *\n * ```html\n * <code>\n *   {{ { users: users$, query: query$ } | ngrxPush | json }}\n * </code>\n * ```\n *\n * @publicApi\n */\nlet PushPipe = /*#__PURE__*/(() => {\n  class PushPipe {\n    constructor(errorHandler) {\n      this.errorHandler = errorHandler;\n      this.renderScheduler = createRenderScheduler();\n      this.renderEventManager = createRenderEventManager({\n        suspense: event => this.setRenderedValue(undefined, event.synchronous),\n        next: event => this.setRenderedValue(event.value, event.synchronous),\n        error: event => {\n          if (event.reset) {\n            this.setRenderedValue(undefined, event.synchronous);\n          }\n          this.errorHandler.handleError(event.error);\n        },\n        complete: event => {\n          if (event.reset) {\n            this.setRenderedValue(undefined, event.synchronous);\n          }\n        }\n      });\n      this.subscription = this.renderEventManager.handlePotentialObservableChanges().subscribe();\n    }\n    transform(potentialObservable) {\n      this.renderEventManager.nextPotentialObservable(potentialObservable);\n      return this.renderedValue;\n    }\n    ngOnDestroy() {\n      this.subscription.unsubscribe();\n    }\n    setRenderedValue(value, isSyncEvent) {\n      if (value !== this.renderedValue) {\n        this.renderedValue = value;\n        if (!isSyncEvent) {\n          this.renderScheduler.schedule();\n        }\n      }\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function PushPipe_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || PushPipe)(i0.ɵɵdirectiveInject(i0.ErrorHandler, 16));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵpipe = /* @__PURE__ */i0.ɵɵdefinePipe({\n        name: \"ngrxPush\",\n        type: PushPipe,\n        pure: false,\n        standalone: true\n      });\n    }\n  }\n  return PushPipe;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/**\n * DO NOT EDIT\n *\n * This file is automatically generated at build\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { LetDirective, PushPipe, RenderScheduler };\n"],"mappings":"+NAIA,SAASA,EAASC,EAAM,CACtB,OAAOA,aAAgBC,CACzB,CACA,IAAIC,GAA8B,IAAM,CACtC,IAAMC,EAAN,MAAMA,CAAc,CAiBpB,EAfIA,EAAK,UAAO,SAA+BC,EAAmB,CAC5D,OAAO,IAAKA,GAAqBD,EACnC,EAIAA,EAAK,WAA0BE,EAAmB,CAChD,MAAOF,EACP,QAAS,KAAO,IAAM,CACpB,IAAMH,EAAOM,EAAOL,CAAM,EAC1B,OAAOF,EAASC,CAAI,EAAI,IAAIO,EAAsBD,EAAOE,CAA2B,CACtF,GAAG,EACH,WAAY,MACd,CAAC,EAfL,IAAMN,EAANC,EAkBA,OAAOD,CACT,GAAG,EAICM,GAA4C,IAAM,CACpD,IAAMC,EAAN,MAAMA,UAAoCP,CAAc,CACtD,YAAYQ,EAAQ,CAClB,MAAM,EACN,KAAK,OAASA,EACd,KAAK,YAAc,EACrB,CACA,UAAW,CACJ,KAAK,cACR,KAAK,YAAc,GACnB,sBAAsB,IAAM,CAC1B,KAAK,OAAO,KAAK,EACjB,KAAK,YAAc,EACrB,CAAC,EAEL,CAeF,EAZID,EAAK,UAAO,SAA6CL,EAAmB,CAC1E,OAAO,IAAKA,GAAqBK,GAAgCE,EAAYC,CAAc,CAAC,CAC9F,EAIAH,EAAK,WAA0BJ,EAAmB,CAChD,MAAOI,EACP,QAASA,EAA4B,UACrC,WAAY,MACd,CAAC,EA3BL,IAAMD,EAANC,EA8BA,OAAOD,CACT,GAAG,EAIGD,EAAN,cAAgCL,CAAc,CAE5C,UAAW,CAAC,CACd,EAwDIW,GAAgC,IAAM,CACxC,IAAMC,EAAN,MAAMA,CAAgB,CACpB,YAAYC,EAAOC,EAAe,CAChC,KAAK,MAAQD,EACb,KAAK,cAAgBC,CACvB,CAKA,UAAW,CACT,KAAK,MAAM,aAAa,EACxB,KAAK,cAAc,SAAS,CAC9B,CAcF,EAXIF,EAAK,UAAO,SAAiCV,EAAmB,CAC9D,OAAO,IAAKA,GAAqBU,GAAoBH,EAAYM,CAAiB,EAAMN,EAAST,CAAa,CAAC,CACjH,EAIAY,EAAK,WAA0BT,EAAmB,CAChD,MAAOS,EACP,QAASA,EAAgB,SAC3B,CAAC,EAxBL,IAAMD,EAANC,EA2BA,OAAOD,CACT,GAAG,EAOH,SAASK,EAA2BC,EAAU,CAC5C,OAAOC,GAASD,EAASC,EAAM,IAAI,IAAIA,CAAK,CAC9C,CACA,SAASC,EAAwBC,EAAqB,CACpD,OAAIC,EAAaD,CAAmB,EAC3BA,EAELE,EAAuBF,CAAmB,EACrCG,EAAcC,EAAwBJ,CAAmB,CAAC,EAE/DK,EAAcL,CAAmB,EAC5BM,EAAKN,CAAmB,EAE1B,IAAIO,EAAWC,GAAc,CAClCA,EAAW,KAAKR,CAAmB,CACrC,CAAC,CACH,CACA,SAASK,EAAcI,EAAO,CAC5B,OAAO,OAAOA,GAAO,MAAS,UAChC,CACA,SAASP,EAAuBO,EAAO,CACrC,OAAOC,EAAaD,CAAK,GAAK,OAAO,KAAKA,CAAK,EAAE,OAAS,GAAK,OAAO,OAAOA,CAAK,EAAE,MAAMR,CAAY,CACxG,CACA,SAASS,EAAaD,EAAO,CAC3B,MAAO,CAAC,CAACA,GAAS,OAAOA,GAAU,UAAY,CAAC,MAAM,QAAQA,CAAK,CACrE,CACA,SAASL,EAAwBO,EAAe,CAC9C,OAAO,OAAO,KAAKA,CAAa,EAAE,OAAO,CAACC,EAAKC,IAASC,EAAAC,EAAA,GACnDH,GADmD,CAEtD,CAACC,CAAG,EAAGF,EAAcE,CAAG,EAAE,KAAKG,EAAqB,CAAC,CACvD,GAAI,CAAC,CAAC,CACR,CACA,SAASC,EAAyBpB,EAAU,CAC1C,IAAMqB,EAAoBtB,EAA2BC,CAAQ,EACvDsB,EAAuB,IAAIC,EAAc,CAAC,EAChD,MAAO,CACL,wBAAwBpB,EAAqB,CAC3CmB,EAAqB,KAAKnB,CAAmB,CAC/C,EACA,kCAAmC,CACjC,OAAOmB,EAAqB,KAAKH,EAAqB,EAAGK,EAAuB,EAAGL,EAAqBM,CAAqB,EAAGC,EAAIL,CAAiB,CAAC,CACxJ,CACF,CACF,CACA,SAASG,GAAyB,CAChC,OAAOG,EAAKC,EAAUzB,GAAuB,CAC3C,IAAM0B,EAAc3B,EAAwBC,CAAmB,EAC3D2B,EAAQ,GACRC,EAAc,GAClB,OAAO,IAAIrB,EAAWC,GAAc,CAClC,IAAMqB,EAAeC,EAAU,IAAMJ,EAAY,UAAU,CACzD,KAAKjB,EAAO,CACVD,EAAW,KAAK,CACd,KAAM,OACN,MAAAC,EACA,MAAAkB,EACA,YAAAC,CACF,CAAC,EACDD,EAAQ,EACV,EACA,MAAMI,EAAO,CACXvB,EAAW,KAAK,CACd,KAAM,QACN,MAAAuB,EACA,MAAAJ,EACA,YAAAC,CACF,CAAC,EACDD,EAAQ,EACV,EACA,UAAW,CACTnB,EAAW,KAAK,CACd,KAAM,WACN,MAAAmB,EACA,YAAAC,CACF,CAAC,EACDD,EAAQ,EACV,CACF,CAAC,CAAC,EACF,OAAIA,IACFnB,EAAW,KAAK,CACd,KAAM,WACN,MAAAmB,EACA,YAAa,EACf,CAAC,EACDA,EAAQ,IAEVC,EAAc,GACPC,CACT,CAAC,CACH,CAAC,CAAC,CACJ,CACA,SAASP,EAAsBU,EAAUC,EAAS,CAChD,OAAID,EAAS,OAASC,EAAQ,MAAQD,EAAS,QAAUC,EAAQ,MACxD,GAELA,EAAQ,OAAS,OACZD,EAAS,QAAUC,EAAQ,MAEhCA,EAAQ,OAAS,QACZD,EAAS,QAAUC,EAAQ,MAE7B,EACT,CAuEA,IAAIC,IAA6B,IAAM,CACrC,IAAMC,EAAN,MAAMA,CAAa,CACjB,IAAI,QAAQnC,EAAqB,CAC/B,KAAK,mBAAmB,wBAAwBA,CAAmB,CACrE,CACA,YAAYoC,EAAiBC,EAAkBC,EAAcC,EAAiB,CAC5E,KAAK,gBAAkBH,EACvB,KAAK,iBAAmBC,EACxB,KAAK,aAAeC,EACpB,KAAK,gBAAkBC,EACvB,KAAK,kBAAoB,GACzB,KAAK,sBAAwB,GAC7B,KAAK,YAAc,CACjB,UAAW,OACX,QAAS,OACT,MAAO,OACP,SAAU,EACZ,EACA,KAAK,mBAAqBtB,EAAyB,CACjD,SAAU,IAAM,CACd,KAAK,YAAY,UAAY,OAC7B,KAAK,YAAY,QAAU,OAC3B,KAAK,YAAY,MAAQ,OACzB,KAAK,YAAY,SAAW,GAC5B,KAAK,mBAAmB,CAC1B,EACA,KAAMnB,GAAS,CACb,KAAK,YAAY,UAAYA,EAAM,MACnC,KAAK,YAAY,QAAUA,EAAM,MAC7BA,EAAM,QACR,KAAK,YAAY,MAAQ,OACzB,KAAK,YAAY,SAAW,IAE9B,KAAK,eAAeA,EAAM,WAAW,CACvC,EACA,MAAOA,GAAS,CACd,KAAK,YAAY,MAAQA,EAAM,MAC3BA,EAAM,QACR,KAAK,YAAY,UAAY,OAC7B,KAAK,YAAY,QAAU,OAC3B,KAAK,YAAY,SAAW,IAE9B,KAAK,eAAeA,EAAM,WAAW,EACrC,KAAK,aAAa,YAAYA,EAAM,KAAK,CAC3C,EACA,SAAUA,GAAS,CACjB,KAAK,YAAY,SAAW,GACxBA,EAAM,QACR,KAAK,YAAY,UAAY,OAC7B,KAAK,YAAY,QAAU,OAC3B,KAAK,YAAY,MAAQ,QAE3B,KAAK,eAAeA,EAAM,WAAW,CACvC,CACF,CAAC,EACD,KAAK,aAAe,IAAI0C,CAC1B,CACA,OAAO,uBAAuBC,EAAKC,EAAK,CACtC,MAAO,EACT,CACA,UAAW,CACT,KAAK,aAAa,IAAI,KAAK,mBAAmB,iCAAiC,EAAE,UAAU,CAAC,CAC9F,CACA,aAAc,CACZ,KAAK,aAAa,YAAY,CAChC,CACA,eAAeC,EAAa,CACtB,KAAK,wBACP,KAAK,sBAAwB,GAC7B,KAAK,iBAAiB,MAAM,GAEzB,KAAK,oBACR,KAAK,kBAAoB,GACzB,KAAK,iBAAiB,mBAAmB,KAAK,gBAAiB,KAAK,WAAW,GAE5EA,GACH,KAAK,gBAAgB,SAAS,CAElC,CACA,oBAAqB,CACf,KAAK,oBACP,KAAK,kBAAoB,GACzB,KAAK,iBAAiB,MAAM,GAE1B,KAAK,qBAAuB,CAAC,KAAK,wBACpC,KAAK,sBAAwB,GAC7B,KAAK,iBAAiB,mBAAmB,KAAK,mBAAmB,EAErE,CAoBF,EAjBIR,EAAK,UAAO,SAA8BS,EAAmB,CAC3D,OAAO,IAAKA,GAAqBT,GAAiBU,EAAqBC,CAAW,EAAMD,EAAqBE,CAAgB,EAAMF,EAAqBG,CAAY,EAAMH,EAAkBI,CAAe,CAAC,CAC9M,EAIAd,EAAK,UAAyBe,EAAkB,CAC9C,KAAMf,EACN,UAAW,CAAC,CAAC,GAAI,UAAW,EAAE,CAAC,EAC/B,OAAQ,CACN,QAAS,UACT,oBAAqB,CAAC,EAAG,qBAAsB,qBAAqB,CACtE,EACA,WAAY,GACZ,SAAU,CAAIgB,EAAmB,CAACF,CAAe,CAAC,CAAC,CACrD,CAAC,EAzGL,IAAMf,EAANC,EA4GA,OAAOD,CACT,GAAG","names":["isNgZone","zone","NgZone","TickScheduler","_TickScheduler","__ngFactoryType__","ɵɵdefineInjectable","inject","NoopTickScheduler","AnimationFrameTickScheduler","_AnimationFrameTickScheduler","appRef","ɵɵinject","ApplicationRef","RenderScheduler","_RenderScheduler","cdRef","tickScheduler","ChangeDetectorRef","combineRenderEventHandlers","handlers","event","fromPotentialObservable","potentialObservable","isObservable","isObservableDictionary","combineLatest","toDistinctObsDictionary","isPromiseLike","from","Observable","subscriber","value","isDictionary","obsDictionary","acc","key","__spreadProps","__spreadValues","distinctUntilChanged","createRenderEventManager","handleRenderEvent","potentialObservable$","ReplaySubject","switchMapToRenderEvent","renderEventComparator","tap","pipe","switchMap","observable$","reset","synchronous","subscription","untracked","error","previous","current","LetDirective","_LetDirective","mainTemplateRef","viewContainerRef","errorHandler","renderScheduler","Subscription","dir","ctx","isSyncEvent","__ngFactoryType__","ɵɵdirectiveInject","TemplateRef","ViewContainerRef","ErrorHandler","RenderScheduler","ɵɵdefineDirective","ɵɵProvidersFeature"],"x_google_ignoreList":[0]}