{"version":3,"file":"index.cjs","sources":["../../src/core/interceptor.ts","../../src/core/typing-util.ts","../../src/core/signal/signal.ts","../../src/core/signal/computed.ts","../../src/core/store/set.ts","../../src/core/signal/state.ts","../../src/core/store/sub.ts","../../src/core/store/store.ts","../../src/debug/debug-store.ts","../../src/debug/console-inspector.ts"],"sourcesContent":["import type { Command, Computed, Signal, State } from '../../types/core/signal';\nimport type {\n  ComputedState,\n  InterceptorComputed,\n  InterceptorGet,\n  InterceptorSet,\n  SetArgs,\n} from '../../types/core/store';\n\ntype DataWithCalledState<T> =\n  | {\n      called: false;\n    }\n  | {\n      called: true;\n      data: T;\n    };\n\nexport function withSetInterceptor<T, Args extends SetArgs<T, unknown[]>>(\n  fn: () => T | undefined,\n  writable$: State<T> | Command<T, Args>,\n  interceptor: InterceptorSet | undefined,\n  ...args: Args\n): T | undefined {\n  if (!interceptor) {\n    return fn();\n  }\n\n  let result = { called: false } as DataWithCalledState<T | undefined>;\n  const wrappedFn = () => {\n    result = { called: true, data: fn() };\n    return result.data;\n  };\n  if ('write' in writable$) {\n    interceptor(writable$, wrappedFn, ...args);\n  } else {\n    interceptor(writable$, wrappedFn, args[0]);\n  }\n\n  if (!result.called) {\n    throw new Error('interceptor must call fn sync');\n  }\n\n  return result.data;\n}\n\nexport function withGetInterceptor<T>(fn: () => T, signal: Signal<T>, interceptor?: InterceptorGet): T {\n  if (!interceptor) {\n    return fn();\n  }\n\n  let result = { called: false } as DataWithCalledState<T>;\n\n  interceptor(signal, () => {\n    result = { called: true, data: fn() };\n    return result.data;\n  });\n\n  if (!result.called) {\n    throw new Error('interceptor must call fn sync');\n  }\n\n  return result.data;\n}\n\nexport function withComputedInterceptor<T>(\n  fn: () => ComputedState<T>,\n  signal: Computed<T>,\n  interceptor?: InterceptorComputed,\n): ComputedState<T> {\n  if (!interceptor) {\n    return fn();\n  }\n\n  let result = { called: false } as DataWithCalledState<ComputedState<T>>;\n\n  interceptor(signal, () => {\n    result = { called: true, data: fn() };\n    return result.data.val;\n  });\n\n  if (!result.called) {\n    throw new Error('interceptor must call fn sync');\n  }\n\n  return result.data;\n}\n\nexport function withGeValInterceptor<T>(fn: () => T, signal: Signal<T>, interceptor?: InterceptorGet): T {\n  if (!interceptor) {\n    return fn();\n  }\n\n  let result = { called: false } as DataWithCalledState<T>;\n\n  interceptor(signal, () => {\n    result = { called: true, data: fn() };\n    return result.data;\n  });\n\n  if (!result.called) {\n    throw new Error('interceptor must call fn sync');\n  }\n\n  return result.data;\n}\n","import type { Computed, Signal } from '../../types/core/signal';\nimport type { ComputedState, SignalState } from '../../types/core/store';\n\nexport function canReadAsCompute<T>(atom: Signal<T>): atom is Computed<T> {\n  return 'read' in atom;\n}\n\nexport function isComputedState<T>(state: SignalState<T>): state is ComputedState<T> {\n  return 'dependencies' in state;\n}\n","import type { Computed, Signal } from '../../../types/core/signal';\nimport type { StoreContext } from '../../../types/core/store';\n\nexport function shouldDistinct<T>(signal: Signal<T>, value: T, context: StoreContext) {\n  const signalState = context.stateMap.get(signal);\n  return !!signalState && 'val' in signalState && !('error' in signalState) && signalState.val === value;\n}\n\nexport function shouldDistinctError(signal: Computed<unknown>, error: unknown, context: StoreContext) {\n  const signalState = context.stateMap.get(signal);\n  return !!signalState && 'error' in signalState && signalState.error === error;\n}\n","import type { Computed, Getter, Signal } from '../../../types/core/signal';\nimport type {\n  ComputedState,\n  Mount,\n  Mutation,\n  ReadComputed,\n  ReadSignal,\n  StoreContext,\n  Unmount,\n} from '../../../types/core/store';\nimport { withGeValInterceptor } from '../interceptor';\nimport { canReadAsCompute } from '../typing-util';\nimport { shouldDistinct, shouldDistinctError } from './signal';\n\nfunction checkEpoch<T>(\n  readComputed: ReadComputed,\n  computedState: ComputedState<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): boolean {\n  for (const [dep, epoch] of computedState.dependencies.entries()) {\n    const depEpoch = canReadAsCompute(dep)\n      ? readComputed(dep, context, mutation).epoch\n      : context.stateMap.get(dep)?.epoch;\n\n    if (depEpoch !== epoch) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function tryGetCached<T>(\n  readComputed: ReadComputed,\n  computed$: Computed<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): ComputedState<T> | undefined {\n  const signalState = context.stateMap.get(computed$) as ComputedState<T> | undefined;\n  if (!signalState) {\n    return undefined;\n  }\n\n  // If a computed is marked as potentially dirty, we should perform a\n  // thorough epoch check. Alternatively, we can check the mounted state since\n  // a mounted computed is always re-evaluated immediately.\n  // Unmounted caches also stay valid until the store's next write.\n  const writeVersion = context.writeVersion;\n  const mayDirty = (context.pendingMutation ?? mutation)?.potentialDirtyIds.has(computed$.id);\n  if (!mayDirty && (signalState.mounted || signalState.verifiedAt === writeVersion)) {\n    return signalState;\n  }\n\n  if (checkEpoch(readComputed, signalState, context, mutation)) {\n    signalState.verifiedAt = writeVersion;\n    if (mayDirty) {\n      mutation?.potentialDirtyIds.delete(computed$.id);\n    }\n    return signalState;\n  }\n\n  return undefined;\n}\n\nfunction wrapGet<T>(\n  readSignal: ReadSignal,\n  mount: Mount,\n  callerComputed$: Computed<T>,\n  callerState: ComputedState<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): [Getter, Map<Signal<unknown>, number>] {\n  const readDeps = new Map<Signal<unknown>, number>();\n\n  return [\n    (dep$) => {\n      const depState = readSignal(dep$, context, mutation);\n\n      if (callerState.dependencies === readDeps) {\n        readDeps.set(dep$, depState.epoch);\n\n        const callerMounted = !!callerState.mounted;\n        if (callerMounted && !depState.mounted) {\n          mount(dep$, context, mutation).readDepts.add(callerComputed$);\n        } else if (callerMounted && depState.mounted) {\n          depState.mounted.readDepts.add(callerComputed$);\n        }\n      }\n\n      if ('error' in depState) {\n        throw depState.error;\n      }\n\n      return depState.val;\n    },\n    readDeps,\n  ];\n}\n\nfunction getOrInitComputedState<T>(computed$: Computed<T>, context: StoreContext): ComputedState<T> {\n  let computedState: ComputedState<T> | undefined = context.stateMap.get(computed$) as ComputedState<T> | undefined;\n  if (!computedState) {\n    computedState = {\n      dependencies: new Map<Signal<unknown>, number>(),\n      epoch: -1,\n    } as ComputedState<T>;\n    context.stateMap.set(computed$, computedState);\n  }\n\n  return computedState;\n}\n\nfunction cleanupMissingDependencies<T>(\n  unmount: Unmount,\n  computed$: Computed<T>,\n  lastDeps: Map<Signal<unknown>, number>,\n  currDeps: Map<Signal<unknown>, number>,\n  context: StoreContext,\n  mutation?: Mutation,\n) {\n  for (const key of lastDeps.keys()) {\n    if (!currDeps.has(key)) {\n      const depState = context.stateMap.get(key);\n      depState?.mounted?.readDepts.delete(computed$);\n      unmount(key, context, mutation);\n    }\n  }\n}\n\ntype ComputedResult<T> =\n  | {\n      value: T;\n    }\n  | {\n      error: unknown;\n    };\n\nexport function evaluateComputed<T>(\n  readSignal: ReadSignal,\n  mount: Mount,\n  unmount: Unmount,\n  computed$: Computed<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): ComputedState<T> {\n  const writeVersion = context.writeVersion;\n  const computedState = getOrInitComputedState(computed$, context);\n  const previousEpoch = computedState.epoch;\n  const wasDirty = mutation?.potentialDirtyIds.has(computed$.id);\n\n  const lastDeps = computedState.dependencies;\n\n  const [_get, dependencies] = wrapGet(readSignal, mount, computed$, computedState, context, mutation);\n  computedState.dependencies = dependencies;\n\n  const previousController = computedState.abortController;\n  delete computedState.abortController;\n  previousController?.abort(`abort ${computed$.debugLabel ?? 'anonymous'} atom`);\n  let controller: AbortController | undefined;\n\n  let result: ComputedResult<T>;\n  try {\n    result = {\n      value: computed$.read(\n        function <U>(depAtom: Signal<U>) {\n          return withGeValInterceptor(() => _get(depAtom), depAtom, context.interceptor?.get);\n        },\n        {\n          get signal() {\n            if (!controller) {\n              controller = new AbortController();\n              // An older async evaluation may first request its signal after\n              // a newer evaluation has replaced its dependency map.\n              if (computedState.dependencies === dependencies) {\n                computedState.abortController = controller;\n              } else {\n                controller.abort(`abort ${computed$.debugLabel ?? 'anonymous'} atom`);\n              }\n            }\n            return controller.signal;\n          },\n        },\n      ),\n    };\n  } catch (error) {\n    result = {\n      error,\n    };\n  }\n\n  mutation?.potentialDirtyIds.delete(computed$.id);\n\n  cleanupMissingDependencies(unmount, computed$, lastDeps, dependencies, context, mutation);\n\n  if ('error' in result) {\n    if (!shouldDistinctError(computed$, result.error, context)) {\n      computedState.error = result.error;\n      delete computedState.val;\n      computedState.epoch += 1;\n    }\n  } else if (!shouldDistinct(computed$, result.value, context)) {\n    computedState.val = result.value;\n    delete computedState.error;\n    computedState.epoch += 1;\n  }\n\n  if (wasDirty && computedState.epoch !== previousEpoch) context.changedSignals.add(computed$);\n  computedState.verifiedAt = writeVersion;\n  return computedState;\n}\n","import type { Command, State, Computed, Signal, Updater, StateArg, Getter, Setter } from '../../../types/core/signal';\nimport type { Mutation, ReadComputed, StoreContext, StoreGet, SetArgs } from '../../../types/core/store';\nimport { shouldDistinct } from '../signal/signal';\nimport { withSetInterceptor } from '../interceptor';\n\ntype Flush = (context: StoreContext) => void;\n\n// Writes mark the current mounted graph, but do not evaluate it. Repeated\n// invalidations must still mark nodes whose dirty flag an eager get cleared.\nfunction markDirty(dependents: Set<Computed<unknown>>, context: StoreContext, mutation: Mutation) {\n  let queue = Array.from(dependents);\n  while (queue.length) {\n    const next: Computed<unknown>[] = [];\n    for (const computed$ of queue) {\n      // Jotai likewise stops at an already invalidated node (#2950). An\n      // eager read clears this flag, so a later write can invalidate it again.\n      if (mutation.potentialDirtyIds.has(computed$.id)) continue;\n      const computedState = context.stateMap.get(computed$);\n      if (!mutation.oldEpochs.has(computed$)) mutation.oldEpochs.set(computed$, computedState?.epoch);\n      mutation.potentialDirtyIds.add(computed$.id);\n      for (const dep of computedState?.mounted?.readDepts ?? []) next.push(dep);\n    }\n    queue = next;\n  }\n}\n\nfunction pullEvaluate(\n  readComputed: ReadComputed,\n  dependents: Set<Computed<unknown>>,\n  context: StoreContext,\n  mutation: Mutation,\n) {\n  let queue = Array.from(dependents);\n  const visited = new Set<Computed<unknown>>();\n  while (queue.length) {\n    const next: Computed<unknown>[] = [];\n    for (const computed$ of queue) {\n      if (visited.has(computed$)) continue;\n      visited.add(computed$);\n      const current = readComputed(computed$, context, mutation);\n      // Newly mounted roots already computed their initial value and must not\n      // receive an initial notification merely because an earlier write exists.\n      if (!mutation.oldEpochs.has(computed$) || mutation.oldEpochs.get(computed$) === current.epoch) continue;\n      context.changedSignals.add(computed$);\n      for (const dep of current.mounted?.readDepts ?? []) next.push(dep);\n    }\n    queue = next;\n  }\n}\n\nfunction getPendingMutation(context: StoreContext): Mutation {\n  // Like Jotai's store-owned invalidation collections, reuse cleared work\n  // buffers. Evaluation dependency Maps and AbortSignal owners are not reused.\n  return (context.pendingMutation ??= context.mutationWork ??=\n    {\n      potentialDirtyIds: new Set(),\n      oldEpochs: new Map(),\n      changedSources: new Set(),\n      flushing: false,\n    });\n}\n\nexport function flushMutation(readComputed: ReadComputed, context: StoreContext): boolean {\n  const mutation = context.pendingMutation;\n  if (!mutation) return true;\n  // A computed's old AbortSignal can synchronously cause a write while the new\n  // evaluation is being constructed. Finish that graph before firing listeners.\n  if (mutation.flushing) return false;\n  mutation.flushing = true;\n  try {\n    while (mutation.changedSources.size) {\n      const sources = Array.from(mutation.changedSources);\n      mutation.changedSources.clear();\n      for (const source of sources) {\n        const dependents = context.stateMap.get(source)?.mounted?.readDepts;\n        if (dependents?.size) pullEvaluate(readComputed, dependents, context, mutation);\n      }\n    }\n    mutation.potentialDirtyIds.clear();\n    mutation.oldEpochs.clear();\n    if (context.pendingMutation === mutation) context.pendingMutation = undefined;\n    return true;\n  } finally {\n    mutation.flushing = false;\n  }\n}\n\nfunction setState<T>(signal$: State<T>, context: StoreContext, value: StateArg<T>) {\n  let next: T;\n  if (typeof value === 'function') {\n    const updaterState = context.stateMap.get(signal$);\n    next = (value as Updater<T>)(updaterState ? (updaterState.val as T) : signal$.init);\n  } else {\n    next = value;\n  }\n  if (shouldDistinct(signal$, next, context)) return;\n  context.writeVersion += 1;\n  // Updaters are user code and can subscribe or write before returning.\n  // Preserve the state object/mounted listeners established during that call.\n  const oldState = context.stateMap.get(signal$);\n  if (oldState) {\n    oldState.val = next;\n    oldState.epoch += 1;\n  } else {\n    context.stateMap.set(signal$, { val: next, epoch: 0 });\n  }\n  // Like Jotai changedAtoms, this records real state changes even without a\n  // listener, and is also the public set entry's flush-work checkpoint.\n  context.changedSignals.add(signal$);\n  const dependents = oldState?.mounted?.readDepts;\n  if (dependents?.size) {\n    const mutation = getPendingMutation(context);\n    mutation.changedSources.add(signal$);\n    markDirty(dependents, context, mutation);\n  }\n}\n\nexport function set<T, Args extends SetArgs<T, unknown[]>>(\n  readComputed: ReadComputed,\n  writable$: State<T> | Command<T, Args>,\n  context: StoreContext,\n  get: StoreGet,\n  flush: Flush,\n  ...args: Args\n): undefined | T {\n  if ('read' in writable$) return;\n  if (!('write' in writable$)) {\n    setState(writable$, context, args[0]);\n    return;\n  }\n  let isSync = true;\n  const visitor: { get: Getter; set: Setter } = {\n    get: <U>(signal$: Signal<U>) => get(signal$, context),\n    set: <U, Params extends SetArgs<U, unknown[]>>(\n      child: State<U> | Command<U, Params>,\n      ...innerArgs: Params\n    ): undefined | U => {\n      try {\n        return withSetInterceptor(\n          () => set<U, Params>(readComputed, child, context, get, flush, ...innerArgs),\n          child,\n          context.interceptor?.set,\n          ...innerArgs,\n        );\n      } finally {\n        // Each write invocation owns this flag. Returning a Promise (or the\n        // setter itself) ends its synchronous phase, just as in Jotai.\n        if (!isSync) flush(context);\n      }\n    },\n  };\n  try {\n    return writable$.write(visitor, ...args);\n  } finally {\n    isSync = false;\n  }\n}\n","import type { State } from '../../../types/core/signal';\nimport type { StateState, StoreContext } from '../../../types/core/store';\n\nexport function readState<T>(state: State<T>, context: StoreContext): StateState<T> {\n  const atomState = context.stateMap.get(state);\n  if (!atomState) {\n    const initState = {\n      val: state.init,\n      epoch: 0,\n    };\n    context.stateMap.set(state, initState);\n    return initState as StateState<T>;\n  }\n\n  return atomState as StateState<T>;\n}\n","import type { Computed, Signal } from '../../../types/core/signal';\nimport type {\n  ComputedState,\n  Mounted,\n  Mutation,\n  ReadSignal,\n  SignalState,\n  StoreContext,\n} from '../../../types/core/store';\nimport { isComputedState } from '../typing-util';\n\nfunction unmountComputedDependencies<T>(\n  computed$: Computed<T>,\n  computedState: ComputedState<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n) {\n  for (const [dep] of Array.from(computedState.dependencies)) {\n    context.stateMap.get(dep)?.mounted?.readDepts.delete(computed$ as Computed<unknown>);\n    unmount(dep, context, mutation);\n  }\n}\n\nfunction mountComputedDependencies<T>(\n  readSignal: ReadSignal,\n  computed$: Computed<T>,\n  computedState: ComputedState<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n) {\n  for (const [dep] of Array.from(computedState.dependencies)) {\n    const mounted = mount(readSignal, dep, context, mutation);\n    mounted.readDepts.add(computed$ as Computed<unknown>);\n  }\n}\n\nfunction initMount<T>(readSignal: ReadSignal, signal$: Signal<T>, context: StoreContext, mutation?: Mutation): Mounted {\n  context.interceptor?.mount?.(signal$);\n\n  const signalState = readSignal(signal$, context, mutation);\n\n  signalState.mounted = {\n    readDepts: new Set(),\n    listeners: new Set(),\n  };\n\n  if (isComputedState(signalState)) {\n    mountComputedDependencies(readSignal, signal$ as Computed<unknown>, signalState, context, mutation);\n  }\n\n  return signalState.mounted;\n}\n\nexport function mount<T>(\n  readSignal: ReadSignal,\n  signal$: Signal<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): Mounted {\n  const mounted = context.stateMap.get(signal$)?.mounted;\n  if (mounted) {\n    return mounted;\n  }\n\n  return initMount(readSignal, signal$, context, mutation);\n}\n\nfunction doUnmount<T>(\n  signal$: Signal<T>,\n  signalState: SignalState<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): void {\n  context.interceptor?.unmount?.(signal$);\n\n  if (isComputedState(signalState)) {\n    unmountComputedDependencies(signal$ as Computed<unknown>, signalState, context, mutation);\n  }\n\n  signalState.mounted = undefined;\n}\n\nexport function unmount<T>(signal$: Signal<T>, context: StoreContext, mutation?: Mutation): void {\n  const signalState = context.stateMap.get(signal$);\n  if (!signalState?.mounted || signalState.mounted.readDepts.size || signalState.mounted.listeners.size) {\n    return;\n  }\n\n  doUnmount(signal$, signalState, context, mutation);\n}\n","import type { Command, Getter, Setter, Signal, State, Computed } from '../../../types/core/signal';\nimport type {\n  StateMap,\n  Store,\n  StoreContext,\n  StoreOptions,\n  ComputedState,\n  Mounted,\n  Mutation,\n  ReadComputed,\n  SignalState,\n  StoreGet,\n  StoreSet,\n  SetArgs,\n  Watcher,\n  StoreWatch,\n} from '../../../types/core/store';\nimport { evaluateComputed, tryGetCached } from '../signal/computed';\nimport { withComputedInterceptor, withGetInterceptor, withSetInterceptor } from '../interceptor';\nimport { flushMutation, set as innerSet } from './set';\nimport { readState } from '../signal/state';\nimport { canReadAsCompute } from '../typing-util';\nimport { mount as innerMount, unmount } from './sub';\n\nconst readComputed: ReadComputed = <T>(\n  computed$: Computed<T>,\n  context: StoreContext,\n  mutation?: Mutation,\n): ComputedState<T> => {\n  const cachedState = tryGetCached(readComputed, computed$, context, mutation);\n  if (cachedState) {\n    return cachedState;\n  }\n\n  return withComputedInterceptor(\n    () => {\n      return evaluateComputed(readSignal, mount, unmount, computed$, context, mutation);\n    },\n    computed$,\n    context.interceptor?.computed,\n  );\n};\n\nfunction readSignal<T>(signal$: Signal<T>, context: StoreContext, mutation?: Mutation): SignalState<T> {\n  mutation = context.pendingMutation ?? mutation;\n  if (canReadAsCompute(signal$)) {\n    return readComputed(signal$, context, mutation);\n  }\n\n  return readState(signal$, context);\n}\n\nfunction mount<T>(signal$: Signal<T>, context: StoreContext, mutation?: Mutation): Mounted {\n  return innerMount(readSignal, signal$, context, mutation);\n}\n\nconst storeGet: StoreGet = (signal, context, mutation) => {\n  return withGetInterceptor(\n    () => {\n      const signalState = readSignal(signal, context, mutation);\n      if ('error' in signalState) {\n        throw signalState.error as Error;\n      }\n\n      return signalState.val;\n    },\n    signal,\n    context.interceptor?.get,\n  );\n};\n\nconst storeSet: StoreSet = <T, Args extends SetArgs<T, unknown[]>>(\n  atom: State<T> | Command<T, Args>,\n  context: StoreContext,\n  ...args: Args\n): T | undefined => {\n  return withSetInterceptor<T, Args>(\n    () => {\n      const previousChangedSize = context.changedSignals.size;\n      try {\n        return innerSet<T, Args>(readComputed, atom, context, storeGet, flushPending, ...args);\n      } finally {\n        if (context.changedSignals.size !== previousChangedSize) flushPending(context);\n      }\n    },\n    atom,\n    context.interceptor?.set,\n    ...args,\n  );\n};\n\nfunction flushPending(context: StoreContext): void {\n  if (flushMutation(readComputed, context)) flushCallbacks(context);\n}\n\nfunction flushCallbacks(context: StoreContext): void {\n  if (!context.changedSignals.size) return;\n  const errors: unknown[] = [];\n  do {\n    // changedSignals is also write-boundary bookkeeping. It may contain only\n    // unobserved sources, so do not allocate notification work until needed.\n    let callbacks: Set<() => void> | undefined;\n    for (const signal$ of context.changedSignals) {\n      const listeners = context.stateMap.get(signal$)?.mounted?.listeners;\n      if (listeners?.size) {\n        callbacks ??= new Set();\n        for (const listener of listeners) callbacks.add(listener);\n      }\n    }\n    context.changedSignals.clear();\n    if (!callbacks) continue;\n    for (const callback of callbacks) {\n      try {\n        callback();\n      } catch (error) {\n        errors.push(error);\n      }\n    }\n  } while (context.changedSignals.size);\n  if (errors.length) {\n    const AggregateErrorCtor = (\n      globalThis as typeof globalThis & {\n        AggregateError?: new (errors: unknown[]) => Error;\n      }\n    ).AggregateError;\n    if (AggregateErrorCtor) throw new AggregateErrorCtor(errors);\n    throw Object.assign(new Error(), { errors });\n  }\n}\n\nconst storeWatch: StoreWatch = (signal$, context, listener) => {\n  if (!('read' in signal$) && !('init' in signal$)) throw new TypeError('watch requires a state or computed');\n  const mounted = innerMount(readSignal, signal$, context);\n  mounted.listeners.add(listener);\n  flushPending(context);\n  let subscription:\n    | { signal: Signal<unknown>; mounted: Mounted; listener: () => void; context: StoreContext }\n    | undefined = {\n    signal: signal$,\n    mounted,\n    listener,\n    context,\n  };\n  return () => {\n    const current = subscription;\n    if (!current) return;\n    // An owner may retain its disposed cleanup function. Release the captured\n    // signal/listener so that retention cannot keep an unmounted graph alive.\n    subscription = undefined;\n    current.mounted.listeners.delete(current.listener);\n    unmount(current.signal, current.context);\n    flushPending(current.context);\n  };\n};\n\nexport class StoreImpl implements Store {\n  protected readonly stateMap: StateMap = new WeakMap();\n  protected readonly context: StoreContext;\n\n  constructor(protected readonly options?: StoreOptions) {\n    this.context = {\n      stateMap: this.stateMap,\n      interceptor: this.options?.interceptor,\n      writeVersion: 0,\n      changedSignals: new Set(),\n      pendingMutation: undefined,\n      mutationWork: undefined,\n    };\n  }\n\n  get: Getter = <T>(atom: Signal<T>): T => {\n    return storeGet(atom, this.context);\n  };\n\n  set: Setter = <T, Args extends SetArgs<T, unknown[]>>(\n    atom: State<T> | Command<T, Args>,\n    ...args: Args\n  ): undefined | T => {\n    return storeSet<T, Args>(atom, this.context, ...args);\n  };\n\n  watch: Watcher = (signal$, listener) => {\n    return storeWatch(signal$, this.context, listener);\n  };\n}\n\nexport function createStore(): Store {\n  return new StoreImpl();\n}\n","import type { ComputedState, SignalState, StoreInterceptor } from '../../types/core/store';\nimport type { DebugStore, Edge, NestedAtom } from '../../types/debug/debug-store';\nimport type { Computed, State } from '../core';\nimport { StoreImpl } from '../core/store/store';\nimport { canReadAsCompute } from '../core/typing-util';\n\nexport class DebugStoreImpl extends StoreImpl implements DebugStore {\n  getReadDependencies = (atom: State<unknown> | Computed<unknown>): NestedAtom => {\n    const atomState = this.context.stateMap.get(atom);\n    if (!atomState) {\n      return [atom];\n    }\n\n    if (!('dependencies' in atomState)) {\n      return [atom];\n    }\n\n    return [\n      atom,\n      ...Array.from(atomState.dependencies).map(([key]) => {\n        return this.getReadDependencies(key);\n      }),\n    ] as NestedAtom;\n  };\n\n  getReadDependents = (atom: State<unknown> | Computed<unknown>): NestedAtom => {\n    const atomState = this.context.stateMap.get(atom);\n    if (!atomState) {\n      return [atom];\n    }\n\n    return [\n      atom,\n      ...Array.from(atomState.mounted?.readDepts ?? []).map((key) => this.getReadDependents(key)),\n    ] as NestedAtom;\n  };\n\n  isMounted = (atom: State<unknown> | Computed<unknown>): boolean => {\n    const mountState = this.stateMap.get(atom);\n    return mountState?.mounted !== undefined;\n  };\n\n  getDependenciesGraph = (computed$: Computed<unknown>): Edge[] => {\n    const stateMap = this.context.stateMap;\n    function fillDependenciesGraph(computed$: Computed<unknown>, result: Edge[]) {\n      const computedState = stateMap.get(computed$) as ComputedState<unknown>;\n      for (const [child$, epoch] of computedState.dependencies.entries()) {\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion\n        const childState = stateMap.get(child$)! as SignalState<unknown>;\n        result.push([\n          {\n            signal: computed$,\n            val: computedState.val,\n            epoch: computedState.epoch,\n          },\n          {\n            signal: child$,\n            val: childState.val,\n            epoch: childState.epoch,\n          },\n          epoch,\n        ]);\n        if (canReadAsCompute(child$)) {\n          fillDependenciesGraph(child$, result);\n        }\n      }\n    }\n\n    const result: Edge[] = [];\n    fillDependenciesGraph(computed$, result);\n    return result;\n  };\n}\n\nexport function createDebugStoreInternal(interceptor?: StoreInterceptor): DebugStore {\n  return new DebugStoreImpl({\n    interceptor: interceptor,\n  });\n}\n","import type { SetArgs, StoreEventType, StoreInterceptor } from '../../types/core/store';\nimport type { DebugStore } from '../../types/debug/debug-store';\nimport type { Computed, Command, State } from '../core';\nimport { createDebugStoreInternal } from './debug-store';\n\nexport interface AtomWatch {\n  target: State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | string | RegExp;\n  actions?: Set<StoreEventType>;\n}\n\nexport class ConsoleInterceptor implements StoreInterceptor {\n  constructor(private readonly watches: AtomWatch[]) {}\n\n  private shouldLog = (\n    atom: State<unknown> | Computed<unknown> | Command<unknown, unknown[]>,\n    action: StoreEventType,\n  ) => {\n    return this.watches.some((watch) => {\n      let atomMatched = false;\n      if (typeof watch.target === 'string') {\n        atomMatched = atom.toString().includes(watch.target);\n      } else if (watch.target instanceof RegExp) {\n        atomMatched = watch.target.test(atom.toString());\n      } else {\n        atomMatched = watch.target === atom;\n      }\n\n      if (!atomMatched) {\n        return false;\n      }\n\n      return !watch.actions || watch.actions.has(action);\n    });\n  };\n\n  get = <T>(atom$: State<T> | Computed<T>, fn: () => T) => {\n    if (!this.shouldLog(atom$, 'get')) {\n      fn();\n      return;\n    }\n\n    console.group('[R][GET] ' + atom$.toString());\n    console.log('ret:', fn());\n    console.groupEnd();\n  };\n\n  computed = <T>(atom$: Computed<T>, fn: () => T) => {\n    if (!this.shouldLog(atom$, 'computed')) {\n      fn();\n      return;\n    }\n\n    console.group('[R][CPT] ' + atom$.toString());\n    console.log('ret:', fn());\n    console.groupEnd();\n  };\n\n  set = <T, Args extends SetArgs<T, unknown[]>>(atom$: State<T> | Command<T, Args>, fn: () => T, ...args: Args) => {\n    if (!this.shouldLog(atom$ as unknown as State<T>, 'set')) {\n      fn();\n      return;\n    }\n\n    console.group('[R][SET] ' + atom$.toString(), '(', ...args, ')');\n    console.log('ret:', fn());\n    console.groupEnd();\n  };\n\n  mount = <T>(atom$: State<T> | Computed<T>) => {\n    if (!this.shouldLog(atom$, 'mount')) {\n      return;\n    }\n\n    console.log('[R][MNT] ' + atom$.toString());\n  };\n\n  unmount = <T>(atom$: State<T> | Computed<T>) => {\n    if (!this.shouldLog(atom$, 'unmount')) {\n      return;\n    }\n\n    console.log('[R][UNM] ' + atom$.toString());\n  };\n}\n\nexport function createDebugStore(\n  watches: (AtomWatch | string | RegExp | State<unknown> | Computed<unknown> | Command<unknown, unknown[]>)[] = [],\n  defaultActions?: StoreEventType[],\n): DebugStore {\n  const parsedDefaultActions = defaultActions ? new Set(defaultActions) : undefined;\n\n  const parsedWatches = watches.map((watch): AtomWatch => {\n    if (typeof watch === 'string' || watch instanceof RegExp) {\n      return { target: watch, actions: parsedDefaultActions };\n    }\n\n    if ('target' in watch) {\n      return watch;\n    }\n\n    return { target: watch, actions: parsedDefaultActions };\n  });\n\n  const interceptor = new ConsoleInterceptor(parsedWatches);\n  return createDebugStoreInternal(interceptor);\n}\n"],"names":["withSetInterceptor","fn","writable$","interceptor","result","called","wrappedFn","data","_len","arguments","length","args","Array","_key","apply","concat","Error","withGetInterceptor","signal","withComputedInterceptor","val","withGeValInterceptor","canReadAsCompute","atom","isComputedState","state","shouldDistinct","value","context","signalState","stateMap","get","shouldDistinctError","error","checkEpoch","readComputed","computedState","mutation","_iterator","_createForOfIteratorHelper","dependencies","entries","_step","s","n","done","_context$stateMap$get","_step$value","_slicedToArray","dep","epoch","depEpoch","err","e","f","tryGetCached","computed$","_ref","_context$pendingMutat","undefined","writeVersion","mayDirty","pendingMutation","potentialDirtyIds","has","id","mounted","verifiedAt","wrapGet","readSignal","mount","callerComputed$","callerState","readDeps","Map","dep$","depState","set","callerMounted","readDepts","add","getOrInitComputedState","cleanupMissingDependencies","unmount","lastDeps","currDeps","_iterator2","keys","_step2","key","_depState$mounted","evaluateComputed","_computed$$debugLabel","previousEpoch","wasDirty","_wrapGet","_wrapGet2","_get","previousController","abortController","abort","debugLabel","controller","read","depAtom","_context$interceptor","AbortController","_computed$$debugLabel2","changedSignals","markDirty","dependents","queue","from","next","_computedState$mounte","_computedState$mounte2","oldEpochs","push","pullEvaluate","visited","Set","_iterator3","_step3","_current$mounted$read","_current$mounted","current","_iterator4","_step4","getPendingMutation","_context$mutationWork","mutationWork","changedSources","flushing","flushMutation","size","sources","clear","_i","_sources","source","setState","signal$","_oldState$mounted","updaterState","init","oldState","flush","isSync","visitor","child","_len2","innerArgs","_key2","write","readState","atomState","initState","unmountComputedDependencies","_Array$from","_Array$from$_i","mountComputedDependencies","_i2","_Array$from2","_Array$from2$_i","initMount","_context$interceptor$","call","listeners","_context$stateMap$get2","doUnmount","_context$interceptor2","_context$interceptor3","cachedState","computed","innerMount","storeGet","storeSet","previousChangedSize","innerSet","flushPending","flushCallbacks","errors","callbacks","_callbacks","listener","callback","AggregateErrorCtor","globalThis","AggregateError","Object","assign","storeWatch","TypeError","subscription","StoreImpl","_createClass","options","_this","_this$options","_classCallCheck","_defineProperty","WeakMap","DebugStoreImpl","_StoreImpl","_callSuper","_toConsumableArray","map","_ref2","getReadDependencies","_atomState$mounted$re","_atomState$mounted","getReadDependents","mountState","fillDependenciesGraph","child$","childState","_inherits","createDebugStoreInternal","ConsoleInterceptor","watches","action","some","watch","atomMatched","target","toString","includes","RegExp","test","actions","atom$","shouldLog","console","group","log","groupEnd","_console","createDebugStore","defaultActions","parsedDefaultActions","parsedWatches"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBO,SAASA,kBAAkBA,CAChCC,EAAuB,EACvBC,SAAsC,EACtCC,WAAuC,EAExB;EACf,IAAI,CAACA,WAAW,EAAE;IAChB,OAAOF,EAAE,EAAE;AACb;AAEA,EAAA,IAAIG,MAAM,GAAG;AAAEC,IAAAA,MAAM,EAAE;GAA6C;AACpE,EAAA,IAAMC,SAAS,GAAG,SAAZA,SAASA,GAAS;AACtBF,IAAAA,MAAM,GAAG;AAAEC,MAAAA,MAAM,EAAE,IAAI;MAAEE,IAAI,EAAEN,EAAE;KAAI;IACrC,OAAOG,MAAM,CAACG,IAAI;GACnB;EAAC,KAAAC,IAAAA,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAVCC,IAAI,OAAAC,KAAA,CAAAJ,IAAA,GAAAA,CAAAA,GAAAA,IAAA,WAAAK,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA,EAAA,EAAA;AAAJF,IAAAA,IAAI,CAAAE,IAAA,GAAAJ,CAAAA,CAAAA,GAAAA,SAAA,CAAAI,IAAA,CAAA;AAAA;EAWP,IAAI,OAAO,IAAIX,SAAS,EAAE;IACxBC,WAAW,CAAAW,KAAA,CAAA,KAAA,CAAA,EAAA,CAACZ,SAAS,EAAEI,SAAS,CAAAS,CAAAA,MAAA,CAAKJ,IAAI,CAAC,CAAA;AAC5C,GAAC,MAAM;IACLR,WAAW,CAACD,SAAS,EAAEI,SAAS,EAAEK,IAAI,CAAC,CAAC,CAAC,CAAC;AAC5C;AAEA,EAAA,IAAI,CAACP,MAAM,CAACC,MAAM,EAAE;AAClB,IAAA,MAAM,IAAIW,KAAK,CAAC,+BAA+B,CAAC;AAClD;EAEA,OAAOZ,MAAM,CAACG,IAAI;AACpB;AAEO,SAASU,kBAAkBA,CAAIhB,EAAW,EAAEiB,MAAiB,EAAEf,WAA4B,EAAK;EACrG,IAAI,CAACA,WAAW,EAAE;IAChB,OAAOF,EAAE,EAAE;AACb;AAEA,EAAA,IAAIG,MAAM,GAAG;AAAEC,IAAAA,MAAM,EAAE;GAAiC;EAExDF,WAAW,CAACe,MAAM,EAAE,YAAM;AACxBd,IAAAA,MAAM,GAAG;AAAEC,MAAAA,MAAM,EAAE,IAAI;MAAEE,IAAI,EAAEN,EAAE;KAAI;IACrC,OAAOG,MAAM,CAACG,IAAI;AACpB,GAAC,CAAC;AAEF,EAAA,IAAI,CAACH,MAAM,CAACC,MAAM,EAAE;AAClB,IAAA,MAAM,IAAIW,KAAK,CAAC,+BAA+B,CAAC;AAClD;EAEA,OAAOZ,MAAM,CAACG,IAAI;AACpB;AAEO,SAASY,uBAAuBA,CACrClB,EAA0B,EAC1BiB,MAAmB,EACnBf,WAAiC,EACf;EAClB,IAAI,CAACA,WAAW,EAAE;IAChB,OAAOF,EAAE,EAAE;AACb;AAEA,EAAA,IAAIG,MAAM,GAAG;AAAEC,IAAAA,MAAM,EAAE;GAAgD;EAEvEF,WAAW,CAACe,MAAM,EAAE,YAAM;AACxBd,IAAAA,MAAM,GAAG;AAAEC,MAAAA,MAAM,EAAE,IAAI;MAAEE,IAAI,EAAEN,EAAE;KAAI;AACrC,IAAA,OAAOG,MAAM,CAACG,IAAI,CAACa,GAAG;AACxB,GAAC,CAAC;AAEF,EAAA,IAAI,CAAChB,MAAM,CAACC,MAAM,EAAE;AAClB,IAAA,MAAM,IAAIW,KAAK,CAAC,+BAA+B,CAAC;AAClD;EAEA,OAAOZ,MAAM,CAACG,IAAI;AACpB;AAEO,SAASc,oBAAoBA,CAAIpB,EAAW,EAAEiB,MAAiB,EAAEf,WAA4B,EAAK;EACvG,IAAI,CAACA,WAAW,EAAE;IAChB,OAAOF,EAAE,EAAE;AACb;AAEA,EAAA,IAAIG,MAAM,GAAG;AAAEC,IAAAA,MAAM,EAAE;GAAiC;EAExDF,WAAW,CAACe,MAAM,EAAE,YAAM;AACxBd,IAAAA,MAAM,GAAG;AAAEC,MAAAA,MAAM,EAAE,IAAI;MAAEE,IAAI,EAAEN,EAAE;KAAI;IACrC,OAAOG,MAAM,CAACG,IAAI;AACpB,GAAC,CAAC;AAEF,EAAA,IAAI,CAACH,MAAM,CAACC,MAAM,EAAE;AAClB,IAAA,MAAM,IAAIW,KAAK,CAAC,+BAA+B,CAAC;AAClD;EAEA,OAAOZ,MAAM,CAACG,IAAI;AACpB;;ACtGO,SAASe,gBAAgBA,CAAIC,IAAe,EAAuB;EACxE,OAAO,MAAM,IAAIA,IAAI;AACvB;AAEO,SAASC,eAAeA,CAAIC,KAAqB,EAA6B;EACnF,OAAO,cAAc,IAAIA,KAAK;AAChC;;ACNO,SAASC,cAAcA,CAAIR,MAAiB,EAAES,KAAQ,EAAEC,OAAqB,EAAE;EACpF,IAAMC,WAAW,GAAGD,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACb,MAAM,CAAC;AAChD,EAAA,OAAO,CAAC,CAACW,WAAW,IAAI,KAAK,IAAIA,WAAW,IAAI,EAAE,OAAO,IAAIA,WAAW,CAAC,IAAIA,WAAW,CAACT,GAAG,KAAKO,KAAK;AACxG;AAEO,SAASK,mBAAmBA,CAACd,MAAyB,EAAEe,KAAc,EAAEL,OAAqB,EAAE;EACpG,IAAMC,WAAW,GAAGD,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACb,MAAM,CAAC;AAChD,EAAA,OAAO,CAAC,CAACW,WAAW,IAAI,OAAO,IAAIA,WAAW,IAAIA,WAAW,CAACI,KAAK,KAAKA,KAAK;AAC/E;;ACGA,SAASC,UAAUA,CACjBC,YAA0B,EAC1BC,aAA+B,EAC/BR,OAAqB,EACrBS,QAAmB,EACV;EAAA,IAAAC,SAAA,GAAAC,0BAAA,CACkBH,aAAa,CAACI,YAAY,CAACC,OAAO,EAAE,CAAA;IAAAC,KAAA;AAAA,EAAA,IAAA;IAA/D,KAAAJ,SAAA,CAAAK,CAAA,EAAAD,EAAAA,CAAAA,CAAAA,KAAA,GAAAJ,SAAA,CAAAM,CAAA,EAAAC,EAAAA,IAAA,GAAiE;AAAA,MAAA,IAAAC,qBAAA;AAAA,MAAA,IAAAC,WAAA,GAAAC,cAAA,CAAAN,KAAA,CAAAf,KAAA,EAAA,CAAA,CAAA;AAArDsB,QAAAA,GAAG,GAAAF,WAAA,CAAA,CAAA,CAAA;AAAEG,QAAAA,KAAK,GAAAH,WAAA,CAAA,CAAA,CAAA;AACpB,MAAA,IAAMI,QAAQ,GAAG7B,gBAAgB,CAAC2B,GAAG,CAAC,GAClCd,YAAY,CAACc,GAAG,EAAErB,OAAO,EAAES,QAAQ,CAAC,CAACa,KAAK,GAAA,CAAAJ,qBAAA,GAC1ClB,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACkB,GAAG,CAAC,MAAAH,IAAAA,IAAAA,qBAAA,KAAzBA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,qBAAA,CAA2BI,KAAK;MAEpC,IAAIC,QAAQ,KAAKD,KAAK,EAAE;AACtB,QAAA,OAAO,KAAK;AACd;AACF;AAAC,GAAA,CAAA,OAAAE,GAAA,EAAA;IAAAd,SAAA,CAAAe,CAAA,CAAAD,GAAA,CAAA;AAAA,GAAA,SAAA;AAAAd,IAAAA,SAAA,CAAAgB,CAAA,EAAA;AAAA;AAED,EAAA,OAAO,IAAI;AACb;AAEO,SAASC,YAAYA,CAC1BpB,YAA0B,EAC1BqB,SAAsB,EACtB5B,OAAqB,EACrBS,QAAmB,EACW;EAAA,IAAAoB,IAAA,EAAAC,qBAAA;EAC9B,IAAM7B,WAAW,GAAGD,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACyB,SAAS,CAAiC;EACnF,IAAI,CAAC3B,WAAW,EAAE;AAChB,IAAA,OAAO8B,SAAS;AAClB;;AAEA;AACA;AACA;AACA;AACA,EAAA,IAAMC,YAAY,GAAGhC,OAAO,CAACgC,YAAY;EACzC,IAAMC,QAAQ,GAAAJ,CAAAA,IAAA,GAAAC,CAAAA,qBAAA,GAAI9B,OAAO,CAACkC,eAAe,MAAAJ,IAAAA,IAAAA,qBAAA,KAAAA,KAAAA,CAAAA,GAAAA,qBAAA,GAAIrB,QAAQ,MAAAoB,IAAAA,IAAAA,IAAA,KAApCA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,IAAA,CAAuCM,iBAAiB,CAACC,GAAG,CAACR,SAAS,CAACS,EAAE,CAAC;AAC3F,EAAA,IAAI,CAACJ,QAAQ,KAAKhC,WAAW,CAACqC,OAAO,IAAIrC,WAAW,CAACsC,UAAU,KAAKP,YAAY,CAAC,EAAE;AACjF,IAAA,OAAO/B,WAAW;AACpB;EAEA,IAAIK,UAAU,CAACC,YAAY,EAAEN,WAAW,EAAED,OAAO,EAAES,QAAQ,CAAC,EAAE;IAC5DR,WAAW,CAACsC,UAAU,GAAGP,YAAY;AACrC,IAAA,IAAIC,QAAQ,EAAE;MACZxB,QAAQ,KAAA,IAAA,IAARA,QAAQ,KAAA,KAAA,CAAA,IAARA,QAAQ,CAAE0B,iBAAiB,CAAA,QAAA,CAAO,CAACP,SAAS,CAACS,EAAE,CAAC;AAClD;AACA,IAAA,OAAOpC,WAAW;AACpB;AAEA,EAAA,OAAO8B,SAAS;AAClB;AAEA,SAASS,OAAOA,CACdC,UAAsB,EACtBC,KAAY,EACZC,eAA4B,EAC5BC,WAA6B,EAC7B5C,OAAqB,EACrBS,QAAmB,EACqB;AACxC,EAAA,IAAMoC,QAAQ,GAAG,IAAIC,GAAG,EAA2B;EAEnD,OAAO,CACL,UAACC,IAAI,EAAK;IACR,IAAMC,QAAQ,GAAGP,UAAU,CAACM,IAAI,EAAE/C,OAAO,EAAES,QAAQ,CAAC;AAEpD,IAAA,IAAImC,WAAW,CAAChC,YAAY,KAAKiC,QAAQ,EAAE;MACzCA,QAAQ,CAACI,GAAG,CAACF,IAAI,EAAEC,QAAQ,CAAC1B,KAAK,CAAC;AAElC,MAAA,IAAM4B,aAAa,GAAG,CAAC,CAACN,WAAW,CAACN,OAAO;AAC3C,MAAA,IAAIY,aAAa,IAAI,CAACF,QAAQ,CAACV,OAAO,EAAE;AACtCI,QAAAA,KAAK,CAACK,IAAI,EAAE/C,OAAO,EAAES,QAAQ,CAAC,CAAC0C,SAAS,CAACC,GAAG,CAACT,eAAe,CAAC;AAC/D,OAAC,MAAM,IAAIO,aAAa,IAAIF,QAAQ,CAACV,OAAO,EAAE;QAC5CU,QAAQ,CAACV,OAAO,CAACa,SAAS,CAACC,GAAG,CAACT,eAAe,CAAC;AACjD;AACF;IAEA,IAAI,OAAO,IAAIK,QAAQ,EAAE;MACvB,MAAMA,QAAQ,CAAC3C,KAAK;AACtB;IAEA,OAAO2C,QAAQ,CAACxD,GAAG;GACpB,EACDqD,QAAQ,CACT;AACH;AAEA,SAASQ,sBAAsBA,CAAIzB,SAAsB,EAAE5B,OAAqB,EAAoB;EAClG,IAAIQ,aAA2C,GAAGR,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACyB,SAAS,CAAiC;EACjH,IAAI,CAACpB,aAAa,EAAE;AAClBA,IAAAA,aAAa,GAAG;AACdI,MAAAA,YAAY,EAAE,IAAIkC,GAAG,EAA2B;AAChDxB,MAAAA,KAAK,EAAE,CAAC;KACW;IACrBtB,OAAO,CAACE,QAAQ,CAAC+C,GAAG,CAACrB,SAAS,EAAEpB,aAAa,CAAC;AAChD;AAEA,EAAA,OAAOA,aAAa;AACtB;AAEA,SAAS8C,0BAA0BA,CACjCC,OAAgB,EAChB3B,SAAsB,EACtB4B,QAAsC,EACtCC,QAAsC,EACtCzD,OAAqB,EACrBS,QAAmB,EACnB;EAAA,IAAAiD,UAAA,GAAA/C,0BAAA,CACkB6C,QAAQ,CAACG,IAAI,EAAE,CAAA;IAAAC,MAAA;AAAA,EAAA,IAAA;IAAjC,KAAAF,UAAA,CAAA3C,CAAA,EAAA6C,EAAAA,CAAAA,CAAAA,MAAA,GAAAF,UAAA,CAAA1C,CAAA,EAAAC,EAAAA,IAAA,GAAmC;AAAA,MAAA,IAAxB4C,GAAG,GAAAD,MAAA,CAAA7D,KAAA;AACZ,MAAA,IAAI,CAAC0D,QAAQ,CAACrB,GAAG,CAACyB,GAAG,CAAC,EAAE;AAAA,QAAA,IAAAC,iBAAA;QACtB,IAAMd,QAAQ,GAAGhD,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC0D,GAAG,CAAC;AAC1Cb,QAAAA,QAAQ,aAARA,QAAQ,KAAA,KAAA,CAAA,IAAA,CAAAc,iBAAA,GAARd,QAAQ,CAAEV,OAAO,MAAAwB,IAAAA,IAAAA,iBAAA,eAAjBA,iBAAA,CAAmBX,SAAS,CAAO,QAAA,CAAA,CAACvB,SAAS,CAAC;AAC9C2B,QAAAA,OAAO,CAACM,GAAG,EAAE7D,OAAO,EAAES,QAAQ,CAAC;AACjC;AACF;AAAC,GAAA,CAAA,OAAAe,GAAA,EAAA;IAAAkC,UAAA,CAAAjC,CAAA,CAAAD,GAAA,CAAA;AAAA,GAAA,SAAA;AAAAkC,IAAAA,UAAA,CAAAhC,CAAA,EAAA;AAAA;AACH;AAUO,SAASqC,gBAAgBA,CAC9BtB,UAAsB,EACtBC,KAAY,EACZa,OAAgB,EAChB3B,SAAsB,EACtB5B,OAAqB,EACrBS,QAAmB,EACD;AAAA,EAAA,IAAAuD,qBAAA;AAClB,EAAA,IAAMhC,YAAY,GAAGhC,OAAO,CAACgC,YAAY;AACzC,EAAA,IAAMxB,aAAa,GAAG6C,sBAAsB,CAACzB,SAAS,EAAE5B,OAAO,CAAC;AAChE,EAAA,IAAMiE,aAAa,GAAGzD,aAAa,CAACc,KAAK;AACzC,EAAA,IAAM4C,QAAQ,GAAGzD,QAAQ,KAAA,IAAA,IAARA,QAAQ,KAARA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,QAAQ,CAAE0B,iBAAiB,CAACC,GAAG,CAACR,SAAS,CAACS,EAAE,CAAC;AAE9D,EAAA,IAAMmB,QAAQ,GAAGhD,aAAa,CAACI,YAAY;AAE3C,EAAA,IAAAuD,QAAA,GAA6B3B,OAAO,CAACC,UAAU,EAAEC,KAAK,EAAEd,SAAS,EAAEpB,aAAa,EAAER,OAAO,EAAES,QAAQ,CAAC;IAAA2D,SAAA,GAAAhD,cAAA,CAAA+C,QAAA,EAAA,CAAA,CAAA;AAA7FE,IAAAA,IAAI,GAAAD,SAAA,CAAA,CAAA,CAAA;AAAExD,IAAAA,YAAY,GAAAwD,SAAA,CAAA,CAAA,CAAA;EACzB5D,aAAa,CAACI,YAAY,GAAGA,YAAY;AAEzC,EAAA,IAAM0D,kBAAkB,GAAG9D,aAAa,CAAC+D,eAAe;EACxD,OAAO/D,aAAa,CAAC+D,eAAe;EACpCD,kBAAkB,KAAA,IAAA,IAAlBA,kBAAkB,KAAlBA,KAAAA,CAAAA,IAAAA,kBAAkB,CAAEE,KAAK,CAAA,QAAA,CAAArF,MAAA,CAAA6E,CAAAA,qBAAA,GAAUpC,SAAS,CAAC6C,UAAU,MAAAT,IAAAA,IAAAA,qBAAA,cAAAA,qBAAA,GAAI,WAAW,EAAA,OAAA,CAAO,CAAC;AAC9E,EAAA,IAAIU,UAAuC;AAE3C,EAAA,IAAIlG,MAAyB;EAC7B,IAAI;AACFA,IAAAA,MAAM,GAAG;AACPuB,MAAAA,KAAK,EAAE6B,SAAS,CAAC+C,IAAI,CACnB,UAAaC,OAAkB,EAAE;AAAA,QAAA,IAAAC,oBAAA;AAC/B,QAAA,OAAOpF,oBAAoB,CAAC,YAAA;UAAA,OAAM4E,IAAI,CAACO,OAAO,CAAC;AAAA,SAAA,EAAEA,OAAO,EAAA,CAAAC,oBAAA,GAAE7E,OAAO,CAACzB,WAAW,MAAA,IAAA,IAAAsG,oBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAnBA,oBAAA,CAAqB1E,GAAG,CAAC;AACrF,OAAC,EACD;QACE,IAAIb,MAAMA,GAAG;UACX,IAAI,CAACoF,UAAU,EAAE;AACfA,YAAAA,UAAU,GAAG,IAAII,eAAe,EAAE;AAClC;AACA;AACA,YAAA,IAAItE,aAAa,CAACI,YAAY,KAAKA,YAAY,EAAE;cAC/CJ,aAAa,CAAC+D,eAAe,GAAGG,UAAU;AAC5C,aAAC,MAAM;AAAA,cAAA,IAAAK,sBAAA;AACLL,cAAAA,UAAU,CAACF,KAAK,CAAA,QAAA,CAAArF,MAAA,CAAA,CAAA4F,sBAAA,GAAUnD,SAAS,CAAC6C,UAAU,cAAAM,sBAAA,KAAA,KAAA,CAAA,GAAAA,sBAAA,GAAI,WAAW,UAAO,CAAC;AACvE;AACF;UACA,OAAOL,UAAU,CAACpF,MAAM;AAC1B;OAEJ;KACD;GACF,CAAC,OAAOe,KAAK,EAAE;AACd7B,IAAAA,MAAM,GAAG;AACP6B,MAAAA,KAAK,EAALA;KACD;AACH;EAEAI,QAAQ,KAAA,IAAA,IAARA,QAAQ,KAAA,KAAA,CAAA,IAARA,QAAQ,CAAE0B,iBAAiB,CAAA,QAAA,CAAO,CAACP,SAAS,CAACS,EAAE,CAAC;AAEhDiB,EAAAA,0BAA0B,CAACC,OAAO,EAAE3B,SAAS,EAAE4B,QAAQ,EAAE5C,YAAY,EAAEZ,OAAO,EAAES,QAAQ,CAAC;EAEzF,IAAI,OAAO,IAAIjC,MAAM,EAAE;IACrB,IAAI,CAAC4B,mBAAmB,CAACwB,SAAS,EAAEpD,MAAM,CAAC6B,KAAK,EAAEL,OAAO,CAAC,EAAE;AAC1DQ,MAAAA,aAAa,CAACH,KAAK,GAAG7B,MAAM,CAAC6B,KAAK;MAClC,OAAOG,aAAa,CAAChB,GAAG;MACxBgB,aAAa,CAACc,KAAK,IAAI,CAAC;AAC1B;AACF,GAAC,MAAM,IAAI,CAACxB,cAAc,CAAC8B,SAAS,EAAEpD,MAAM,CAACuB,KAAK,EAAEC,OAAO,CAAC,EAAE;AAC5DQ,IAAAA,aAAa,CAAChB,GAAG,GAAGhB,MAAM,CAACuB,KAAK;IAChC,OAAOS,aAAa,CAACH,KAAK;IAC1BG,aAAa,CAACc,KAAK,IAAI,CAAC;AAC1B;AAEA,EAAA,IAAI4C,QAAQ,IAAI1D,aAAa,CAACc,KAAK,KAAK2C,aAAa,EAAEjE,OAAO,CAACgF,cAAc,CAAC5B,GAAG,CAACxB,SAAS,CAAC;EAC5FpB,aAAa,CAAC+B,UAAU,GAAGP,YAAY;AACvC,EAAA,OAAOxB,aAAa;AACtB;;AC3MA;AACA;AACA,SAASyE,SAASA,CAACC,UAAkC,EAAElF,OAAqB,EAAES,QAAkB,EAAE;AAChG,EAAA,IAAI0E,KAAK,GAAGnG,KAAK,CAACoG,IAAI,CAACF,UAAU,CAAC;EAClC,OAAOC,KAAK,CAACrG,MAAM,EAAE;IACnB,IAAMuG,IAAyB,GAAG,EAAE;AAAC,IAAA,IAAA3E,SAAA,GAAAC,0BAAA,CACbwE,KAAK,CAAA;MAAArE,KAAA;AAAA,IAAA,IAAA;MAA7B,KAAAJ,SAAA,CAAAK,CAAA,EAAAD,EAAAA,CAAAA,CAAAA,KAAA,GAAAJ,SAAA,CAAAM,CAAA,EAAAC,EAAAA,IAAA,GAA+B;QAAA,IAAAqE,qBAAA,EAAAC,sBAAA;AAAA,QAAA,IAApB3D,SAAS,GAAAd,KAAA,CAAAf,KAAA;AAClB;AACA;QACA,IAAIU,QAAQ,CAAC0B,iBAAiB,CAACC,GAAG,CAACR,SAAS,CAACS,EAAE,CAAC,EAAE;QAClD,IAAM7B,aAAa,GAAGR,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACyB,SAAS,CAAC;QACrD,IAAI,CAACnB,QAAQ,CAAC+E,SAAS,CAACpD,GAAG,CAACR,SAAS,CAAC,EAAEnB,QAAQ,CAAC+E,SAAS,CAACvC,GAAG,CAACrB,SAAS,EAAEpB,aAAa,KAAbA,IAAAA,IAAAA,aAAa,KAAbA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,aAAa,CAAEc,KAAK,CAAC;QAC/Fb,QAAQ,CAAC0B,iBAAiB,CAACiB,GAAG,CAACxB,SAAS,CAACS,EAAE,CAAC;QAAC,IAAAqB,UAAA,GAAA/C,0BAAA,CAAA2E,CAAAA,qBAAA,GAC3B9E,aAAa,KAAbA,IAAAA,IAAAA,aAAa,KAAA+E,KAAAA,CAAAA,IAAAA,CAAAA,sBAAA,GAAb/E,aAAa,CAAE8B,OAAO,MAAA,IAAA,IAAAiD,sBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAtBA,sBAAA,CAAwBpC,SAAS,MAAA,IAAA,IAAAmC,qBAAA,KAAA,KAAA,CAAA,GAAAA,qBAAA,GAAI,EAAE,CAAA;UAAA1B,MAAA;AAAA,QAAA,IAAA;UAAzD,KAAAF,UAAA,CAAA3C,CAAA,EAAA6C,EAAAA,CAAAA,CAAAA,MAAA,GAAAF,UAAA,CAAA1C,CAAA,EAAAC,EAAAA,IAAA,GAA2D;AAAA,YAAA,IAAhDI,GAAG,GAAAuC,MAAA,CAAA7D,KAAA;AAA6CsF,YAAAA,IAAI,CAACI,IAAI,CAACpE,GAAG,CAAC;AAAA;AAAC,SAAA,CAAA,OAAAG,GAAA,EAAA;UAAAkC,UAAA,CAAAjC,CAAA,CAAAD,GAAA,CAAA;AAAA,SAAA,SAAA;AAAAkC,UAAAA,UAAA,CAAAhC,CAAA,EAAA;AAAA;AAC5E;AAAC,KAAA,CAAA,OAAAF,GAAA,EAAA;MAAAd,SAAA,CAAAe,CAAA,CAAAD,GAAA,CAAA;AAAA,KAAA,SAAA;AAAAd,MAAAA,SAAA,CAAAgB,CAAA,EAAA;AAAA;AACDyD,IAAAA,KAAK,GAAGE,IAAI;AACd;AACF;AAEA,SAASK,YAAYA,CACnBnF,YAA0B,EAC1B2E,UAAkC,EAClClF,OAAqB,EACrBS,QAAkB,EAClB;AACA,EAAA,IAAI0E,KAAK,GAAGnG,KAAK,CAACoG,IAAI,CAACF,UAAU,CAAC;AAClC,EAAA,IAAMS,OAAO,GAAG,IAAIC,GAAG,EAAqB;EAC5C,OAAOT,KAAK,CAACrG,MAAM,EAAE;IACnB,IAAMuG,IAAyB,GAAG,EAAE;AAAC,IAAA,IAAAQ,UAAA,GAAAlF,0BAAA,CACbwE,KAAK,CAAA;MAAAW,MAAA;AAAA,IAAA,IAAA;MAA7B,KAAAD,UAAA,CAAA9E,CAAA,EAAA+E,EAAAA,CAAAA,CAAAA,MAAA,GAAAD,UAAA,CAAA7E,CAAA,EAAAC,EAAAA,IAAA,GAA+B;QAAA,IAAA8E,qBAAA,EAAAC,gBAAA;AAAA,QAAA,IAApBpE,SAAS,GAAAkE,MAAA,CAAA/F,KAAA;AAClB,QAAA,IAAI4F,OAAO,CAACvD,GAAG,CAACR,SAAS,CAAC,EAAE;AAC5B+D,QAAAA,OAAO,CAACvC,GAAG,CAACxB,SAAS,CAAC;QACtB,IAAMqE,OAAO,GAAG1F,YAAY,CAACqB,SAAS,EAAE5B,OAAO,EAAES,QAAQ,CAAC;AAC1D;AACA;QACA,IAAI,CAACA,QAAQ,CAAC+E,SAAS,CAACpD,GAAG,CAACR,SAAS,CAAC,IAAInB,QAAQ,CAAC+E,SAAS,CAACrF,GAAG,CAACyB,SAAS,CAAC,KAAKqE,OAAO,CAAC3E,KAAK,EAAE;AAC/FtB,QAAAA,OAAO,CAACgF,cAAc,CAAC5B,GAAG,CAACxB,SAAS,CAAC;QAAC,IAAAsE,UAAA,GAAAvF,0BAAA,CAAA,CAAAoF,qBAAA,GAAAC,CAAAA,gBAAA,GACpBC,OAAO,CAAC3D,OAAO,cAAA0D,gBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAfA,gBAAA,CAAiB7C,SAAS,cAAA4C,qBAAA,KAAA,KAAA,CAAA,GAAAA,qBAAA,GAAI,EAAE,CAAA;UAAAI,MAAA;AAAA,QAAA,IAAA;UAAlD,KAAAD,UAAA,CAAAnF,CAAA,EAAAoF,EAAAA,CAAAA,CAAAA,MAAA,GAAAD,UAAA,CAAAlF,CAAA,EAAAC,EAAAA,IAAA,GAAoD;AAAA,YAAA,IAAzCI,GAAG,GAAA8E,MAAA,CAAApG,KAAA;AAAsCsF,YAAAA,IAAI,CAACI,IAAI,CAACpE,GAAG,CAAC;AAAA;AAAC,SAAA,CAAA,OAAAG,GAAA,EAAA;UAAA0E,UAAA,CAAAzE,CAAA,CAAAD,GAAA,CAAA;AAAA,SAAA,SAAA;AAAA0E,UAAAA,UAAA,CAAAxE,CAAA,EAAA;AAAA;AACrE;AAAC,KAAA,CAAA,OAAAF,GAAA,EAAA;MAAAqE,UAAA,CAAApE,CAAA,CAAAD,GAAA,CAAA;AAAA,KAAA,SAAA;AAAAqE,MAAAA,UAAA,CAAAnE,CAAA,EAAA;AAAA;AACDyD,IAAAA,KAAK,GAAGE,IAAI;AACd;AACF;AAEA,SAASe,kBAAkBA,CAACpG,OAAqB,EAAY;EAAA,IAAA8B,qBAAA,EAAAuE,qBAAA;AAC3D;AACA;EACA,OAAAvE,CAAAA,qBAAA,GAAQ9B,OAAO,CAACkC,eAAe,MAAAJ,IAAAA,IAAAA,qBAAA,KAAAA,KAAAA,CAAAA,GAAAA,qBAAA,GAAvB9B,OAAO,CAACkC,eAAe,GAAAmE,CAAAA,qBAAA,GAAKrG,OAAO,CAACsG,YAAY,MAAAD,IAAAA,IAAAA,qBAAA,KAAAA,KAAAA,CAAAA,GAAAA,qBAAA,GAApBrG,OAAO,CAACsG,YAAY,GACtD;AACEnE,IAAAA,iBAAiB,EAAE,IAAIyD,GAAG,EAAE;AAC5BJ,IAAAA,SAAS,EAAE,IAAI1C,GAAG,EAAE;AACpByD,IAAAA,cAAc,EAAE,IAAIX,GAAG,EAAE;AACzBY,IAAAA,QAAQ,EAAE;GACX;AACL;AAEO,SAASC,aAAaA,CAAClG,YAA0B,EAAEP,OAAqB,EAAW;AACxF,EAAA,IAAMS,QAAQ,GAAGT,OAAO,CAACkC,eAAe;AACxC,EAAA,IAAI,CAACzB,QAAQ,EAAE,OAAO,IAAI;AAC1B;AACA;AACA,EAAA,IAAIA,QAAQ,CAAC+F,QAAQ,EAAE,OAAO,KAAK;EACnC/F,QAAQ,CAAC+F,QAAQ,GAAG,IAAI;EACxB,IAAI;AACF,IAAA,OAAO/F,QAAQ,CAAC8F,cAAc,CAACG,IAAI,EAAE;MACnC,IAAMC,OAAO,GAAG3H,KAAK,CAACoG,IAAI,CAAC3E,QAAQ,CAAC8F,cAAc,CAAC;AACnD9F,MAAAA,QAAQ,CAAC8F,cAAc,CAACK,KAAK,EAAE;AAC/B,MAAA,KAAA,IAAAC,EAAA,GAAA,CAAA,EAAAC,QAAA,GAAqBH,OAAO,EAAAE,EAAA,GAAAC,QAAA,CAAAhI,MAAA,EAAA+H,EAAA,EAAE,EAAA;AAAA,QAAA,IAAA3F,qBAAA;AAAzB,QAAA,IAAM6F,MAAM,GAAAD,QAAA,CAAAD,EAAA,CAAA;QACf,IAAM3B,UAAU,GAAAhE,CAAAA,qBAAA,GAAGlB,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC4G,MAAM,CAAC,cAAA7F,qBAAA,KAAA,KAAA,CAAA,IAAA,CAAAA,qBAAA,GAA5BA,qBAAA,CAA8BoB,OAAO,MAAA,IAAA,IAAApB,qBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAArCA,qBAAA,CAAuCiC,SAAS;AACnE,QAAA,IAAI+B,UAAU,KAAVA,IAAAA,IAAAA,UAAU,KAAVA,KAAAA,CAAAA,IAAAA,UAAU,CAAEwB,IAAI,EAAEhB,YAAY,CAACnF,YAAY,EAAE2E,UAAU,EAAElF,OAAO,EAAES,QAAQ,CAAC;AACjF;AACF;AACAA,IAAAA,QAAQ,CAAC0B,iBAAiB,CAACyE,KAAK,EAAE;AAClCnG,IAAAA,QAAQ,CAAC+E,SAAS,CAACoB,KAAK,EAAE;IAC1B,IAAI5G,OAAO,CAACkC,eAAe,KAAKzB,QAAQ,EAAET,OAAO,CAACkC,eAAe,GAAGH,SAAS;AAC7E,IAAA,OAAO,IAAI;AACb,GAAC,SAAS;IACRtB,QAAQ,CAAC+F,QAAQ,GAAG,KAAK;AAC3B;AACF;AAEA,SAASQ,QAAQA,CAAIC,OAAiB,EAAEjH,OAAqB,EAAED,KAAkB,EAAE;AAAA,EAAA,IAAAmH,iBAAA;AACjF,EAAA,IAAI7B,IAAO;AACX,EAAA,IAAI,OAAOtF,KAAK,KAAK,UAAU,EAAE;IAC/B,IAAMoH,YAAY,GAAGnH,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC8G,OAAO,CAAC;AAClD5B,IAAAA,IAAI,GAAItF,KAAK,CAAgBoH,YAAY,GAAIA,YAAY,CAAC3H,GAAG,GAASyH,OAAO,CAACG,IAAI,CAAC;AACrF,GAAC,MAAM;AACL/B,IAAAA,IAAI,GAAGtF,KAAK;AACd;EACA,IAAID,cAAc,CAACmH,OAAO,EAAE5B,IAAI,EAAErF,OAAO,CAAC,EAAE;EAC5CA,OAAO,CAACgC,YAAY,IAAI,CAAC;AACzB;AACA;EACA,IAAMqF,QAAQ,GAAGrH,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC8G,OAAO,CAAC;AAC9C,EAAA,IAAII,QAAQ,EAAE;IACZA,QAAQ,CAAC7H,GAAG,GAAG6F,IAAI;IACnBgC,QAAQ,CAAC/F,KAAK,IAAI,CAAC;AACrB,GAAC,MAAM;AACLtB,IAAAA,OAAO,CAACE,QAAQ,CAAC+C,GAAG,CAACgE,OAAO,EAAE;AAAEzH,MAAAA,GAAG,EAAE6F,IAAI;AAAE/D,MAAAA,KAAK,EAAE;AAAE,KAAC,CAAC;AACxD;AACA;AACA;AACAtB,EAAAA,OAAO,CAACgF,cAAc,CAAC5B,GAAG,CAAC6D,OAAO,CAAC;AACnC,EAAA,IAAM/B,UAAU,GAAGmC,QAAQ,KAARA,IAAAA,IAAAA,QAAQ,gBAAAH,iBAAA,GAARG,QAAQ,CAAE/E,OAAO,MAAA4E,IAAAA,IAAAA,iBAAA,KAAjBA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,iBAAA,CAAmB/D,SAAS;AAC/C,EAAA,IAAI+B,UAAU,KAAVA,IAAAA,IAAAA,UAAU,eAAVA,UAAU,CAAEwB,IAAI,EAAE;AACpB,IAAA,IAAMjG,QAAQ,GAAG2F,kBAAkB,CAACpG,OAAO,CAAC;AAC5CS,IAAAA,QAAQ,CAAC8F,cAAc,CAACnD,GAAG,CAAC6D,OAAO,CAAC;AACpChC,IAAAA,SAAS,CAACC,UAAU,EAAElF,OAAO,EAAES,QAAQ,CAAC;AAC1C;AACF;AAEO,SAASwC,IAAGA,CACjB1C,YAA0B,EAC1BjC,SAAsC,EACtC0B,OAAqB,EACrBG,IAAa,EACbmH,KAAY,EAEG;EACf,IAAI,MAAM,IAAIhJ,SAAS,EAAE;EAAO,KAAAM,IAAAA,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAF7BC,IAAI,OAAAC,KAAA,CAAAJ,IAAA,GAAAA,CAAAA,GAAAA,IAAA,WAAAK,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA,EAAA,EAAA;AAAJF,IAAAA,IAAI,CAAAE,IAAA,GAAAJ,CAAAA,CAAAA,GAAAA,SAAA,CAAAI,IAAA,CAAA;AAAA;AAGP,EAAA,IAAI,EAAE,OAAO,IAAIX,SAAS,CAAC,EAAE;IAC3B0I,QAAQ,CAAC1I,SAAS,EAAE0B,OAAO,EAAEjB,IAAI,CAAC,CAAC,CAAC,CAAC;AACrC,IAAA;AACF;EACA,IAAIwI,MAAM,GAAG,IAAI;AACjB,EAAA,IAAMC,OAAqC,GAAG;AAC5CrH,IAAAA,GAAG,EAAE,SAALA,GAAGA,CAAM8G,OAAkB,EAAA;AAAA,MAAA,OAAK9G,IAAG,CAAC8G,OAAO,EAAEjH,OAAO,CAAC;AAAA,KAAA;AACrDiD,IAAAA,GAAG,EAAE,SAALA,GAAGA,CACDwE,KAAoC,EAElB;MAAA,KAAAC,IAAAA,KAAA,GAAA7I,SAAA,CAAAC,MAAA,EADf6I,SAAS,OAAA3I,KAAA,CAAA0I,KAAA,GAAAA,CAAAA,GAAAA,KAAA,WAAAE,KAAA,GAAA,CAAA,EAAAA,KAAA,GAAAF,KAAA,EAAAE,KAAA,EAAA,EAAA;AAATD,QAAAA,SAAS,CAAAC,KAAA,GAAA/I,CAAAA,CAAAA,GAAAA,SAAA,CAAA+I,KAAA,CAAA;AAAA;MAEZ,IAAI;AAAA,QAAA,IAAA/C,oBAAA;QACF,OAAOzG,kBAAkB,CAAAc,KAAA,CACvB,KAAA,CAAA,EAAA,CAAA,YAAA;AAAA,UAAA,OAAM+D,IAAG,CAAA/D,KAAA,CAAYqB,KAAAA,CAAAA,EAAAA,CAAAA,YAAY,EAAEkH,KAAK,EAAEzH,OAAO,EAAEG,IAAG,EAAEmH,KAAK,EAAAnI,MAAA,CAAKwI,SAAS,CAAC,CAAA;AAAA,SAAA,EAC5EF,KAAK,EAAA5C,CAAAA,oBAAA,GACL7E,OAAO,CAACzB,WAAW,MAAAsG,IAAAA,IAAAA,oBAAA,KAAnBA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,oBAAA,CAAqB5B,GAAG,CAAA,CAAA9D,MAAA,CACrBwI,SAAS,CACd,CAAC;AACH,OAAC,SAAS;AACR;AACA;AACA,QAAA,IAAI,CAACJ,MAAM,EAAED,KAAK,CAACtH,OAAO,CAAC;AAC7B;AACF;GACD;EACD,IAAI;AACF,IAAA,OAAO1B,SAAS,CAACuJ,KAAK,CAAA3I,KAAA,CAAfZ,SAAS,EAAA,CAAOkJ,OAAO,CAAA,CAAArI,MAAA,CAAKJ,IAAI,CAAC,CAAA;AAC1C,GAAC,SAAS;AACRwI,IAAAA,MAAM,GAAG,KAAK;AAChB;AACF;;ACzJO,SAASO,SAASA,CAAIjI,KAAe,EAAEG,OAAqB,EAAiB;EAClF,IAAM+H,SAAS,GAAG/H,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACN,KAAK,CAAC;EAC7C,IAAI,CAACkI,SAAS,EAAE;AACd,IAAA,IAAMC,SAAS,GAAG;MAChBxI,GAAG,EAAEK,KAAK,CAACuH,IAAI;AACf9F,MAAAA,KAAK,EAAE;KACR;IACDtB,OAAO,CAACE,QAAQ,CAAC+C,GAAG,CAACpD,KAAK,EAAEmI,SAAS,CAAC;AACtC,IAAA,OAAOA,SAAS;AAClB;AAEA,EAAA,OAAOD,SAAS;AAClB;;ACJA,SAASE,2BAA2BA,CAClCrG,SAAsB,EACtBpB,aAA+B,EAC/BR,OAAqB,EACrBS,QAAmB,EACnB;EACA,KAAAoG,IAAAA,EAAA,MAAAqB,WAAA,GAAoBlJ,KAAK,CAACoG,IAAI,CAAC5E,aAAa,CAACI,YAAY,CAAC,EAAAiG,EAAA,GAAAqB,WAAA,CAAApJ,MAAA,EAAA+H,EAAA,EAAE,EAAA;AAAA,IAAA,IAAA3F,qBAAA;AAAvD,IAAA,IAAAiH,cAAA,GAAA/G,cAAA,CAAA8G,WAAA,CAAArB,EAAA,CAAA,EAAA,CAAA,CAAA;AAAOxF,MAAAA,GAAG,GAAA8G,cAAA,CAAA,CAAA,CAAA;IACb,CAAAjH,qBAAA,GAAAlB,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACkB,GAAG,CAAC,MAAA,IAAA,IAAAH,qBAAA,KAAA,KAAA,CAAA,IAAA,CAAAA,qBAAA,GAAzBA,qBAAA,CAA2BoB,OAAO,MAAA,IAAA,IAAApB,qBAAA,KAAA,KAAA,CAAA,IAAlCA,qBAAA,CAAoCiC,SAAS,CAAA,QAAA,CAAO,CAACvB,SAA8B,CAAC;AACpF2B,IAAAA,OAAO,CAAClC,GAAG,EAAErB,OAAiB,CAAC;AACjC;AACF;AAEA,SAASoI,yBAAyBA,CAChC3F,UAAsB,EACtBb,SAAsB,EACtBpB,aAA+B,EAC/BR,OAAqB,EACrBS,QAAmB,EACnB;EACA,KAAA4H,IAAAA,GAAA,MAAAC,YAAA,GAAoBtJ,KAAK,CAACoG,IAAI,CAAC5E,aAAa,CAACI,YAAY,CAAC,EAAAyH,GAAA,GAAAC,YAAA,CAAAxJ,MAAA,EAAAuJ,GAAA,EAAE,EAAA;AAAvD,IAAA,IAAAE,eAAA,GAAAnH,cAAA,CAAAkH,YAAA,CAAAD,GAAA,CAAA,EAAA,CAAA,CAAA;AAAOhH,MAAAA,GAAG,GAAAkH,eAAA,CAAA,CAAA,CAAA;IACb,IAAMjG,OAAO,GAAGI,OAAK,CAACD,UAAU,EAAEpB,GAAG,EAAErB,OAAO,EAAES,QAAQ,CAAC;AACzD6B,IAAAA,OAAO,CAACa,SAAS,CAACC,GAAG,CAACxB,SAA8B,CAAC;AACvD;AACF;AAEA,SAAS4G,SAASA,CAAI/F,UAAsB,EAAEwE,OAAkB,EAAEjH,OAAqB,EAAES,QAAmB,EAAW;EAAA,IAAAoE,oBAAA,EAAA4D,qBAAA;EACrH,CAAA5D,oBAAA,GAAA7E,OAAO,CAACzB,WAAW,MAAAsG,IAAAA,IAAAA,oBAAA,KAAA4D,KAAAA,CAAAA,IAAAA,CAAAA,qBAAA,GAAnB5D,oBAAA,CAAqBnC,KAAK,MAAA,IAAA,IAAA+F,qBAAA,KAAA,KAAA,CAAA,IAA1BA,qBAAA,CAAAC,IAAA,CAAA7D,oBAAA,EAA6BoC,OAAO,CAAC;EAErC,IAAMhH,WAAW,GAAGwC,UAAU,CAACwE,OAAO,EAAEjH,OAAO,EAAES,QAAQ,CAAC;EAE1DR,WAAW,CAACqC,OAAO,GAAG;AACpBa,IAAAA,SAAS,EAAE,IAAIyC,GAAG,EAAE;IACpB+C,SAAS,EAAE,IAAI/C,GAAG;GACnB;AAED,EAAA,IAAIhG,eAAe,CAACK,WAAW,CAAC,EAAE;IAChCmI,yBAAyB,CAAC3F,UAAU,EAAEwE,OAAO,EAAuBhH,WAAW,EAAED,OAAO,EAAES,QAAQ,CAAC;AACrG;EAEA,OAAOR,WAAW,CAACqC,OAAO;AAC5B;AAEO,SAASI,OAAKA,CACnBD,UAAsB,EACtBwE,OAAkB,EAClBjH,OAAqB,EACrBS,QAAmB,EACV;AAAA,EAAA,IAAAmI,sBAAA;AACT,EAAA,IAAMtG,OAAO,GAAAsG,CAAAA,sBAAA,GAAG5I,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC8G,OAAO,CAAC,MAAA,IAAA,IAAA2B,sBAAA,KAA7BA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,sBAAA,CAA+BtG,OAAO;AACtD,EAAA,IAAIA,OAAO,EAAE;AACX,IAAA,OAAOA,OAAO;AAChB;EAEA,OAAOkG,SAAS,CAAC/F,UAAU,EAAEwE,OAAO,EAAEjH,OAAO,EAAES,QAAQ,CAAC;AAC1D;AAEA,SAASoI,SAASA,CAChB5B,OAAkB,EAClBhH,WAA2B,EAC3BD,OAAqB,EACrBS,QAAmB,EACb;EAAA,IAAAqI,qBAAA,EAAAC,qBAAA;EACN,CAAAD,qBAAA,GAAA9I,OAAO,CAACzB,WAAW,MAAAuK,IAAAA,IAAAA,qBAAA,KAAAC,KAAAA,CAAAA,IAAAA,CAAAA,qBAAA,GAAnBD,qBAAA,CAAqBvF,OAAO,MAAA,IAAA,IAAAwF,qBAAA,KAAA,KAAA,CAAA,IAA5BA,qBAAA,CAAAL,IAAA,CAAAI,qBAAA,EAA+B7B,OAAO,CAAC;AAEvC,EAAA,IAAIrH,eAAe,CAACK,WAAW,CAAC,EAAE;IAChCgI,2BAA2B,CAAChB,OAAO,EAAuBhH,WAAW,EAAED,OAAiB,CAAC;AAC3F;EAEAC,WAAW,CAACqC,OAAO,GAAGP,SAAS;AACjC;AAEO,SAASwB,OAAOA,CAAI0D,OAAkB,EAAEjH,OAAqB,EAAES,QAAmB,EAAQ;EAC/F,IAAMR,WAAW,GAAGD,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC8G,OAAO,CAAC;EACjD,IAAI,EAAChH,WAAW,KAAA,IAAA,IAAXA,WAAW,KAAA,KAAA,CAAA,IAAXA,WAAW,CAAEqC,OAAO,CAAIrC,IAAAA,WAAW,CAACqC,OAAO,CAACa,SAAS,CAACuD,IAAI,IAAIzG,WAAW,CAACqC,OAAO,CAACqG,SAAS,CAACjC,IAAI,EAAE;AACrG,IAAA;AACF;EAEAmC,SAAS,CAAC5B,OAAO,EAAEhH,WAAW,EAAED,OAAiB,CAAC;AACpD;;ACjEA,IAAMO,aAA0B,GAAG,SAA7BA,YAA0BA,CAC9BqB,SAAsB,EACtB5B,OAAqB,EACrBS,QAAmB,EACE;AAAA,EAAA,IAAAoE,oBAAA;EACrB,IAAMmE,WAAW,GAAGrH,YAAY,CAACpB,aAAY,EAAEqB,SAAS,EAAE5B,OAAO,EAAES,QAAQ,CAAC;AAC5E,EAAA,IAAIuI,WAAW,EAAE;AACf,IAAA,OAAOA,WAAW;AACpB;EAEA,OAAOzJ,uBAAuB,CAC5B,YAAM;AACJ,IAAA,OAAOwE,gBAAgB,CAACtB,UAAU,EAAEC,KAAK,EAAEa,OAAO,EAAE3B,SAAS,EAAE5B,OAAO,EAAES,QAAQ,CAAC;AACnF,GAAC,EACDmB,SAAS,EAAAiD,CAAAA,oBAAA,GACT7E,OAAO,CAACzB,WAAW,MAAA,IAAA,IAAAsG,oBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAnBA,oBAAA,CAAqBoE,QACvB,CAAC;AACH,CAAC;AAED,SAASxG,UAAUA,CAAIwE,OAAkB,EAAEjH,OAAqB,EAAES,QAAmB,EAAkB;AAAA,EAAA,IAAAqB,qBAAA;EACrGrB,QAAQ,GAAA,CAAAqB,qBAAA,GAAG9B,OAAO,CAACkC,eAAe,MAAA,IAAA,IAAAJ,qBAAA,KAAA,KAAA,CAAA,GAAAA,qBAAA,GAAIrB,QAAQ;AAC9C,EAAA,IAAIf,gBAAgB,CAACuH,OAAO,CAAC,EAAE;AAC7B,IAAA,OAAO1G,aAAY,CAAC0G,OAAO,EAAEjH,OAAO,EAAES,QAAQ,CAAC;AACjD;AAEA,EAAA,OAAOqH,SAAS,CAACb,OAAO,EAAEjH,OAAO,CAAC;AACpC;AAEA,SAAS0C,KAAKA,CAAIuE,OAAkB,EAAEjH,OAAqB,EAAES,QAAmB,EAAW;EACzF,OAAOyI,OAAU,CAACzG,UAAU,EAAEwE,OAAO,EAAEjH,OAAO,EAAES,QAAQ,CAAC;AAC3D;AAEA,IAAM0I,QAAkB,GAAG,SAArBA,QAAkBA,CAAI7J,MAAM,EAAEU,OAAO,EAAES,QAAQ,EAAK;AAAA,EAAA,IAAAqI,qBAAA;EACxD,OAAOzJ,kBAAkB,CACvB,YAAM;IACJ,IAAMY,WAAW,GAAGwC,UAAU,CAACnD,MAAM,EAAEU,OAAO,EAAES,QAAQ,CAAC;IACzD,IAAI,OAAO,IAAIR,WAAW,EAAE;MAC1B,MAAMA,WAAW,CAACI,KAAK;AACzB;IAEA,OAAOJ,WAAW,CAACT,GAAG;AACxB,GAAC,EACDF,MAAM,EAAAwJ,CAAAA,qBAAA,GACN9I,OAAO,CAACzB,WAAW,MAAA,IAAA,IAAAuK,qBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAnBA,qBAAA,CAAqB3I,GACvB,CAAC;AACH,CAAC;AAED,IAAMiJ,QAAkB,GAAG,SAArBA,QAAkBA,CACtBzJ,IAAiC,EACjCK,OAAqB,EAEH;AAAA,EAAA,IAAA+I,qBAAA;EAAA,KAAAnK,IAAAA,IAAA,GAAAC,SAAA,CAAAC,MAAA,EADfC,IAAI,OAAAC,KAAA,CAAAJ,IAAA,GAAAA,CAAAA,GAAAA,IAAA,WAAAK,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA,EAAA,EAAA;AAAJF,IAAAA,IAAI,CAAAE,IAAA,GAAAJ,CAAAA,CAAAA,GAAAA,SAAA,CAAAI,IAAA,CAAA;AAAA;AAEP,EAAA,OAAOb,kBAAkB,CAAAc,KAAA,CAAA,KAAA,CAAA,EAAA,CACvB,YAAM;AACJ,IAAA,IAAMmK,mBAAmB,GAAGrJ,OAAO,CAACgF,cAAc,CAAC0B,IAAI;IACvD,IAAI;AACF,MAAA,OAAO4C,IAAQ,CAAApK,KAAA,CAAUqB,KAAAA,CAAAA,EAAAA,CAAAA,aAAY,EAAEZ,IAAI,EAAEK,OAAO,EAAEmJ,QAAQ,EAAEI,YAAY,EAAApK,MAAA,CAAKJ,IAAI,CAAC,CAAA;AACxF,KAAC,SAAS;MACR,IAAIiB,OAAO,CAACgF,cAAc,CAAC0B,IAAI,KAAK2C,mBAAmB,EAAEE,YAAY,CAACvJ,OAAO,CAAC;AAChF;AACF,GAAC,EACDL,IAAI,EAAA,CAAAoJ,qBAAA,GACJ/I,OAAO,CAACzB,WAAW,MAAA,IAAA,IAAAwK,qBAAA,KAAnBA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,qBAAA,CAAqB9F,GAAG,CAAA,CAAA9D,MAAA,CACrBJ,IAAI,CACT,CAAC;AACH,CAAC;AAED,SAASwK,YAAYA,CAACvJ,OAAqB,EAAQ;EACjD,IAAIyG,aAAa,CAAClG,aAAY,EAAEP,OAAO,CAAC,EAAEwJ,cAAc,CAACxJ,OAAO,CAAC;AACnE;AAEA,SAASwJ,cAAcA,CAACxJ,OAAqB,EAAQ;AACnD,EAAA,IAAI,CAACA,OAAO,CAACgF,cAAc,CAAC0B,IAAI,EAAE;EAClC,IAAM+C,MAAiB,GAAG,EAAE;EAC5B,GAAG;AACD;AACA;AACA,IAAA,IAAIC,SAAsC,GAAA,KAAA,CAAA;AAAC,IAAA,IAAAhJ,SAAA,GAAAC,0BAAA,CACrBX,OAAO,CAACgF,cAAc,CAAA;MAAAlE,KAAA;AAAA,IAAA,IAAA;MAA5C,KAAAJ,SAAA,CAAAK,CAAA,EAAAD,EAAAA,CAAAA,CAAAA,KAAA,GAAAJ,SAAA,CAAAM,CAAA,EAAAC,EAAAA,IAAA,GAA8C;AAAA,QAAA,IAAAC,qBAAA;AAAA,QAAA,IAAnC+F,OAAO,GAAAnG,KAAA,CAAAf,KAAA;QAChB,IAAM4I,SAAS,GAAAzH,CAAAA,qBAAA,GAAGlB,OAAO,CAACE,QAAQ,CAACC,GAAG,CAAC8G,OAAO,CAAC,cAAA/F,qBAAA,KAAA,KAAA,CAAA,IAAA,CAAAA,qBAAA,GAA7BA,qBAAA,CAA+BoB,OAAO,MAAA,IAAA,IAAApB,qBAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAtCA,qBAAA,CAAwCyH,SAAS;AACnE,QAAA,IAAIA,SAAS,KAATA,IAAAA,IAAAA,SAAS,eAATA,SAAS,CAAEjC,IAAI,EAAE;AAAA,UAAA,IAAAiD,UAAA;AACnB,UAAA,CAAAA,UAAA,GAAAD,SAAS,MAAA,IAAA,IAAAC,UAAA,KAAA,KAAA,CAAA,GAAAA,UAAA,GAATD,SAAS,GAAK,IAAI9D,GAAG,EAAE;AAAC,UAAA,IAAAC,UAAA,GAAAlF,0BAAA,CACDgI,SAAS,CAAA;YAAA7C,MAAA;AAAA,UAAA,IAAA;YAAhC,KAAAD,UAAA,CAAA9E,CAAA,EAAA+E,EAAAA,CAAAA,CAAAA,MAAA,GAAAD,UAAA,CAAA7E,CAAA,EAAAC,EAAAA,IAAA,GAAkC;AAAA,cAAA,IAAvB2I,QAAQ,GAAA9D,MAAA,CAAA/F,KAAA;AAAe2J,cAAAA,SAAS,CAACtG,GAAG,CAACwG,QAAQ,CAAC;AAAA;AAAC,WAAA,CAAA,OAAApI,GAAA,EAAA;YAAAqE,UAAA,CAAApE,CAAA,CAAAD,GAAA,CAAA;AAAA,WAAA,SAAA;AAAAqE,YAAAA,UAAA,CAAAnE,CAAA,EAAA;AAAA;AAC5D;AACF;AAAC,KAAA,CAAA,OAAAF,GAAA,EAAA;MAAAd,SAAA,CAAAe,CAAA,CAAAD,GAAA,CAAA;AAAA,KAAA,SAAA;AAAAd,MAAAA,SAAA,CAAAgB,CAAA,EAAA;AAAA;AACD1B,IAAAA,OAAO,CAACgF,cAAc,CAAC4B,KAAK,EAAE;IAC9B,IAAI,CAAC8C,SAAS,EAAE;AAAS,IAAA,IAAAhG,UAAA,GAAA/C,0BAAA,CACF+I,SAAS,CAAA;MAAA9F,MAAA;AAAA,IAAA,IAAA;MAAhC,KAAAF,UAAA,CAAA3C,CAAA,EAAA6C,EAAAA,CAAAA,CAAAA,MAAA,GAAAF,UAAA,CAAA1C,CAAA,EAAAC,EAAAA,IAAA,GAAkC;AAAA,QAAA,IAAvB4I,QAAQ,GAAAjG,MAAA,CAAA7D,KAAA;QACjB,IAAI;AACF8J,UAAAA,QAAQ,EAAE;SACX,CAAC,OAAOxJ,KAAK,EAAE;AACdoJ,UAAAA,MAAM,CAAChE,IAAI,CAACpF,KAAK,CAAC;AACpB;AACF;AAAC,KAAA,CAAA,OAAAmB,GAAA,EAAA;MAAAkC,UAAA,CAAAjC,CAAA,CAAAD,GAAA,CAAA;AAAA,KAAA,SAAA;AAAAkC,MAAAA,UAAA,CAAAhC,CAAA,EAAA;AAAA;AACH,GAAC,QAAQ1B,OAAO,CAACgF,cAAc,CAAC0B,IAAI;EACpC,IAAI+C,MAAM,CAAC3K,MAAM,EAAE;AACjB,IAAA,IAAMgL,kBAAkB,GACtBC,UAAU,CAGVC,cAAc;AAChB,IAAA,IAAIF,kBAAkB,EAAE,MAAM,IAAIA,kBAAkB,CAACL,MAAM,CAAC;IAC5D,MAAMQ,MAAM,CAACC,MAAM,CAAC,IAAI9K,KAAK,EAAE,EAAE;AAAEqK,MAAAA,MAAM,EAANA;AAAO,KAAC,CAAC;AAC9C;AACF;AAEA,IAAMU,UAAsB,GAAG,SAAzBA,UAAsBA,CAAIlD,OAAO,EAAEjH,OAAO,EAAE4J,QAAQ,EAAK;AAC7D,EAAA,IAAI,EAAE,MAAM,IAAI3C,OAAO,CAAC,IAAI,EAAE,MAAM,IAAIA,OAAO,CAAC,EAAE,MAAM,IAAImD,SAAS,CAAC,oCAAoC,CAAC;EAC3G,IAAM9H,OAAO,GAAG4G,OAAU,CAACzG,UAAU,EAAEwE,OAAO,EAAEjH,OAAO,CAAC;AACxDsC,EAAAA,OAAO,CAACqG,SAAS,CAACvF,GAAG,CAACwG,QAAQ,CAAC;EAC/BL,YAAY,CAACvJ,OAAO,CAAC;AACrB,EAAA,IAAIqK,YAES,GAAG;AACd/K,IAAAA,MAAM,EAAE2H,OAAO;AACf3E,IAAAA,OAAO,EAAPA,OAAO;AACPsH,IAAAA,QAAQ,EAARA,QAAQ;AACR5J,IAAAA,OAAO,EAAPA;GACD;AACD,EAAA,OAAO,YAAM;IACX,IAAMiG,OAAO,GAAGoE,YAAY;IAC5B,IAAI,CAACpE,OAAO,EAAE;AACd;AACA;AACAoE,IAAAA,YAAY,GAAGtI,SAAS;IACxBkE,OAAO,CAAC3D,OAAO,CAACqG,SAAS,UAAO,CAAC1C,OAAO,CAAC2D,QAAQ,CAAC;IAClDrG,OAAO,CAAC0C,OAAO,CAAC3G,MAAM,EAAE2G,OAAO,CAACjG,OAAO,CAAC;AACxCuJ,IAAAA,YAAY,CAACtD,OAAO,CAACjG,OAAO,CAAC;GAC9B;AACH,CAAC;AAED,IAAasK,SAAS,gBAAAC,YAAA,CAIpB,SAAAD,SAAAA,CAA+BE,OAAsB,EAAE;AAAA,EAAA,IAAAC,KAAA,GAAA,IAAA;IAAAC,aAAA;AAAAC,EAAAA,eAAA,OAAAL,SAAA,CAAA;AAAAM,EAAAA,eAAA,CAHf,IAAA,EAAA,UAAA,EAAA,IAAIC,OAAO,EAAE,CAAA;EAAAD,eAAA,CAAA,IAAA,EAAA,KAAA,EAcvC,UAAIjL,IAAe,EAAQ;AACvC,IAAA,OAAOwJ,QAAQ,CAACxJ,IAAI,EAAE8K,KAAI,CAACzK,OAAO,CAAC;GACpC,CAAA;EAAA4K,eAAA,CAAA,IAAA,EAAA,KAAA,EAEa,UACZjL,IAAiC,EAEf;IAAA,KAAA+H,IAAAA,KAAA,GAAA7I,SAAA,CAAAC,MAAA,EADfC,IAAI,OAAAC,KAAA,CAAA0I,KAAA,GAAAA,CAAAA,GAAAA,KAAA,WAAAE,KAAA,GAAA,CAAA,EAAAA,KAAA,GAAAF,KAAA,EAAAE,KAAA,EAAA,EAAA;AAAJ7I,MAAAA,IAAI,CAAA6I,KAAA,GAAA/I,CAAAA,CAAAA,GAAAA,SAAA,CAAA+I,KAAA,CAAA;AAAA;AAEP,IAAA,OAAOwB,QAAQ,CAAAlK,KAAA,CAAA,KAAA,CAAA,EAAA,CAAUS,IAAI,EAAE8K,KAAI,CAACzK,OAAO,CAAA,CAAAb,MAAA,CAAKJ,IAAI,CAAC,CAAA;GACtD,CAAA;AAAA6L,EAAAA,eAAA,CAEgB,IAAA,EAAA,OAAA,EAAA,UAAC3D,OAAO,EAAE2C,QAAQ,EAAK;IACtC,OAAOO,UAAU,CAAClD,OAAO,EAAEwD,KAAI,CAACzK,OAAO,EAAE4J,QAAQ,CAAC;GACnD,CAAA;EAAA,IAxB8BY,CAAAA,OAAsB,GAAtBA,OAAsB;EACnD,IAAI,CAACxK,OAAO,GAAG;IACbE,QAAQ,EAAE,IAAI,CAACA,QAAQ;IACvB3B,WAAW,EAAA,CAAAmM,aAAA,GAAE,IAAI,CAACF,OAAO,MAAA,IAAA,IAAAE,aAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAZA,aAAA,CAAcnM,WAAW;AACtCyD,IAAAA,YAAY,EAAE,CAAC;AACfgD,IAAAA,cAAc,EAAE,IAAIY,GAAG,EAAE;AACzB1D,IAAAA,eAAe,EAAEH,SAAS;AAC1BuE,IAAAA,YAAY,EAAEvE;GACf;AACH,CAAC,CAAA;;AClKU+I,IAAAA,cAAc,0BAAAC,UAAA,EAAA;AAAA,EAAA,SAAAD,cAAA,GAAA;AAAA,IAAA,IAAAL,KAAA;AAAAE,IAAAA,eAAA,OAAAG,cAAA,CAAA;AAAA,IAAA,KAAA,IAAAlM,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAAC,IAAA,GAAAC,IAAAA,KAAA,CAAAJ,IAAA,GAAAK,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA,EAAA,EAAA;AAAAF,MAAAA,IAAA,CAAAE,IAAA,CAAAJ,GAAAA,SAAA,CAAAI,IAAA,CAAA;AAAA;AAAAwL,IAAAA,KAAA,GAAAO,UAAA,CAAA,IAAA,EAAAF,cAAA,EAAA3L,EAAAA,CAAAA,MAAA,CAAAJ,IAAA,CAAA,CAAA;AAAA6L,IAAAA,eAAA,CAAAH,KAAA,EACH,qBAAA,EAAA,UAAC9K,IAAwC,EAAiB;MAC9E,IAAMoI,SAAS,GAAG0C,KAAA,CAAKzK,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACR,IAAI,CAAC;MACjD,IAAI,CAACoI,SAAS,EAAE;QACd,OAAO,CAACpI,IAAI,CAAC;AACf;AAEA,MAAA,IAAI,EAAE,cAAc,IAAIoI,SAAS,CAAC,EAAE;QAClC,OAAO,CAACpI,IAAI,CAAC;AACf;AAEA,MAAA,OAAA,CACEA,IAAI,CAAAR,CAAAA,MAAA,CAAA8L,kBAAA,CACDjM,KAAK,CAACoG,IAAI,CAAC2C,SAAS,CAACnH,YAAY,CAAC,CAACsK,GAAG,CAAC,UAAArJ,IAAA,EAAW;AAAA,QAAA,IAAAsJ,KAAA,GAAA/J,cAAA,CAAAS,IAAA,EAAA,CAAA,CAAA;AAATgC,UAAAA,GAAG,GAAAsH,KAAA,CAAA,CAAA,CAAA;AAC7C,QAAA,OAAOV,KAAA,CAAKW,mBAAmB,CAACvH,GAAG,CAAC;AACtC,OAAC,CAAC,CAAA,CAAA;KAEL,CAAA;AAAA+G,IAAAA,eAAA,CAAAH,KAAA,EAEmB,mBAAA,EAAA,UAAC9K,IAAwC,EAAiB;MAAA,IAAA0L,qBAAA,EAAAC,kBAAA;MAC5E,IAAMvD,SAAS,GAAG0C,KAAA,CAAKzK,OAAO,CAACE,QAAQ,CAACC,GAAG,CAACR,IAAI,CAAC;MACjD,IAAI,CAACoI,SAAS,EAAE;QACd,OAAO,CAACpI,IAAI,CAAC;AACf;AAEA,MAAA,OAAA,CACEA,IAAI,CAAA,CAAAR,MAAA,CAAA8L,kBAAA,CACDjM,KAAK,CAACoG,IAAI,EAAAiG,qBAAA,GAAA,CAAAC,kBAAA,GAACvD,SAAS,CAACzF,OAAO,MAAAgJ,IAAAA,IAAAA,kBAAA,KAAjBA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,kBAAA,CAAmBnI,SAAS,cAAAkI,qBAAA,KAAA,KAAA,CAAA,GAAAA,qBAAA,GAAI,EAAE,CAAC,CAACH,GAAG,CAAC,UAACrH,GAAG,EAAA;AAAA,QAAA,OAAK4G,KAAA,CAAKc,iBAAiB,CAAC1H,GAAG,CAAC;OAAC,CAAA,CAAA,CAAA;KAE9F,CAAA;AAAA+G,IAAAA,eAAA,CAAAH,KAAA,EAEW,WAAA,EAAA,UAAC9K,IAAwC,EAAc;MACjE,IAAM6L,UAAU,GAAGf,KAAA,CAAKvK,QAAQ,CAACC,GAAG,CAACR,IAAI,CAAC;MAC1C,OAAO,CAAA6L,UAAU,KAAVA,IAAAA,IAAAA,UAAU,uBAAVA,UAAU,CAAElJ,OAAO,MAAKP,SAAS;KACzC,CAAA;AAAA6I,IAAAA,eAAA,CAAAH,KAAA,EAEsB,sBAAA,EAAA,UAAC7I,SAA4B,EAAa;AAC/D,MAAA,IAAM1B,QAAQ,GAAGuK,KAAA,CAAKzK,OAAO,CAACE,QAAQ;AACtC,MAAA,SAASuL,qBAAqBA,CAAC7J,SAA4B,EAAEpD,MAAc,EAAE;AAC3E,QAAA,IAAMgC,aAAa,GAAGN,QAAQ,CAACC,GAAG,CAACyB,SAAS,CAA2B;QAAC,IAAAlB,SAAA,GAAAC,0BAAA,CAC1CH,aAAa,CAACI,YAAY,CAACC,OAAO,EAAE,CAAA;UAAAC,KAAA;AAAA,QAAA,IAAA;UAAlE,KAAAJ,SAAA,CAAAK,CAAA,EAAAD,EAAAA,CAAAA,CAAAA,KAAA,GAAAJ,SAAA,CAAAM,CAAA,EAAAC,EAAAA,IAAA,GAAoE;AAAA,YAAA,IAAAE,WAAA,GAAAC,cAAA,CAAAN,KAAA,CAAAf,KAAA,EAAA,CAAA,CAAA;AAAxD2L,cAAAA,MAAM,GAAAvK,WAAA,CAAA,CAAA,CAAA;AAAEG,cAAAA,KAAK,GAAAH,WAAA,CAAA,CAAA,CAAA;AACvB;AACA,YAAA,IAAMwK,UAAU,GAAGzL,QAAQ,CAACC,GAAG,CAACuL,MAAM,CAA0B;YAChElN,MAAM,CAACiH,IAAI,CAAC,CACV;AACEnG,cAAAA,MAAM,EAAEsC,SAAS;cACjBpC,GAAG,EAAEgB,aAAa,CAAChB,GAAG;cACtB8B,KAAK,EAAEd,aAAa,CAACc;AACvB,aAAC,EACD;AACEhC,cAAAA,MAAM,EAAEoM,MAAM;cACdlM,GAAG,EAAEmM,UAAU,CAACnM,GAAG;cACnB8B,KAAK,EAAEqK,UAAU,CAACrK;aACnB,EACDA,KAAK,CACN,CAAC;AACF,YAAA,IAAI5B,gBAAgB,CAACgM,MAAM,CAAC,EAAE;AAC5BD,cAAAA,qBAAqB,CAACC,MAAM,EAAElN,MAAM,CAAC;AACvC;AACF;AAAC,SAAA,CAAA,OAAAgD,GAAA,EAAA;UAAAd,SAAA,CAAAe,CAAA,CAAAD,GAAA,CAAA;AAAA,SAAA,SAAA;AAAAd,UAAAA,SAAA,CAAAgB,CAAA,EAAA;AAAA;AACH;MAEA,IAAMlD,MAAc,GAAG,EAAE;AACzBiN,MAAAA,qBAAqB,CAAC7J,SAAS,EAAEpD,MAAM,CAAC;AACxC,MAAA,OAAOA,MAAM;KACd,CAAA;AAAA,IAAA,OAAAiM,KAAA;AAAA;EAAAmB,SAAA,CAAAd,cAAA,EAAAC,UAAA,CAAA;EAAA,OAAAR,YAAA,CAAAO,cAAA,CAAA;AAAA,CAAA,CAjEiCR,SAAS,CAAA;AAoEtC,SAASuB,wBAAwBA,CAACtN,WAA8B,EAAc;EACnF,OAAO,IAAIuM,cAAc,CAAC;AACxBvM,IAAAA,WAAW,EAAEA;AACf,GAAC,CAAC;AACJ;;ACpEA,IAAauN,kBAAkB,gBAAAvB,YAAA,CAC7B,SAAAuB,kBAAAA,CAA6BC,OAAoB,EAAE;AAAA,EAAA,IAAAtB,KAAA,GAAA,IAAA;AAAAE,EAAAA,eAAA,OAAAmB,kBAAA,CAAA;AAAAlB,EAAAA,eAAA,CAE/B,IAAA,EAAA,WAAA,EAAA,UAClBjL,IAAsE,EACtEqM,MAAsB,EACnB;IACH,OAAOvB,KAAI,CAACsB,OAAO,CAACE,IAAI,CAAC,UAACC,KAAK,EAAK;MAClC,IAAIC,WAAW,GAAG,KAAK;AACvB,MAAA,IAAI,OAAOD,KAAK,CAACE,MAAM,KAAK,QAAQ,EAAE;AACpCD,QAAAA,WAAW,GAAGxM,IAAI,CAAC0M,QAAQ,EAAE,CAACC,QAAQ,CAACJ,KAAK,CAACE,MAAM,CAAC;AACtD,OAAC,MAAM,IAAIF,KAAK,CAACE,MAAM,YAAYG,MAAM,EAAE;AACzCJ,QAAAA,WAAW,GAAGD,KAAK,CAACE,MAAM,CAACI,IAAI,CAAC7M,IAAI,CAAC0M,QAAQ,EAAE,CAAC;AAClD,OAAC,MAAM;AACLF,QAAAA,WAAW,GAAGD,KAAK,CAACE,MAAM,KAAKzM,IAAI;AACrC;MAEA,IAAI,CAACwM,WAAW,EAAE;AAChB,QAAA,OAAO,KAAK;AACd;AAEA,MAAA,OAAO,CAACD,KAAK,CAACO,OAAO,IAAIP,KAAK,CAACO,OAAO,CAACrK,GAAG,CAAC4J,MAAM,CAAC;AACpD,KAAC,CAAC;GACH,CAAA;AAAApB,EAAAA,eAAA,CAEK,IAAA,EAAA,KAAA,EAAA,UAAI8B,KAA6B,EAAErO,EAAW,EAAK;IACvD,IAAI,CAACoM,KAAI,CAACkC,SAAS,CAACD,KAAK,EAAE,KAAK,CAAC,EAAE;AACjCrO,MAAAA,EAAE,EAAE;AACJ,MAAA;AACF;IAEAuO,OAAO,CAACC,KAAK,CAAC,WAAW,GAAGH,KAAK,CAACL,QAAQ,EAAE,CAAC;IAC7CO,OAAO,CAACE,GAAG,CAAC,MAAM,EAAEzO,EAAE,EAAE,CAAC;IACzBuO,OAAO,CAACG,QAAQ,EAAE;GACnB,CAAA;AAAAnC,EAAAA,eAAA,CAEU,IAAA,EAAA,UAAA,EAAA,UAAI8B,KAAkB,EAAErO,EAAW,EAAK;IACjD,IAAI,CAACoM,KAAI,CAACkC,SAAS,CAACD,KAAK,EAAE,UAAU,CAAC,EAAE;AACtCrO,MAAAA,EAAE,EAAE;AACJ,MAAA;AACF;IAEAuO,OAAO,CAACC,KAAK,CAAC,WAAW,GAAGH,KAAK,CAACL,QAAQ,EAAE,CAAC;IAC7CO,OAAO,CAACE,GAAG,CAAC,MAAM,EAAEzO,EAAE,EAAE,CAAC;IACzBuO,OAAO,CAACG,QAAQ,EAAE;GACnB,CAAA;AAAAnC,EAAAA,eAAA,CAEK,IAAA,EAAA,KAAA,EAAA,UAAwC8B,KAAkC,EAAErO,EAAW,EAAoB;AAAA,IAAA,IAAA2O,QAAA;IAC/G,IAAI,CAACvC,KAAI,CAACkC,SAAS,CAACD,KAAK,EAAyB,KAAK,CAAC,EAAE;AACxDrO,MAAAA,EAAE,EAAE;AACJ,MAAA;AACF;IAAC,KAAAO,IAAAA,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAJ+FC,IAAI,OAAAC,KAAA,CAAAJ,IAAA,GAAAA,CAAAA,GAAAA,IAAA,WAAAK,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA,EAAA,EAAA;AAAJF,MAAAA,IAAI,CAAAE,IAAA,GAAAJ,CAAAA,CAAAA,GAAAA,SAAA,CAAAI,IAAA,CAAA;AAAA;IAMpG,CAAA+N,QAAA,GAAAJ,OAAO,EAACC,KAAK,CAAA3N,KAAA,CAAA8N,QAAA,EAAA,CAAC,WAAW,GAAGN,KAAK,CAACL,QAAQ,EAAE,EAAE,GAAG,CAAAlN,CAAAA,MAAA,CAAKJ,IAAI,EAAE,CAAA,GAAG,CAAC,CAAA,CAAA;IAChE6N,OAAO,CAACE,GAAG,CAAC,MAAM,EAAEzO,EAAE,EAAE,CAAC;IACzBuO,OAAO,CAACG,QAAQ,EAAE;GACnB,CAAA;EAAAnC,eAAA,CAAA,IAAA,EAAA,OAAA,EAEO,UAAI8B,KAA6B,EAAK;IAC5C,IAAI,CAACjC,KAAI,CAACkC,SAAS,CAACD,KAAK,EAAE,OAAO,CAAC,EAAE;AACnC,MAAA;AACF;IAEAE,OAAO,CAACE,GAAG,CAAC,WAAW,GAAGJ,KAAK,CAACL,QAAQ,EAAE,CAAC;GAC5C,CAAA;EAAAzB,eAAA,CAAA,IAAA,EAAA,SAAA,EAES,UAAI8B,KAA6B,EAAK;IAC9C,IAAI,CAACjC,KAAI,CAACkC,SAAS,CAACD,KAAK,EAAE,SAAS,CAAC,EAAE;AACrC,MAAA;AACF;IAEAE,OAAO,CAACE,GAAG,CAAC,WAAW,GAAGJ,KAAK,CAACL,QAAQ,EAAE,CAAC;GAC5C,CAAA;EAAA,IAvE4BN,CAAAA,OAAoB,GAApBA,OAAoB;AAAG,CAAC,CAAA;AA0EhD,SAASkB,gBAAgBA,GAGlB;AAAA,EAAA,IAFZlB,OAA2G,GAAAlN,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAkD,SAAA,GAAAlD,SAAA,CAAA,CAAA,CAAA,GAAG,EAAE;EAAA,IAChHqO,cAAiC,GAAArO,SAAA,CAAAC,MAAA,GAAAD,CAAAA,GAAAA,SAAA,MAAAkD,SAAA;EAEjC,IAAMoL,oBAAoB,GAAGD,cAAc,GAAG,IAAItH,GAAG,CAACsH,cAAc,CAAC,GAAGnL,SAAS;EAEjF,IAAMqL,aAAa,GAAGrB,OAAO,CAACb,GAAG,CAAC,UAACgB,KAAK,EAAgB;IACtD,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,YAAYK,MAAM,EAAE;MACxD,OAAO;AAAEH,QAAAA,MAAM,EAAEF,KAAK;AAAEO,QAAAA,OAAO,EAAEU;OAAsB;AACzD;IAEA,IAAI,QAAQ,IAAIjB,KAAK,EAAE;AACrB,MAAA,OAAOA,KAAK;AACd;IAEA,OAAO;AAAEE,MAAAA,MAAM,EAAEF,KAAK;AAAEO,MAAAA,OAAO,EAAEU;KAAsB;AACzD,GAAC,CAAC;AAEF,EAAA,IAAM5O,WAAW,GAAG,IAAIuN,kBAAkB,CAACsB,aAAa,CAAC;EACzD,OAAOvB,wBAAwB,CAACtN,WAAW,CAAC;AAC9C;;;;"}