{"version":3,"sources":["node_modules/@angular/core/fesm2022/rxjs-interop.mjs","node_modules/@ngneat/until-destroy/fesm2022/ngneat-until-destroy.mjs"],"sourcesContent":["/**\n * @license Angular v19.1.7\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { assertInInjectionContext, inject, DestroyRef, ɵRuntimeError, ɵgetOutputDestroyRef, Injector, effect, untracked, ɵmicrotaskEffect, assertNotInReactiveContext, signal, computed, PendingTasks, resource } from '@angular/core';\nimport { Observable, ReplaySubject, Subject } from 'rxjs';\nimport { takeUntil, take } from 'rxjs/operators';\n\n/**\n * Operator which completes the Observable when the calling context (component, directive, service,\n * etc) is destroyed.\n *\n * @param destroyRef optionally, the `DestroyRef` representing the current context. This can be\n *     passed explicitly to use `takeUntilDestroyed` outside of an [injection\n * context](guide/di/dependency-injection-context). Otherwise, the current `DestroyRef` is injected.\n *\n * @publicApi\n */\nfunction takeUntilDestroyed(destroyRef) {\n  if (!destroyRef) {\n    assertInInjectionContext(takeUntilDestroyed);\n    destroyRef = inject(DestroyRef);\n  }\n  const destroyed$ = new Observable(observer => {\n    const unregisterFn = destroyRef.onDestroy(observer.next.bind(observer));\n    return unregisterFn;\n  });\n  return source => {\n    return source.pipe(takeUntil(destroyed$));\n  };\n}\n\n/**\n * Implementation of `OutputRef` that emits values from\n * an RxJS observable source.\n *\n * @internal\n */\nclass OutputFromObservableRef {\n  source;\n  destroyed = false;\n  destroyRef = /*#__PURE__*/inject(DestroyRef);\n  constructor(source) {\n    this.source = source;\n    this.destroyRef.onDestroy(() => {\n      this.destroyed = true;\n    });\n  }\n  subscribe(callbackFn) {\n    if (this.destroyed) {\n      throw new ɵRuntimeError(953 /* ɵRuntimeErrorCode.OUTPUT_REF_DESTROYED */, ngDevMode && 'Unexpected subscription to destroyed `OutputRef`. ' + 'The owning directive/component is destroyed.');\n    }\n    // Stop yielding more values when the directive/component is already destroyed.\n    const subscription = this.source.pipe(takeUntilDestroyed(this.destroyRef)).subscribe({\n      next: value => callbackFn(value)\n    });\n    return {\n      unsubscribe: () => subscription.unsubscribe()\n    };\n  }\n}\n/**\n * Declares an Angular output that is using an RxJS observable as a source\n * for events dispatched to parent subscribers.\n *\n * The behavior for an observable as source is defined as followed:\n *    1. New values are forwarded to the Angular output (next notifications).\n *    2. Errors notifications are not handled by Angular. You need to handle these manually.\n *       For example by using `catchError`.\n *    3. Completion notifications stop the output from emitting new values.\n *\n * @usageNotes\n * Initialize an output in your directive by declaring a\n * class field and initializing it with the `outputFromObservable()` function.\n *\n * ```ts\n * @Directive({..})\n * export class MyDir {\n *   nameChange$ = <some-observable>;\n *   nameChange = outputFromObservable(this.nameChange$);\n * }\n * ```\n *\n * @publicApi\n */\nfunction outputFromObservable(observable, opts) {\n  ngDevMode && assertInInjectionContext(outputFromObservable);\n  return new OutputFromObservableRef(observable);\n}\n\n/**\n * Converts an Angular output declared via `output()` or `outputFromObservable()`\n * to an observable.\n *\n * You can subscribe to the output via `Observable.subscribe` then.\n *\n * @publicApi\n */\nfunction outputToObservable(ref) {\n  const destroyRef = ɵgetOutputDestroyRef(ref);\n  return new Observable(observer => {\n    // Complete the observable upon directive/component destroy.\n    // Note: May be `undefined` if an `EventEmitter` is declared outside\n    // of an injection context.\n    destroyRef?.onDestroy(() => observer.complete());\n    const subscription = ref.subscribe(v => observer.next(v));\n    return () => subscription.unsubscribe();\n  });\n}\n\n/**\n * Exposes the value of an Angular `Signal` as an RxJS `Observable`.\n *\n * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.\n *\n * `toObservable` must be called in an injection context unless an injector is provided via options.\n *\n * @developerPreview\n */\nfunction toObservable(source, options) {\n  !options?.injector && assertInInjectionContext(toObservable);\n  const injector = options?.injector ?? inject(Injector);\n  const subject = new ReplaySubject(1);\n  const watcher = effect(() => {\n    let value;\n    try {\n      value = source();\n    } catch (err) {\n      untracked(() => subject.error(err));\n      return;\n    }\n    untracked(() => subject.next(value));\n  }, {\n    injector,\n    manualCleanup: true\n  });\n  injector.get(DestroyRef).onDestroy(() => {\n    watcher.destroy();\n    subject.complete();\n  });\n  return subject.asObservable();\n}\nfunction toObservableMicrotask(source, options) {\n  !options?.injector && assertInInjectionContext(toObservable);\n  const injector = options?.injector ?? inject(Injector);\n  const subject = new ReplaySubject(1);\n  const watcher = ɵmicrotaskEffect(() => {\n    let value;\n    try {\n      value = source();\n    } catch (err) {\n      untracked(() => subject.error(err));\n      return;\n    }\n    untracked(() => subject.next(value));\n  }, {\n    injector,\n    manualCleanup: true\n  });\n  injector.get(DestroyRef).onDestroy(() => {\n    watcher.destroy();\n    subject.complete();\n  });\n  return subject.asObservable();\n}\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * With `requireSync` set to `true`, `toSignal` will assert that the `Observable` produces a value\n * immediately upon subscription. No `initialValue` is needed in this case, and the returned signal\n * does not include an `undefined` type.\n *\n * By default, the subscription will be automatically cleaned up when the current [injection\n * context](guide/di/dependency-injection-context) is destroyed. For example, when `toSignal` is\n * called during the construction of a component, the subscription will be cleaned up when the\n * component is destroyed. If an injection context is not available, an explicit `Injector` can be\n * passed instead.\n *\n * If the subscription should persist until the `Observable` itself completes, the `manualCleanup`\n * option can be specified instead, which disables the automatic subscription teardown. No injection\n * context is needed in this configuration as well.\n *\n * @developerPreview\n */\nfunction toSignal(source, options) {\n  ngDevMode && assertNotInReactiveContext(toSignal, 'Invoking `toSignal` causes new subscriptions every time. ' + 'Consider moving `toSignal` outside of the reactive context and read the signal value where needed.');\n  const requiresCleanup = !options?.manualCleanup;\n  requiresCleanup && !options?.injector && assertInInjectionContext(toSignal);\n  const cleanupRef = requiresCleanup ? options?.injector?.get(DestroyRef) ?? inject(DestroyRef) : null;\n  const equal = makeToSignalEqual(options?.equal);\n  // Note: T is the Observable value type, and U is the initial value type. They don't have to be\n  // the same - the returned signal gives values of type `T`.\n  let state;\n  if (options?.requireSync) {\n    // Initially the signal is in a `NoValue` state.\n    state = signal({\n      kind: 0 /* StateKind.NoValue */\n    }, {\n      equal\n    });\n  } else {\n    // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.\n    state = signal({\n      kind: 1 /* StateKind.Value */,\n      value: options?.initialValue\n    }, {\n      equal\n    });\n  }\n  // Note: This code cannot run inside a reactive context (see assertion above). If we'd support\n  // this, we would subscribe to the observable outside of the current reactive context, avoiding\n  // that side-effect signal reads/writes are attribute to the current consumer. The current\n  // consumer only needs to be notified when the `state` signal changes through the observable\n  // subscription. Additional context (related to async pipe):\n  // https://github.com/angular/angular/pull/50522.\n  const sub = source.subscribe({\n    next: value => state.set({\n      kind: 1 /* StateKind.Value */,\n      value\n    }),\n    error: error => {\n      if (options?.rejectErrors) {\n        // Kick the error back to RxJS. It will be caught and rethrown in a macrotask, which causes\n        // the error to end up as an uncaught exception.\n        throw error;\n      }\n      state.set({\n        kind: 2 /* StateKind.Error */,\n        error\n      });\n    }\n    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of\n    // \"complete\".\n  });\n  if (options?.requireSync && state().kind === 0 /* StateKind.NoValue */) {\n    throw new ɵRuntimeError(601 /* ɵRuntimeErrorCode.REQUIRE_SYNC_WITHOUT_SYNC_EMIT */, (typeof ngDevMode === 'undefined' || ngDevMode) && '`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');\n  }\n  // Unsubscribe when the current context is destroyed, if requested.\n  cleanupRef?.onDestroy(sub.unsubscribe.bind(sub));\n  // The actual returned signal is a `computed` of the `State` signal, which maps the various states\n  // to either values or errors.\n  return computed(() => {\n    const current = state();\n    switch (current.kind) {\n      case 1 /* StateKind.Value */:\n        return current.value;\n      case 2 /* StateKind.Error */:\n        throw current.error;\n      case 0 /* StateKind.NoValue */:\n        // This shouldn't really happen because the error is thrown on creation.\n        throw new ɵRuntimeError(601 /* ɵRuntimeErrorCode.REQUIRE_SYNC_WITHOUT_SYNC_EMIT */, (typeof ngDevMode === 'undefined' || ngDevMode) && '`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');\n    }\n  }, {\n    equal: options?.equal\n  });\n}\nfunction makeToSignalEqual(userEquality = Object.is) {\n  return (a, b) => a.kind === 1 /* StateKind.Value */ && b.kind === 1 /* StateKind.Value */ && userEquality(a.value, b.value);\n}\n\n/**\n * Operator which makes the application unstable until the observable emits, complets, errors, or is unsubscribed.\n *\n * Use this operator in observables whose subscriptions are important for rendering and should be included in SSR serialization.\n *\n * @param injector The `Injector` to use during creation. If this is not provided, the current injection context will be used instead (via `inject`).\n *\n * @experimental\n */\nfunction pendingUntilEvent(injector) {\n  if (injector === undefined) {\n    assertInInjectionContext(pendingUntilEvent);\n    injector = inject(Injector);\n  }\n  const taskService = injector.get(PendingTasks);\n  return sourceObservable => {\n    return new Observable(originalSubscriber => {\n      // create a new task on subscription\n      const removeTask = taskService.add();\n      let cleanedUp = false;\n      function cleanupTask() {\n        if (cleanedUp) {\n          return;\n        }\n        removeTask();\n        cleanedUp = true;\n      }\n      const innerSubscription = sourceObservable.subscribe({\n        next: v => {\n          originalSubscriber.next(v);\n          cleanupTask();\n        },\n        complete: () => {\n          originalSubscriber.complete();\n          cleanupTask();\n        },\n        error: e => {\n          originalSubscriber.error(e);\n          cleanupTask();\n        }\n      });\n      innerSubscription.add(() => {\n        originalSubscriber.unsubscribe();\n        cleanupTask();\n      });\n      return innerSubscription;\n    });\n  };\n}\n\n/**\n * Like `resource` but uses an RxJS based `loader` which maps the request to an `Observable` of the\n * resource's value. Like `firstValueFrom`, only the first emission of the Observable is considered.\n *\n * @experimental\n */\nfunction rxResource(opts) {\n  opts?.injector || assertInInjectionContext(rxResource);\n  return resource({\n    ...opts,\n    loader: params => {\n      const cancelled = new Subject();\n      params.abortSignal.addEventListener('abort', () => cancelled.next());\n      // Note: this is identical to `firstValueFrom` which we can't use,\n      // because at the time of writing, `core` still supports rxjs 6.x.\n      return new Promise((resolve, reject) => {\n        opts.loader(params).pipe(take(1), takeUntil(cancelled)).subscribe({\n          next: resolve,\n          error: reject,\n          complete: () => reject(new Error('Resource completed before producing a value'))\n        });\n      });\n    }\n  });\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { outputFromObservable, outputToObservable, pendingUntilEvent, rxResource, takeUntilDestroyed, toObservable, toSignal, toObservableMicrotask as ɵtoObservableMicrotask };\n","import { Subject, Subscription, from, EMPTY } from 'rxjs';\nimport { ɵNG_PIPE_DEF, ɵgetLContext, ɵglobal } from '@angular/core';\nimport { mergeMap, takeUntil } from 'rxjs/operators';\nconst NG_PIPE_DEF = ɵNG_PIPE_DEF;\nfunction isPipe(target) {\n  return !!target[NG_PIPE_DEF];\n}\n\n/**\n * Applied to instances and stores `Subject` instance when\n * no custom destroy method is provided.\n */\nconst DESTROY = Symbol('__destroy');\n/**\n * Applied to definitions and informs that class is decorated\n */\nconst DECORATOR_APPLIED = Symbol('__decoratorApplied');\n/**\n * If we use the `untilDestroyed` operator multiple times inside the single\n * instance providing different `destroyMethodName`, then all streams will\n * subscribe to the single subject. If any method is invoked, the subject will\n * emit and all streams will be unsubscribed. We wan't to prevent this behavior,\n * thus we store subjects under different symbols.\n */\nfunction getSymbol(destroyMethodName) {\n  if (typeof destroyMethodName === 'string') {\n    return Symbol(`__destroy__${destroyMethodName}`);\n  } else {\n    return DESTROY;\n  }\n}\nfunction markAsDecorated(type) {\n  // Store this property on the prototype if it's an injectable class, component or directive.\n  // We will be able to handle class extension this way.\n  type.prototype[DECORATOR_APPLIED] = true;\n}\nfunction createSubjectOnTheInstance(instance, symbol) {\n  if (!instance[symbol]) {\n    instance[symbol] = new Subject();\n  }\n}\nfunction completeSubjectOnTheInstance(instance, symbol) {\n  if (instance[symbol]) {\n    instance[symbol].next();\n    instance[symbol].complete();\n    // We also have to re-assign this property thus in the future\n    // we will be able to create new subject on the same instance.\n    instance[symbol] = null;\n  }\n}\nfunction unsubscribe(property) {\n  if (property instanceof Subscription) {\n    property.unsubscribe();\n  }\n}\nfunction unsubscribeIfPropertyIsArrayLike(property) {\n  Array.isArray(property) && property.forEach(unsubscribe);\n}\nfunction decorateNgOnDestroy(ngOnDestroy, options) {\n  return function () {\n    // Invoke the original `ngOnDestroy` if it exists\n    ngOnDestroy && ngOnDestroy.call(this);\n    // It's important to use `this` instead of caching instance\n    // that may lead to memory leaks\n    completeSubjectOnTheInstance(this, getSymbol());\n    // Check if subscriptions are pushed to some array\n    if (options.arrayName) {\n      unsubscribeIfPropertyIsArrayLike(this[options.arrayName]);\n    }\n    // Loop through the properties and find subscriptions\n    if (options.checkProperties) {\n      for (const property in this) {\n        if (options.blackList?.includes(property)) {\n          continue;\n        }\n        unsubscribe(this[property]);\n      }\n    }\n  };\n}\nfunction decorateProviderDirectiveOrComponent(type, options) {\n  type.prototype.ngOnDestroy = decorateNgOnDestroy(type.prototype.ngOnDestroy, options);\n}\nfunction decoratePipe(type, options) {\n  const def = type.ɵpipe;\n  def.onDestroy = decorateNgOnDestroy(def.onDestroy, options);\n}\nfunction UntilDestroy(options = {}) {\n  return type => {\n    if (isPipe(type)) {\n      decoratePipe(type, options);\n    } else {\n      decorateProviderDirectiveOrComponent(type, options);\n    }\n    markAsDecorated(type);\n  };\n}\n\n// `LView` is an array where each index matches the specific data structure.\n// The 7th element in an `LView` is an array of cleanup listeners. They are\n// invoked when the view is removed (similar to `ComponentRef.onDestroy`).\nconst CLEANUP = 7;\nconst CheckerHasBeenSet = Symbol('CheckerHasBeenSet');\nfunction setupSubjectUnsubscribedChecker(instance, destroy$) {\n  // This function is used within the `untilDestroyed` operator and setups a function that\n  // listens for the view removal and checks if the `destroy$` subject has any observers (usually `takeUntil`).\n  // Note: this code will not be shipped into production since it's guarded with `ngDevMode`,\n  // this means it'll exist only in development mode.\n  if (instance[CheckerHasBeenSet] || isAngularInTestMode()) {\n    return;\n  }\n  runOutsideAngular(() => from(Promise.resolve()).pipe(mergeMap(() => {\n    let lContext;\n    try {\n      // The `ɵgetLContext` might not work for a pipe, because it's not a component nor a directive,\n      // which means there's no `RNode` for an instance.\n      lContext = ɵgetLContext(instance);\n    } catch {\n      lContext = null;\n    }\n    const lView = lContext?.lView;\n    if (lView == null) {\n      return EMPTY;\n    }\n    const lCleanup = lView[CLEANUP] || (lView[CLEANUP] = []);\n    const cleanupHasBeenExecuted$ = new Subject();\n    // Note: this function is named for debugging purposes.\n    lCleanup.push(function untilDestroyedLCleanup() {\n      // We leave the Angular zone, so RxJS will also call subsequent `next` functions\n      // outside of the Angular zone, which is done to avoid scheduling a microtask (through\n      // `asapScheduler`) within the Angular zone.\n      runOutsideAngular(() => {\n        cleanupHasBeenExecuted$.next();\n        cleanupHasBeenExecuted$.complete();\n      });\n    });\n    return cleanupHasBeenExecuted$;\n  }),\n  // We can't use `observeOn(asapScheduler)` because this might break the app's change detection.\n  // RxJS schedulers coalesce tasks and then flush the queue, which means our task might be scheduled\n  // within the root zone, and then all of the tasks (that were set up by developers in the Angular zone)\n  // will also be flushed in the root zone.\n  mergeMap(() => Promise.resolve())).subscribe(() => {\n    // Note: The `observed` property is available only in RxJS@7.2.0, which will throw\n    // an error in lower versions. We have integration test with RxJS@6 to ensure we don't\n    // import operators from `rxjs`; that's why it's wrapped into braces. The `observers`\n    // property is also being deprecated.\n    const observed = destroy$['observed'] ?? destroy$['observers'].length > 0;\n    if (observed) {\n      console.warn(createMessage(instance));\n    }\n  }));\n  instance[CheckerHasBeenSet] = true;\n}\nfunction isAngularInTestMode() {\n  // Gets whether the code is currently running in a test environment.\n  // We don't use `declare const` because it might cause conflicts with the real typings.\n  return (\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    typeof __karma__ !== 'undefined' && !!__karma__ ||\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    typeof jasmine !== 'undefined' && !!jasmine ||\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    typeof jest !== 'undefined' && !!jest ||\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    typeof Mocha !== 'undefined' && !!Mocha ||\n    // Jest is not defined in ESM mode since it must be access only by importing from `@jest/globals`.\n    // There's no way to check if we're in Jest ESM mode or not, but we can check if the `process` is defined.\n    // Note: it's required to check for `[object process]` because someone might be running unit tests with\n    // Webpack and shimming `process`.\n    typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]'\n  );\n}\nfunction runOutsideAngular(fn) {\n  // We cannot inject the `NgZone` class when running the checker. The `__ngContext__` is read\n  // for the first time within a microtask which triggers change detection; we want to avoid that.\n  // The `Zone` is always available globally when the `zone.js` is imported. Otherwise, it may be\n  // nooped through bootstrap options. The `NgZone.runOutsideAngular` calls `Zone.root.run`, so we're\n  // safe calling that function directly.\n  const Zone = ɵglobal.Zone;\n  const isNgZoneEnabled = !!Zone && typeof Zone.root?.run === 'function';\n  return isNgZoneEnabled ? Zone.root.run(fn) : fn();\n}\nfunction createMessage(instance) {\n  return `\n  The ${instance.constructor.name} still has subscriptions that haven't been unsubscribed.\n  This may happen if the class extends another class decorated with @UntilDestroy().\n  The child class implements its own ngOnDestroy() method but doesn't call super.ngOnDestroy().\n  Let's look at the following example:\n  @UntilDestroy()\n  @Directive()\n  export abstract class BaseDirective {}\n  @Component({ template: '' })\n  export class ConcreteComponent extends BaseDirective implements OnDestroy {\n    constructor() {\n      super();\n      someObservable$.pipe(untilDestroyed(this)).subscribe();\n    }\n    ngOnDestroy(): void {\n      // Some logic here...\n    }\n  }\n  The BaseDirective.ngOnDestroy() will not be called since Angular will call ngOnDestroy()\n  on the ConcreteComponent, but not on the BaseDirective.\n  One of the solutions is to declare an empty ngOnDestroy method on the BaseDirective:\n  @UntilDestroy()\n  @Directive()\n  export abstract class BaseDirective {\n    ngOnDestroy(): void {}\n  }\n  @Component({ template: '' })\n  export class ConcreteComponent extends BaseDirective implements OnDestroy {\n    constructor() {\n      super();\n      someObservable$.pipe(untilDestroyed(this)).subscribe();\n    }\n    ngOnDestroy(): void {\n      // Some logic here...\n      super.ngOnDestroy();\n    }\n  }\n  `;\n}\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;\nfunction overrideNonDirectiveInstanceMethod(instance, destroyMethodName, symbol) {\n  const originalDestroy = instance[destroyMethodName];\n  if (NG_DEV_MODE && typeof originalDestroy !== 'function') {\n    throw new Error(`${instance.constructor.name} is using untilDestroyed but doesn't implement ${destroyMethodName}`);\n  }\n  createSubjectOnTheInstance(instance, symbol);\n  instance[destroyMethodName] = function () {\n    // eslint-disable-next-line prefer-rest-params\n    originalDestroy.apply(this, arguments);\n    completeSubjectOnTheInstance(this, symbol);\n    // We have to re-assign this property back to the original value.\n    // If the `untilDestroyed` operator is called for the same instance\n    // multiple times, then we will be able to get the original\n    // method again and not the patched one.\n    instance[destroyMethodName] = originalDestroy;\n  };\n}\nfunction untilDestroyed(instance, destroyMethodName) {\n  return source => {\n    const symbol = getSymbol(destroyMethodName);\n    // If `destroyMethodName` is passed then the developer applies\n    // this operator to something non-related to Angular DI system\n    if (typeof destroyMethodName === 'string') {\n      overrideNonDirectiveInstanceMethod(instance, destroyMethodName, symbol);\n    } else {\n      NG_DEV_MODE && ensureClassIsDecorated(instance);\n      createSubjectOnTheInstance(instance, symbol);\n    }\n    const destroy$ = instance[symbol];\n    NG_DEV_MODE && setupSubjectUnsubscribedChecker(instance, destroy$);\n    return source.pipe(takeUntil(destroy$));\n  };\n}\nfunction ensureClassIsDecorated(instance) {\n  const prototype = Object.getPrototypeOf(instance);\n  const missingDecorator = !(DECORATOR_APPLIED in prototype);\n  if (missingDecorator) {\n    throw new Error('untilDestroyed operator cannot be used inside directives or ' + 'components or providers that are not decorated with UntilDestroy decorator');\n  }\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { UntilDestroy, untilDestroyed };\n"],"mappings":"uNAoBA,SAASA,EAAmBC,EAAY,CACjCA,IACHC,EAAyBF,CAAkB,EAC3CC,EAAaE,EAAOC,CAAU,GAEhC,IAAMC,EAAa,IAAIC,EAAWC,GACXN,EAAW,UAAUM,EAAS,KAAK,KAAKA,CAAQ,CAAC,CAEvE,EACD,OAAOC,GACEA,EAAO,KAAKC,EAAUJ,CAAU,CAAC,CAE5C,CAyFA,SAASK,EAAaC,EAAQC,EAAS,CAzHvC,IAAAC,EA0HE,EAACD,GAAA,MAAAA,EAAS,WAAYE,EAAyBJ,CAAY,EAC3D,IAAMK,GAAWF,EAAAD,GAAA,YAAAA,EAAS,WAAT,KAAAC,EAAqBG,EAAOC,CAAQ,EAC/CC,EAAU,IAAIC,EAAc,CAAC,EAC7BC,EAAUC,EAAO,IAAM,CAC3B,IAAIC,EACJ,GAAI,CACFA,EAAQX,EAAO,CACjB,OAASY,EAAK,CACZC,EAAU,IAAMN,EAAQ,MAAMK,CAAG,CAAC,EAClC,MACF,CACAC,EAAU,IAAMN,EAAQ,KAAKI,CAAK,CAAC,CACrC,EAAG,CACD,SAAAP,EACA,cAAe,EACjB,CAAC,EACD,OAAAA,EAAS,IAAIU,CAAU,EAAE,UAAU,IAAM,CACvCL,EAAQ,QAAQ,EAChBF,EAAQ,SAAS,CACnB,CAAC,EACMA,EAAQ,aAAa,CAC9B,CAiDA,SAASQ,EAASC,EAAQC,EAAS,CAhMnC,IAAAC,EAAAC,EAkME,IAAMC,EAAkB,EAACH,GAAA,MAAAA,EAAS,eAClCG,GAAmB,EAACH,GAAA,MAAAA,EAAS,WAAYI,EAAyBN,CAAQ,EAC1E,IAAMO,EAAaF,GAAkBD,GAAAD,EAAAD,GAAA,YAAAA,EAAS,WAAT,YAAAC,EAAmB,IAAIK,KAAvB,KAAAJ,EAAsCK,EAAOD,CAAU,EAAI,KAC1FE,EAAQC,EAAkBT,GAAA,YAAAA,EAAS,KAAK,EAG1CU,EACAV,GAAA,MAAAA,EAAS,YAEXU,EAAQC,EAAO,CACb,KAAM,CACR,EAAG,CACD,MAAAH,CACF,CAAC,EAGDE,EAAQC,EAAO,CACb,KAAM,EACN,MAAOX,GAAA,YAAAA,EAAS,YAClB,EAAG,CACD,MAAAQ,CACF,CAAC,EAQH,IAAMI,EAAMb,EAAO,UAAU,CAC3B,KAAMc,GAASH,EAAM,IAAI,CACvB,KAAM,EACN,MAAAG,CACF,CAAC,EACD,MAAOC,GAAS,CACd,GAAId,GAAA,MAAAA,EAAS,aAGX,MAAMc,EAERJ,EAAM,IAAI,CACR,KAAM,EACN,MAAAI,CACF,CAAC,CACH,CAGF,CAAC,EACD,GAAId,GAAA,MAAAA,EAAS,aAAeU,EAAM,EAAE,OAAS,EAC3C,MAAM,IAAIK,EAAc,IAAiG,EAAmG,EAG9N,OAAAV,GAAA,MAAAA,EAAY,UAAUO,EAAI,YAAY,KAAKA,CAAG,GAGvCI,EAAS,IAAM,CACpB,IAAMC,EAAUP,EAAM,EACtB,OAAQO,EAAQ,KAAM,CACpB,IAAK,GACH,OAAOA,EAAQ,MACjB,IAAK,GACH,MAAMA,EAAQ,MAChB,IAAK,GAEH,MAAM,IAAIF,EAAc,IAAiG,EAAmG,CAChO,CACF,EAAG,CACD,MAAOf,GAAA,YAAAA,EAAS,KAClB,CAAC,CACH,CACA,SAASS,EAAkBS,EAAe,OAAO,GAAI,CACnD,MAAO,CAACC,EAAGC,IAAMD,EAAE,OAAS,GAA2BC,EAAE,OAAS,GAA2BF,EAAaC,EAAE,MAAOC,EAAE,KAAK,CAC5H,CA0DA,SAASC,EAAWC,EAAM,CACxB,OAAAA,GAAA,MAAAA,EAAM,UAAYC,EAAyBF,CAAU,EAC9CG,EAASC,EAAAC,EAAA,GACXJ,GADW,CAEd,OAAQK,GAAU,CAChB,IAAMC,EAAY,IAAIC,EACtB,OAAAF,EAAO,YAAY,iBAAiB,QAAS,IAAMC,EAAU,KAAK,CAAC,EAG5D,IAAI,QAAQ,CAACE,EAASC,IAAW,CACtCT,EAAK,OAAOK,CAAM,EAAE,KAAKK,EAAK,CAAC,EAAGC,EAAUL,CAAS,CAAC,EAAE,UAAU,CAChE,KAAME,EACN,MAAOC,EACP,SAAU,IAAMA,EAAO,IAAI,MAAM,6CAA6C,CAAC,CACjF,CAAC,CACH,CAAC,CACH,CACF,EAAC,CACH,CCnVA,IAAMG,EAAcA,EACpB,SAASC,EAAOC,EAAQ,CACtB,MAAO,CAAC,CAACA,EAAOF,CAAW,CAC7B,CAMA,IAAMG,EAAU,OAAO,WAAW,EAI5BC,EAAoB,OAAO,oBAAoB,EAQrD,SAASC,EAAUC,EAAmB,CACpC,OAAI,OAAOA,GAAsB,SACxB,OAAO,cAAcA,CAAiB,EAAE,EAExCH,CAEX,CACA,SAASI,EAAgBC,EAAM,CAG7BA,EAAK,UAAUJ,CAAiB,EAAI,EACtC,CACA,SAASK,EAA2BC,EAAUC,EAAQ,CAC/CD,EAASC,CAAM,IAClBD,EAASC,CAAM,EAAI,IAAIC,EAE3B,CACA,SAASC,EAA6BH,EAAUC,EAAQ,CAClDD,EAASC,CAAM,IACjBD,EAASC,CAAM,EAAE,KAAK,EACtBD,EAASC,CAAM,EAAE,SAAS,EAG1BD,EAASC,CAAM,EAAI,KAEvB,CACA,SAASG,EAAYC,EAAU,CACzBA,aAAoBC,GACtBD,EAAS,YAAY,CAEzB,CACA,SAASE,EAAiCF,EAAU,CAClD,MAAM,QAAQA,CAAQ,GAAKA,EAAS,QAAQD,CAAW,CACzD,CACA,SAASI,EAAoBC,EAAaC,EAAS,CACjD,OAAO,UAAY,CA3DrB,IAAAC,EAsEI,GATAF,GAAeA,EAAY,KAAK,IAAI,EAGpCN,EAA6B,KAAMR,EAAU,CAAC,EAE1Ce,EAAQ,WACVH,EAAiC,KAAKG,EAAQ,SAAS,CAAC,EAGtDA,EAAQ,gBACV,QAAWL,KAAY,MACjBM,EAAAD,EAAQ,YAAR,MAAAC,EAAmB,SAASN,IAGhCD,EAAY,KAAKC,CAAQ,CAAC,CAGhC,CACF,CACA,SAASO,GAAqCd,EAAMY,EAAS,CAC3DZ,EAAK,UAAU,YAAcU,EAAoBV,EAAK,UAAU,YAAaY,CAAO,CACtF,CACA,SAASG,GAAaf,EAAMY,EAAS,CACnC,IAAMI,EAAMhB,EAAK,WACjBgB,EAAI,UAAYN,EAAoBM,EAAI,UAAWJ,CAAO,CAC5D,CACA,SAASK,GAAaL,EAAU,CAAC,EAAG,CAClC,OAAOZ,GAAQ,CACTP,EAAOO,CAAI,EACbe,GAAaf,EAAMY,CAAO,EAE1BE,GAAqCd,EAAMY,CAAO,EAEpDb,EAAgBC,CAAI,CACtB,CACF,CAKA,IAAMkB,EAAU,EACVC,EAAoB,OAAO,mBAAmB,EACpD,SAASC,GAAgClB,EAAUmB,EAAU,CAKvDnB,EAASiB,CAAiB,GAAKG,GAAoB,IAGvDC,EAAkB,IAAMC,EAAK,QAAQ,QAAQ,CAAC,EAAE,KAAKC,EAAS,IAAM,CAClE,IAAIC,EACJ,GAAI,CAGFA,EAAWC,EAAazB,CAAQ,CAClC,MAAQ,CACNwB,EAAW,IACb,CACA,IAAME,EAAQF,GAAA,YAAAA,EAAU,MACxB,GAAIE,GAAS,KACX,OAAOC,EAET,IAAMC,EAAWF,EAAMV,CAAO,IAAMU,EAAMV,CAAO,EAAI,CAAC,GAChDa,EAA0B,IAAI3B,EAEpC,OAAA0B,EAAS,KAAK,UAAkC,CAI9CP,EAAkB,IAAM,CACtBQ,EAAwB,KAAK,EAC7BA,EAAwB,SAAS,CACnC,CAAC,CACH,CAAC,EACMA,CACT,CAAC,EAKDN,EAAS,IAAM,QAAQ,QAAQ,CAAC,CAAC,EAAE,UAAU,IAAM,CA9IrD,IAAAZ,IAmJqBA,EAAAQ,EAAS,WAAT,KAAAR,EAAwBQ,EAAS,UAAa,OAAS,IAEtE,QAAQ,KAAKW,GAAc9B,CAAQ,CAAC,CAExC,CAAC,CAAC,EACFA,EAASiB,CAAiB,EAAI,GAChC,CACA,SAASG,IAAsB,CAG7B,OAGE,OAAO,UAAc,KAAe,CAAC,CAAC,WAGtC,OAAO,QAAY,KAAe,CAAC,CAAC,SAGpC,OAAO,KAAS,KAAe,CAAC,CAAC,MAGjC,OAAO,MAAU,KAAe,CAAC,CAAC,OAKlC,OAAO,QAAY,KAAe,OAAO,UAAU,SAAS,KAAK,OAAO,IAAM,kBAElF,CACA,SAASC,EAAkBU,EAAI,CAjL/B,IAAApB,EAuLE,IAAMqB,EAAOC,EAAQ,KAErB,MADwB,CAAC,CAACD,GAAQ,QAAOrB,EAAAqB,EAAK,OAAL,YAAArB,EAAW,MAAQ,WACnCqB,EAAK,KAAK,IAAID,CAAE,EAAIA,EAAG,CAClD,CACA,SAASD,GAAc9B,EAAU,CAC/B,MAAO;AAAA,QACDA,EAAS,YAAY,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAqCjC,CACA,IAAMkC,EAAkD,GACxD,SAASC,GAAmCnC,EAAUJ,EAAmBK,EAAQ,CAC/E,IAAMmC,EAAkBpC,EAASJ,CAAiB,EAClD,GAAIsC,GAAe,OAAOE,GAAoB,WAC5C,MAAM,IAAI,MAAM,GAAGpC,EAAS,YAAY,IAAI,kDAAkDJ,CAAiB,EAAE,EAEnHG,EAA2BC,EAAUC,CAAM,EAC3CD,EAASJ,CAAiB,EAAI,UAAY,CAExCwC,EAAgB,MAAM,KAAM,SAAS,EACrCjC,EAA6B,KAAMF,CAAM,EAKzCD,EAASJ,CAAiB,EAAIwC,CAChC,CACF,CACA,SAASC,GAAerC,EAAUJ,EAAmB,CACnD,OAAO0C,GAAU,CACf,IAAMrC,EAASN,EAAUC,CAAiB,EAGtC,OAAOA,GAAsB,SAC/BuC,GAAmCnC,EAAUJ,EAAmBK,CAAM,GAEtEiC,GAAeK,GAAuBvC,CAAQ,EAC9CD,EAA2BC,EAAUC,CAAM,GAE7C,IAAMkB,EAAWnB,EAASC,CAAM,EAChC,OAAAiC,GAAehB,GAAgClB,EAAUmB,CAAQ,EAC1DmB,EAAO,KAAKE,EAAUrB,CAAQ,CAAC,CACxC,CACF,CACA,SAASoB,GAAuBvC,EAAU,CACxC,IAAMyC,EAAY,OAAO,eAAezC,CAAQ,EAEhD,GADyB,EAAEN,KAAqB+C,GAE9C,MAAM,IAAI,MAAM,wIAA6I,CAEjK","names":["takeUntilDestroyed","destroyRef","assertInInjectionContext","inject","DestroyRef","destroyed$","Observable","observer","source","takeUntil","toObservable","source","options","_a","assertInInjectionContext","injector","inject","Injector","subject","ReplaySubject","watcher","effect","value","err","untracked","DestroyRef","toSignal","source","options","_a","_b","requiresCleanup","assertInInjectionContext","cleanupRef","DestroyRef","inject","equal","makeToSignalEqual","state","signal","sub","value","error","RuntimeError","computed","current","userEquality","a","b","rxResource","opts","assertInInjectionContext","resource","__spreadProps","__spreadValues","params","cancelled","Subject","resolve","reject","take","takeUntil","NG_PIPE_DEF","isPipe","target","DESTROY","DECORATOR_APPLIED","getSymbol","destroyMethodName","markAsDecorated","type","createSubjectOnTheInstance","instance","symbol","Subject","completeSubjectOnTheInstance","unsubscribe","property","Subscription","unsubscribeIfPropertyIsArrayLike","decorateNgOnDestroy","ngOnDestroy","options","_a","decorateProviderDirectiveOrComponent","decoratePipe","def","UntilDestroy","CLEANUP","CheckerHasBeenSet","setupSubjectUnsubscribedChecker","destroy$","isAngularInTestMode","runOutsideAngular","from","mergeMap","lContext","getLContext","lView","EMPTY","lCleanup","cleanupHasBeenExecuted$","createMessage","fn","Zone","_global","NG_DEV_MODE","overrideNonDirectiveInstanceMethod","originalDestroy","untilDestroyed","source","ensureClassIsDecorated","takeUntil","prototype"],"x_google_ignoreList":[0,1]}