{"version":3,"file":"index.mjs","names":[],"sources":["../src/internals/TRPCUntypedClient.ts","../src/createTRPCUntypedClient.ts","../src/createTRPCClient.ts","../src/links/httpBatchStreamLink.ts","../src/internals/inputWithTrackedEventId.ts","../src/links/httpSubscriptionLink.ts","../src/links/retryLink.ts","../src/links/localLink.ts"],"sourcesContent":["import type {\n  inferObservableValue,\n  Unsubscribable,\n} from '@trpc/server/observable';\nimport { observableToPromise, share } from '@trpc/server/observable';\nimport type {\n  AnyRouter,\n  inferAsyncIterableYield,\n  InferrableClientTypes,\n  Maybe,\n  TypeError,\n} from '@trpc/server/unstable-core-do-not-import';\nimport { createChain } from '../links/internals/createChain';\nimport type { TRPCConnectionState } from '../links/internals/subscriptions';\nimport type {\n  OperationContext,\n  OperationLink,\n  TRPCClientRuntime,\n  TRPCLink,\n} from '../links/types';\nimport { TRPCClientError } from '../TRPCClientError';\n\ntype TRPCType = 'mutation' | 'query' | 'subscription';\nexport interface TRPCRequestOptions {\n  /**\n   * Pass additional context to links\n   */\n  context?: OperationContext;\n  signal?: AbortSignal;\n}\n\nexport interface TRPCSubscriptionObserver<TValue, TError> {\n  onStarted: (opts: { context: OperationContext | undefined }) => void;\n  onData: (value: inferAsyncIterableYield<TValue>) => void;\n  onError: (err: TError) => void;\n  onStopped: () => void;\n  onComplete: () => void;\n  onConnectionStateChange: (state: TRPCConnectionState<TError>) => void;\n}\n\n/** @internal */\nexport type CreateTRPCClientOptions<TRouter extends InferrableClientTypes> = {\n  links: TRPCLink<TRouter>[];\n  transformer?: TypeError<'The transformer property has moved to httpLink/httpBatchLink/wsLink'>;\n};\n\nexport class TRPCUntypedClient<TInferrable extends InferrableClientTypes> {\n  private readonly links: OperationLink<TInferrable>[];\n  public readonly runtime: TRPCClientRuntime;\n  private requestId: number;\n\n  constructor(opts: CreateTRPCClientOptions<TInferrable>) {\n    this.requestId = 0;\n\n    this.runtime = {};\n\n    // Initialize the links\n    this.links = opts.links.map((link) => link(this.runtime));\n  }\n\n  private $request<TInput = unknown, TOutput = unknown>(opts: {\n    type: TRPCType;\n    input: TInput;\n    path: string;\n    context?: OperationContext;\n    signal: Maybe<AbortSignal>;\n  }) {\n    const chain$ = createChain<AnyRouter, TInput, TOutput>({\n      links: this.links as OperationLink<any, any, any>[],\n      op: {\n        ...opts,\n        context: opts.context ?? {},\n        id: ++this.requestId,\n      },\n    });\n    return chain$.pipe(share());\n  }\n\n  private async requestAsPromise<TInput = unknown, TOutput = unknown>(opts: {\n    type: TRPCType;\n    input: TInput;\n    path: string;\n    context?: OperationContext;\n    signal: Maybe<AbortSignal>;\n  }): Promise<TOutput> {\n    try {\n      const req$ = this.$request<TInput, TOutput>(opts);\n      type TValue = inferObservableValue<typeof req$>;\n\n      const envelope = await observableToPromise<TValue>(req$);\n      const data = (envelope.result as any).data;\n      return data;\n    } catch (err) {\n      throw TRPCClientError.from(err as Error);\n    }\n  }\n  public query(path: string, input?: unknown, opts?: TRPCRequestOptions) {\n    return this.requestAsPromise<unknown, unknown>({\n      type: 'query',\n      path,\n      input,\n      context: opts?.context,\n      signal: opts?.signal,\n    });\n  }\n  public mutation(path: string, input?: unknown, opts?: TRPCRequestOptions) {\n    return this.requestAsPromise<unknown, unknown>({\n      type: 'mutation',\n      path,\n      input,\n      context: opts?.context,\n      signal: opts?.signal,\n    });\n  }\n  public subscription(\n    path: string,\n    input: unknown,\n    opts: Partial<\n      TRPCSubscriptionObserver<unknown, TRPCClientError<AnyRouter>>\n    > &\n      TRPCRequestOptions,\n  ): Unsubscribable {\n    const observable$ = this.$request({\n      type: 'subscription',\n      path,\n      input,\n      context: opts.context,\n      signal: opts.signal,\n    });\n    return observable$.subscribe({\n      next(envelope) {\n        switch (envelope.result.type) {\n          case 'state': {\n            opts.onConnectionStateChange?.(envelope.result);\n            break;\n          }\n          case 'started': {\n            opts.onStarted?.({\n              context: envelope.context,\n            });\n            break;\n          }\n          case 'stopped': {\n            opts.onStopped?.();\n            break;\n          }\n          case 'data':\n          case undefined: {\n            opts.onData?.(envelope.result.data);\n            break;\n          }\n        }\n      },\n      error(err) {\n        opts.onError?.(err);\n      },\n      complete() {\n        opts.onComplete?.();\n      },\n    });\n  }\n}\n","import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';\nimport type { CreateTRPCClientOptions } from './internals/TRPCUntypedClient';\nimport { TRPCUntypedClient } from './internals/TRPCUntypedClient';\n\nexport function createTRPCUntypedClient<TRouter extends AnyRouter>(\n  opts: CreateTRPCClientOptions<TRouter>,\n): TRPCUntypedClient<TRouter> {\n  return new TRPCUntypedClient(opts);\n}\n\nexport type {\n  CreateTRPCClientOptions,\n  TRPCRequestOptions,\n} from './internals/TRPCUntypedClient';\nexport { TRPCUntypedClient } from './internals/TRPCUntypedClient';\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport type { Unsubscribable } from '@trpc/server/observable';\nimport type {\n  AnyProcedure,\n  AnyRouter,\n  inferClientTypes,\n  inferProcedureInput,\n  InferrableClientTypes,\n  inferTransformedProcedureOutput,\n  ProcedureType,\n  RouterRecord,\n} from '@trpc/server/unstable-core-do-not-import';\nimport {\n  createFlatProxy,\n  createRecursiveProxy,\n} from '@trpc/server/unstable-core-do-not-import';\nimport type { CreateTRPCClientOptions } from './createTRPCUntypedClient';\nimport type { TRPCSubscriptionObserver } from './internals/TRPCUntypedClient';\nimport { TRPCUntypedClient } from './internals/TRPCUntypedClient';\nimport type { TRPCProcedureOptions } from './internals/types';\nimport type { TRPCClientError } from './TRPCClientError';\n\n/**\n * @public\n * @deprecated use {@link TRPCClient} instead, will be removed in v12\n **/\nexport type inferRouterClient<TRouter extends AnyRouter> = TRPCClient<TRouter>;\n\n/**\n * @public\n * @deprecated use {@link TRPCClient} instead, will be removed in v12\n **/\nexport type CreateTRPCClient<TRouter extends AnyRouter> = TRPCClient<TRouter>;\n\nconst untypedClientSymbol = Symbol.for('trpc_untypedClient');\n\n/**\n * @public\n **/\nexport type TRPCClient<TRouter extends AnyRouter> = DecoratedProcedureRecord<\n  {\n    transformer: TRouter['_def']['_config']['$types']['transformer'];\n    errorShape: TRouter['_def']['_config']['$types']['errorShape'];\n  },\n  TRouter['_def']['record']\n> & {\n  [untypedClientSymbol]: TRPCUntypedClient<TRouter>;\n};\n\n/** @internal */\nexport type TRPCResolverDef = {\n  input: any;\n  output: any;\n  transformer: boolean;\n  errorShape: any;\n};\n\ntype coerceAsyncGeneratorToIterable<T> =\n  T extends AsyncGenerator<infer $T, infer $Return, infer $Next>\n    ? AsyncIterable<$T, $Return, $Next>\n    : T;\n\n/** @internal */\nexport type Resolver<TDef extends TRPCResolverDef> = (\n  input: TDef['input'],\n  opts?: TRPCProcedureOptions,\n) => Promise<coerceAsyncGeneratorToIterable<TDef['output']>>;\n\n/** @internal */\nexport type SubscriptionResolver<TDef extends TRPCResolverDef> = (\n  input: TDef['input'],\n  opts: Partial<\n    TRPCSubscriptionObserver<TDef['output'], TRPCClientError<TDef>>\n  > &\n    TRPCProcedureOptions,\n) => Unsubscribable;\n\ntype DecorateProcedure<\n  TType extends ProcedureType,\n  TDef extends TRPCResolverDef,\n> = TType extends 'query'\n  ? {\n      query: Resolver<TDef>;\n    }\n  : TType extends 'mutation'\n    ? {\n        mutate: Resolver<TDef>;\n      }\n    : TType extends 'subscription'\n      ? {\n          subscribe: SubscriptionResolver<TDef>;\n        }\n      : never;\n\n/**\n * @internal\n */\ntype DecoratedProcedureRecord<\n  TRoot extends InferrableClientTypes,\n  TRecord extends RouterRecord,\n> = {\n  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value\n    ? $Value extends AnyProcedure\n      ? DecorateProcedure<\n          $Value['_def']['type'],\n          {\n            input: inferProcedureInput<$Value>;\n            output: inferTransformedProcedureOutput<\n              inferClientTypes<TRoot>,\n              $Value\n            >;\n            errorShape: inferClientTypes<TRoot>['errorShape'];\n            transformer: inferClientTypes<TRoot>['transformer'];\n          }\n        >\n      : $Value extends RouterRecord\n        ? DecoratedProcedureRecord<TRoot, $Value>\n        : never\n    : never;\n};\n\nconst clientCallTypeMap: Record<\n  keyof DecorateProcedure<any, any>,\n  ProcedureType\n> = {\n  query: 'query',\n  mutate: 'mutation',\n  subscribe: 'subscription',\n};\n\n/** @internal */\nexport const clientCallTypeToProcedureType = (\n  clientCallType: string,\n): ProcedureType => {\n  return clientCallTypeMap[clientCallType as keyof typeof clientCallTypeMap];\n};\n\n/**\n * @internal\n */\nexport function createTRPCClientProxy<TRouter extends AnyRouter>(\n  client: TRPCUntypedClient<TRouter>,\n): TRPCClient<TRouter> {\n  const proxy = createRecursiveProxy<TRPCClient<TRouter>>(({ path, args }) => {\n    const pathCopy = [...path];\n    const procedureType = clientCallTypeToProcedureType(pathCopy.pop()!);\n\n    const fullPath = pathCopy.join('.');\n\n    return (client[procedureType] as any)(fullPath, ...(args as any));\n  });\n  return createFlatProxy<TRPCClient<TRouter>>((key) => {\n    if (key === untypedClientSymbol) {\n      return client;\n    }\n    return proxy[key];\n  });\n}\n\nexport function createTRPCClient<TRouter extends AnyRouter>(\n  opts: CreateTRPCClientOptions<TRouter>,\n): TRPCClient<TRouter> {\n  const client = new TRPCUntypedClient(opts);\n  const proxy = createTRPCClientProxy<TRouter>(client);\n  return proxy;\n}\n\n/**\n * Get an untyped client from a proxy client\n * @internal\n */\nexport function getUntypedClient<TRouter extends AnyRouter>(\n  client: TRPCClient<TRouter>,\n): TRPCUntypedClient<TRouter> {\n  return client[untypedClientSymbol];\n}\n","import type { AnyRouter, ProcedureType } from '@trpc/server';\nimport { observable } from '@trpc/server/observable';\nimport type { TRPCErrorShape, TRPCResponse } from '@trpc/server/rpc';\nimport type { AnyClientTypes } from '@trpc/server/unstable-core-do-not-import';\nimport { jsonlStreamConsumer } from '@trpc/server/unstable-core-do-not-import';\nimport type { BatchLoader } from '../internals/dataLoader';\nimport { dataLoader } from '../internals/dataLoader';\nimport { allAbortSignals, raceAbortSignals } from '../internals/signals';\nimport type { NonEmptyArray } from '../internals/types';\nimport { TRPCClientError } from '../TRPCClientError';\nimport type { HTTPBatchLinkOptions } from './HTTPBatchLinkOptions';\nimport type { HTTPResult } from './internals/httpUtils';\nimport {\n  fetchHTTPResponse,\n  getBody,\n  getUrl,\n  resolveHTTPLinkOptions,\n} from './internals/httpUtils';\nimport type { Operation, TRPCLink } from './types';\n\nexport type HTTPBatchStreamLinkOptions<TRoot extends AnyClientTypes> =\n  HTTPBatchLinkOptions<TRoot> & {\n    /**\n     * Which header to use to signal the server that the client wants a streaming response.\n     * - `'trpc-accept'` (default): sends `trpc-accept: application/jsonl` header\n     * - `'accept'`: sends `Accept: application/jsonl` header, which can avoid CORS preflight for cross-origin streaming queries. Be aware that `application/jsonl` is not an official MIME type and so this is not completely spec-compliant - you should test that your infrastructure supports this value.\n     * @default 'trpc-accept'\n     */\n    streamHeader?: 'trpc-accept' | 'accept';\n  };\n\n/**\n * @see https://trpc.io/docs/client/links/httpBatchStreamLink\n */\nexport function httpBatchStreamLink<TRouter extends AnyRouter>(\n  opts: HTTPBatchStreamLinkOptions<TRouter['_def']['_config']['$types']>,\n): TRPCLink<TRouter> {\n  const resolvedOpts = resolveHTTPLinkOptions(opts);\n  const maxURLLength = opts.maxURLLength ?? Infinity;\n  const maxItems = opts.maxItems ?? Infinity;\n\n  return () => {\n    const batchLoader = (\n      type: ProcedureType,\n    ): BatchLoader<Operation, HTTPResult> => {\n      return {\n        validate(batchOps) {\n          if (maxURLLength === Infinity && maxItems === Infinity) {\n            // escape hatch for quick calcs\n            return true;\n          }\n          if (batchOps.length > maxItems) {\n            return false;\n          }\n          const path = batchOps.map((op) => op.path).join(',');\n          const inputs = batchOps.map((op) => op.input);\n\n          const url = getUrl({\n            ...resolvedOpts,\n            type,\n            path,\n            inputs,\n            signal: null,\n          });\n\n          return url.length <= maxURLLength;\n        },\n        async fetch(batchOps) {\n          const path = batchOps.map((op) => op.path).join(',');\n          const inputs = batchOps.map((op) => op.input);\n\n          const batchSignals = allAbortSignals(\n            ...batchOps.map((op) => op.signal),\n          );\n          const abortController = new AbortController();\n\n          const responsePromise = fetchHTTPResponse({\n            ...resolvedOpts,\n            signal: raceAbortSignals(batchSignals, abortController.signal),\n            type,\n            contentTypeHeader: 'application/json',\n            trpcAcceptHeader: 'application/jsonl',\n            trpcAcceptHeaderKey: opts.streamHeader ?? 'trpc-accept',\n            getUrl,\n            getBody,\n            inputs,\n            path,\n            headers() {\n              if (!opts.headers) {\n                return {};\n              }\n              if (typeof opts.headers === 'function') {\n                return opts.headers({\n                  opList: batchOps as NonEmptyArray<Operation>,\n                });\n              }\n              return opts.headers;\n            },\n          });\n\n          const res = await responsePromise;\n\n          if (!res.ok) {\n            // Server returned a non-2xx response (e.g. batching disabled).\n            // The body is plain JSON, not JSONL, so parse it directly and\n            // propagate the same error to every operation in the batch.\n            const json = (await res.json()) as TRPCResponse;\n            if ('error' in json) {\n              json.error = resolvedOpts.transformer.output.deserialize(\n                json.error,\n              );\n            }\n\n            return batchOps.map((): Promise<HTTPResult> =>\n              Promise.resolve({\n                json,\n                meta: {\n                  response: res,\n                },\n              }),\n            );\n          }\n\n          const [head] = await jsonlStreamConsumer<\n            Record<string, Promise<any>>\n          >({\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            from: res.body!,\n            deserialize: (data) =>\n              resolvedOpts.transformer.output.deserialize(data),\n            // onError: console.error,\n            formatError(opts) {\n              const error = opts.error as TRPCErrorShape;\n              return TRPCClientError.from({\n                error,\n              });\n            },\n            abortController,\n          });\n          const promises = Object.keys(batchOps).map(\n            async (key): Promise<HTTPResult> => {\n              let json: TRPCResponse = await Promise.resolve(head[key]);\n\n              if ('result' in json) {\n                /**\n                 * Not very pretty, but we need to unwrap nested data as promises\n                 * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value\n                 */\n                const result = await Promise.resolve(json.result);\n                json = {\n                  result: {\n                    data: await Promise.resolve(result.data),\n                  },\n                };\n              }\n\n              return {\n                json,\n                meta: {\n                  response: res,\n                },\n              };\n            },\n          );\n          return promises;\n        },\n      };\n    };\n\n    const query = dataLoader(batchLoader('query'));\n    const mutation = dataLoader(batchLoader('mutation'));\n\n    const loaders = { query, mutation };\n    return ({ op }) => {\n      return observable((observer) => {\n        /* istanbul ignore if -- @preserve */\n        if (op.type === 'subscription') {\n          throw new Error(\n            'Subscriptions are unsupported by `httpBatchStreamLink` - use `httpSubscriptionLink` or `wsLink`',\n          );\n        }\n        const ac = new AbortController();\n        const loader = loaders[op.type];\n        const promise = loader.load({\n          ...op,\n          signal: raceAbortSignals(op.signal, ac.signal),\n        });\n\n        let isDone = false;\n        let _res = undefined as HTTPResult | undefined;\n        promise\n          .then((res) => {\n            isDone = true;\n            _res = res;\n            if ('error' in res.json) {\n              observer.error(\n                TRPCClientError.from(res.json, {\n                  meta: res.meta,\n                }),\n              );\n              return;\n            } else if ('result' in res.json) {\n              observer.next({\n                context: res.meta,\n                result: res.json.result,\n              });\n              observer.complete();\n              return;\n            }\n\n            observer.complete();\n          })\n          .catch((err) => {\n            isDone = true;\n            observer.error(\n              TRPCClientError.from(err, {\n                meta: _res?.meta,\n              }),\n            );\n          });\n\n        return () => {\n          if (!isDone) {\n            ac.abort();\n          }\n        };\n      });\n    };\n  };\n}\n\n/**\n * @deprecated use {@link httpBatchStreamLink} instead\n */\nexport const unstable_httpBatchStreamLink = httpBatchStreamLink;\n","export function inputWithTrackedEventId(\n  input: unknown,\n  lastEventId: string | undefined,\n) {\n  if (!lastEventId) {\n    return input;\n  }\n  if (input != null && typeof input !== 'object') {\n    return input;\n  }\n  return {\n    ...(input ?? {}),\n    lastEventId,\n  };\n}\n","import { behaviorSubject, observable } from '@trpc/server/observable';\nimport type { TRPCErrorShape, TRPCResult } from '@trpc/server/rpc';\nimport type {\n  AnyClientTypes,\n  EventSourceLike,\n  inferClientTypes,\n  InferrableClientTypes,\n} from '@trpc/server/unstable-core-do-not-import';\nimport {\n  retryableRpcCodes,\n  run,\n  sseStreamConsumer,\n} from '@trpc/server/unstable-core-do-not-import';\nimport { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId';\nimport { raceAbortSignals } from '../internals/signals';\nimport { TRPCClientError } from '../TRPCClientError';\nimport type { TRPCConnectionState } from '../unstable-internals';\nimport { getTransformer, type TransformerOptions } from '../unstable-internals';\nimport { getUrl } from './internals/httpUtils';\nimport {\n  resultOf,\n  type UrlOptionsWithConnectionParams,\n} from './internals/urlWithConnectionParams';\nimport type { Operation, TRPCLink } from './types';\n\nasync function urlWithConnectionParams(\n  opts: UrlOptionsWithConnectionParams,\n): Promise<string> {\n  let url = await resultOf(opts.url);\n  if (opts.connectionParams) {\n    const params = await resultOf(opts.connectionParams);\n\n    const prefix = url.includes('?') ? '&' : '?';\n    url +=\n      prefix + 'connectionParams=' + encodeURIComponent(JSON.stringify(params));\n  }\n\n  return url;\n}\n\ntype HTTPSubscriptionLinkOptions<\n  TRoot extends AnyClientTypes,\n  TEventSource extends EventSourceLike.AnyConstructor = typeof EventSource,\n> = {\n  /**\n   * EventSource ponyfill\n   */\n  EventSource?: TEventSource;\n  /**\n   * EventSource options or a callback that returns them\n   */\n  eventSourceOptions?:\n    | EventSourceLike.InitDictOf<TEventSource>\n    | ((opts: {\n        op: Operation;\n      }) =>\n        | EventSourceLike.InitDictOf<TEventSource>\n        | Promise<EventSourceLike.InitDictOf<TEventSource>>);\n} & TransformerOptions<TRoot> &\n  UrlOptionsWithConnectionParams;\n\n/**\n * @see https://trpc.io/docs/client/links/httpSubscriptionLink\n */\nexport function httpSubscriptionLink<\n  TInferrable extends InferrableClientTypes,\n  TEventSource extends EventSourceLike.AnyConstructor,\n>(\n  opts: HTTPSubscriptionLinkOptions<\n    inferClientTypes<TInferrable>,\n    TEventSource\n  >,\n): TRPCLink<TInferrable> {\n  const transformer = getTransformer(opts.transformer);\n\n  return () => {\n    return ({ op }) => {\n      return observable((observer) => {\n        const { type, path, input } = op;\n\n        /* istanbul ignore if -- @preserve */\n        if (type !== 'subscription') {\n          throw new Error('httpSubscriptionLink only supports subscriptions');\n        }\n\n        let lastEventId: string | undefined = undefined;\n        const ac = new AbortController();\n        const signal = raceAbortSignals(op.signal, ac.signal);\n        const eventSourceStream = sseStreamConsumer<{\n          EventSource: TEventSource;\n          data: Partial<{\n            id?: string;\n            data: unknown;\n          }>;\n          error: TRPCErrorShape;\n        }>({\n          url: async () =>\n            getUrl({\n              transformer,\n              url: await urlWithConnectionParams(opts),\n              input: inputWithTrackedEventId(input, lastEventId),\n              path,\n              type,\n              signal: null,\n            }),\n          init: () => resultOf(opts.eventSourceOptions, { op }),\n          signal,\n          deserialize: (data) => transformer.output.deserialize(data),\n          EventSource: opts.EventSource ?? (globalThis.EventSource as never),\n        });\n\n        const connectionState = behaviorSubject<\n          TRPCConnectionState<TRPCClientError<any>>\n        >({\n          type: 'state',\n          state: 'connecting',\n          error: null,\n        });\n\n        const connectionSub = connectionState.subscribe({\n          next(state) {\n            observer.next({\n              result: state,\n            });\n          },\n        });\n        run(async () => {\n          for await (const chunk of eventSourceStream) {\n            switch (chunk.type) {\n              case 'ping':\n                // do nothing\n                break;\n              case 'data':\n                const chunkData = chunk.data;\n\n                let result: TRPCResult<unknown>;\n                if (chunkData.id) {\n                  // if the `tracked()`-helper is used, we always have an `id` field\n                  lastEventId = chunkData.id;\n                  result = {\n                    id: chunkData.id,\n                    data: chunkData,\n                  };\n                } else {\n                  result = {\n                    data: chunkData.data,\n                  };\n                }\n\n                observer.next({\n                  result,\n                  context: {\n                    eventSource: chunk.eventSource,\n                  },\n                });\n                break;\n              case 'connected': {\n                observer.next({\n                  result: {\n                    type: 'started',\n                  },\n                  context: {\n                    eventSource: chunk.eventSource,\n                  },\n                });\n                connectionState.next({\n                  type: 'state',\n                  state: 'pending',\n                  error: null,\n                });\n                break;\n              }\n              case 'serialized-error': {\n                const error = TRPCClientError.from({ error: chunk.error });\n\n                if (retryableRpcCodes.includes(chunk.error.code)) {\n                  //\n                  connectionState.next({\n                    type: 'state',\n                    state: 'connecting',\n                    error,\n                  });\n                  break;\n                }\n                //\n                // non-retryable error, cancel the subscription\n                throw error;\n              }\n              case 'connecting': {\n                const lastState = connectionState.get();\n\n                const error = chunk.event && TRPCClientError.from(chunk.event);\n                if (!error && lastState.state === 'connecting') {\n                  break;\n                }\n\n                connectionState.next({\n                  type: 'state',\n                  state: 'connecting',\n                  error,\n                });\n                break;\n              }\n              case 'timeout': {\n                connectionState.next({\n                  type: 'state',\n                  state: 'connecting',\n                  error: new TRPCClientError(\n                    `Timeout of ${chunk.ms}ms reached while waiting for a response`,\n                  ),\n                });\n              }\n            }\n          }\n          observer.next({\n            result: {\n              type: 'stopped',\n            },\n          });\n          connectionState.next({\n            type: 'state',\n            state: 'idle',\n            error: null,\n          });\n          observer.complete();\n        }).catch((error) => {\n          observer.error(TRPCClientError.from(error));\n        });\n\n        return () => {\n          observer.complete();\n          ac.abort();\n          connectionSub.unsubscribe();\n        };\n      });\n    };\n  };\n}\n\n/**\n * @deprecated use {@link httpSubscriptionLink} instead\n */\nexport const unstable_httpSubscriptionLink = httpSubscriptionLink;\n","/* istanbul ignore file -- @preserve */\n// We're not actually exporting this link\nimport type { Unsubscribable } from '@trpc/server/observable';\nimport { observable } from '@trpc/server/observable';\nimport type { InferrableClientTypes } from '@trpc/server/unstable-core-do-not-import';\nimport { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId';\nimport type { TRPCClientError } from '../TRPCClientError';\nimport type { Operation, TRPCLink } from './types';\n\ninterface RetryLinkOptions<TInferrable extends InferrableClientTypes> {\n  /**\n   * The retry function\n   */\n  retry: (opts: RetryFnOptions<TInferrable>) => boolean;\n  /**\n   * The delay between retries in ms (defaults to 0)\n   */\n  retryDelayMs?: (attempt: number) => number;\n}\n\ninterface RetryFnOptions<TInferrable extends InferrableClientTypes> {\n  /**\n   * The operation that failed\n   */\n  op: Operation;\n  /**\n   * The error that occurred\n   */\n  error: TRPCClientError<TInferrable>;\n  /**\n   * The number of attempts that have been made (including the first call)\n   */\n  attempts: number;\n}\n\n/**\n * @see https://trpc.io/docs/v11/client/links/retryLink\n */\nexport function retryLink<TInferrable extends InferrableClientTypes>(\n  opts: RetryLinkOptions<TInferrable>,\n): TRPCLink<TInferrable> {\n  // initialized config\n  return () => {\n    // initialized in app\n    return (callOpts) => {\n      // initialized for request\n      return observable((observer) => {\n        let next$: Unsubscribable;\n        let callNextTimeout: ReturnType<typeof setTimeout> | undefined =\n          undefined;\n\n        let lastEventId: string | undefined = undefined;\n\n        attempt(1);\n\n        function opWithLastEventId() {\n          const op = callOpts.op;\n          if (!lastEventId) {\n            return op;\n          }\n\n          return {\n            ...op,\n            input: inputWithTrackedEventId(op.input, lastEventId),\n          };\n        }\n\n        function attempt(attempts: number) {\n          const op = opWithLastEventId();\n\n          next$ = callOpts.next(op).subscribe({\n            error(error) {\n              const shouldRetry = opts.retry({\n                op,\n                attempts,\n                error,\n              });\n              if (!shouldRetry) {\n                observer.error(error);\n                return;\n              }\n              const delayMs = opts.retryDelayMs?.(attempts) ?? 0;\n\n              if (delayMs <= 0) {\n                attempt(attempts + 1);\n                return;\n              }\n              callNextTimeout = setTimeout(\n                () => attempt(attempts + 1),\n                delayMs,\n              );\n            },\n            next(envelope) {\n              //\n              if (\n                (!envelope.result.type || envelope.result.type === 'data') &&\n                envelope.result.id\n              ) {\n                //\n                lastEventId = envelope.result.id;\n              }\n\n              observer.next(envelope);\n            },\n            complete() {\n              observer.complete();\n            },\n          });\n        }\n        return () => {\n          next$.unsubscribe();\n          clearTimeout(callNextTimeout);\n        };\n      });\n    };\n  };\n}\n","import {\n  getTRPCErrorFromUnknown,\n  getTRPCErrorShape,\n  isTrackedEnvelope,\n} from '@trpc/server';\nimport { behaviorSubject, observable } from '@trpc/server/observable';\nimport { TRPC_ERROR_CODES_BY_KEY, type TRPCResult } from '@trpc/server/rpc';\nimport {\n  callProcedure,\n  isAbortError,\n  isAsyncIterable,\n  iteratorResource,\n  makeResource,\n  retryableRpcCodes,\n  run,\n  type AnyRouter,\n  type ErrorHandlerOptions,\n  type inferClientTypes,\n  type inferRouterContext,\n} from '@trpc/server/unstable-core-do-not-import';\nimport { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId';\nimport { abortSignalToPromise, raceAbortSignals } from '../internals/signals';\nimport { getTransformer } from '../internals/transformer';\nimport type { TransformerOptions } from '../internals/transformer';\nimport { isTRPCClientError, TRPCClientError } from '../TRPCClientError';\nimport type { TRPCConnectionState } from './internals/subscriptions';\nimport type { TRPCLink } from './types';\n\nexport type LocalLinkOptions<TRouter extends AnyRouter> = {\n  router: TRouter;\n  createContext: () => Promise<inferRouterContext<TRouter>>;\n  onError?: (opts: ErrorHandlerOptions<inferRouterContext<TRouter>>) => void;\n} & TransformerOptions<inferClientTypes<TRouter>>;\n\n/**\n * localLink is a terminating link that allows you to make tRPC procedure calls directly in your application without going through HTTP.\n *\n * @see https://trpc.io/docs/links/localLink\n */\nexport function unstable_localLink<TRouter extends AnyRouter>(\n  opts: LocalLinkOptions<TRouter>,\n): TRPCLink<TRouter> {\n  const transformer = getTransformer(opts.transformer);\n\n  const transformChunk = (chunk: unknown) => {\n    if (opts.transformer) {\n      // assume transformer will do the right thing\n      return chunk;\n    }\n    // Special case for undefined, because `JSON.stringify(undefined)` throws\n    if (chunk === undefined) {\n      return chunk;\n    }\n    const serialized = JSON.stringify(transformer.input.serialize(chunk));\n    const deserialized = JSON.parse(transformer.output.deserialize(serialized));\n    return deserialized;\n  };\n\n  return () =>\n    ({ op }) =>\n      observable((observer) => {\n        let ctx: inferRouterContext<TRouter> | undefined = undefined;\n        const ac = new AbortController();\n\n        const signal = raceAbortSignals(op.signal, ac.signal);\n        const signalPromise = abortSignalToPromise(signal);\n\n        signalPromise.catch(() => {\n          // prevent unhandled rejection\n        });\n\n        let input = op.input;\n        async function runProcedure(newInput: unknown): Promise<unknown> {\n          input = newInput;\n\n          ctx = await opts.createContext();\n\n          return callProcedure({\n            router: opts.router,\n            path: op.path,\n            getRawInput: async () => newInput,\n            ctx,\n            type: op.type,\n            signal,\n            batchIndex: 0,\n          });\n        }\n\n        function onErrorCallback(cause: unknown) {\n          if (isAbortError(cause)) {\n            return;\n          }\n          opts.onError?.({\n            error: getTRPCErrorFromUnknown(cause),\n            type: op.type,\n            path: op.path,\n            input,\n            ctx,\n          });\n        }\n\n        function coerceToTRPCClientError(cause: unknown) {\n          if (isTRPCClientError<TRouter>(cause)) {\n            return cause;\n          }\n          const error = getTRPCErrorFromUnknown(cause);\n\n          const shape = getTRPCErrorShape({\n            config: opts.router._def._config,\n            ctx,\n            error,\n            input,\n            path: op.path,\n            type: op.type,\n          });\n          return TRPCClientError.from(\n            { error: transformChunk(shape) },\n            { cause: cause instanceof Error ? cause : undefined },\n          );\n        }\n\n        run(async () => {\n          switch (op.type) {\n            case 'query':\n            case 'mutation': {\n              const result = await runProcedure(op.input);\n              if (!isAsyncIterable(result)) {\n                observer.next({\n                  result: { data: transformChunk(result) },\n                });\n                observer.complete();\n                break;\n              }\n\n              observer.next({\n                result: {\n                  data: (async function* () {\n                    await using iterator = iteratorResource(result);\n                    using _finally = makeResource({}, () => {\n                      observer.complete();\n                    });\n                    try {\n                      while (true) {\n                        const res = await Promise.race([\n                          iterator.next(),\n                          signalPromise,\n                        ]);\n                        if (res.done) {\n                          return transformChunk(res.value);\n                        }\n                        yield transformChunk(res.value);\n                      }\n                    } catch (cause) {\n                      onErrorCallback(cause);\n                      throw coerceToTRPCClientError(cause);\n                    }\n                  })(),\n                },\n              });\n              break;\n            }\n            case 'subscription': {\n              const connectionState = behaviorSubject<\n                TRPCConnectionState<TRPCClientError<any>>\n              >({\n                type: 'state',\n                state: 'connecting',\n                error: null,\n              });\n\n              const connectionSub = connectionState.subscribe({\n                next(state) {\n                  observer.next({\n                    result: state,\n                  });\n                },\n              });\n              let lastEventId: string | undefined = undefined;\n\n              using _finally = makeResource({}, async () => {\n                observer.complete();\n\n                connectionState.next({\n                  type: 'state',\n                  state: 'idle',\n                  error: null,\n                });\n                connectionSub.unsubscribe();\n              });\n              while (true) {\n                const result = await runProcedure(\n                  inputWithTrackedEventId(op.input, lastEventId),\n                );\n                if (!isAsyncIterable(result)) {\n                  throw new Error('Expected an async iterable');\n                }\n                await using iterator = iteratorResource(result);\n\n                observer.next({\n                  result: {\n                    type: 'started',\n                  },\n                });\n                connectionState.next({\n                  type: 'state',\n                  state: 'pending',\n                  error: null,\n                });\n\n                // Use a while loop to handle errors and reconnects\n                while (true) {\n                  let res;\n                  try {\n                    res = await Promise.race([iterator.next(), signalPromise]);\n                  } catch (cause) {\n                    if (isAbortError(cause)) {\n                      return;\n                    }\n                    const error = getTRPCErrorFromUnknown(cause);\n\n                    if (\n                      !retryableRpcCodes.includes(\n                        TRPC_ERROR_CODES_BY_KEY[error.code],\n                      )\n                    ) {\n                      throw coerceToTRPCClientError(error);\n                    }\n\n                    onErrorCallback(error);\n                    connectionState.next({\n                      type: 'state',\n                      state: 'connecting',\n                      error: coerceToTRPCClientError(error),\n                    });\n\n                    break;\n                  }\n\n                  if (res.done) {\n                    return;\n                  }\n                  let chunk: TRPCResult<unknown>;\n                  if (isTrackedEnvelope(res.value)) {\n                    lastEventId = res.value[0];\n\n                    chunk = {\n                      id: res.value[0],\n                      data: {\n                        id: res.value[0],\n                        data: res.value[1],\n                      },\n                    };\n                  } else {\n                    chunk = {\n                      data: res.value,\n                    };\n                  }\n\n                  observer.next({\n                    result: {\n                      ...chunk,\n                      data: transformChunk(chunk.data),\n                    },\n                  });\n                }\n              }\n              break;\n            }\n          }\n        }).catch((cause) => {\n          onErrorCallback(cause);\n          observer.error(coerceToTRPCClientError(cause));\n        });\n\n        return () => {\n          ac.abort();\n        };\n      });\n}\n/**\n * @deprecated Renamed to `unstable_localLink`. This alias will be removed in a future major release.\n */\nexport const experimental_localLink: typeof unstable_localLink =\n  unstable_localLink;\n"],"mappings":";;;;;;;;;;;;;;AA8CA,IAAa,oBAAb,MAA0E;CAKxE,YAAY,MAA4C;EAJvC,gBAAA,MAAA,SAAA,KAAA,CAAA;EACD,gBAAA,MAAA,WAAA,KAAA,CAAA;EACR,gBAAA,MAAA,aAAA,KAAA,CAAA;EAGN,KAAK,YAAY;EAEjB,KAAK,UAAU,CAAC;EAGhB,KAAK,QAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,KAAK,OAAO,CAAC;CAC1D;CAEA,SAAsD,MAMnD;;EASD,OARe,YAAwC;GACrD,OAAO,KAAK;GACZ,IAAA,eAAA,eAAA,CAAA,GACK,IAAA,GAAA,CAAA,GAAA;IACH,UAAA,gBAAS,KAAK,aAAA,QAAA,kBAAA,KAAA,IAAA,gBAAW,CAAC;IAC1B,IAAI,EAAE,KAAK;GACb,CAAA;EACF,CACY,CAAC,CAAC,KAAK,MAAM,CAAC;CAC5B;CAEA,MAAc,iBAAsD,MAM/C;EACnB,IAAI;GACF,MAAM,OAAO,KAAK,SAA0B,IAAI;GAKhD,QADc,MADS,oBAA4B,IAAI,EAAA,CAChC,OAAe;EAExC,SAAS,KAAK;GACZ,MAAM,gBAAgB,KAAK,GAAY;EACzC;CACF;CACA,MAAa,MAAc,OAAiB,MAA2B;EACrE,OAAO,KAAK,iBAAmC;GAC7C,MAAM;GACN;GACA;GACA,SAAA,SAAA,QAAA,SAAA,KAAA,IAAA,KAAA,IAAS,KAAM;GACf,QAAA,SAAA,QAAA,SAAA,KAAA,IAAA,KAAA,IAAQ,KAAM;EAChB,CAAC;CACH;CACA,SAAgB,MAAc,OAAiB,MAA2B;EACxE,OAAO,KAAK,iBAAmC;GAC7C,MAAM;GACN;GACA;GACA,SAAA,SAAA,QAAA,SAAA,KAAA,IAAA,KAAA,IAAS,KAAM;GACf,QAAA,SAAA,QAAA,SAAA,KAAA,IAAA,KAAA,IAAQ,KAAM;EAChB,CAAC;CACH;CACA,aACE,MACA,OACA,MAIgB;EAQhB,OAPoB,KAAK,SAAS;GAChC,MAAM;GACN;GACA;GACA,SAAS,KAAK;GACd,QAAQ,KAAK;EACf,CACiB,CAAC,CAAC,UAAU;GAC3B,KAAK,UAAU;IACb,QAAQ,SAAS,OAAO,MAAxB;KACE,KAAK;;MACH,CAAA,wBAAA,KAAK,6BAAA,QAAA,0BAAA,KAAA,KAAA,sBAAA,KAAA,MAA0B,SAAS,MAAM;MAC9C;KAEF,KAAK;;MACH,CAAA,kBAAA,KAAK,eAAA,QAAA,oBAAA,KAAA,KAAA,gBAAA,KAAA,MAAY,EACf,SAAS,SAAS,QACpB,CAAC;MACD;KAEF,KAAK;;MACH,CAAA,kBAAA,KAAK,eAAA,QAAA,oBAAA,KAAA,KAAA,gBAAA,KAAA,IAAY;MACjB;KAEF,KAAK;KACL,KAAK,KAAA;;MACH,CAAA,eAAA,KAAK,YAAA,QAAA,iBAAA,KAAA,KAAA,aAAA,KAAA,MAAS,SAAS,OAAO,IAAI;IAGtC;GACF;GACA,MAAM,KAAK;;IACT,CAAA,gBAAA,KAAK,aAAA,QAAA,kBAAA,KAAA,KAAA,cAAA,KAAA,MAAU,GAAG;GACpB;GACA,WAAW;;IACT,CAAA,mBAAA,KAAK,gBAAA,QAAA,qBAAA,KAAA,KAAA,iBAAA,KAAA,IAAa;GACpB;EACF,CAAC;CACH;AACF;;;AC7JA,SAAgB,wBACd,MAC4B;CAC5B,OAAO,IAAI,kBAAkB,IAAI;AACnC;;;AC0BA,MAAM,sBAAsB,OAAO,IAAI,oBAAoB;AAuF3D,MAAM,oBAGF;CACF,OAAO;CACP,QAAQ;CACR,WAAW;AACb;;AAGA,MAAa,iCACX,mBACkB;CAClB,OAAO,kBAAkB;AAC3B;;;;AAKA,SAAgB,sBACd,QACqB;CACrB,MAAM,QAAQ,sBAA2C,EAAE,MAAM,WAAW;EAC1E,MAAM,WAAW,CAAC,GAAG,IAAI;EACzB,MAAM,gBAAgB,8BAA8B,SAAS,IAAI,CAAE;EAEnE,MAAM,WAAW,SAAS,KAAK,GAAG;EAElC,OAAQ,OAAO,cAAc,CAAS,UAAU,GAAI,IAAY;CAClE,CAAC;CACD,OAAO,iBAAsC,QAAQ;EACnD,IAAI,QAAQ,qBACV,OAAO;EAET,OAAO,MAAM;CACf,CAAC;AACH;AAEA,SAAgB,iBACd,MACqB;CAGrB,OADc,sBAA+B,IAD1B,kBAAkB,IACa,CACvC;AACb;;;;;AAMA,SAAgB,iBACd,QAC4B;CAC5B,OAAO,OAAO;AAChB;;;;;;AC7IA,SAAgB,oBACd,MACmB;;CACnB,MAAM,eAAe,uBAAuB,IAAI;CAChD,MAAM,gBAAA,qBAAe,KAAK,kBAAA,QAAA,uBAAA,KAAA,IAAA,qBAAgB;CAC1C,MAAM,YAAA,iBAAW,KAAK,cAAA,QAAA,mBAAA,KAAA,IAAA,iBAAY;CAElC,aAAa;EACX,MAAM,eACJ,SACuC;GACvC,OAAO;IACL,SAAS,UAAU;KACjB,IAAI,iBAAiB,YAAY,aAAa,UAE5C,OAAO;KAET,IAAI,SAAS,SAAS,UACpB,OAAO;KAET,MAAM,OAAO,SAAS,KAAK,OAAO,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG;KACnD,MAAM,SAAS,SAAS,KAAK,OAAO,GAAG,KAAK;KAU5C,OARY,OAAA,eAAA,eAAA,CAAA,GACP,YAAA,GAAA,CAAA,GAAA;MACH;MACA;MACA;MACA,QAAQ;KACV,CAAA,CAES,CAAC,CAAC,UAAU;IACvB;IACA,MAAM,MAAM,UAAU;;KACpB,MAAM,OAAO,SAAS,KAAK,OAAO,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG;KACnD,MAAM,SAAS,SAAS,KAAK,OAAO,GAAG,KAAK;KAE5C,MAAM,eAAe,gBACnB,GAAG,SAAS,KAAK,OAAO,GAAG,MAAM,CACnC;KACA,MAAM,kBAAkB,IAAI,gBAAgB;KA0B5C,MAAM,MAAM,MAxBY,kBAAA,eAAA,eAAA,CAAA,GACnB,YAAA,GAAA,CAAA,GAAA;MACH,QAAQ,iBAAiB,cAAc,gBAAgB,MAAM;MAC7D;MACA,mBAAmB;MACnB,kBAAkB;MAClB,sBAAA,qBAAqB,KAAK,kBAAA,QAAA,uBAAA,KAAA,IAAA,qBAAgB;MAC1C;MACA;MACA;MACA;MACA,UAAU;OACR,IAAI,CAAC,KAAK,SACR,OAAO,CAAC;OAEV,IAAI,OAAO,KAAK,YAAY,YAC1B,OAAO,KAAK,QAAQ,EAClB,QAAQ,SACV,CAAC;OAEH,OAAO,KAAK;MACd;KACF,CAAA,CAEgC;KAEhC,IAAI,CAAC,IAAI,IAAI;MAIX,MAAM,OAAQ,MAAM,IAAI,KAAK;MAC7B,IAAI,WAAW,MACb,KAAK,QAAQ,aAAa,YAAY,OAAO,YAC3C,KAAK,KACP;MAGF,OAAO,SAAS,UACd,QAAQ,QAAQ;OACd;OACA,MAAM,EACJ,UAAU,IACZ;MACF,CAAC,CACH;KACF;KAEA,MAAM,CAAC,QAAQ,MAAM,oBAEnB;MAEA,MAAM,IAAI;MACV,cAAc,SACZ,aAAa,YAAY,OAAO,YAAY,IAAI;MAElD,YAAY,MAAM;OAChB,MAAM,QAAQ,KAAK;OACnB,OAAO,gBAAgB,KAAK,EAC1B,MACF,CAAC;MACH;MACA;KACF,CAAC;KA0BD,OAzBiB,OAAO,KAAK,QAAQ,CAAC,CAAC,IACrC,OAAO,QAA6B;MAClC,IAAI,OAAqB,MAAM,QAAQ,QAAQ,KAAK,IAAI;MAExD,IAAI,YAAY,MAAM;;;;;OAKpB,MAAM,SAAS,MAAM,QAAQ,QAAQ,KAAK,MAAM;OAChD,OAAO,EACL,QAAQ,EACN,MAAM,MAAM,QAAQ,QAAQ,OAAO,IAAI,EACzC,EACF;MACF;MAEA,OAAO;OACL;OACA,MAAM,EACJ,UAAU,IACZ;MACF;KACF,CAEY;IAChB;GACF;EACF;EAKA,MAAM,UAAU;GAAE,OAHJ,WAAW,YAAY,OAAO,CAGtB;GAAG,UAFR,WAAW,YAAY,UAAU,CAElB;EAAE;EAClC,QAAQ,EAAE,SAAS;GACjB,OAAO,YAAY,aAAa;;IAE9B,IAAI,GAAG,SAAS,gBACd,MAAM,IAAI,MACR,iGACF;IAEF,MAAM,KAAK,IAAI,gBAAgB;IAE/B,MAAM,UADS,QAAQ,GAAG,KACJ,CAAC,KAAA,eAAA,eAAA,CAAA,GAClB,EAAA,GAAA,CAAA,GAAA,EACH,QAAQ,iBAAiB,GAAG,QAAQ,GAAG,MAAM,EAAA,CAC/C,CAAC;IAED,IAAI,SAAS;IACb,IAAI,OAAO,KAAA;IACX,QACG,MAAM,QAAQ;KACb,SAAS;KACT,OAAO;KACP,IAAI,WAAW,IAAI,MAAM;MACvB,SAAS,MACP,gBAAgB,KAAK,IAAI,MAAM,EAC7B,MAAM,IAAI,KACZ,CAAC,CACH;MACA;KACF,OAAO,IAAI,YAAY,IAAI,MAAM;MAC/B,SAAS,KAAK;OACZ,SAAS,IAAI;OACb,QAAQ,IAAI,KAAK;MACnB,CAAC;MACD,SAAS,SAAS;MAClB;KACF;KAEA,SAAS,SAAS;IACpB,CAAC,CAAC,CACD,OAAO,QAAQ;KACd,SAAS;KACT,SAAS,MACP,gBAAgB,KAAK,KAAK,EACxB,MAAA,SAAA,QAAA,SAAA,KAAA,IAAA,KAAA,IAAM,KAAM,KACd,CAAC,CACH;IACF,CAAC;IAEH,aAAa;KACX,IAAI,CAAC,QACH,GAAG,MAAM;IAEb;GACF,CAAC;EACH;CACF;AACF;;;;AAKA,MAAa,+BAA+B;;;AC1O5C,SAAgB,wBACd,OACA,aACA;CACA,IAAI,CAAC,aACH,OAAO;CAET,IAAI,SAAS,QAAQ,OAAO,UAAU,UACpC,OAAO;CAET,OAAA,eAAA,eAAA,CAAA,GACM,UAAA,QAAA,UAAA,KAAA,IAAA,QAAS,CAAC,CAAA,GAAA,CAAA,GAAA,EACd,YAAA,CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACWA,eAAe,wBACb,MACiB;CACjB,IAAI,MAAM,MAAM,SAAS,KAAK,GAAG;CACjC,IAAI,KAAK,kBAAkB;EACzB,MAAM,SAAS,MAAM,SAAS,KAAK,gBAAgB;EAEnD,MAAM,SAAS,IAAI,SAAS,GAAG,IAAI,MAAM;EACzC,OACE,SAAS,sBAAsB,mBAAmB,KAAK,UAAU,MAAM,CAAC;CAC5E;CAEA,OAAO;AACT;;;;AA0BA,SAAgB,qBAId,MAIuB;CACvB,MAAM,cAAc,eAAe,KAAK,WAAW;CAEnD,aAAa;EACX,QAAQ,EAAE,SAAS;GACjB,OAAO,YAAY,aAAa;;IAC9B,MAAM,EAAE,MAAM,MAAM,UAAU;;IAG9B,IAAI,SAAS,gBACX,MAAM,IAAI,MAAM,kDAAkD;IAGpE,IAAI,cAAkC,KAAA;IACtC,MAAM,KAAK,IAAI,gBAAgB;IAC/B,MAAM,SAAS,iBAAiB,GAAG,QAAQ,GAAG,MAAM;IACpD,MAAM,oBAAoB,kBAOvB;KACD,KAAK,YACH,OAAO;MACL;MACA,KAAK,MAAM,wBAAwB,IAAI;MACvC,OAAO,wBAAwB,OAAO,WAAW;MACjD;MACA;MACA,QAAQ;KACV,CAAC;KACH,YAAY,SAAS,KAAK,oBAAoB,EAAE,GAAG,CAAC;KACpD;KACA,cAAc,SAAS,YAAY,OAAO,YAAY,IAAI;KAC1D,cAAA,oBAAa,KAAK,iBAAA,QAAA,sBAAA,KAAA,IAAA,oBAAgB,WAAW;IAC/C,CAAC;IAED,MAAM,kBAAkB,gBAEtB;KACA,MAAM;KACN,OAAO;KACP,OAAO;IACT,CAAC;IAED,MAAM,gBAAgB,gBAAgB,UAAU,EAC9C,KAAK,OAAO;KACV,SAAS,KAAK,EACZ,QAAQ,MACV,CAAC;IACH,EACF,CAAC;IACD,IAAI,YAAY;;;;KACd,IAAA;MAA0B,KAAA,IAAA,YAAA,eAAA,iBAAA,GAAA,OAAA,4BAAA,EAAA,QAAA,MAAA,UAAA,KAAA,EAAA,CAAA,MAAA,4BAAA,OAAA;OAAT,MAAA,QAAA,MAAA;OACf,QAAQ,MAAM,MAAd;QACE,KAAK,QAEH;QACF,KAAK;SACH,MAAM,YAAY,MAAM;SAExB,IAAI;SACJ,IAAI,UAAU,IAAI;UAEhB,cAAc,UAAU;UACxB,SAAS;WACP,IAAI,UAAU;WACd,MAAM;UACR;SACF,OACE,SAAS,EACP,MAAM,UAAU,KAClB;SAGF,SAAS,KAAK;UACZ;UACA,SAAS,EACP,aAAa,MAAM,YACrB;SACF,CAAC;SACD;QACF,KAAK;SACH,SAAS,KAAK;UACZ,QAAQ,EACN,MAAM,UACR;UACA,SAAS,EACP,aAAa,MAAM,YACrB;SACF,CAAC;SACD,gBAAgB,KAAK;UACnB,MAAM;UACN,OAAO;UACP,OAAO;SACT,CAAC;SACD;QAEF,KAAK,oBAAoB;SACvB,MAAM,QAAQ,gBAAgB,KAAK,EAAE,OAAO,MAAM,MAAM,CAAC;SAEzD,IAAI,kBAAkB,SAAS,MAAM,MAAM,IAAI,GAAG;UAEhD,gBAAgB,KAAK;WACnB,MAAM;WACN,OAAO;WACP;UACF,CAAC;UACD;SACF;SAGA,MAAM;QACR;QACA,KAAK,cAAc;SACjB,MAAM,YAAY,gBAAgB,IAAI;SAEtC,MAAM,QAAQ,MAAM,SAAS,gBAAgB,KAAK,MAAM,KAAK;SAC7D,IAAI,CAAC,SAAS,UAAU,UAAU,cAChC;SAGF,gBAAgB,KAAK;UACnB,MAAM;UACN,OAAO;UACP;SACF,CAAC;SACD;QACF;QACA,KAAK,WACH,gBAAgB,KAAK;SACnB,MAAM;SACN,OAAO;SACP,OAAO,IAAI,gBACT,cAAc,MAAM,GAAG,wCACzB;QACF,CAAC;OAEL;;;;;;;;;;;;KAEF,SAAS,KAAK,EACZ,QAAQ,EACN,MAAM,UACR,EACF,CAAC;KACD,gBAAgB,KAAK;MACnB,MAAM;MACN,OAAO;MACP,OAAO;KACT,CAAC;KACD,SAAS,SAAS;IACpB,CAAC,CAAC,CAAC,OAAO,UAAU;KAClB,SAAS,MAAM,gBAAgB,KAAK,KAAK,CAAC;IAC5C,CAAC;IAED,aAAa;KACX,SAAS,SAAS;KAClB,GAAG,MAAM;KACT,cAAc,YAAY;IAC5B;GACF,CAAC;EACH;CACF;AACF;;;;AAKA,MAAa,gCAAgC;;;;;;;AC5M7C,SAAgB,UACd,MACuB;CAEvB,aAAa;EAEX,QAAQ,aAAa;GAEnB,OAAO,YAAY,aAAa;IAC9B,IAAI;IACJ,IAAI,kBACF,KAAA;IAEF,IAAI,cAAkC,KAAA;IAEtC,QAAQ,CAAC;IAET,SAAS,oBAAoB;KAC3B,MAAM,KAAK,SAAS;KACpB,IAAI,CAAC,aACH,OAAO;KAGT,OAAA,eAAA,eAAA,CAAA,GACK,EAAA,GAAA,CAAA,GAAA,EACH,OAAO,wBAAwB,GAAG,OAAO,WAAW,EAAA,CACtD;IACF;IAEA,SAAS,QAAQ,UAAkB;KACjC,MAAM,KAAK,kBAAkB;KAE7B,QAAQ,SAAS,KAAK,EAAE,CAAC,CAAC,UAAU;MAClC,MAAM,OAAO;;OAMX,IAAI,CALgB,KAAK,MAAM;QAC7B;QACA;QACA;OACF,CACe,GAAG;QAChB,SAAS,MAAM,KAAK;QACpB;OACF;OACA,MAAM,WAAA,sBAAA,sBAAU,KAAK,kBAAA,QAAA,wBAAA,KAAA,IAAA,KAAA,IAAA,oBAAA,KAAA,MAAe,QAAQ,OAAA,QAAA,uBAAA,KAAA,IAAA,qBAAK;OAEjD,IAAI,WAAW,GAAG;QAChB,QAAQ,WAAW,CAAC;QACpB;OACF;OACA,kBAAkB,iBACV,QAAQ,WAAW,CAAC,GAC1B,OACF;MACF;MACA,KAAK,UAAU;OAEb,KACG,CAAC,SAAS,OAAO,QAAQ,SAAS,OAAO,SAAS,WACnD,SAAS,OAAO,IAGhB,cAAc,SAAS,OAAO;OAGhC,SAAS,KAAK,QAAQ;MACxB;MACA,WAAW;OACT,SAAS,SAAS;MACpB;KACF,CAAC;IACH;IACA,aAAa;KACX,MAAM,YAAY;KAClB,aAAa,eAAe;IAC9B;GACF,CAAC;EACH;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7EA,SAAgB,mBACd,MACmB;CACnB,MAAM,cAAc,eAAe,KAAK,WAAW;CAEnD,MAAM,kBAAkB,UAAmB;EACzC,IAAI,KAAK,aAEP,OAAO;EAGT,IAAI,UAAU,KAAA,GACZ,OAAO;EAET,MAAM,aAAa,KAAK,UAAU,YAAY,MAAM,UAAU,KAAK,CAAC;EAEpE,OADqB,KAAK,MAAM,YAAY,OAAO,YAAY,UAAU,CACvD;CACpB;CAEA,cACG,EAAE,SACD,YAAY,aAAa;EACvB,IAAI,MAA+C,KAAA;EACnD,MAAM,KAAK,IAAI,gBAAgB;EAE/B,MAAM,SAAS,iBAAiB,GAAG,QAAQ,GAAG,MAAM;EACpD,MAAM,gBAAgB,qBAAqB,MAAM;EAEjD,cAAc,YAAY,CAE1B,CAAC;EAED,IAAI,QAAQ,GAAG;EACf,eAAe,aAAa,UAAqC;GAC/D,QAAQ;GAER,MAAM,MAAM,KAAK,cAAc;GAE/B,OAAO,cAAc;IACnB,QAAQ,KAAK;IACb,MAAM,GAAG;IACT,aAAa,YAAY;IACzB;IACA,MAAM,GAAG;IACT;IACA,YAAY;GACd,CAAC;EACH;EAEA,SAAS,gBAAgB,OAAgB;;GACvC,IAAI,aAAa,KAAK,GACpB;GAEF,CAAA,gBAAA,KAAK,aAAA,QAAA,kBAAA,KAAA,KAAA,cAAA,KAAA,MAAU;IACb,OAAO,wBAAwB,KAAK;IACpC,MAAM,GAAG;IACT,MAAM,GAAG;IACT;IACA;GACF,CAAC;EACH;EAEA,SAAS,wBAAwB,OAAgB;GAC/C,IAAI,kBAA2B,KAAK,GAClC,OAAO;GAET,MAAM,QAAQ,wBAAwB,KAAK;GAE3C,MAAM,QAAQ,kBAAkB;IAC9B,QAAQ,KAAK,OAAO,KAAK;IACzB;IACA;IACA;IACA,MAAM,GAAG;IACT,MAAM,GAAG;GACX,CAAC;GACD,OAAO,gBAAgB,KACrB,EAAE,OAAO,eAAe,KAAK,EAAE,GAC/B,EAAE,OAAO,iBAAiB,QAAQ,QAAQ,KAAA,EAAU,CACtD;EACF;EAEA,IAAI,YAAY;GACd,QAAQ,GAAG,MAAX;IACE,KAAK;IACL,KAAK,YAAY;KACf,MAAM,SAAS,MAAM,aAAa,GAAG,KAAK;KAC1C,IAAI,CAAC,gBAAgB,MAAM,GAAG;MAC5B,SAAS,KAAK,EACZ,QAAQ,EAAE,MAAM,eAAe,MAAM,EAAE,EACzC,CAAC;MACD,SAAS,SAAS;MAClB;KACF;KAEA,SAAS,KAAK,EACZ,QAAQ,EACN,MAAA,oBAAA,aAA0B;;;OACxB,MAAY,WAAA,YAAA,EAAW,iBAAiB,MAAM,CAAA;OAC7B,YAAA,EAAA,aAAa,CAAC,SAAS;QACtC,SAAS,SAAS;OACpB,CAAC,CAAA;OACD,IAAI;QACF,OAAO,MAAM;SACX,MAAM,MAAA,MAAA,qBAAY,QAAQ,KAAK,CAC7B,SAAS,KAAK,GACd,aACF,CAAC,CAAA;SACD,IAAI,IAAI,MACN,OAAO,eAAe,IAAI,KAAK;SAEjC,MAAM,eAAe,IAAI,KAAK;QAChC;OACF,SAAS,OAAO;QACd,gBAAgB,KAAK;QACrB,MAAM,wBAAwB,KAAK;OACrC;;;;;;KACF,CAAA,CAAA,CAAG,EACL,EACF,CAAC;KACD;IACF;IACA,KAAK,gBAAgB,IAAA;;KACnB,MAAM,kBAAkB,gBAEtB;MACA,MAAM;MACN,OAAO;MACP,OAAO;KACT,CAAC;KAED,MAAM,gBAAgB,gBAAgB,UAAU,EAC9C,KAAK,OAAO;MACV,SAAS,KAAK,EACZ,QAAQ,MACV,CAAC;KACH,EACF,CAAC;KACD,IAAI,cAAkC,KAAA;KAErB,WAAA,EAAA,aAAa,CAAC,GAAG,YAAY;MAC5C,SAAS,SAAS;MAElB,gBAAgB,KAAK;OACnB,MAAM;OACN,OAAO;OACP,OAAO;MACT,CAAC;MACD,cAAc,YAAY;KAC5B,CAAC,CAAA;KACD,OAAO,MAAM,IAAA;;MACX,MAAM,SAAS,MAAM,aACnB,wBAAwB,GAAG,OAAO,WAAW,CAC/C;MACA,IAAI,CAAC,gBAAgB,MAAM,GACzB,MAAM,IAAI,MAAM,4BAA4B;MAE9C,MAAY,WAAA,WAAA,EAAW,iBAAiB,MAAM,CAAA;MAE9C,SAAS,KAAK,EACZ,QAAQ,EACN,MAAM,UACR,EACF,CAAC;MACD,gBAAgB,KAAK;OACnB,MAAM;OACN,OAAO;OACP,OAAO;MACT,CAAC;MAGD,OAAO,MAAM;OACX,IAAI;OACJ,IAAI;QACF,MAAM,MAAM,QAAQ,KAAK,CAAC,SAAS,KAAK,GAAG,aAAa,CAAC;OAC3D,SAAS,OAAO;QACd,IAAI,aAAa,KAAK,GACpB;QAEF,MAAM,QAAQ,wBAAwB,KAAK;QAE3C,IACE,CAAC,kBAAkB,SACjB,wBAAwB,MAAM,KAChC,GAEA,MAAM,wBAAwB,KAAK;QAGrC,gBAAgB,KAAK;QACrB,gBAAgB,KAAK;SACnB,MAAM;SACN,OAAO;SACP,OAAO,wBAAwB,KAAK;QACtC,CAAC;QAED;OACF;OAEA,IAAI,IAAI,MACN;OAEF,IAAI;OACJ,IAAI,kBAAkB,IAAI,KAAK,GAAG;QAChC,cAAc,IAAI,MAAM;QAExB,QAAQ;SACN,IAAI,IAAI,MAAM;SACd,MAAM;UACJ,IAAI,IAAI,MAAM;UACd,MAAM,IAAI,MAAM;SAClB;QACF;OACF,OACE,QAAQ,EACN,MAAM,IAAI,MACZ;OAGF,SAAS,KAAK,EACZ,QAAA,eAAA,eAAA,CAAA,GACK,KAAA,GAAA,CAAA,GAAA,EACH,MAAM,eAAe,MAAM,IAAI,EAAA,CACjC,EACF,CAAC;MACH;;;;;;KAEF;;;;;;GAEJ;EACF,CAAC,CAAC,CAAC,OAAO,UAAU;GAClB,gBAAgB,KAAK;GACrB,SAAS,MAAM,wBAAwB,KAAK,CAAC;EAC/C,CAAC;EAED,aAAa;GACX,GAAG,MAAM;EACX;CACF,CAAC;AACP;;;;AAIA,MAAa,yBACX"}