{"version":3,"file":"ngx-signals-plus.mjs","sources":["../../../projects/ngx-signals-plus/src/lib/bindable-signal.ts","../../../projects/ngx-signals-plus/src/lib/event-signal.ts","../../../projects/ngx-signals-plus/src/lib/custom-observables.ts","../../../projects/ngx-signals-plus/src/lib/to-behavior-observable.ts","../../../projects/ngx-signals-plus/src/public-api.ts","../../../projects/ngx-signals-plus/src/ngx-signals-plus.ts"],"sourcesContent":["import {\n  CreateSignalOptions,\n  DestroyRef,\n  EffectRef,\n  Injector,\n  Signal,\n  VERSION,\n  WritableSignal,\n  assertNotInReactiveContext,\n  effect,\n  inject,\n  isSignal,\n  signal,\n  untracked,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { MonoTypeOperatorFunction, Observable, Subscription, pipe } from 'rxjs';\n\nexport type BindableSignal<T> = WritableSignal<T> & {\n  bindTo: (source: Observable<T> | Signal<T>) => WritableSignal<T>;\n  unbind: () => void;\n};\n\n/**\n * Factory method to create a BindableSignal.\n * The BindableSignal is a type of WritableSignal and has a bindTo method that will bind the signal to updates from an observable or another signal.\n *\n * @param initialValue The initial value assigned to the signal.\n * @param options\n * @param options.destroyRef Used when the method is called outside of the injection context. If provided, the signal will be destroyed when the destroyRef is destroyed.\n *                           Note that in case of manualCleanup, the destroyRef will not be used therefor cannot be provided.\n *                           In case of binding to a signal, the destroyRef cannot be provided because it will not provide the neccessary hooks to create the updater effect.\n * @param options.injector Used to bind to a signal or to inject the destroyRef outside of injection context.\n *                         If provided, the signal updater will be destroyed when the injector.get(DestroyRef) is destroyed.\n *                         Note that in case of manualCleanup, the injector will not be used therefor cannot be provided.\n * @param options.manualCleanup When true, the signal will not be destroyed when the destroyRef is destroyed. The operatorFunction has to be provided in this case.\n *                              In case of binding to a signal, the manualCleanup cannot be used.\n * @returns BindableSignal<T> A signal that can be bound to an observable or signal.\n */\nexport function bindable<T>(\n  initialValue: T,\n  options?: CreateSignalOptions<T> & {\n    destroyRef?: DestroyRef;\n    injector?: Injector;\n    manualCleanup?: boolean;\n  }\n): BindableSignal<T> {\n  assertNoDestroyRefOrInjectorProvidedWithManualCleanup(options);\n\n  let injector: Injector | undefined = undefined;\n  if (options?.destroyRef === undefined && options?.manualCleanup !== true) {\n    injector = options?.injector ?? inject(Injector);\n  }\n\n  const bindableSignal = signal<T>(initialValue, options);\n  let bound = false;\n\n  let effectRef: EffectRef | undefined = undefined;\n  let subscription: Subscription | undefined = undefined;\n  const unbind: () => void = () => {\n    if (effectRef !== undefined) {\n      effectRef.destroy();\n      effectRef = undefined;\n    } else if (subscription !== undefined) {\n      subscription.unsubscribe();\n      subscription = undefined;\n    } else {\n      throw new Error(\n        'Unbind was called before the BindableSignal was bound to an Observable or Signal!'\n      );\n    }\n    bound = false;\n  };\n\n  const bindTo: (source: Observable<T> | Signal<T>) => WritableSignal<T> = (\n    source: Observable<T> | Signal<T>\n  ) => {\n    assertNotInReactiveContext(\n      bindTo,\n      'Invoking `bindTo` causes new subscriptions every time. ' +\n        'Consider moving `bindTo` outside of the reactive context and read the signal value where needed.'\n    );\n    if (bound) {\n      throw new Error(\n        'Signal is already bound to an observable. Call unbind() before binding it again.'\n      );\n    }\n    if (isSignal(source)) {\n      if (injector === undefined) {\n        throw new Error(\n          'Tried to bind the signal to a signal without a provided Injector. In this case the bindTo method is creating an effect and there is no ' +\n            'possibility to provide a terminator operator unlike with observables. To prevent memory leaks the Injector has to be provided or the ' +\n            'bindable() factory method needs to be called in injection context. Providing the DestroyRef will make the Injector undefined.'\n        );\n      }\n\n      effectRef = effect(\n        () => {\n          const sourceValue = source();\n          untracked(() => bindableSignal.set(sourceValue));\n        },\n        parseInt(VERSION.major) < 19\n          ? {\n              injector,\n              allowSignalWrites: true,\n            }\n          : { injector }\n      );\n    } else {\n      let operatorFunction: MonoTypeOperatorFunction<T>;\n      if (options?.manualCleanup === true) {\n        operatorFunction = pipe();\n      } else {\n        const destroyRef = options?.destroyRef ?? injector?.get(DestroyRef);\n        if (destroyRef === undefined) {\n          throw new Error(\n            'Using the bindable() factory function in injection context or prodiving the DestroyRef ' +\n              'or the Injector is required when not using manual cleanup to prevent memory leaks.'\n          );\n        }\n        operatorFunction = takeUntilDestroyed(destroyRef);\n      }\n\n      subscription = source\n        .pipe(operatorFunction)\n        .subscribe((value) => bindableSignal.set(value));\n    }\n    bound = true;\n    return bindableSignal;\n  };\n\n  return Object.assign(bindableSignal, { bindTo, unbind }) as BindableSignal<T>;\n}\n\nfunction assertNoDestroyRefOrInjectorProvidedWithManualCleanup(options?: {\n  manualCleanup?: boolean;\n  destroyRef?: DestroyRef;\n  injector?: Injector;\n}): void {\n  if (options?.manualCleanup === true) {\n    if (options?.destroyRef !== undefined || options?.injector !== undefined) {\n      throw new Error(\n        'When using manual cleanup, DestroyRef or Injector will not provide automated cleanup. ' +\n          'Make sure that the operator functions contain the take or takeUntil operator to prevent memory leaks.'\n      );\n    }\n  }\n}\n","import {\n  DestroyRef,\n  effect,\n  EffectRef,\n  ElementRef,\n  inject,\n  Injector,\n  isSignal,\n  signal,\n  Signal,\n  VERSION,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { Observable, Subscription, throttleTime } from 'rxjs';\nimport { HasEventTargetAddRemove } from 'rxjs/internal/observable/fromEvent';\nimport { asyncScheduler } from 'rxjs/internal/scheduler/async';\nimport { Subject } from 'rxjs/internal/Subject';\n\nexport type EventSignal<T> = Signal<T> & {\n  attachActivator: (\n    activator: true | Signal<boolean> | Observable<boolean>\n  ) => void;\n  deactivate: () => void;\n};\n\ntype Listener<T> = {\n  listening: boolean;\n  target: Signal<ElementRef<HasEventTargetAddRemove<T>> | undefined>;\n  eventName: Signal<string | string[]>;\n  eventListener: (event: T) => void;\n  options?: EventListenerOptions;\n};\n\nexport type SignalFromEventOptions<T extends Event, R = never> = {\n  target?:\n    | HasEventTargetAddRemove<T>\n    | Signal<ElementRef<HasEventTargetAddRemove<T>> | undefined>;\n  eventListenerOptions?: AddEventListenerOptions;\n  tap?: (event: T) => void;\n  resultSelector?: (event: T) => R;\n  initialValue?: R;\n  activate?: boolean;\n  injector?: Injector;\n};\n\n/**\n * Creates an `EventSignal` based on DOM events, similar to the `fromEvent` function from NgRx,\n * but returns a `Signal` with enhanced capabilities, including dynamic event management and\n * activation controls for better performance and usability.\n *\n * @template T The type of the DOM event.\n * @template R The transformed result type of the event, defaulting to `T`. If provided options.resultSelector has to defined.\n *\n * @param {string | string[] | Signal<string | string[]>} eventName\n * The name(s) of the event(s) to listen for. Supports a single string, an array of strings,\n * or a `Signal` that dynamically updates the event names.\n *\n * @param {SignalFromEventOptions<T, R>} [options]\n * Configuration options for the `signalFromEvent`. These options allow for additional customizations:\n *\n * - **target**: Specifies the event target. Supports a `HasEventTargetAddRemove<T>`, a `Signal` resolving\n *   to an `ElementRef` containing the target, or is inferred from the ElementRef of the component automatically when undefined.\n * - **eventListenerOptions**: The options for the underlying `addEventListener` call.\n * - **tap**: A function invoked on every event, allowing side effects without modifying the result.\n * - **resultSelector**: A transformation function that maps the event to the desired output type `R`. If not provided, the event itself is returned (default behavior).\n * - **initialValue**: An initial value for the signal before any events occur. Can only be provided with a resultSelector since giving initial value to an event is not useful.\n * - **activate**: A flag indicating whether the signal should be activated immediately.\n * - **injector**: Specifies a custom dependency injector, defaulting to the current injector. Also used to call the function outside of the injection context.\n *\n * @returns {EventSignal<R | undefined>}\n * Returns an `EventSignal` with additional methods:\n * - **attachActivator**: Attaches an activator to control the event listener's lifecycle.\n *   Accepts `true`, a `Signal<boolean>`, or an `Observable<boolean>`. Deactivating removes the event listener.\n * - **deactivate**: Deactivates the event signal, removing the associated event listeners.\n *\n * ### Features:\n * - **Signal-Based Targets**: Dynamically attach or detach listeners based on the truthiness of a `Signal`.\n * - **Dynamic Event Names**: Supports updating event types dynamically using a `Signal` or a collection of event names.\n * - **Efficient Deactivation**: Removes event listeners when deactivated, reducing memory usage and improving performance\n *   compared to reactive operators like `filter` that retain listeners.\n *\n * ### Example:\n * Getting the mouse's position while moving the mouse over a child element:\n *\n * ```typescript\n * const mousePosition = signalFromEvent<MouseEvent, { x: number, y: number }>('mousemove', {\n *   target: viewChild(...),\n *   resultSelector: (event) => ({ x: event.clientX, y: event.clientY }),\n *   activate: true,\n * });\n *\n * effect(() => {\n *   const { x, y } = mousePosition();\n *   // do something\n * });\n * ```\n *\n * For more details, refer to the **[documentation or article](https://medium.com/p/8138c57353d6)**.\n */\nexport function signalFromEvent<T extends Event>(\n  eventName: string | string[] | Signal<string | string[]>,\n  options?: SignalFromEventOptions<T>\n): EventSignal<T | undefined>;\nexport function signalFromEvent<T extends Event, R>(\n  eventName: string | string[] | Signal<string | string[]>,\n  options: SignalFromEventOptions<T, R> & {\n    resultSelector: (event: T) => R;\n  } & { initialValue?: never }\n): EventSignal<R | undefined>;\nexport function signalFromEvent<T extends Event, R>(\n  eventName: string | string[] | Signal<string | string[]>,\n  options: SignalFromEventOptions<T, R> & {\n    resultSelector: (event: T) => R;\n  } & { initialValue: R }\n): EventSignal<R>;\n\nexport function signalFromEvent<T extends Event, R = T>(\n  eventName: string | string[] | Signal<string | string[]>,\n  options?: SignalFromEventOptions<T, R>\n): EventSignal<R | undefined> {\n  const injector = options?.injector ?? inject(Injector);\n  const destroyRef = injector.get(DestroyRef);\n\n  const optionsTarget = options?.target;\n  const listenerTarget: Signal<\n    ElementRef<HasEventTargetAddRemove<T>> | undefined\n  > =\n    optionsTarget === undefined\n      ? signal(\n          injector.get(ElementRef<HasEventTargetAddRemove<T>>)\n        ).asReadonly()\n      : isSignal(optionsTarget)\n      ? optionsTarget\n      : signal({ nativeElement: optionsTarget } as ElementRef).asReadonly();\n\n  const eventNameSignal = isSignal(eventName) ? eventName : signal(eventName);\n\n  const eventSignal = signal<R | undefined>(options?.initialValue);\n\n  const resultSelector =\n    options?.resultSelector ??\n    ((value: T) => {\n      return value as unknown as R; // if resultSelector is not defined, R has to be T\n    });\n\n  const eventListener: (event: T) => void = (event: T) => {\n    if (options?.tap !== undefined) {\n      options.tap(event);\n    }\n    eventSignal.set(resultSelector(event));\n  };\n\n  let activatorAttached = false;\n  let listener: Listener<T> = {\n    listening: false,\n    target: listenerTarget,\n    eventName: eventNameSignal,\n    eventListener,\n    options: options?.eventListenerOptions,\n  };\n\n  let effectRef: EffectRef | undefined = undefined;\n  let subscription: Subscription | undefined = undefined;\n\n  const terminateUpdaters = () => {\n    if (effectRef !== undefined) {\n      effectRef.destroy();\n      effectRef = undefined;\n    } else if (subscription !== undefined) {\n      subscription.unsubscribe();\n      subscription = undefined;\n    }\n  };\n\n  let deactivate: () => void = () => {\n    terminateUpdaters();\n    removeEventListenerFromTarget(listener);\n    activatorAttached = false;\n    activatorProxy = undefined;\n  };\n\n  let activatorProxy: true | Signal<boolean> | Observable<boolean> | undefined =\n    undefined;\n\n  const activateProxySource = new Subject<void>();\n  activateProxySource\n    .pipe(\n      throttleTime(0, asyncScheduler, { leading: false, trailing: true }),\n      takeUntilDestroyed(injector.get(DestroyRef))\n    )\n    .subscribe(() => {\n      if (activatorProxy !== undefined) {\n        activatorAttached = false;\n        attachActivator(activatorProxy);\n      }\n    });\n\n  let previousListenerTarget:\n    | ElementRef<HasEventTargetAddRemove<T>>\n    | undefined = listenerTarget();\n  const listenerChangeEffectRef = effect(\n    () => {\n      const listenerTargetValue = listenerTarget();\n      if (\n        activatorAttached === false ||\n        previousListenerTarget === listenerTargetValue\n      ) {\n        return;\n      }\n      if (listenerTargetValue !== undefined) {\n        if (previousListenerTarget?.nativeElement !== undefined) {\n          removeEventListenerFromTarget(listener, {\n            target: previousListenerTarget.nativeElement,\n          });\n        }\n        activateProxySource.next();\n      } else {\n        listener.listening = false;\n      }\n      previousListenerTarget = listenerTargetValue;\n    },\n    { injector }\n  );\n\n  let previousEventName = eventNameSignal();\n  const eventNameChangeEffectRef = effect(\n    () => {\n      const eventName = eventNameSignal();\n      if (eventName !== previousEventName) {\n        removeEventListenerFromTarget(listener, {\n          eventName: previousEventName,\n        });\n        activateProxySource.next();\n        previousEventName = eventName;\n      }\n    },\n    { injector }\n  );\n\n  destroyRef.onDestroy(() => {\n    deactivate();\n    listenerChangeEffectRef.destroy();\n    eventNameChangeEffectRef.destroy();\n  });\n\n  const attachActivator = (\n    activator: true | Signal<boolean> | Observable<boolean>\n  ) => {\n    if (activatorAttached) {\n      throw new Error(\n        'Cannot attach another activator! EventSignal is already attached to an activator! Call deactivate first!'\n      );\n    }\n\n    terminateUpdaters();\n\n    activatorAttached = true;\n    activatorProxy = activator;\n\n    if (listenerTarget() === undefined) {\n      return;\n    }\n\n    if (activator === true) {\n      addEventListenerToTarget(listener);\n    } else if (isSignal(activator)) {\n      effectRef = effect(\n        () => addOrRemoveEventListener(activator(), listener),\n        parseInt(VERSION.major) < 19\n          ? {\n              injector,\n              allowSignalWrites: true,\n            }\n          : { injector }\n      );\n    } else {\n      subscription = activator.subscribe((activate) =>\n        addOrRemoveEventListener(activate, listener)\n      );\n    }\n  };\n\n  if (options?.activate === true) {\n    attachActivator(true);\n  }\n\n  return Object.assign(eventSignal.asReadonly(), {\n    attachActivator,\n    deactivate,\n  }) as EventSignal<R | undefined>;\n}\n\nfunction addOrRemoveEventListener<T>(activate: boolean, listener: Listener<T>) {\n  activate\n    ? addEventListenerToTarget(listener)\n    : removeEventListenerFromTarget(listener);\n}\n\nfunction addEventListenerToTarget<T>(listener: Listener<T>) {\n  const target = listener.target()?.nativeElement;\n  const eventName = listener.eventName();\n  if (target !== undefined && listener.listening === false) {\n    for (const eName of Array.isArray(eventName) ? eventName : [eventName]) {\n      target.addEventListener(eName, listener.eventListener, listener.options);\n    }\n    listener.listening = true;\n  }\n}\n\nfunction removeEventListenerFromTarget<T>(\n  listener: Listener<T>,\n  previousListener?: {\n    target?: HasEventTargetAddRemove<T>;\n    eventName?: string | string[];\n  }\n) {\n  const target = previousListener?.target ?? listener.target()?.nativeElement;\n  const eventName = previousListener?.eventName ?? listener.eventName();\n  if (target !== undefined && listener.listening === true) {\n    for (const eName of Array.isArray(eventName) ? eventName : [eventName]) {\n      target.removeEventListener(\n        eName,\n        listener.eventListener,\n        listener.options\n      );\n    }\n  }\n  listener.listening = false;\n}\n","import { concat, defer, Observable, of } from 'rxjs';\n\n/**\n * Same as the original rxjs startWith operator but the value is created by a factory function at subscription time to lazily evaluate.\n *\n * @param factory to evaluate the start value lazily at subscription time\n * @returns\n */\nexport function lazyStartWith<T>(factory: () => T) {\n  return (source: Observable<T>): Observable<T> =>\n    defer(() => concat(of(factory()), source));\n}\n","import {\n  DestroyRef,\n  effect,\n  EffectRef,\n  inject,\n  Injector,\n  Signal,\n  untracked,\n  VERSION,\n} from '@angular/core';\nimport { ToObservableOptions } from '@angular/core/rxjs-interop';\nimport { Observable, shareReplay, Subject, tap } from 'rxjs';\nimport { lazyStartWith } from './custom-observables';\n\n/**\n * Converts a signal to a hot observable with the initial value emitted synchronously.\n * Similar to BehaviorSubject behavior, using shareReplay under the hood.\n * Every following signal value change will be emitted asynchronously just like with the original toObservable method.\n *\n * Use the original toObservable method from '@angular/core/rxjs-interop' if asynchronous initial value readout is sufficient.\n *\n * @param source The source signal to convert to an observable.\n * @param options toBehaviorObservable must be called in an injection context unless an injector is provided via options.\n * @returns An observable that emits the signal's current value synchronously upon subscription, and subsequent values asynchronously.\n */\nexport const toBehaviorObservable = <T>(\n  source: Signal<T>,\n  options?: ToObservableOptions\n): Observable<T> => {\n  const subject = new Subject<T>();\n  const injector = options?.injector ?? inject(Injector);\n  injector.get(DestroyRef).onDestroy(() => {\n    subject.complete();\n  });\n  let watcher: EffectRef | undefined = undefined;\n  let initialValue: T | undefined = undefined;\n  return subject.pipe(\n    lazyStartWith(() => {\n      initialValue = source();\n      return initialValue;\n    }),\n    tap({\n      subscribe: () => {\n        let skipFirst = true;\n        watcher = effect(\n          () => {\n            try {\n              const sourceValue = source();\n              // !skipFirst\n              // Skipping the first run as the initial value is already emitted by lazyStartWith and the\n              // subject should not emit the same value twice in a row, since the effect would emit the\n              // initial value asynchronously.\n              //\n              // initialValue !== sourceValue\n              // Still emit the value on the subject in case the signal value changed between the\n              // lazyStartWith and the first effect run.\n              if (!skipFirst || initialValue !== sourceValue) {\n                untracked(() => subject.next(sourceValue));\n              }\n              skipFirst = false;\n            } catch (err) {\n              untracked(() => subject.error(err));\n            }\n          },\n          parseInt(VERSION.major) < 19\n            ? {\n                injector,\n                allowSignalWrites: true,\n                manualCleanup: true,\n              }\n            : { injector, manualCleanup: true }\n        );\n      },\n      finalize: () => {\n        watcher?.destroy();\n      },\n    }),\n    shareReplay({ bufferSize: 1, refCount: true })\n  );\n};\n","/*\n * Public API Surface of angular-signal-plus\n */\n\nexport * from './lib/bindable-signal';\nexport * from './lib/event-signal';\nexport * from './lib/custom-observables';\nexport * from './lib/to-behavior-observable';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["Subject"],"mappings":";;;;;;AAuBA;;;;;;;;;;;;;;;AAeG;AACa,SAAA,QAAQ,CACtB,YAAe,EACf,OAIC,EAAA;IAED,qDAAqD,CAAC,OAAO,CAAC,CAAC;IAE/D,IAAI,QAAQ,GAAyB,SAAS,CAAC;AAC/C,IAAA,IAAI,OAAO,EAAE,UAAU,KAAK,SAAS,IAAI,OAAO,EAAE,aAAa,KAAK,IAAI,EAAE;QACxE,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;KAClD;IAED,MAAM,cAAc,GAAG,MAAM,CAAI,YAAY,EAAE,OAAO,CAAC,CAAC;IACxD,IAAI,KAAK,GAAG,KAAK,CAAC;IAElB,IAAI,SAAS,GAA0B,SAAS,CAAC;IACjD,IAAI,YAAY,GAA6B,SAAS,CAAC;IACvD,MAAM,MAAM,GAAe,MAAK;AAC9B,QAAA,IAAI,SAAS,KAAK,SAAS,EAAE;YAC3B,SAAS,CAAC,OAAO,EAAE,CAAC;YACpB,SAAS,GAAG,SAAS,CAAC;SACvB;AAAM,aAAA,IAAI,YAAY,KAAK,SAAS,EAAE;YACrC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;SAC1B;aAAM;AACL,YAAA,MAAM,IAAI,KAAK,CACb,mFAAmF,CACpF,CAAC;SACH;QACD,KAAK,GAAG,KAAK,CAAC;AAChB,KAAC,CAAC;AAEF,IAAA,MAAM,MAAM,GAA6D,CACvE,MAAiC,KAC/B;QACF,0BAA0B,CACxB,MAAM,EACN,yDAAyD;AACvD,YAAA,kGAAkG,CACrG,CAAC;QACF,IAAI,KAAK,EAAE;AACT,YAAA,MAAM,IAAI,KAAK,CACb,kFAAkF,CACnF,CAAC;SACH;AACD,QAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;AACpB,YAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;gBAC1B,MAAM,IAAI,KAAK,CACb,yIAAyI;oBACvI,uIAAuI;AACvI,oBAAA,+HAA+H,CAClI,CAAC;aACH;AAED,YAAA,SAAS,GAAG,MAAM,CAChB,MAAK;AACH,gBAAA,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC;gBAC7B,SAAS,CAAC,MAAM,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;aAClD,EACD,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;AAC1B,kBAAE;oBACE,QAAQ;AACR,oBAAA,iBAAiB,EAAE,IAAI;AACxB,iBAAA;AACH,kBAAE,EAAE,QAAQ,EAAE,CACjB,CAAC;SACH;aAAM;AACL,YAAA,IAAI,gBAA6C,CAAC;AAClD,YAAA,IAAI,OAAO,EAAE,aAAa,KAAK,IAAI,EAAE;gBACnC,gBAAgB,GAAG,IAAI,EAAE,CAAC;aAC3B;iBAAM;AACL,gBAAA,MAAM,UAAU,GAAG,OAAO,EAAE,UAAU,IAAI,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;AACpE,gBAAA,IAAI,UAAU,KAAK,SAAS,EAAE;oBAC5B,MAAM,IAAI,KAAK,CACb,yFAAyF;AACvF,wBAAA,oFAAoF,CACvF,CAAC;iBACH;AACD,gBAAA,gBAAgB,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC;aACnD;AAED,YAAA,YAAY,GAAG,MAAM;iBAClB,IAAI,CAAC,gBAAgB,CAAC;AACtB,iBAAA,SAAS,CAAC,CAAC,KAAK,KAAK,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;SACpD;QACD,KAAK,GAAG,IAAI,CAAC;AACb,QAAA,OAAO,cAAc,CAAC;AACxB,KAAC,CAAC;AAEF,IAAA,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAsB,CAAC;AAChF,CAAC;AAED,SAAS,qDAAqD,CAAC,OAI9D,EAAA;AACC,IAAA,IAAI,OAAO,EAAE,aAAa,KAAK,IAAI,EAAE;AACnC,QAAA,IAAI,OAAO,EAAE,UAAU,KAAK,SAAS,IAAI,OAAO,EAAE,QAAQ,KAAK,SAAS,EAAE;YACxE,MAAM,IAAI,KAAK,CACb,wFAAwF;AACtF,gBAAA,uGAAuG,CAC1G,CAAC;SACH;KACF;AACH;;AC/BgB,SAAA,eAAe,CAC7B,SAAwD,EACxD,OAAsC,EAAA;IAEtC,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAE5C,IAAA,MAAM,aAAa,GAAG,OAAO,EAAE,MAAM,CAAC;AACtC,IAAA,MAAM,cAAc,GAGlB,aAAa,KAAK,SAAS;AACzB,UAAE,MAAM,CACJ,QAAQ,CAAC,GAAG,EAAC,UAAsC,EAAC,CACrD,CAAC,UAAU,EAAE;AAChB,UAAE,QAAQ,CAAC,aAAa,CAAC;AACzB,cAAE,aAAa;AACf,cAAE,MAAM,CAAC,EAAE,aAAa,EAAE,aAAa,EAAgB,CAAC,CAAC,UAAU,EAAE,CAAC;AAE1E,IAAA,MAAM,eAAe,GAAG,QAAQ,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAE5E,MAAM,WAAW,GAAG,MAAM,CAAgB,OAAO,EAAE,YAAY,CAAC,CAAC;AAEjE,IAAA,MAAM,cAAc,GAClB,OAAO,EAAE,cAAc;SACtB,CAAC,KAAQ,KAAI;YACZ,OAAO,KAAqB,CAAC;AAC/B,SAAC,CAAC,CAAC;AAEL,IAAA,MAAM,aAAa,GAAuB,CAAC,KAAQ,KAAI;AACrD,QAAA,IAAI,OAAO,EAAE,GAAG,KAAK,SAAS,EAAE;AAC9B,YAAA,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;SACpB;QACD,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;AACzC,KAAC,CAAC;IAEF,IAAI,iBAAiB,GAAG,KAAK,CAAC;AAC9B,IAAA,IAAI,QAAQ,GAAgB;AAC1B,QAAA,SAAS,EAAE,KAAK;AAChB,QAAA,MAAM,EAAE,cAAc;AACtB,QAAA,SAAS,EAAE,eAAe;QAC1B,aAAa;QACb,OAAO,EAAE,OAAO,EAAE,oBAAoB;KACvC,CAAC;IAEF,IAAI,SAAS,GAA0B,SAAS,CAAC;IACjD,IAAI,YAAY,GAA6B,SAAS,CAAC;IAEvD,MAAM,iBAAiB,GAAG,MAAK;AAC7B,QAAA,IAAI,SAAS,KAAK,SAAS,EAAE;YAC3B,SAAS,CAAC,OAAO,EAAE,CAAC;YACpB,SAAS,GAAG,SAAS,CAAC;SACvB;AAAM,aAAA,IAAI,YAAY,KAAK,SAAS,EAAE;YACrC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;SAC1B;AACH,KAAC,CAAC;IAEF,IAAI,UAAU,GAAe,MAAK;AAChC,QAAA,iBAAiB,EAAE,CAAC;QACpB,6BAA6B,CAAC,QAAQ,CAAC,CAAC;QACxC,iBAAiB,GAAG,KAAK,CAAC;QAC1B,cAAc,GAAG,SAAS,CAAC;AAC7B,KAAC,CAAC;IAEF,IAAI,cAAc,GAChB,SAAS,CAAC;AAEZ,IAAA,MAAM,mBAAmB,GAAG,IAAI,OAAO,EAAQ,CAAC;IAChD,mBAAmB;SAChB,IAAI,CACH,YAAY,CAAC,CAAC,EAAE,cAAc,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,EACnE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAC7C;SACA,SAAS,CAAC,MAAK;AACd,QAAA,IAAI,cAAc,KAAK,SAAS,EAAE;YAChC,iBAAiB,GAAG,KAAK,CAAC;YAC1B,eAAe,CAAC,cAAc,CAAC,CAAC;SACjC;AACH,KAAC,CAAC,CAAC;AAEL,IAAA,IAAI,sBAAsB,GAEV,cAAc,EAAE,CAAC;AACjC,IAAA,MAAM,uBAAuB,GAAG,MAAM,CACpC,MAAK;AACH,QAAA,MAAM,mBAAmB,GAAG,cAAc,EAAE,CAAC;QAC7C,IACE,iBAAiB,KAAK,KAAK;YAC3B,sBAAsB,KAAK,mBAAmB,EAC9C;YACA,OAAO;SACR;AACD,QAAA,IAAI,mBAAmB,KAAK,SAAS,EAAE;AACrC,YAAA,IAAI,sBAAsB,EAAE,aAAa,KAAK,SAAS,EAAE;gBACvD,6BAA6B,CAAC,QAAQ,EAAE;oBACtC,MAAM,EAAE,sBAAsB,CAAC,aAAa;AAC7C,iBAAA,CAAC,CAAC;aACJ;YACD,mBAAmB,CAAC,IAAI,EAAE,CAAC;SAC5B;aAAM;AACL,YAAA,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC;SAC5B;QACD,sBAAsB,GAAG,mBAAmB,CAAC;AAC/C,KAAC,EACD,EAAE,QAAQ,EAAE,CACb,CAAC;AAEF,IAAA,IAAI,iBAAiB,GAAG,eAAe,EAAE,CAAC;AAC1C,IAAA,MAAM,wBAAwB,GAAG,MAAM,CACrC,MAAK;AACH,QAAA,MAAM,SAAS,GAAG,eAAe,EAAE,CAAC;AACpC,QAAA,IAAI,SAAS,KAAK,iBAAiB,EAAE;YACnC,6BAA6B,CAAC,QAAQ,EAAE;AACtC,gBAAA,SAAS,EAAE,iBAAiB;AAC7B,aAAA,CAAC,CAAC;YACH,mBAAmB,CAAC,IAAI,EAAE,CAAC;YAC3B,iBAAiB,GAAG,SAAS,CAAC;SAC/B;AACH,KAAC,EACD,EAAE,QAAQ,EAAE,CACb,CAAC;AAEF,IAAA,UAAU,CAAC,SAAS,CAAC,MAAK;AACxB,QAAA,UAAU,EAAE,CAAC;QACb,uBAAuB,CAAC,OAAO,EAAE,CAAC;QAClC,wBAAwB,CAAC,OAAO,EAAE,CAAC;AACrC,KAAC,CAAC,CAAC;AAEH,IAAA,MAAM,eAAe,GAAG,CACtB,SAAuD,KACrD;QACF,IAAI,iBAAiB,EAAE;AACrB,YAAA,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G,CAAC;SACH;AAED,QAAA,iBAAiB,EAAE,CAAC;QAEpB,iBAAiB,GAAG,IAAI,CAAC;QACzB,cAAc,GAAG,SAAS,CAAC;AAE3B,QAAA,IAAI,cAAc,EAAE,KAAK,SAAS,EAAE;YAClC,OAAO;SACR;AAED,QAAA,IAAI,SAAS,KAAK,IAAI,EAAE;YACtB,wBAAwB,CAAC,QAAQ,CAAC,CAAC;SACpC;AAAM,aAAA,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE;YAC9B,SAAS,GAAG,MAAM,CAChB,MAAM,wBAAwB,CAAC,SAAS,EAAE,EAAE,QAAQ,CAAC,EACrD,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;AAC1B,kBAAE;oBACE,QAAQ;AACR,oBAAA,iBAAiB,EAAE,IAAI;AACxB,iBAAA;AACH,kBAAE,EAAE,QAAQ,EAAE,CACjB,CAAC;SACH;aAAM;AACL,YAAA,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,QAAQ,KAC1C,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAC7C,CAAC;SACH;AACH,KAAC,CAAC;AAEF,IAAA,IAAI,OAAO,EAAE,QAAQ,KAAK,IAAI,EAAE;QAC9B,eAAe,CAAC,IAAI,CAAC,CAAC;KACvB;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE;QAC7C,eAAe;QACf,UAAU;AACX,KAAA,CAA+B,CAAC;AACnC,CAAC;AAED,SAAS,wBAAwB,CAAI,QAAiB,EAAE,QAAqB,EAAA;IAC3E,QAAQ;AACN,UAAE,wBAAwB,CAAC,QAAQ,CAAC;AACpC,UAAE,6BAA6B,CAAC,QAAQ,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,wBAAwB,CAAI,QAAqB,EAAA;IACxD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,aAAa,CAAC;AAChD,IAAA,MAAM,SAAS,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC;IACvC,IAAI,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,SAAS,KAAK,KAAK,EAAE;QACxD,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,CAAC,SAAS,CAAC,EAAE;AACtE,YAAA,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;SAC1E;AACD,QAAA,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC;KAC3B;AACH,CAAC;AAED,SAAS,6BAA6B,CACpC,QAAqB,EACrB,gBAGC,EAAA;AAED,IAAA,MAAM,MAAM,GAAG,gBAAgB,EAAE,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,EAAE,aAAa,CAAC;IAC5E,MAAM,SAAS,GAAG,gBAAgB,EAAE,SAAS,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;IACtE,IAAI,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,SAAS,KAAK,IAAI,EAAE;QACvD,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,CAAC,SAAS,CAAC,EAAE;AACtE,YAAA,MAAM,CAAC,mBAAmB,CACxB,KAAK,EACL,QAAQ,CAAC,aAAa,EACtB,QAAQ,CAAC,OAAO,CACjB,CAAC;SACH;KACF;AACD,IAAA,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC;AAC7B;;ACtUA;;;;;AAKG;AACG,SAAU,aAAa,CAAI,OAAgB,EAAA;IAC/C,OAAO,CAAC,MAAqB,KAC3B,KAAK,CAAC,MAAM,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC/C;;ACGA;;;;;;;;;;AAUG;MACU,oBAAoB,GAAG,CAClC,MAAiB,EACjB,OAA6B,KACZ;AACjB,IAAA,MAAM,OAAO,GAAG,IAAIA,SAAO,EAAK,CAAC;IACjC,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,MAAK;QACtC,OAAO,CAAC,QAAQ,EAAE,CAAC;AACrB,KAAC,CAAC,CAAC;IACH,IAAI,OAAO,GAA0B,SAAS,CAAC;IAC/C,IAAI,YAAY,GAAkB,SAAS,CAAC;AAC5C,IAAA,OAAO,OAAO,CAAC,IAAI,CACjB,aAAa,CAAC,MAAK;QACjB,YAAY,GAAG,MAAM,EAAE,CAAC;AACxB,QAAA,OAAO,YAAY,CAAC;KACrB,CAAC,EACF,GAAG,CAAC;QACF,SAAS,EAAE,MAAK;YACd,IAAI,SAAS,GAAG,IAAI,CAAC;AACrB,YAAA,OAAO,GAAG,MAAM,CACd,MAAK;AACH,gBAAA,IAAI;AACF,oBAAA,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC;;;;;;;;;AAS7B,oBAAA,IAAI,CAAC,SAAS,IAAI,YAAY,KAAK,WAAW,EAAE;wBAC9C,SAAS,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;qBAC5C;oBACD,SAAS,GAAG,KAAK,CAAC;iBACnB;gBAAC,OAAO,GAAG,EAAE;oBACZ,SAAS,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;iBACrC;aACF,EACD,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;AAC1B,kBAAE;oBACE,QAAQ;AACR,oBAAA,iBAAiB,EAAE,IAAI;AACvB,oBAAA,aAAa,EAAE,IAAI;AACpB,iBAAA;kBACD,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,CACtC,CAAC;SACH;QACD,QAAQ,EAAE,MAAK;YACb,OAAO,EAAE,OAAO,EAAE,CAAC;SACpB;AACF,KAAA,CAAC,EACF,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAC/C,CAAC;AACJ;;AC/EA;;AAEG;;ACFH;;AAEG;;;;"}