{"version":3,"file":"resource-CEl6olOs.js","sources":["../../src/semanticAttributes.ts","../../src/utils/getParentSpanId.ts","../../src/utils/spanTypes.ts","../../src/utils/getRequestSpanData.ts","../../src/custom/client.ts","../../src/utils/getSpanKind.ts","../../src/constants.ts","../../src/utils/contextData.ts","../../src/utils/isSentryRequest.ts","../../src/utils/getSamplingDecision.ts","../../src/utils/parseSpanDescription.ts","../../src/utils/enhanceDscWithOpenTelemetryRootSpanName.ts","../../src/utils/getActiveSpan.ts","../../src/utils/TraceState.ts","../../src/utils/makeTraceState.ts","../../src/utils/setupCheck.ts","../../src/propagator.ts","../../src/trace.ts","../../src/utils/suppressTracing.ts","../../src/setupEventContextTrace.ts","../../src/utils/getTraceData.ts","../../src/asyncContextStrategy.ts","../../src/utils/buildContextWithSentryScopes.ts","../../src/contextManager.ts","../../src/utils/groupSpansWithParents.ts","../../src/utils/mapStatus.ts","../../src/spanExporter.ts","../../src/spanProcessor.ts","../../src/sampler.ts","../../src/resource.ts"],"sourcesContent":["/** If this attribute is true, it means that the parent is a remote span. */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE = 'sentry.parentIsRemote';\n\n// These are not standardized yet, but used by the graphql instrumentation\nexport const SEMANTIC_ATTRIBUTE_SENTRY_GRAPHQL_OPERATION = 'sentry.graphql.operation';\n","import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';\n\n/**\n * Get the parent span id from a span.\n * In OTel v1, the parent span id is accessed as `parentSpanId`\n * In OTel v2, the parent span id is accessed as `spanId` on the `parentSpanContext`\n */\nexport function getParentSpanId(span: ReadableSpan): string | undefined {\n  if ('parentSpanId' in span) {\n    return span.parentSpanId as string | undefined;\n  } else if ('parentSpanContext' in span) {\n    return (span.parentSpanContext as { spanId?: string } | undefined)?.spanId;\n  }\n\n  return undefined;\n}\n","import type { SpanKind, SpanStatus } from '@opentelemetry/api';\nimport type { ReadableSpan, TimedEvent } from '@opentelemetry/sdk-trace-base';\nimport type { AbstractSpan } from '../types';\nimport { getParentSpanId } from './getParentSpanId';\n\n/**\n * Check if a given span has attributes.\n * This is necessary because the base `Span` type does not have attributes,\n * so in places where we are passed a generic span, we need to check if we want to access them.\n */\nexport function spanHasAttributes<SpanType extends AbstractSpan>(\n  span: SpanType,\n): span is SpanType & { attributes: ReadableSpan['attributes'] } {\n  const castSpan = span as ReadableSpan;\n  return !!castSpan.attributes && typeof castSpan.attributes === 'object';\n}\n\n/**\n * Check if a given span has a kind.\n * This is necessary because the base `Span` type does not have a kind,\n * so in places where we are passed a generic span, we need to check if we want to access it.\n */\nexport function spanHasKind<SpanType extends AbstractSpan>(span: SpanType): span is SpanType & { kind: SpanKind } {\n  const castSpan = span as ReadableSpan;\n  return typeof castSpan.kind === 'number';\n}\n\n/**\n * Check if a given span has a status.\n * This is necessary because the base `Span` type does not have a status,\n * so in places where we are passed a generic span, we need to check if we want to access it.\n */\nexport function spanHasStatus<SpanType extends AbstractSpan>(\n  span: SpanType,\n): span is SpanType & { status: SpanStatus } {\n  const castSpan = span as ReadableSpan;\n  return !!castSpan.status;\n}\n\n/**\n * Check if a given span has a name.\n * This is necessary because the base `Span` type does not have a name,\n * so in places where we are passed a generic span, we need to check if we want to access it.\n */\nexport function spanHasName<SpanType extends AbstractSpan>(span: SpanType): span is SpanType & { name: string } {\n  const castSpan = span as ReadableSpan;\n  return !!castSpan.name;\n}\n\n/**\n * Check if a given span has a kind.\n * This is necessary because the base `Span` type does not have a kind,\n * so in places where we are passed a generic span, we need to check if we want to access it.\n */\nexport function spanHasParentId<SpanType extends AbstractSpan>(\n  span: SpanType,\n): span is SpanType & { parentSpanId: string } {\n  const castSpan = span as ReadableSpan;\n  return !!getParentSpanId(castSpan);\n}\n\n/**\n * Check if a given span has events.\n * This is necessary because the base `Span` type does not have events,\n * so in places where we are passed a generic span, we need to check if we want to access it.\n */\nexport function spanHasEvents<SpanType extends AbstractSpan>(\n  span: SpanType,\n): span is SpanType & { events: TimedEvent[] } {\n  const castSpan = span as ReadableSpan;\n  return Array.isArray(castSpan.events);\n}\n","import type { Span } from '@opentelemetry/api';\nimport type { ReadableSpan } from '@opentelemetry/sdk-trace-base';\nimport {\n  ATTR_HTTP_REQUEST_METHOD,\n  ATTR_URL_FULL,\n  SEMATTRS_HTTP_METHOD,\n  SEMATTRS_HTTP_URL,\n} from '@opentelemetry/semantic-conventions';\nimport type { SanitizedRequestData } from '@sentry/core';\nimport { getSanitizedUrlString, parseUrl } from '@sentry/core';\nimport { spanHasAttributes } from './spanTypes';\n\n/**\n * Get sanitizied request data from an OTEL span.\n */\nexport function getRequestSpanData(span: Span | ReadableSpan): Partial<SanitizedRequestData> {\n  // The base `Span` type has no `attributes`, so we need to guard here against that\n  if (!spanHasAttributes(span)) {\n    return {};\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  const maybeUrlAttribute = (span.attributes[ATTR_URL_FULL] || span.attributes[SEMATTRS_HTTP_URL]) as\n    | string\n    | undefined;\n\n  const data: Partial<SanitizedRequestData> = {\n    url: maybeUrlAttribute,\n    // eslint-disable-next-line deprecation/deprecation\n    'http.method': (span.attributes[ATTR_HTTP_REQUEST_METHOD] || span.attributes[SEMATTRS_HTTP_METHOD]) as\n      | string\n      | undefined,\n  };\n\n  // Default to GET if URL is set but method is not\n  if (!data['http.method'] && data.url) {\n    data['http.method'] = 'GET';\n  }\n\n  try {\n    if (typeof maybeUrlAttribute === 'string') {\n      const url = parseUrl(maybeUrlAttribute);\n\n      data.url = getSanitizedUrlString(url);\n\n      if (url.search) {\n        data['http.query'] = url.search;\n      }\n      if (url.hash) {\n        data['http.fragment'] = url.hash;\n      }\n    }\n  } catch {\n    // ignore\n  }\n\n  return data;\n}\n","import type { Tracer } from '@opentelemetry/api';\nimport { trace } from '@opentelemetry/api';\nimport type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';\nimport type { Client } from '@sentry/core';\nimport { SDK_VERSION } from '@sentry/core';\nimport type { OpenTelemetryClient as OpenTelemetryClientInterface } from '../types';\n\n// Typescript complains if we do not use `...args: any[]` for the mixin, with:\n// A mixin class must have a constructor with a single rest parameter of type 'any[]'.ts(2545)\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Wrap an Client class with things we need for OpenTelemetry support.\n * Make sure that the Client class passed in is non-abstract!\n *\n * Usage:\n * const OpenTelemetryClient = getWrappedClientClass(NodeClient);\n * const client = new OpenTelemetryClient(options);\n */\nexport function wrapClientClass<\n  ClassConstructor extends new (...args: any[]) => Client,\n  WrappedClassConstructor extends new (...args: any[]) => Client & OpenTelemetryClientInterface,\n>(ClientClass: ClassConstructor): WrappedClassConstructor {\n  // @ts-expect-error We just assume that this is non-abstract, if you pass in an abstract class this would make it non-abstract\n  class OpenTelemetryClient extends ClientClass implements OpenTelemetryClientInterface {\n    public traceProvider: BasicTracerProvider | undefined;\n    private _tracer: Tracer | undefined;\n\n    public constructor(...args: any[]) {\n      super(...args);\n    }\n\n    /** Get the OTEL tracer. */\n    public get tracer(): Tracer {\n      if (this._tracer) {\n        return this._tracer;\n      }\n\n      const name = '@sentry/opentelemetry';\n      const version = SDK_VERSION;\n      const tracer = trace.getTracer(name, version);\n      this._tracer = tracer;\n\n      return tracer;\n    }\n\n    /**\n     * @inheritDoc\n     */\n    public async flush(timeout?: number): Promise<boolean> {\n      const provider = this.traceProvider;\n      await provider?.forceFlush();\n      return super.flush(timeout);\n    }\n  }\n\n  return OpenTelemetryClient as unknown as WrappedClassConstructor;\n}\n/* eslint-enable @typescript-eslint/no-explicit-any */\n","import { SpanKind } from '@opentelemetry/api';\nimport type { AbstractSpan } from '../types';\nimport { spanHasKind } from './spanTypes';\n\n/**\n * Get the span kind from a span.\n * For whatever reason, this is not public API on the generic \"Span\" type,\n * so we need to check if we actually have a `SDKTraceBaseSpan` where we can fetch this from.\n * Otherwise, we fall back to `SpanKind.INTERNAL`.\n */\nexport function getSpanKind(span: AbstractSpan): SpanKind {\n  if (spanHasKind(span)) {\n    return span.kind;\n  }\n\n  return SpanKind.INTERNAL;\n}\n","import { createContextKey } from '@opentelemetry/api';\n\nexport const SENTRY_TRACE_HEADER = 'sentry-trace';\nexport const SENTRY_BAGGAGE_HEADER = 'baggage';\n\nexport const SENTRY_TRACE_STATE_DSC = 'sentry.dsc';\nexport const SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING = 'sentry.sampled_not_recording';\nexport const SENTRY_TRACE_STATE_URL = 'sentry.url';\nexport const SENTRY_TRACE_STATE_SAMPLE_RAND = 'sentry.sample_rand';\nexport const SENTRY_TRACE_STATE_SAMPLE_RATE = 'sentry.sample_rate';\n\n/**\n *  A flag marking a context as ignored because the span associated with the context\n *  is ignored (`ignoreSpans` filter).\n */\nexport const SENTRY_TRACE_STATE_CHILD_IGNORED = 'sentry.ignored';\n\n/**\n *  A flag marking a segment span as ignored because it matched the `ignoreSpans` filter.\n *  Unlike `SENTRY_TRACE_STATE_CHILD_IGNORED` (used for child spans), this flag is NOT consumed\n *  by the context manager for re-parenting. Instead, it propagates to child spans so they\n *  can record the correct client report outcome (`ignored` instead of `sample_rate`).\n */\nexport const SENTRY_TRACE_STATE_SEGMENT_IGNORED = 'sentry.segment_ignored';\n\nexport const SENTRY_SCOPES_CONTEXT_KEY = createContextKey('sentry_scopes');\n\nexport const SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY = createContextKey('sentry_fork_isolation_scope');\n\nexport const SENTRY_FORK_SET_SCOPE_CONTEXT_KEY = createContextKey('sentry_fork_set_scope');\n\nexport const SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY = createContextKey('sentry_fork_set_isolation_scope');\n","import type { Context } from '@opentelemetry/api';\nimport type { Scope } from '@sentry/core';\nimport { addNonEnumerableProperty, derefWeakRef, makeWeakRef, type MaybeWeakRef } from '@sentry/core';\nimport { SENTRY_SCOPES_CONTEXT_KEY } from '../constants';\nimport type { CurrentScopes } from '../types';\n\nconst SCOPE_CONTEXT_FIELD = '_scopeContext';\n\ntype ScopeWithContext = Scope & {\n  [SCOPE_CONTEXT_FIELD]?: MaybeWeakRef<Context>;\n};\n\n/**\n * Try to get the current scopes from the given OTEL context.\n * This requires a Context Manager that was wrapped with getWrappedContextManager.\n */\nexport function getScopesFromContext(context: Context): CurrentScopes | undefined {\n  return context.getValue(SENTRY_SCOPES_CONTEXT_KEY) as CurrentScopes | undefined;\n}\n\n/**\n * Set the current scopes on an OTEL context.\n * This will return a forked context with the Propagation Context set.\n */\nexport function setScopesOnContext(context: Context, scopes: CurrentScopes): Context {\n  return context.setValue(SENTRY_SCOPES_CONTEXT_KEY, scopes);\n}\n\n/**\n * Set the context on the scope so we can later look it up.\n * We need this to get the context from the scope in the `trace` functions.\n *\n * We use WeakRef to avoid a circular reference between the scope and the context.\n * The context holds scopes (via SENTRY_SCOPES_CONTEXT_KEY), and if the scope held\n * a strong reference back to the context, neither could be garbage collected even\n * when the context is no longer reachable from application code (e.g., after a\n * request completes but pooled connections retain patched callbacks).\n */\nexport function setContextOnScope(scope: Scope, context: Context): void {\n  addNonEnumerableProperty(scope, SCOPE_CONTEXT_FIELD, makeWeakRef(context));\n}\n\n/**\n * Get the context related to a scope.\n * Returns undefined if the context has been garbage collected (when WeakRef is used).\n */\nexport function getContextFromScope(scope: Scope): Context | undefined {\n  return derefWeakRef((scope as ScopeWithContext)[SCOPE_CONTEXT_FIELD]);\n}\n","import { ATTR_URL_FULL, SEMATTRS_HTTP_URL } from '@opentelemetry/semantic-conventions';\nimport { getClient, isSentryRequestUrl } from '@sentry/core';\nimport type { AbstractSpan } from '../types';\nimport { spanHasAttributes } from './spanTypes';\n\n/**\n *\n * @param otelSpan Checks whether a given OTEL Span is an http request to sentry.\n * @returns boolean\n */\nexport function isSentryRequestSpan(span: AbstractSpan): boolean {\n  if (!spanHasAttributes(span)) {\n    return false;\n  }\n\n  const { attributes } = span;\n\n  // `ATTR_URL_FULL` is the new attribute, but we still support the old one, `ATTR_HTTP_URL`, for now.\n  // eslint-disable-next-line deprecation/deprecation\n  const httpUrl = attributes[SEMATTRS_HTTP_URL] || attributes[ATTR_URL_FULL];\n\n  if (!httpUrl) {\n    return false;\n  }\n\n  return isSentryRequestUrl(httpUrl.toString(), getClient());\n}\n","import type { SpanContext } from '@opentelemetry/api';\nimport { TraceFlags } from '@opentelemetry/api';\nimport { baggageHeaderToDynamicSamplingContext } from '@sentry/core';\nimport { SENTRY_TRACE_STATE_DSC, SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING } from '../constants';\n\n/**\n * OpenTelemetry only knows about SAMPLED or NONE decision,\n * but for us it is important to differentiate between unset and unsampled.\n *\n * Both of these are identified as `traceFlags === TracegFlags.NONE`,\n * but we additionally look at a special trace state to differentiate between them.\n */\nexport function getSamplingDecision(spanContext: SpanContext): boolean | undefined {\n  const { traceFlags, traceState } = spanContext;\n\n  const sampledNotRecording = traceState ? traceState.get(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING) === '1' : false;\n\n  // If trace flag is `SAMPLED`, we interpret this as sampled\n  // If it is `NONE`, it could mean either it was sampled to be not recorder, or that it was not sampled at all\n  // For us this is an important difference, sow e look at the SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING\n  // to identify which it is\n  if (traceFlags === TraceFlags.SAMPLED) {\n    return true;\n  }\n\n  if (sampledNotRecording) {\n    return false;\n  }\n\n  // Fall back to DSC as a last resort, that may also contain `sampled`...\n  const dscString = traceState ? traceState.get(SENTRY_TRACE_STATE_DSC) : undefined;\n  const dsc = dscString ? baggageHeaderToDynamicSamplingContext(dscString) : undefined;\n\n  if (dsc?.sampled === 'true') {\n    return true;\n  }\n  if (dsc?.sampled === 'false') {\n    return false;\n  }\n\n  return undefined;\n}\n","import type { Attributes, AttributeValue } from '@opentelemetry/api';\nimport { SpanKind } from '@opentelemetry/api';\nimport {\n  ATTR_DB_SYSTEM_NAME,\n  ATTR_HTTP_REQUEST_METHOD,\n  ATTR_HTTP_ROUTE,\n  ATTR_URL_FULL,\n  SEMATTRS_DB_STATEMENT,\n  SEMATTRS_DB_SYSTEM,\n  SEMATTRS_FAAS_TRIGGER,\n  SEMATTRS_HTTP_METHOD,\n  SEMATTRS_HTTP_TARGET,\n  SEMATTRS_HTTP_URL,\n  SEMATTRS_MESSAGING_SYSTEM,\n  SEMATTRS_RPC_SERVICE,\n} from '@opentelemetry/semantic-conventions';\nimport type { SpanAttributes, TransactionSource } from '@sentry/core';\nimport {\n  getSanitizedUrlString,\n  parseUrl,\n  SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  stripUrlQueryAndFragment,\n} from '@sentry/core';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_GRAPHQL_OPERATION } from '../semanticAttributes';\nimport type { AbstractSpan } from '../types';\nimport { getSpanKind } from './getSpanKind';\nimport { spanHasAttributes, spanHasName } from './spanTypes';\n\ninterface SpanDescription {\n  op: string | undefined;\n  description: string;\n  source: TransactionSource;\n  data?: Record<string, string | undefined>;\n}\n\n/**\n * Infer the op & description for a set of name, attributes and kind of a span.\n */\nexport function inferSpanData(spanName: string, attributes: SpanAttributes, kind: SpanKind): SpanDescription {\n  // if http.method exists, this is an http request span\n  // eslint-disable-next-line deprecation/deprecation\n  const httpMethod = attributes[ATTR_HTTP_REQUEST_METHOD] || attributes[SEMATTRS_HTTP_METHOD];\n  if (httpMethod) {\n    return descriptionForHttpMethod({ attributes, name: spanName, kind }, httpMethod);\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  const dbSystem = attributes[ATTR_DB_SYSTEM_NAME] || attributes[SEMATTRS_DB_SYSTEM];\n  const opIsCache =\n    typeof attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] === 'string' &&\n    attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP].startsWith('cache.');\n\n  // If db.type exists then this is a database call span\n  // If the Redis DB is used as a cache, the span description should not be changed\n  if (dbSystem && !opIsCache) {\n    return descriptionForDbSystem({ attributes, name: spanName });\n  }\n\n  const customSourceOrRoute = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] === 'custom' ? 'custom' : 'route';\n\n  // If rpc.service exists then this is a rpc call span.\n  // eslint-disable-next-line deprecation/deprecation\n  const rpcService = attributes[SEMATTRS_RPC_SERVICE];\n  if (rpcService) {\n    return {\n      ...getUserUpdatedNameAndSource(spanName, attributes, 'route'),\n      op: 'rpc',\n    };\n  }\n\n  // If messaging.system exists then this is a messaging system span.\n  // eslint-disable-next-line deprecation/deprecation\n  const messagingSystem = attributes[SEMATTRS_MESSAGING_SYSTEM];\n  if (messagingSystem) {\n    return {\n      ...getUserUpdatedNameAndSource(spanName, attributes, customSourceOrRoute),\n      op: 'message',\n    };\n  }\n\n  // If faas.trigger exists then this is a function as a service span.\n  // eslint-disable-next-line deprecation/deprecation\n  const faasTrigger = attributes[SEMATTRS_FAAS_TRIGGER];\n  if (faasTrigger) {\n    return {\n      ...getUserUpdatedNameAndSource(spanName, attributes, customSourceOrRoute),\n      op: faasTrigger.toString(),\n    };\n  }\n\n  return { op: undefined, description: spanName, source: 'custom' };\n}\n\n/**\n * Extract better op/description from an otel span.\n *\n * Does not overwrite the span name if the source is already set to custom to ensure\n * that user-updated span names are preserved. In this case, we only adjust the op but\n * leave span description and source unchanged.\n *\n * Based on https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/7422ce2a06337f68a59b552b8c5a2ac125d6bae5/exporter/sentryexporter/sentry_exporter.go#L306\n */\nexport function parseSpanDescription(span: AbstractSpan): SpanDescription {\n  const attributes = spanHasAttributes(span) ? span.attributes : {};\n  const name = spanHasName(span) ? span.name : '<unknown>';\n  const kind = getSpanKind(span);\n\n  return inferSpanData(name, attributes, kind);\n}\n\nfunction descriptionForDbSystem({ attributes, name }: { attributes: Attributes; name: string }): SpanDescription {\n  // if we already have a custom name, we don't overwrite it but only set the op\n  const userDefinedName = attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME];\n  if (typeof userDefinedName === 'string') {\n    return {\n      op: 'db',\n      description: userDefinedName,\n      source: (attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] as TransactionSource) || 'custom',\n    };\n  }\n\n  // if we already have the source set to custom, we don't overwrite the span description but only set the op\n  if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] === 'custom') {\n    return { op: 'db', description: name, source: 'custom' };\n  }\n\n  // Use DB statement (Ex \"SELECT * FROM table\") if possible as description.\n  // eslint-disable-next-line deprecation/deprecation\n  const statement = attributes[SEMATTRS_DB_STATEMENT];\n\n  const description = statement ? statement.toString() : name;\n\n  return { op: 'db', description, source: 'task' };\n}\n\n/** Only exported for tests. */\nexport function descriptionForHttpMethod(\n  { name, kind, attributes }: { name: string; attributes: Attributes; kind: SpanKind },\n  httpMethod: AttributeValue,\n): SpanDescription {\n  const opParts = ['http'];\n\n  switch (kind) {\n    case SpanKind.CLIENT:\n      opParts.push('client');\n      break;\n    case SpanKind.SERVER:\n      opParts.push('server');\n      break;\n  }\n\n  // Spans for HTTP requests we have determined to be prefetch requests will have a `.prefetch` postfix in the op\n  if (attributes['sentry.http.prefetch']) {\n    opParts.push('prefetch');\n  }\n\n  const { urlPath, url, query, fragment, hasRoute } = getSanitizedUrl(attributes, kind);\n\n  if (!urlPath) {\n    return { ...getUserUpdatedNameAndSource(name, attributes), op: opParts.join('.') };\n  }\n\n  const graphqlOperationsAttribute = attributes[SEMANTIC_ATTRIBUTE_SENTRY_GRAPHQL_OPERATION];\n\n  // Ex. GET /api/users\n  const baseDescription = `${httpMethod} ${urlPath}`;\n\n  // When the http span has a graphql operation, append it to the description\n  // We add these in the graphqlIntegration\n  const inferredDescription = graphqlOperationsAttribute\n    ? `${baseDescription} (${getGraphqlOperationNamesFromAttribute(graphqlOperationsAttribute)})`\n    : baseDescription;\n\n  // If `httpPath` is a root path, then we can categorize the transaction source as route.\n  const inferredSource: TransactionSource = hasRoute || urlPath === '/' ? 'route' : 'url';\n\n  const data: Record<string, string> = {};\n\n  if (url) {\n    data.url = url;\n  }\n  if (query) {\n    data['http.query'] = query;\n  }\n  if (fragment) {\n    data['http.fragment'] = fragment;\n  }\n\n  // If the span kind is neither client nor server, we use the original name\n  // this infers that somebody manually started this span, in which case we don't want to overwrite the name\n  const isClientOrServerKind = kind === SpanKind.CLIENT || kind === SpanKind.SERVER;\n\n  // If the span is an auto-span (=it comes from one of our instrumentations),\n  // we always want to infer the name\n  // this is necessary because some of the auto-instrumentation we use uses kind=INTERNAL\n  const origin = attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] || 'manual';\n  const isManualSpan = !`${origin}`.startsWith('auto');\n\n  // If users (or in very rare occasions we) set the source to custom, we don't overwrite the name\n  const alreadyHasCustomSource = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] === 'custom';\n  const customSpanName = attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME];\n\n  const useInferredDescription =\n    !alreadyHasCustomSource && customSpanName == null && (isClientOrServerKind || !isManualSpan);\n\n  const { description, source } = useInferredDescription\n    ? { description: inferredDescription, source: inferredSource }\n    : getUserUpdatedNameAndSource(name, attributes);\n\n  return {\n    op: opParts.join('.'),\n    description,\n    source,\n    data,\n  };\n}\n\nfunction getGraphqlOperationNamesFromAttribute(attr: AttributeValue): string {\n  if (Array.isArray(attr)) {\n    // oxlint-disable-next-line typescript/require-array-sort-compare\n    const sorted = attr.slice().sort();\n\n    // Up to 5 items, we just add all of them\n    if (sorted.length <= 5) {\n      return sorted.join(', ');\n    } else {\n      // Else, we add the first 5 and the diff of other operations\n      return `${sorted.slice(0, 5).join(', ')}, +${sorted.length - 5}`;\n    }\n  }\n\n  return `${attr}`;\n}\n\n/** Exported for tests only */\nexport function getSanitizedUrl(\n  attributes: Attributes,\n  kind: SpanKind,\n): {\n  url: string | undefined;\n  urlPath: string | undefined;\n  query: string | undefined;\n  fragment: string | undefined;\n  hasRoute: boolean;\n} {\n  // This is the relative path of the URL, e.g. /sub\n  // eslint-disable-next-line deprecation/deprecation\n  const httpTarget = attributes[SEMATTRS_HTTP_TARGET];\n  // This is the full URL, including host & query params etc., e.g. https://example.com/sub?foo=bar\n  // eslint-disable-next-line deprecation/deprecation\n  const httpUrl = attributes[SEMATTRS_HTTP_URL] || attributes[ATTR_URL_FULL];\n  // This is the normalized route name - may not always be available!\n  const httpRoute = attributes[ATTR_HTTP_ROUTE];\n\n  const parsedUrl = typeof httpUrl === 'string' ? parseUrl(httpUrl) : undefined;\n  const url = parsedUrl ? getSanitizedUrlString(parsedUrl) : undefined;\n  const query = parsedUrl?.search || undefined;\n  const fragment = parsedUrl?.hash || undefined;\n\n  if (typeof httpRoute === 'string') {\n    return { urlPath: httpRoute, url, query, fragment, hasRoute: true };\n  }\n\n  if (kind === SpanKind.SERVER && typeof httpTarget === 'string') {\n    return { urlPath: stripUrlQueryAndFragment(httpTarget), url, query, fragment, hasRoute: false };\n  }\n\n  if (parsedUrl) {\n    return { urlPath: url, url, query, fragment, hasRoute: false };\n  }\n\n  // fall back to target even for client spans, if no URL is present\n  if (typeof httpTarget === 'string') {\n    return { urlPath: stripUrlQueryAndFragment(httpTarget), url, query, fragment, hasRoute: false };\n  }\n\n  return { urlPath: undefined, url, query, fragment, hasRoute: false };\n}\n\n/**\n * Because Otel instrumentation sometimes mutates span names via `span.updateName`, the only way\n * to ensure that a user-set span name is preserved is to store it as a tmp attribute on the span.\n * We delete this attribute once we're done with it when preparing the event envelope.\n *\n * This temp attribute always takes precedence over the original name.\n *\n * We also need to take care of setting the correct source. Users can always update the source\n * after updating the name, so we need to respect that.\n *\n * @internal exported only for testing\n */\nexport function getUserUpdatedNameAndSource(\n  originalName: string,\n  attributes: Attributes,\n  fallbackSource: TransactionSource = 'custom',\n): {\n  description: string;\n  source: TransactionSource;\n} {\n  const source = (attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] as TransactionSource) || fallbackSource;\n  const description = attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME];\n\n  if (description && typeof description === 'string') {\n    return {\n      description,\n      source,\n    };\n  }\n\n  return { description: originalName, source };\n}\n","import type { Client } from '@sentry/core';\nimport { hasSpansEnabled, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, spanToJSON } from '@sentry/core';\nimport { getSamplingDecision } from './getSamplingDecision';\nimport { parseSpanDescription } from './parseSpanDescription';\nimport { spanHasName } from './spanTypes';\n\n/**\n * Setup a DSC handler on the passed client,\n * ensuring that the transaction name is inferred from the span correctly.\n */\nexport function enhanceDscWithOpenTelemetryRootSpanName(client: Client): void {\n  client.on('createDsc', (dsc, rootSpan) => {\n    if (!rootSpan) {\n      return;\n    }\n\n    // We want to overwrite the transaction on the DSC that is created by default in core\n    // The reason for this is that we want to infer the span name, not use the initial one\n    // Otherwise, we'll get names like \"GET\" instead of e.g. \"GET /foo\"\n    // `parseSpanDescription` takes the attributes of the span into account for the name\n    // This mutates the passed-in DSC\n\n    const jsonSpan = spanToJSON(rootSpan);\n    const attributes = jsonSpan.data;\n    const source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n    const { description } = spanHasName(rootSpan) ? parseSpanDescription(rootSpan) : { description: undefined };\n    if (source !== 'url' && description) {\n      dsc.transaction = description;\n    }\n\n    // Also ensure sampling decision is correctly inferred\n    // In core, we use `spanIsSampled`, which just looks at the trace flags\n    // but in OTEL, we use a slightly more complex logic to be able to differntiate between unsampled and deferred sampling\n    if (hasSpansEnabled()) {\n      const sampled = getSamplingDecision(rootSpan.spanContext());\n      dsc.sampled = sampled == undefined ? undefined : String(sampled);\n    }\n  });\n}\n","import type { Span } from '@opentelemetry/api';\nimport { trace } from '@opentelemetry/api';\n\n/**\n * Returns the currently active span.\n */\nexport function getActiveSpan(): Span | undefined {\n  return trace.getActiveSpan();\n}\n","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Minimal vendored implementation of `TraceState` from `@opentelemetry/core`\n *   to avoid pulling in that dependency for a single class.\n * - Drops raw-string parsing and key/value validation, neither of which are\n *   used by the SDK — the W3C `tracestate` header is parsed by OTel's own\n *   propagators (which use their own `TraceState`), and every key we `set`\n *   is a known constant.\n */\nimport type { TraceState as TraceStateInterface } from '@opentelemetry/api';\n\n/**\n * Minimal implementation of the W3C `tracestate` field as a `@opentelemetry/api`\n * `TraceState`. New entries are inserted at the front of the list, and updating\n * an existing key moves it to the front.\n *\n * See https://www.w3.org/TR/trace-context/#tracestate-field for the field spec.\n */\nexport class TraceState implements TraceStateInterface {\n  private _internalState: Map<string, string> = new Map();\n\n  /** @inheritDoc */\n  public set(key: string, value: string): TraceState {\n    const next = this._clone();\n    if (next._internalState.has(key)) {\n      next._internalState.delete(key);\n    }\n    next._internalState.set(key, value);\n    return next;\n  }\n\n  /** @inheritDoc */\n  public unset(key: string): TraceState {\n    const next = this._clone();\n    next._internalState.delete(key);\n    return next;\n  }\n\n  /** @inheritDoc */\n  public get(key: string): string | undefined {\n    return this._internalState.get(key);\n  }\n\n  /** @inheritDoc */\n  public serialize(): string {\n    return Array.from(this._internalState.keys())\n      .reverse()\n      .map(key => `${key}=${this._internalState.get(key)}`)\n      .join(',');\n  }\n\n  private _clone(): TraceState {\n    const next = new TraceState();\n    next._internalState = new Map(this._internalState);\n    return next;\n  }\n}\n","import type { DynamicSamplingContext } from '@sentry/core';\nimport { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/core';\nimport { SENTRY_TRACE_STATE_DSC, SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING } from '../constants';\nimport { TraceState } from './TraceState';\n\n/**\n * Generate a TraceState for the given data.\n */\nexport function makeTraceState({\n  dsc,\n  sampled,\n}: {\n  dsc?: Partial<DynamicSamplingContext>;\n  sampled?: boolean;\n}): TraceState {\n  // We store the DSC as OTEL trace state on the span context\n  const dscString = dsc ? dynamicSamplingContextToSentryBaggageHeader(dsc) : undefined;\n\n  const traceStateBase = new TraceState();\n\n  const traceStateWithDsc = dscString ? traceStateBase.set(SENTRY_TRACE_STATE_DSC, dscString) : traceStateBase;\n\n  // We also specifically want to store if this is sampled to be not recording,\n  // or unsampled (=could be either sampled or not)\n  return sampled === false ? traceStateWithDsc.set(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING, '1') : traceStateWithDsc;\n}\n","type OpenTelemetryElement = 'SentrySpanProcessor' | 'SentryContextManager' | 'SentryPropagator' | 'SentrySampler';\n\nconst setupElements = new Set<OpenTelemetryElement>();\n\n/** Get all the OpenTelemetry elements that have been set up. */\nexport function openTelemetrySetupCheck(): OpenTelemetryElement[] {\n  return Array.from(setupElements);\n}\n\n/** Mark an OpenTelemetry element as setup. */\nexport function setIsSetup(element: OpenTelemetryElement): void {\n  setupElements.add(element);\n}\n\n/** Only exported for tests. */\nexport function clearOpenTelemetrySetupCheck(): void {\n  setupElements.clear();\n}\n","import type { Baggage, Context, Span, SpanContext, TextMapGetter, TextMapSetter } from '@opentelemetry/api';\nimport { context, INVALID_TRACEID, propagation, trace, TraceFlags } from '@opentelemetry/api';\nimport { isTracingSuppressed, W3CBaggagePropagator } from '@opentelemetry/core';\nimport { ATTR_URL_FULL, SEMATTRS_HTTP_URL } from '@opentelemetry/semantic-conventions';\nimport type { Client, continueTrace, DynamicSamplingContext, Scope } from '@sentry/core';\nimport {\n  baggageHeaderToDynamicSamplingContext,\n  debug,\n  generateSentryTraceHeader,\n  generateTraceparentHeader,\n  getClient,\n  getCurrentScope,\n  getDynamicSamplingContextFromScope,\n  getDynamicSamplingContextFromSpan,\n  getIsolationScope,\n  LRUMap,\n  parseBaggageHeader,\n  propagationContextFromHeaders,\n  SENTRY_BAGGAGE_KEY_PREFIX,\n  shouldContinueTrace,\n  shouldPropagateTraceForUrl,\n  spanToJSON,\n} from '@sentry/core';\nimport { SENTRY_BAGGAGE_HEADER, SENTRY_TRACE_HEADER, SENTRY_TRACE_STATE_URL } from './constants';\nimport { DEBUG_BUILD } from './debug-build';\nimport { getScopesFromContext, setScopesOnContext } from './utils/contextData';\nimport { getSamplingDecision } from './utils/getSamplingDecision';\nimport { makeTraceState } from './utils/makeTraceState';\nimport { setIsSetup } from './utils/setupCheck';\n\n/**\n * Injects and extracts `sentry-trace` and `baggage` headers from carriers.\n */\nexport class SentryPropagator extends W3CBaggagePropagator {\n  /** A map of URLs that have already been checked for if they match tracePropagationTargets. */\n  private _urlMatchesTargetsMap: LRUMap<string, boolean>;\n\n  public constructor() {\n    super();\n    setIsSetup('SentryPropagator');\n\n    // We're caching results so we don't have to recompute regexp every time we create a request.\n    this._urlMatchesTargetsMap = new LRUMap<string, boolean>(100);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public inject(context: Context, carrier: unknown, setter: TextMapSetter): void {\n    if (isTracingSuppressed(context)) {\n      DEBUG_BUILD && debug.log('[Tracing] Not injecting trace data for url because tracing is suppressed.');\n      return;\n    }\n\n    const activeSpan = trace.getSpan(context);\n    const url = activeSpan && getCurrentURL(activeSpan);\n\n    const { tracePropagationTargets, propagateTraceparent } = getClient()?.getOptions() || {};\n    if (!shouldPropagateTraceForUrl(url, tracePropagationTargets, this._urlMatchesTargetsMap)) {\n      DEBUG_BUILD &&\n        debug.log('[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:', url);\n      return;\n    }\n\n    const existingBaggageHeader = getExistingBaggage(carrier);\n    const existingSentryTraceHeader = getExistingSentryTrace(carrier);\n\n    let baggage = propagation.getBaggage(context) || propagation.createBaggage({});\n\n    const { dynamicSamplingContext, traceId, spanId, sampled } = getInjectionData(context);\n\n    if (existingBaggageHeader) {\n      const baggageEntries = parseBaggageHeader(existingBaggageHeader);\n\n      if (baggageEntries) {\n        Object.entries(baggageEntries).forEach(([key, value]) => {\n          if (!existingSentryTraceHeader && key.startsWith(SENTRY_BAGGAGE_KEY_PREFIX)) {\n            // Edge case: A baggage header with sentry- keys was added previously but no\n            // sentry-trace header. In this case we remove the old sentry-keys and add new\n            // ones below.\n            return;\n          }\n          baggage = baggage.setEntry(key, { value });\n        });\n      }\n    }\n\n    if (!existingSentryTraceHeader && dynamicSamplingContext) {\n      baggage = Object.entries(dynamicSamplingContext).reduce<Baggage>((b, [dscKey, dscValue]) => {\n        if (dscValue) {\n          return b.setEntry(`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`, { value: dscValue });\n        }\n        return b;\n      }, baggage);\n    }\n\n    // We also want to avoid setting the default OTEL trace ID, if we get that for whatever reason\n    if (!existingSentryTraceHeader && traceId && traceId !== INVALID_TRACEID) {\n      setter.set(carrier, SENTRY_TRACE_HEADER, generateSentryTraceHeader(traceId, spanId, sampled));\n\n      if (propagateTraceparent) {\n        setter.set(carrier, 'traceparent', generateTraceparentHeader(traceId, spanId, sampled));\n      }\n    }\n\n    super.inject(propagation.setBaggage(context, baggage), carrier, setter);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public extract(context: Context, carrier: unknown, getter: TextMapGetter): Context {\n    const maybeSentryTraceHeader: string | string[] | undefined = getter.get(carrier, SENTRY_TRACE_HEADER);\n    const baggage = getter.get(carrier, SENTRY_BAGGAGE_HEADER);\n\n    const sentryTrace = maybeSentryTraceHeader\n      ? Array.isArray(maybeSentryTraceHeader)\n        ? maybeSentryTraceHeader[0]\n        : maybeSentryTraceHeader\n      : undefined;\n\n    // Add remote parent span context\n    // If there is no incoming trace, this will return the context as-is\n    return ensureScopesOnContext(getContextWithRemoteActiveSpan(context, { sentryTrace, baggage }));\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public fields(): string[] {\n    return [SENTRY_TRACE_HEADER, SENTRY_BAGGAGE_HEADER, 'traceparent'];\n  }\n}\n\n// Re-exported from @sentry/core for backwards compatibility\nexport { shouldPropagateTraceForUrl } from '@sentry/core';\n\n/**\n * Get propagation injection data for the given context.\n * The additional options can be passed to override the scope and client that is otherwise derived from the context.\n */\nexport function getInjectionData(\n  context: Context,\n  options: { scope?: Scope; client?: Client } = {},\n): {\n  dynamicSamplingContext: Partial<DynamicSamplingContext> | undefined;\n  traceId: string | undefined;\n  spanId: string | undefined;\n  sampled: boolean | undefined;\n} {\n  const span = trace.getSpan(context);\n\n  // If we have a remote span, the spanId should be considered as the parentSpanId, not spanId itself\n  // Instead, we use a virtual (generated) spanId for propagation\n  if (span?.spanContext().isRemote) {\n    const spanContext = span.spanContext();\n    const dynamicSamplingContext = getDynamicSamplingContextFromSpan(span);\n\n    return {\n      dynamicSamplingContext,\n      traceId: spanContext.traceId,\n      spanId: undefined,\n      sampled: getSamplingDecision(spanContext), // TODO: Do we need to change something here?\n    };\n  }\n\n  // If we have a local span, we just use this\n  if (span) {\n    const spanContext = span.spanContext();\n    const dynamicSamplingContext = getDynamicSamplingContextFromSpan(span);\n\n    return {\n      dynamicSamplingContext,\n      traceId: spanContext.traceId,\n      spanId: spanContext.spanId,\n      sampled: getSamplingDecision(spanContext), // TODO: Do we need to change something here?\n    };\n  }\n\n  // Else we try to use the propagation context from the scope\n  // The only scenario where this should happen is when we neither have a span, nor an incoming trace\n  const scope = options.scope || getScopesFromContext(context)?.scope || getCurrentScope();\n  const client = options.client || getClient();\n\n  const propagationContext = scope.getPropagationContext();\n  const dynamicSamplingContext = client ? getDynamicSamplingContextFromScope(client, scope) : undefined;\n  return {\n    dynamicSamplingContext,\n    traceId: propagationContext.traceId,\n    spanId: propagationContext.propagationSpanId,\n    sampled: propagationContext.sampled,\n  };\n}\n\nfunction getContextWithRemoteActiveSpan(\n  ctx: Context,\n  { sentryTrace, baggage }: Parameters<typeof continueTrace>[0],\n): Context {\n  const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n\n  const { traceId, parentSpanId, sampled, dsc } = propagationContext;\n\n  const client = getClient();\n  const incomingDsc = baggageHeaderToDynamicSamplingContext(baggage);\n\n  // We only want to set the virtual span if we are continuing a concrete trace\n  // Otherwise, we ignore the incoming trace here, e.g. if we have no trace headers\n  if (!parentSpanId || (client && !shouldContinueTrace(client, incomingDsc?.org_id))) {\n    return ctx;\n  }\n\n  const spanContext = generateRemoteSpanContext({\n    traceId,\n    spanId: parentSpanId,\n    sampled,\n    dsc,\n  });\n\n  return trace.setSpanContext(ctx, spanContext);\n}\n\n/**\n * Takes trace strings and propagates them as a remote active span.\n * This should be used in addition to `continueTrace` in OTEL-powered environments.\n */\nexport function continueTraceAsRemoteSpan<T>(\n  ctx: Context,\n  options: Parameters<typeof continueTrace>[0],\n  callback: () => T,\n): T {\n  const ctxWithSpanContext = ensureScopesOnContext(getContextWithRemoteActiveSpan(ctx, options));\n\n  return context.with(ctxWithSpanContext, callback);\n}\n\nfunction ensureScopesOnContext(ctx: Context): Context {\n  // If there are no scopes yet on the context, ensure we have them\n  const scopes = getScopesFromContext(ctx);\n  const newScopes = {\n    // If we have no scope here, this is most likely either the root context or a context manually derived from it\n    // In this case, we want to fork the current scope, to ensure we do not pollute the root scope\n    scope: scopes ? scopes.scope : getCurrentScope().clone(),\n    isolationScope: scopes ? scopes.isolationScope : getIsolationScope(),\n  };\n\n  return setScopesOnContext(ctx, newScopes);\n}\n\n/** Try to get the existing baggage header so we can merge this in. */\nfunction getExistingBaggage(carrier: unknown): string | undefined {\n  try {\n    const baggage = (carrier as Record<string, string | string[]>)[SENTRY_BAGGAGE_HEADER];\n    return Array.isArray(baggage) ? baggage.join(',') : baggage;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction getExistingSentryTrace(carrier: unknown): string | string[] | undefined {\n  try {\n    return (carrier as Record<string, string | string[]>)[SENTRY_TRACE_HEADER];\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * It is pretty tricky to get access to the outgoing request URL of a request in the propagator.\n * As we only have access to the context of the span to be sent and the carrier (=headers),\n * but the span may be unsampled and thus have no attributes.\n *\n * So we use the following logic:\n * 1. If we have an active span, we check if it has a URL attribute.\n * 2. Else, if the active span has no URL attribute (e.g. it is unsampled), we check a special trace state (which we set in our sampler).\n */\nfunction getCurrentURL(span: Span): string | undefined {\n  const spanData = spanToJSON(span).data;\n  // `ATTR_URL_FULL` is the new attribute, but we still support the old one, `SEMATTRS_HTTP_URL`, for now.\n  // eslint-disable-next-line deprecation/deprecation\n  const urlAttribute = spanData[SEMATTRS_HTTP_URL] || spanData[ATTR_URL_FULL];\n  if (typeof urlAttribute === 'string') {\n    return urlAttribute;\n  }\n\n  // Also look at the traceState, which we may set in the sampler even for unsampled spans\n  const urlTraceState = span.spanContext().traceState?.get(SENTRY_TRACE_STATE_URL);\n  if (urlTraceState) {\n    return urlTraceState;\n  }\n\n  return undefined;\n}\n\nfunction generateRemoteSpanContext({\n  spanId,\n  traceId,\n  sampled,\n  dsc,\n}: {\n  spanId: string;\n  traceId: string;\n  sampled: boolean | undefined;\n  dsc?: Partial<DynamicSamplingContext>;\n}): SpanContext {\n  // We store the DSC as OTEL trace state on the span context\n  const traceState = makeTraceState({\n    dsc,\n    sampled,\n  });\n\n  const spanContext: SpanContext = {\n    traceId,\n    spanId,\n    isRemote: true,\n    traceFlags: sampled ? TraceFlags.SAMPLED : TraceFlags.NONE,\n    traceState,\n  };\n\n  return spanContext;\n}\n","import type { Context, Span, SpanContext, SpanOptions, TimeInput, Tracer } from '@opentelemetry/api';\nimport { context, SpanStatusCode, trace, TraceFlags } from '@opentelemetry/api';\nimport { isTracingSuppressed, suppressTracing } from '@opentelemetry/core';\nimport type {\n  Client,\n  continueTrace as baseContinueTrace,\n  DynamicSamplingContext,\n  Scope,\n  Span as SentrySpan,\n  TraceContext,\n} from '@sentry/core';\nimport {\n  _INTERNAL_safeMathRandom,\n  generateSpanId,\n  generateTraceId,\n  getClient,\n  getCurrentScope,\n  getDynamicSamplingContextFromScope,\n  getDynamicSamplingContextFromSpan,\n  getRootSpan,\n  getTraceContextFromScope,\n  handleCallbackErrors,\n  hasSpansEnabled,\n  SDK_VERSION,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  spanToJSON,\n  spanToTraceContext,\n} from '@sentry/core';\nimport { continueTraceAsRemoteSpan } from './propagator';\nimport type { OpenTelemetryClient, OpenTelemetrySpanContext } from './types';\nimport { getContextFromScope } from './utils/contextData';\nimport { getSamplingDecision } from './utils/getSamplingDecision';\nimport { makeTraceState } from './utils/makeTraceState';\n\n/**\n * Internal helper for starting spans and manual spans. See {@link startSpan} and {@link startSpanManual} for the public APIs.\n * @param options - The span context options\n * @param callback - The callback to execute with the span\n * @param autoEnd - Whether to automatically end the span after the callback completes\n */\nfunction _startSpan<T>(options: OpenTelemetrySpanContext, callback: (span: Span) => T, autoEnd: boolean): T {\n  const tracer = getTracer();\n\n  const { name, parentSpan: customParentSpan } = options;\n\n  // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n  const wrapper = getActiveSpanWrapper<T>(customParentSpan);\n\n  return wrapper(() => {\n    const activeCtx = getContext(options.scope, options.forceTransaction);\n    const missingRequiredParent = options.onlyIfParent && !trace.getSpan(activeCtx);\n    const ctx = missingRequiredParent ? suppressTracing(activeCtx) : activeCtx;\n\n    if (missingRequiredParent) {\n      getClient()?.recordDroppedEvent('no_parent_span', 'span');\n    }\n\n    const spanOptions = getSpanOptions(options);\n\n    // If spans are not enabled, ensure we suppress tracing for the span creation\n    // but preserve the original context for the callback execution\n    // This ensures that we don't create spans when tracing is disabled which\n    // would otherwise be a problem for users that don't enable tracing but use\n    // custom OpenTelemetry setups.\n    if (!hasSpansEnabled()) {\n      const suppressedCtx = isTracingSuppressed(ctx) ? ctx : suppressTracing(ctx);\n\n      return context.with(suppressedCtx, () => {\n        return tracer.startActiveSpan(name, spanOptions, suppressedCtx, span => {\n          patchSpanEnd(span);\n          // Restore the original unsuppressed context for the callback execution\n          // so that custom OpenTelemetry spans maintain the correct context.\n          // We use activeCtx (not ctx) because ctx may be suppressed when onlyIfParent is true\n          // and no parent span exists. Using activeCtx ensures custom OTel spans are never\n          // inadvertently suppressed.\n          return context.with(activeCtx, () => {\n            return handleCallbackErrors(\n              () => callback(span),\n              () => {\n                // Only set the span status to ERROR when there wasn't any status set before, in order to avoid stomping useful span statuses\n                if (spanToJSON(span).status === undefined) {\n                  span.setStatus({ code: SpanStatusCode.ERROR });\n                }\n              },\n              autoEnd ? () => span.end() : undefined,\n            );\n          });\n        });\n      });\n    }\n\n    return tracer.startActiveSpan(name, spanOptions, ctx, span => {\n      patchSpanEnd(span);\n      return handleCallbackErrors(\n        () => callback(span),\n        () => {\n          // Only set the span status to ERROR when there wasn't any status set before, in order to avoid stomping useful span statuses\n          if (spanToJSON(span).status === undefined) {\n            span.setStatus({ code: SpanStatusCode.ERROR });\n          }\n        },\n        autoEnd ? () => span.end() : undefined,\n      );\n    });\n  });\n}\n\n/**\n * Wraps a function with a transaction/span and finishes the span after the function is done.\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.\n *\n * If you want to create a span that is not set as active, use {@link startInactiveSpan}.\n *\n * You'll always get a span passed to the callback,\n * it may just be a non-recording span if the span is not sampled or if tracing is disabled.\n */\nexport function startSpan<T>(options: OpenTelemetrySpanContext, callback: (span: Span) => T): T {\n  return _startSpan(options, callback, true);\n}\n\n/**\n * Similar to `Sentry.startSpan`. Wraps a function with a span, but does not finish the span\n * after the function is done automatically. You'll have to call `span.end()` or the `finish` function passed to the callback manually.\n *\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.\n *\n * You'll always get a span passed to the callback,\n * it may just be a non-recording span if the span is not sampled or if tracing is disabled.\n */\nexport function startSpanManual<T>(\n  options: OpenTelemetrySpanContext,\n  callback: (span: Span, finish: () => void) => T,\n): T {\n  return _startSpan(options, span => callback(span, () => span.end()), false);\n}\n\n/**\n * Creates a span. This span is not set as active, so will not get automatic instrumentation spans\n * as children or be able to be accessed via `Sentry.getActiveSpan()`.\n *\n * If you want to create a span that is set as active, use {@link startSpan}.\n *\n * This function will always return a span,\n * it may just be a non-recording span if the span is not sampled or if tracing is disabled.\n */\nexport function startInactiveSpan(options: OpenTelemetrySpanContext): Span {\n  const tracer = getTracer();\n\n  const { name, parentSpan: customParentSpan } = options;\n\n  // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n  const wrapper = getActiveSpanWrapper<Span>(customParentSpan);\n\n  return wrapper(() => {\n    const activeCtx = getContext(options.scope, options.forceTransaction);\n    const missingRequiredParent = options.onlyIfParent && !trace.getSpan(activeCtx);\n    let ctx = missingRequiredParent ? suppressTracing(activeCtx) : activeCtx;\n\n    if (missingRequiredParent) {\n      getClient()?.recordDroppedEvent('no_parent_span', 'span');\n    }\n\n    const spanOptions = getSpanOptions(options);\n\n    if (!hasSpansEnabled()) {\n      ctx = isTracingSuppressed(ctx) ? ctx : suppressTracing(ctx);\n    }\n\n    const span = tracer.startSpan(name, spanOptions, ctx);\n    patchSpanEnd(span);\n    return span;\n  });\n}\n\n/**\n * Forks the current scope and sets the provided span as active span in the context of the provided callback. Can be\n * passed `null` to start an entirely new span tree.\n *\n * @param span Spans started in the context of the provided callback will be children of this span. If `null` is passed,\n * spans started within the callback will be root spans.\n * @param callback Execution context in which the provided span will be active. Is passed the newly forked scope.\n * @returns the value returned from the provided callback function.\n */\nexport function withActiveSpan<T>(span: Span | null, callback: (scope: Scope) => T): T {\n  const newContextWithActiveSpan = span ? trace.setSpan(context.active(), span) : trace.deleteSpan(context.active());\n  return context.with(newContextWithActiveSpan, () => callback(getCurrentScope()));\n}\n\nfunction getTracer(): Tracer {\n  const client = getClient<Client & OpenTelemetryClient>();\n  return client?.tracer || trace.getTracer('@sentry/opentelemetry', SDK_VERSION);\n}\n\nfunction getSpanOptions(options: OpenTelemetrySpanContext): SpanOptions {\n  const { startTime, attributes, kind, op, links } = options;\n\n  // OTEL expects timestamps in ms, not seconds\n  const fixedStartTime = typeof startTime === 'number' ? ensureTimestampInMilliseconds(startTime) : startTime;\n\n  return {\n    attributes: op\n      ? {\n          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n          ...attributes,\n        }\n      : attributes,\n    kind,\n    links,\n    startTime: fixedStartTime,\n  };\n}\n\nfunction ensureTimestampInMilliseconds(timestamp: number): number {\n  const isMs = timestamp < 9999999999;\n  return isMs ? timestamp * 1000 : timestamp;\n}\n\n/**\n * Wraps the span's `end()` method so that numeric timestamps passed in seconds\n * are converted to milliseconds before reaching OTel's native `Span.end()`.\n */\nfunction patchSpanEnd(span: Span): void {\n  const originalEnd = span.end.bind(span);\n  span.end = (endTime?: TimeInput) => {\n    return originalEnd(typeof endTime === 'number' ? ensureTimestampInMilliseconds(endTime) : endTime);\n  };\n}\n\nfunction getContext(scope: Scope | undefined, forceTransaction: boolean | undefined): Context {\n  const ctx = getContextForScope(scope);\n  const parentSpan = trace.getSpan(ctx);\n\n  // In the case that we have no parent span, we start a new trace\n  // Note that if we continue a trace, we'll always have a remote parent span here anyhow\n  if (!parentSpan) {\n    return ctx;\n  }\n\n  // If we don't want to force a transaction, and we have a parent span, all good, we just return as-is!\n  if (!forceTransaction) {\n    return ctx;\n  }\n\n  // Else, if we do have a parent span but want to force a transaction, we have to simulate a \"root\" context\n\n  // Else, we need to do two things:\n  // 1. Unset the parent span from the context, so we'll create a new root span\n  // 2. Ensure the propagation context is correct, so we'll continue from the parent span\n  const ctxWithoutSpan = trace.deleteSpan(ctx);\n\n  const { spanId, traceId } = parentSpan.spanContext();\n  const sampled = getSamplingDecision(parentSpan.spanContext());\n\n  // In this case, when we are forcing a transaction, we want to treat this like continuing an incoming trace\n  // so we set the traceState according to the root span\n  const rootSpan = getRootSpan(parentSpan);\n  const dsc = getDynamicSamplingContextFromSpan(rootSpan);\n\n  const traceState = makeTraceState({\n    dsc,\n    sampled,\n  });\n\n  const spanOptions: SpanContext = {\n    traceId,\n    spanId,\n    isRemote: true,\n    traceFlags: sampled ? TraceFlags.SAMPLED : TraceFlags.NONE,\n    traceState,\n  };\n\n  const ctxWithSpanContext = trace.setSpanContext(ctxWithoutSpan, spanOptions);\n\n  return ctxWithSpanContext;\n}\n\nfunction getContextForScope(scope?: Scope): Context {\n  if (scope) {\n    const ctx = getContextFromScope(scope);\n    if (ctx) {\n      return ctx;\n    }\n  }\n\n  return context.active();\n}\n\n/**\n * Continue a trace from `sentry-trace` and `baggage` values.\n * These values can be obtained from incoming request headers, or in the browser from `<meta name=\"sentry-trace\">`\n * and `<meta name=\"baggage\">` HTML tags.\n *\n * Spans started with `startSpan`, `startSpanManual` and `startInactiveSpan`, within the callback will automatically\n * be attached to the incoming trace.\n *\n * This is a custom version of `continueTrace` that is used in OTEL-powered environments.\n * It propagates the trace as a remote span, in addition to setting it on the propagation context.\n */\nexport function continueTrace<T>(options: Parameters<typeof baseContinueTrace>[0], callback: () => T): T {\n  return continueTraceAsRemoteSpan(context.active(), options, callback);\n}\n\n/**\n * Start a new trace with a unique traceId, ensuring all spans created within the callback\n * share the same traceId.\n *\n * This is a custom version of `startNewTrace` for OTEL-powered environments.\n * It injects the new traceId as a remote span context into the OTEL context, so that\n * `startInactiveSpan` and `startSpan` pick it up correctly.\n */\nexport function startNewTrace<T>(callback: () => T): T {\n  const traceId = generateTraceId();\n  const spanId = generateSpanId();\n\n  const spanContext: SpanContext = {\n    traceId,\n    spanId,\n    isRemote: true,\n    traceFlags: TraceFlags.NONE,\n  };\n\n  const ctxWithTrace = trace.setSpanContext(context.active(), spanContext);\n\n  return context.with(ctxWithTrace, () => {\n    getCurrentScope().setPropagationContext({\n      traceId,\n      sampleRand: _INTERNAL_safeMathRandom(),\n    });\n    return callback();\n  });\n}\n\n/**\n * Get the trace context for a given scope.\n * We have a custom implementation here because we need an OTEL-specific way to get the span from a scope.\n */\nexport function getTraceContextForScope(\n  client: Client,\n  scope: Scope,\n): [dynamicSamplingContext: Partial<DynamicSamplingContext>, traceContext: TraceContext] {\n  const ctx = getContextFromScope(scope);\n  const span = ctx && trace.getSpan(ctx);\n\n  const traceContext = span ? spanToTraceContext(span) : getTraceContextFromScope(scope);\n\n  const dynamicSamplingContext = span\n    ? getDynamicSamplingContextFromSpan(span)\n    : getDynamicSamplingContextFromScope(client, scope);\n  return [dynamicSamplingContext, traceContext];\n}\n\nfunction getActiveSpanWrapper<T>(parentSpan: Span | SentrySpan | undefined | null): (callback: () => T) => T {\n  return parentSpan !== undefined\n    ? (callback: () => T) => {\n        return withActiveSpan(parentSpan, callback);\n      }\n    : (callback: () => T) => callback();\n}\n","import { context } from '@opentelemetry/api';\nimport { suppressTracing as suppressTracingImpl } from '@opentelemetry/core';\n\n/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */\nexport function suppressTracing<T>(callback: () => T): T {\n  const ctx = suppressTracingImpl(context.active());\n  return context.with(ctx, callback);\n}\n","import type { Client } from '@sentry/core';\nimport { getDynamicSamplingContextFromSpan, getRootSpan, spanToTraceContext } from '@sentry/core';\nimport { getActiveSpan } from './utils/getActiveSpan';\n\n/** Ensure the `trace` context is set on all events. */\nexport function setupEventContextTrace(client: Client): void {\n  client.on('preprocessEvent', event => {\n    const span = getActiveSpan();\n    // For transaction events, this is handled separately\n    // Because the active span may not be the span that is actually the transaction event\n    if (!span || event.type === 'transaction') {\n      return;\n    }\n\n    // If event has already set `trace` context, use that one.\n    event.contexts = {\n      trace: spanToTraceContext(span),\n      ...event.contexts,\n    };\n\n    const rootSpan = getRootSpan(span);\n\n    event.sdkProcessingMetadata = {\n      dynamicSamplingContext: getDynamicSamplingContextFromSpan(rootSpan),\n      ...event.sdkProcessingMetadata,\n    };\n\n    return event;\n  });\n}\n","import * as api from '@opentelemetry/api';\nimport type { Client, Scope, SerializedTraceData, Span } from '@sentry/core';\nimport {\n  dynamicSamplingContextToSentryBaggageHeader,\n  generateSentryTraceHeader,\n  generateTraceparentHeader,\n  getCapturedScopesOnSpan,\n} from '@sentry/core';\nimport { getInjectionData } from '../propagator';\nimport { getContextFromScope } from './contextData';\n\n/**\n * Otel-specific implementation of `getTraceData`.\n * @see `@sentry/core` version of `getTraceData` for more information\n */\nexport function getTraceData({\n  span,\n  scope,\n  client,\n  propagateTraceparent,\n}: { span?: Span; scope?: Scope; client?: Client; propagateTraceparent?: boolean } = {}): SerializedTraceData {\n  let ctx = (scope && getContextFromScope(scope)) ?? api.context.active();\n\n  if (span) {\n    const { scope } = getCapturedScopesOnSpan(span);\n    // fall back to current context if for whatever reason we can't find the one of the span\n    ctx = (scope && getContextFromScope(scope)) || api.trace.setSpan(api.context.active(), span);\n  }\n\n  const { traceId, spanId, sampled, dynamicSamplingContext } = getInjectionData(ctx, { scope, client });\n\n  const traceData: SerializedTraceData = {\n    'sentry-trace': generateSentryTraceHeader(traceId, spanId, sampled),\n    baggage: dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext),\n  };\n\n  if (propagateTraceparent) {\n    traceData.traceparent = generateTraceparentHeader(traceId, spanId, sampled);\n  }\n\n  return traceData;\n}\n","import * as api from '@opentelemetry/api';\nimport type { Scope, withActiveSpan as defaultWithActiveSpan } from '@sentry/core';\nimport { getDefaultCurrentScope, getDefaultIsolationScope, setAsyncContextStrategy } from '@sentry/core';\nimport {\n  SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY,\n  SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY,\n  SENTRY_FORK_SET_SCOPE_CONTEXT_KEY,\n} from './constants';\nimport { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, withActiveSpan } from './trace';\nimport type { CurrentScopes } from './types';\nimport { getContextFromScope, getScopesFromContext } from './utils/contextData';\nimport { getActiveSpan } from './utils/getActiveSpan';\nimport { getTraceData } from './utils/getTraceData';\nimport { suppressTracing } from './utils/suppressTracing';\n\n/**\n * Sets the async context strategy to use follow the OTEL context under the hood.\n * We handle forking a hub inside of our custom OTEL Context Manager (./otelContextManager.ts)\n */\nexport function setOpenTelemetryContextAsyncContextStrategy(): void {\n  function getScopes(): CurrentScopes {\n    const ctx = api.context.active();\n    const scopes = getScopesFromContext(ctx);\n\n    if (scopes) {\n      return scopes;\n    }\n\n    // fallback behavior:\n    // if, for whatever reason, we can't find scopes on the context here, we have to fix this somehow\n    return {\n      scope: getDefaultCurrentScope(),\n      isolationScope: getDefaultIsolationScope(),\n    };\n  }\n\n  function withScope<T>(callback: (scope: Scope) => T): T {\n    const ctx = api.context.active();\n\n    // We depend on the otelContextManager to handle the context/hub\n    // We set the `SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY` context value, which is picked up by\n    // the OTEL context manager, which uses the presence of this key to determine if it should\n    // fork the isolation scope, or not\n    // as by default, we don't want to fork this, unless triggered explicitly by `withScope`\n    return api.context.with(ctx, () => {\n      return callback(getCurrentScope());\n    });\n  }\n\n  function withSetScope<T>(scope: Scope, callback: (scope: Scope) => T): T {\n    const ctx = getContextFromScope(scope) || api.context.active();\n\n    // We depend on the otelContextManager to handle the context/hub\n    // We set the `SENTRY_FORK_SET_SCOPE_CONTEXT_KEY` context value, which is picked up by\n    // the OTEL context manager, which picks up this scope as the current scope\n    return api.context.with(ctx.setValue(SENTRY_FORK_SET_SCOPE_CONTEXT_KEY, scope), () => {\n      return callback(scope);\n    });\n  }\n\n  function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {\n    const ctx = api.context.active();\n\n    // We depend on the otelContextManager to handle the context/hub\n    // We set the `SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY` context value, which is picked up by\n    // the OTEL context manager, which uses the presence of this key to determine if it should\n    // fork the isolation scope, or not\n    return api.context.with(ctx.setValue(SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY, true), () => {\n      return callback(getIsolationScope());\n    });\n  }\n\n  function withSetIsolationScope<T>(isolationScope: Scope, callback: (isolationScope: Scope) => T): T {\n    const ctx = api.context.active();\n\n    // We depend on the otelContextManager to handle the context/hub\n    // We set the `SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY` context value, which is picked up by\n    // the OTEL context manager, which uses the presence of this key to determine if it should\n    // fork the isolation scope, or not\n    return api.context.with(ctx.setValue(SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY, isolationScope), () => {\n      return callback(getIsolationScope());\n    });\n  }\n\n  function getCurrentScope(): Scope {\n    return getScopes().scope;\n  }\n\n  function getIsolationScope(): Scope {\n    return getScopes().isolationScope;\n  }\n\n  setAsyncContextStrategy({\n    withScope,\n    withSetScope,\n    withSetIsolationScope,\n    withIsolationScope,\n    getCurrentScope,\n    getIsolationScope,\n    startSpan,\n    startSpanManual,\n    startInactiveSpan,\n    getActiveSpan,\n    suppressTracing,\n    getTraceData,\n    continueTrace,\n    startNewTrace,\n    // The types here don't fully align, because our own `Span` type is narrower\n    // than the OTEL one - but this is OK for here, as we now we'll only have OTEL spans passed around\n    withActiveSpan: withActiveSpan as typeof defaultWithActiveSpan,\n  });\n}\n","import type { Context } from '@opentelemetry/api';\nimport { trace } from '@opentelemetry/api';\nimport type { Scope } from '@sentry/core';\nimport { getCurrentScope, getIsolationScope } from '@sentry/core';\nimport {\n  SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY,\n  SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY,\n  SENTRY_FORK_SET_SCOPE_CONTEXT_KEY,\n  SENTRY_TRACE_STATE_CHILD_IGNORED,\n} from '../constants';\nimport { getScopesFromContext, setContextOnScope, setScopesOnContext } from './contextData';\n\n/**\n * Merge Sentry scopes into an OpenTelemetry {@link Context} and apply trace-context adjustments\n * used by Sentry OpenTelemetry context manager(s).\n *\n * @param context - Context passed into `ContextManager.with`.\n * @param activeContext - Context that was active before entering `with` (e.g. `this.active()`), used\n *   to restore the parent span when the incoming span is marked ignored for children.\n * @returns A new context ready for `super.with` / `AsyncLocalStorage.run`.\n */\nexport function buildContextWithSentryScopes(context: Context, activeContext: Context): Context {\n  const span = trace.getSpan(context);\n  let effectiveContext: Context;\n  if (span?.spanContext().traceState?.get(SENTRY_TRACE_STATE_CHILD_IGNORED) === '1') {\n    const contextWithoutSpan = trace.deleteSpan(context);\n    const parentSpan = trace.getSpan(activeContext);\n    effectiveContext = parentSpan ? trace.setSpan(contextWithoutSpan, parentSpan) : contextWithoutSpan;\n  } else {\n    effectiveContext = context;\n  }\n\n  const currentScopes = getScopesFromContext(effectiveContext);\n  const currentScope = currentScopes?.scope || getCurrentScope();\n  const currentIsolationScope = currentScopes?.isolationScope || getIsolationScope();\n\n  const shouldForkIsolationScope = effectiveContext.getValue(SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY) === true;\n  const scope = effectiveContext.getValue(SENTRY_FORK_SET_SCOPE_CONTEXT_KEY) as Scope | undefined;\n  const isolationScope = effectiveContext.getValue(SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY) as Scope | undefined;\n\n  const newCurrentScope = scope || currentScope.clone();\n  const newIsolationScope =\n    isolationScope || (shouldForkIsolationScope ? currentIsolationScope.clone() : currentIsolationScope);\n  const scopes = { scope: newCurrentScope, isolationScope: newIsolationScope };\n\n  const ctx1 = setScopesOnContext(effectiveContext, scopes);\n\n  const ctx2 = ctx1\n    .deleteValue(SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY)\n    .deleteValue(SENTRY_FORK_SET_SCOPE_CONTEXT_KEY)\n    .deleteValue(SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY);\n\n  setContextOnScope(newCurrentScope, ctx2);\n\n  return ctx2;\n}\n","import type { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Context, ContextManager } from '@opentelemetry/api';\nimport { SENTRY_SCOPES_CONTEXT_KEY } from './constants';\nimport { buildContextWithSentryScopes } from './utils/buildContextWithSentryScopes';\nimport { setIsSetup } from './utils/setupCheck';\n\nexport type AsyncLocalStorageLookup = {\n  asyncLocalStorage: AsyncLocalStorage<unknown>;\n  contextSymbol: symbol;\n};\n\ntype ExtendedContextManagerInstance<ContextManagerInstance extends ContextManager> = new (\n  ...args: unknown[]\n) => ContextManagerInstance & {\n  getAsyncLocalStorageLookup(): AsyncLocalStorageLookup;\n};\n\n/**\n * Wrap an OpenTelemetry ContextManager in a way that ensures the context is kept in sync with the Sentry Scope.\n *\n * Usage:\n * import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';\n * const SentryContextManager = wrapContextManagerClass(AsyncLocalStorageContextManager);\n * const contextManager = new SentryContextManager();\n *\n * @deprecated Use {@link SentryAsyncLocalStorageContextManager} instead.\n */\nexport function wrapContextManagerClass<ContextManagerInstance extends ContextManager>(\n  ContextManagerClass: new (...args: unknown[]) => ContextManagerInstance,\n): ExtendedContextManagerInstance<ContextManagerInstance> {\n  /**\n   * This is a custom ContextManager for OpenTelemetry, which extends the default AsyncLocalStorageContextManager.\n   * It ensures that we create new scopes per context, so that the OTEL Context & the Sentry Scope are always in sync.\n   *\n   * Note that we currently only support AsyncHooks with this,\n   * but since this should work for Node 14+ anyhow that should be good enough.\n   */\n\n  // @ts-expect-error TS does not like this, but we know this is fine\n  class SentryContextManager extends ContextManagerClass {\n    public constructor(...args: unknown[]) {\n      super(...args);\n      setIsSetup('SentryContextManager');\n    }\n    /**\n     * Overwrite with() of the original AsyncLocalStorageContextManager\n     * to ensure we also create new scopes per context.\n     */\n    public with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(\n      context: Context,\n      fn: F,\n      thisArg?: ThisParameterType<F>,\n      ...args: A\n    ): ReturnType<F> {\n      const ctx2 = buildContextWithSentryScopes(context, this.active());\n      return super.with(ctx2, fn, thisArg, ...args);\n    }\n\n    /**\n     * Gets underlying AsyncLocalStorage and symbol to allow lookup of scope.\n     */\n    public getAsyncLocalStorageLookup(): AsyncLocalStorageLookup {\n      return {\n        // @ts-expect-error This is on the base class, but not part of the interface\n        asyncLocalStorage: this._asyncLocalStorage,\n        contextSymbol: SENTRY_SCOPES_CONTEXT_KEY,\n      };\n    }\n  }\n\n  return SentryContextManager as unknown as ExtendedContextManagerInstance<ContextManagerInstance>;\n}\n","import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE } from '../semanticAttributes';\nimport { getParentSpanId } from './getParentSpanId';\n\nexport interface SpanNode {\n  id: string;\n  span?: ReadableSpan;\n  parentNode?: SpanNode | undefined;\n  children: SpanNode[];\n}\n\ntype SpanMap = Map<string, SpanNode>;\n\n/**\n * This function runs through a list of OTEL Spans, and wraps them in an `SpanNode`\n * where each node holds a reference to their parent node.\n */\nexport function groupSpansWithParents(spans: ReadableSpan[]): SpanNode[] {\n  const nodeMap: SpanMap = new Map<string, SpanNode>();\n\n  for (const span of spans) {\n    createOrUpdateSpanNodeAndRefs(nodeMap, span);\n  }\n\n  return Array.from(nodeMap, function ([_id, spanNode]) {\n    return spanNode;\n  });\n}\n\n/**\n * This returns the _local_ parent ID - `parentId` on the span may point to a remote span.\n */\nexport function getLocalParentId(span: ReadableSpan): string | undefined {\n  const parentIsRemote = span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE] === true;\n  // If the parentId is the trace parent ID, we pretend it's undefined\n  // As this means the parent exists somewhere else\n  return !parentIsRemote ? getParentSpanId(span) : undefined;\n}\n\nfunction createOrUpdateSpanNodeAndRefs(nodeMap: SpanMap, span: ReadableSpan): void {\n  const id = span.spanContext().spanId;\n  const parentId = getLocalParentId(span);\n\n  if (!parentId) {\n    createOrUpdateNode(nodeMap, { id, span, children: [] });\n    return;\n  }\n\n  // Else make sure to create parent node as well\n  // Note that the parent may not know it's parent _yet_, this may be updated in a later pass\n  const parentNode = createOrGetParentNode(nodeMap, parentId);\n  const node = createOrUpdateNode(nodeMap, { id, span, parentNode, children: [] });\n  parentNode.children.push(node);\n}\n\nfunction createOrGetParentNode(nodeMap: SpanMap, id: string): SpanNode {\n  const existing = nodeMap.get(id);\n\n  if (existing) {\n    return existing;\n  }\n\n  return createOrUpdateNode(nodeMap, { id, children: [] });\n}\n\nfunction createOrUpdateNode(nodeMap: SpanMap, spanNode: SpanNode): SpanNode {\n  const existing = nodeMap.get(spanNode.id);\n\n  // If span is already set, nothing to do here\n  if (existing?.span) {\n    return existing;\n  }\n\n  // If it exists but span is not set yet, we update it\n  if (existing && !existing.span) {\n    existing.span = spanNode.span;\n    existing.parentNode = spanNode.parentNode;\n    return existing;\n  }\n\n  // Else, we create a new one...\n  nodeMap.set(spanNode.id, spanNode);\n  return spanNode;\n}\n","import { SpanStatusCode } from '@opentelemetry/api';\nimport {\n  ATTR_HTTP_RESPONSE_STATUS_CODE,\n  SEMATTRS_HTTP_STATUS_CODE,\n  SEMATTRS_RPC_GRPC_STATUS_CODE,\n} from '@opentelemetry/semantic-conventions';\nimport type { SpanAttributes, SpanStatus } from '@sentry/core';\nimport { getSpanStatusFromHttpCode, SPAN_STATUS_ERROR, SPAN_STATUS_OK } from '@sentry/core';\nimport type { AbstractSpan } from '../types';\nimport { spanHasAttributes, spanHasStatus } from './spanTypes';\n\n// canonicalCodesGrpcMap maps some GRPC codes to Sentry's span statuses. See description in grpc documentation.\nconst canonicalGrpcErrorCodesMap: Record<string, SpanStatus['message']> = {\n  '1': 'cancelled',\n  '2': 'unknown_error',\n  '3': 'invalid_argument',\n  '4': 'deadline_exceeded',\n  '5': 'not_found',\n  '6': 'already_exists',\n  '7': 'permission_denied',\n  '8': 'resource_exhausted',\n  '9': 'failed_precondition',\n  '10': 'aborted',\n  '11': 'out_of_range',\n  '12': 'unimplemented',\n  '13': 'internal_error',\n  '14': 'unavailable',\n  '15': 'data_loss',\n  '16': 'unauthenticated',\n} as const;\n\nconst isStatusErrorMessageValid = (message: string): boolean => {\n  return Object.values(canonicalGrpcErrorCodesMap).includes(message as SpanStatus['message']);\n};\n\n/**\n * Get a Sentry span status from an otel span.\n */\nexport function mapStatus(span: AbstractSpan): SpanStatus {\n  const attributes = spanHasAttributes(span) ? span.attributes : {};\n  const status = spanHasStatus(span) ? span.status : undefined;\n\n  if (status) {\n    // Since span status OK is not set by default, we give it priority: https://opentelemetry.io/docs/concepts/signals/traces/#span-status\n    if (status.code === SpanStatusCode.OK) {\n      return { code: SPAN_STATUS_OK };\n      // If the span is already marked as erroneous we return that exact status\n    } else if (status.code === SpanStatusCode.ERROR) {\n      if (typeof status.message === 'undefined') {\n        const inferredStatus = inferStatusFromAttributes(attributes);\n        if (inferredStatus) {\n          return inferredStatus;\n        }\n      }\n\n      if (status.message && isStatusErrorMessageValid(status.message)) {\n        return { code: SPAN_STATUS_ERROR, message: status.message };\n      } else {\n        return { code: SPAN_STATUS_ERROR, message: 'internal_error' };\n      }\n    }\n  }\n\n  // If the span status is UNSET, we try to infer it from HTTP or GRPC status codes.\n  const inferredStatus = inferStatusFromAttributes(attributes);\n\n  if (inferredStatus) {\n    return inferredStatus;\n  }\n\n  // We default to setting the spans status to ok.\n  if (status?.code === SpanStatusCode.UNSET) {\n    return { code: SPAN_STATUS_OK };\n  } else {\n    return { code: SPAN_STATUS_ERROR, message: 'unknown_error' };\n  }\n}\n\nfunction inferStatusFromAttributes(attributes: SpanAttributes): SpanStatus | undefined {\n  // If the span status is UNSET, we try to infer it from HTTP or GRPC status codes.\n\n  // eslint-disable-next-line deprecation/deprecation\n  const httpCodeAttribute = attributes[ATTR_HTTP_RESPONSE_STATUS_CODE] || attributes[SEMATTRS_HTTP_STATUS_CODE];\n  // eslint-disable-next-line deprecation/deprecation\n  const grpcCodeAttribute = attributes[SEMATTRS_RPC_GRPC_STATUS_CODE];\n\n  const numberHttpCode =\n    typeof httpCodeAttribute === 'number'\n      ? httpCodeAttribute\n      : typeof httpCodeAttribute === 'string'\n        ? parseInt(httpCodeAttribute)\n        : undefined;\n\n  if (typeof numberHttpCode === 'number') {\n    return getSpanStatusFromHttpCode(numberHttpCode);\n  }\n\n  if (typeof grpcCodeAttribute === 'string') {\n    return { code: SPAN_STATUS_ERROR, message: canonicalGrpcErrorCodesMap[grpcCodeAttribute] || 'unknown_error' };\n  }\n\n  return undefined;\n}\n","/* eslint-disable max-lines */\nimport type { Span } from '@opentelemetry/api';\nimport { SpanKind } from '@opentelemetry/api';\nimport type { ReadableSpan } from '@opentelemetry/sdk-trace-base';\nimport { ATTR_HTTP_RESPONSE_STATUS_CODE, SEMATTRS_HTTP_STATUS_CODE } from '@opentelemetry/semantic-conventions';\nimport type {\n  SpanAttributes,\n  SpanJSON,\n  SpanOrigin,\n  TraceContext,\n  TransactionEvent,\n  TransactionSource,\n} from '@sentry/core';\nimport {\n  _INTERNAL_safeDateNow,\n  captureEvent,\n  convertSpanLinksForEnvelope,\n  debounce,\n  debug,\n  getCapturedScopesOnSpan,\n  getDynamicSamplingContextFromSpan,\n  getStatusMessage,\n  LRUMap,\n  SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  spanTimeInputToSeconds,\n  timedEventsToMeasurements,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE } from './semanticAttributes';\nimport { getParentSpanId } from './utils/getParentSpanId';\nimport { getRequestSpanData } from './utils/getRequestSpanData';\nimport type { SpanNode } from './utils/groupSpansWithParents';\nimport { getLocalParentId, groupSpansWithParents } from './utils/groupSpansWithParents';\nimport { mapStatus } from './utils/mapStatus';\nimport { parseSpanDescription } from './utils/parseSpanDescription';\n\ntype SpanNodeCompleted = SpanNode & { span: ReadableSpan };\n\nconst MAX_SPAN_COUNT = 1000;\nconst DEFAULT_TIMEOUT = 300; // 5 min\nconst SENT_SPANS_MAX_SIZE = 10000;\n\ninterface FinishedSpanBucket {\n  timestampInS: number;\n  spans: Set<ReadableSpan>;\n}\n\n/**\n * A Sentry-specific exporter that converts OpenTelemetry Spans to Sentry Spans & Transactions.\n */\nexport class SentrySpanExporter {\n  /*\n   * A quick explanation on the buckets: We do bucketing of finished spans for efficiency. This span exporter is\n   * accumulating spans until a root span is encountered and then it flushes all the spans that are descendants of that\n   * root span. Because it is totally in the realm of possibilities that root spans are never finished, and we don't\n   * want to accumulate spans indefinitely in memory, we need to periodically evacuate spans. Naively we could simply\n   * store the spans in an array and each time a new span comes in we could iterate through the entire array and\n   * evacuate all spans that have an end-timestamp that is older than our limit. This could get quite expensive because\n   * we would have to iterate a potentially large number of spans every time we evacuate. We want to avoid these large\n   * bursts of computation.\n   *\n   * Instead we go for a bucketing approach and put spans into buckets, based on what second\n   * (modulo the time limit) the span was put into the exporter. With buckets, when we decide to evacuate, we can\n   * iterate through the bucket entries instead, which have an upper bound of items, making the evacuation much more\n   * efficient. Cleaning up also becomes much more efficient since it simply involves de-referencing a bucket within the\n   * bucket array, and letting garbage collection take care of the rest.\n   */\n  private _finishedSpanBuckets: (FinishedSpanBucket | undefined)[];\n  private _finishedSpanBucketSize: number;\n  private _spansToBucketEntry: WeakMap<ReadableSpan, FinishedSpanBucket>;\n  private _lastCleanupTimestampInS: number;\n  private _sentSpans: LRUMap<string, number>;\n  /* Internally, we use a debounced flush to give some wiggle room to the span processor to accumulate more spans. */\n  private _debouncedFlush: ReturnType<typeof debounce>;\n\n  public constructor(options?: {\n    /** Lower bound of time in seconds until spans that are buffered but have not been sent as part of a transaction get cleared from memory. */\n    timeout?: number;\n  }) {\n    this._finishedSpanBucketSize = options?.timeout || DEFAULT_TIMEOUT;\n    this._finishedSpanBuckets = new Array(this._finishedSpanBucketSize).fill(undefined);\n    this._lastCleanupTimestampInS = Math.floor(_INTERNAL_safeDateNow() / 1000);\n    this._spansToBucketEntry = new WeakMap();\n    this._sentSpans = new LRUMap<string, number>(SENT_SPANS_MAX_SIZE);\n    this._debouncedFlush = debounce(this.flush.bind(this), 1, { maxWait: 100 });\n  }\n\n  /**\n   * Export a single span.\n   * This is called by the span processor whenever a span is ended.\n   */\n  public export(span: ReadableSpan): void {\n    const currentTimestampInS = Math.floor(_INTERNAL_safeDateNow() / 1000);\n\n    if (this._lastCleanupTimestampInS !== currentTimestampInS) {\n      let droppedSpanCount = 0;\n      this._finishedSpanBuckets.forEach((bucket, i) => {\n        if (bucket && bucket.timestampInS <= currentTimestampInS - this._finishedSpanBucketSize) {\n          droppedSpanCount += bucket.spans.size;\n          this._finishedSpanBuckets[i] = undefined;\n        }\n      });\n      if (droppedSpanCount > 0) {\n        DEBUG_BUILD &&\n          debug.log(\n            `SpanExporter dropped ${droppedSpanCount} spans because they were pending for more than ${this._finishedSpanBucketSize} seconds.`,\n          );\n      }\n      this._lastCleanupTimestampInS = currentTimestampInS;\n    }\n\n    const currentBucketIndex = currentTimestampInS % this._finishedSpanBucketSize;\n    const currentBucket = this._finishedSpanBuckets[currentBucketIndex] || {\n      timestampInS: currentTimestampInS,\n      spans: new Set(),\n    };\n    this._finishedSpanBuckets[currentBucketIndex] = currentBucket;\n    currentBucket.spans.add(span);\n    this._spansToBucketEntry.set(span, currentBucket);\n\n    // If the span doesn't have a local parent ID (it's a root span), we're gonna flush all the ended spans\n    const localParentId = getLocalParentId(span);\n    if (!localParentId || this._sentSpans.get(localParentId)) {\n      this._debouncedFlush();\n    }\n  }\n\n  /**\n   * Try to flush any pending spans immediately.\n   * This is called internally by the exporter (via _debouncedFlush),\n   * but can also be triggered externally if we force-flush.\n   */\n  public flush(): void {\n    const finishedSpans = this._finishedSpanBuckets.flatMap(bucket => (bucket ? Array.from(bucket.spans) : []));\n\n    const sentSpans = this._maybeSend(finishedSpans);\n\n    const sentSpanCount = sentSpans.size;\n    const remainingOpenSpanCount = finishedSpans.length - sentSpanCount;\n    DEBUG_BUILD &&\n      debug.log(\n        `SpanExporter exported ${sentSpanCount} spans, ${remainingOpenSpanCount} spans are waiting for their parent spans to finish`,\n      );\n\n    for (const span of sentSpans) {\n      this._sentSpans.set(span.spanContext().spanId, 1);\n      const bucketEntry = this._spansToBucketEntry.get(span);\n      if (bucketEntry) {\n        bucketEntry.spans.delete(span);\n      }\n    }\n\n    // Cancel a pending debounced flush, if there is one\n    // This can be relevant if we directly flush, circumventing the debounce\n    // in that case, we want to cancel any pending debounced flush\n    this._debouncedFlush.cancel();\n  }\n\n  /**\n   * Clear the exporter.\n   * This is called when the span processor is shut down.\n   */\n  public clear(): void {\n    this._finishedSpanBuckets = this._finishedSpanBuckets.fill(undefined);\n    this._sentSpans.clear();\n    this._debouncedFlush.cancel();\n  }\n\n  /**\n   * Send the given spans, but only if they are part of a finished transaction.\n   *\n   * Returns the sent spans.\n   * Spans remain unsent when their parent span is not yet finished.\n   * This will happen regularly, as child spans are generally finished before their parents.\n   * But it _could_ also happen because, for whatever reason, a parent span was lost.\n   * In this case, we'll eventually need to clean this up.\n   */\n  private _maybeSend(spans: ReadableSpan[]): Set<ReadableSpan> {\n    const grouped = groupSpansWithParents(spans);\n    const sentSpans = new Set<ReadableSpan>();\n\n    const rootNodes = this._getCompletedRootNodes(grouped);\n\n    for (const root of rootNodes) {\n      const span = root.span;\n      sentSpans.add(span);\n      const transactionEvent = createTransactionForOtelSpan(span);\n\n      // Add an attribute to the transaction event to indicate that this transaction is an orphaned transaction\n      if (root.parentNode && this._sentSpans.get(root.parentNode.id)) {\n        const traceData = transactionEvent.contexts?.trace?.data;\n        if (traceData) {\n          traceData['sentry.parent_span_already_sent'] = true;\n        }\n      }\n\n      // We'll recursively add all the child spans to this array\n      const spans = transactionEvent.spans || [];\n\n      let hasGenAiSpans = false;\n      for (const child of root.children) {\n        if (createAndFinishSpanForOtelSpan(child, spans, sentSpans)) {\n          hasGenAiSpans = true;\n        }\n      }\n\n      // spans.sort() mutates the array, but we do not use this anymore after this point\n      // so we can safely mutate it here\n      transactionEvent.spans =\n        spans.length > MAX_SPAN_COUNT\n          ? spans.sort((a, b) => a.start_timestamp - b.start_timestamp).slice(0, MAX_SPAN_COUNT)\n          : spans;\n\n      if (hasGenAiSpans) {\n        transactionEvent.sdkProcessingMetadata = {\n          ...transactionEvent.sdkProcessingMetadata,\n          hasGenAiSpans: true,\n        };\n      }\n\n      const measurements = timedEventsToMeasurements(span.events);\n      if (measurements) {\n        transactionEvent.measurements = measurements;\n      }\n\n      captureEvent(transactionEvent);\n    }\n\n    return sentSpans;\n  }\n\n  /** Check if a node is a completed root node or a node whose parent has already been sent */\n  private _nodeIsCompletedRootNodeOrHasSentParent(node: SpanNode): node is SpanNodeCompleted {\n    return !!node.span && (!node.parentNode || !!this._sentSpans.get(node.parentNode.id));\n  }\n\n  /** Get all completed root nodes from a list of nodes */\n  private _getCompletedRootNodes(nodes: SpanNode[]): SpanNodeCompleted[] {\n    // TODO: We should be able to remove the explicit `node is SpanNodeCompleted` type guard\n    //       once we stop supporting TS < 5.5\n    return nodes.filter((node): node is SpanNodeCompleted => this._nodeIsCompletedRootNodeOrHasSentParent(node));\n  }\n}\n\nfunction parseSpan(span: ReadableSpan): { op?: string; origin?: SpanOrigin; source?: TransactionSource } {\n  const attributes = span.attributes;\n\n  const origin = attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined;\n  const op = attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] as string | undefined;\n  const source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] as TransactionSource | undefined;\n\n  return { origin, op, source };\n}\n\n/** Exported only for tests. */\nexport function createTransactionForOtelSpan(span: ReadableSpan): TransactionEvent {\n  const { op, description, data, origin = 'manual', source } = getSpanData(span);\n  const capturedSpanScopes = getCapturedScopesOnSpan(span as unknown as Span);\n\n  const sampleRate = span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE] as number | undefined;\n\n  const attributes: SpanAttributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source,\n    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: sampleRate,\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: origin,\n    ...data,\n    ...removeSentryAttributes(span.attributes),\n  };\n\n  const { links } = span;\n  const { traceId: trace_id, spanId: span_id } = span.spanContext();\n\n  // If parentSpanIdFromTraceState is defined at all, we want it to take precedence\n  // In that case, an empty string should be interpreted as \"no parent span id\",\n  // even if `span.parentSpanId` is set\n  // this is the case when we are starting a new trace, where we have a virtual span based on the propagationContext\n  // We only want to continue the traceId in this case, but ignore the parent span\n  const parent_span_id = getParentSpanId(span);\n\n  const status = mapStatus(span);\n\n  const traceContext: TraceContext = {\n    parent_span_id,\n    span_id,\n    trace_id,\n    data: attributes,\n    origin,\n    op,\n    status: getStatusMessage(status), // As per protocol, span status is allowed to be undefined\n    links: convertSpanLinksForEnvelope(links),\n  };\n\n  const statusCode = attributes[ATTR_HTTP_RESPONSE_STATUS_CODE];\n  const responseContext = typeof statusCode === 'number' ? { response: { status_code: statusCode } } : undefined;\n\n  const transactionEvent: TransactionEvent = {\n    contexts: {\n      trace: traceContext,\n      otel: {\n        resource: span.resource.attributes,\n      },\n      ...responseContext,\n    },\n    spans: [],\n    start_timestamp: spanTimeInputToSeconds(span.startTime),\n    timestamp: spanTimeInputToSeconds(span.endTime),\n    transaction: description,\n    type: 'transaction',\n    sdkProcessingMetadata: {\n      capturedSpanScope: capturedSpanScopes.scope,\n      capturedSpanIsolationScope: capturedSpanScopes.isolationScope,\n      sampleRate,\n      dynamicSamplingContext: getDynamicSamplingContextFromSpan(span as unknown as Span),\n    },\n    ...(source && {\n      transaction_info: {\n        source,\n      },\n    }),\n  };\n\n  return transactionEvent;\n}\n\n/**\n * Returns `true` if this span or any descendant is a gen_ai span.\n */\nfunction createAndFinishSpanForOtelSpan(node: SpanNode, spans: SpanJSON[], sentSpans: Set<ReadableSpan>): boolean {\n  const span = node.span;\n\n  if (span) {\n    sentSpans.add(span);\n  }\n\n  const shouldDrop = !span;\n\n  // If this span should be dropped, we still want to create spans for the children of this\n  if (shouldDrop) {\n    let hasGenAiSpans = false;\n    node.children.forEach(child => {\n      if (createAndFinishSpanForOtelSpan(child, spans, sentSpans)) {\n        hasGenAiSpans = true;\n      }\n    });\n    return hasGenAiSpans;\n  }\n\n  const span_id = span.spanContext().spanId;\n  const trace_id = span.spanContext().traceId;\n  const parentSpanId = getParentSpanId(span);\n\n  const { attributes, startTime, endTime, links } = span;\n\n  const { op, description, data, origin = 'manual' } = getSpanData(span);\n  const allData = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: origin,\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n    ...removeSentryAttributes(attributes),\n    ...data,\n  };\n\n  const status = mapStatus(span);\n\n  const spanJSON: SpanJSON = {\n    span_id,\n    trace_id,\n    data: allData,\n    description,\n    parent_span_id: parentSpanId,\n    start_timestamp: spanTimeInputToSeconds(startTime),\n    // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time\n    timestamp: spanTimeInputToSeconds(endTime) || undefined,\n    status: getStatusMessage(status), // As per protocol, span status is allowed to be undefined\n    op,\n    origin,\n    measurements: timedEventsToMeasurements(span.events),\n    links: convertSpanLinksForEnvelope(links),\n  };\n\n  spans.push(spanJSON);\n\n  let hasGenAiSpans = !!op?.startsWith('gen_ai.');\n  node.children.forEach(child => {\n    if (createAndFinishSpanForOtelSpan(child, spans, sentSpans)) {\n      hasGenAiSpans = true;\n    }\n  });\n  return hasGenAiSpans;\n}\n\nfunction getSpanData(span: ReadableSpan): {\n  data: Record<string, unknown>;\n  op?: string;\n  description: string;\n  source?: TransactionSource;\n  origin?: SpanOrigin;\n} {\n  const { op: definedOp, source: definedSource, origin } = parseSpan(span);\n  const { op: inferredOp, description, source: inferredSource, data: inferredData } = parseSpanDescription(span);\n\n  const op = definedOp || inferredOp;\n  const source = definedSource || inferredSource;\n\n  const data = { ...inferredData, ...getData(span) };\n\n  return {\n    op,\n    description,\n    source,\n    origin,\n    data,\n  };\n}\n\n/**\n * Remove custom `sentry.` attributes we do not need to send.\n * These are more carrier attributes we use inside of the SDK, we do not need to send them to the API.\n */\nfunction removeSentryAttributes(data: Record<string, unknown>): Record<string, unknown> {\n  const cleanedData = { ...data };\n\n  /* eslint-disable @typescript-eslint/no-dynamic-delete */\n  delete cleanedData[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE];\n  delete cleanedData[SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE];\n  delete cleanedData[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME];\n  /* eslint-enable @typescript-eslint/no-dynamic-delete */\n\n  return cleanedData;\n}\n\nfunction getData(span: ReadableSpan): Record<string, unknown> {\n  const attributes = span.attributes;\n  const data: Record<string, unknown> = {};\n\n  if (span.kind !== SpanKind.INTERNAL) {\n    data['otel.kind'] = SpanKind[span.kind];\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  const maybeHttpStatusCodeAttribute = attributes[SEMATTRS_HTTP_STATUS_CODE];\n  if (maybeHttpStatusCodeAttribute) {\n    data[ATTR_HTTP_RESPONSE_STATUS_CODE] = maybeHttpStatusCodeAttribute as string;\n  }\n\n  const requestData = getRequestSpanData(span);\n\n  if (requestData.url) {\n    data.url = requestData.url;\n  }\n\n  if (requestData['http.query']) {\n    data['http.query'] = requestData['http.query'].slice(1);\n  }\n  if (requestData['http.fragment']) {\n    data['http.fragment'] = requestData['http.fragment'].slice(1);\n  }\n\n  return data;\n}\n","import type { Context } from '@opentelemetry/api';\nimport { ROOT_CONTEXT, trace } from '@opentelemetry/api';\nimport type { ReadableSpan, Span, SpanProcessor as SpanProcessorInterface } from '@opentelemetry/sdk-trace-base';\nimport {\n  addChildSpanToSpan,\n  getClient,\n  getDefaultCurrentScope,\n  getDefaultIsolationScope,\n  hasSpanStreamingEnabled,\n  logSpanEnd,\n  logSpanStart,\n  setCapturedScopesOnSpan,\n} from '@sentry/core';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE } from './semanticAttributes';\nimport { SentrySpanExporter } from './spanExporter';\nimport { getScopesFromContext } from './utils/contextData';\nimport { setIsSetup } from './utils/setupCheck';\n/**\n * Converts OpenTelemetry Spans to Sentry Spans and sends them to Sentry via\n * the Sentry SDK.\n */\nexport class SentrySpanProcessor implements SpanProcessorInterface {\n  private _exporter: SentrySpanExporter;\n\n  public constructor(options?: { timeout?: number }) {\n    setIsSetup('SentrySpanProcessor');\n    this._exporter = new SentrySpanExporter(options);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public async forceFlush(): Promise<void> {\n    this._exporter.flush();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public async shutdown(): Promise<void> {\n    this._exporter.clear();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public onStart(span: Span, parentContext: Context): void {\n    // This is a reliable way to get the parent span - because this is exactly how the parent is identified in the OTEL SDK\n    const parentSpan = trace.getSpan(parentContext);\n\n    let scopes = getScopesFromContext(parentContext);\n\n    // We need access to the parent span in order to be able to move up the span tree for breadcrumbs\n    if (parentSpan && !parentSpan.spanContext().isRemote) {\n      addChildSpanToSpan(parentSpan, span);\n    }\n\n    // We need this in the span exporter\n    if (parentSpan?.spanContext().isRemote) {\n      span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE, true);\n    }\n\n    // The root context does not have scopes stored, so we check for this specifically\n    // As fallback we attach the global scopes\n    if (parentContext === ROOT_CONTEXT) {\n      scopes = {\n        scope: getDefaultCurrentScope(),\n        isolationScope: getDefaultIsolationScope(),\n      };\n    }\n\n    // We need the scope at time of span creation in order to apply it to the event when the span is finished\n    if (scopes) {\n      setCapturedScopesOnSpan(span, scopes.scope, scopes.isolationScope);\n    }\n\n    logSpanStart(span);\n\n    const client = getClient();\n    client?.emit('spanStart', span);\n  }\n\n  /** @inheritDoc */\n  public onEnd(span: Span & ReadableSpan): void {\n    logSpanEnd(span);\n\n    const client = getClient();\n    client?.emit('spanEnd', span);\n\n    if (client && hasSpanStreamingEnabled(client)) {\n      client.emit('afterSpanEnd', span);\n    } else {\n      this._exporter.export(span);\n    }\n  }\n}\n","/* eslint-disable complexity */\nimport type { Context, Span, TraceState as TraceStateInterface } from '@opentelemetry/api';\nimport { isSpanContextValid, SpanKind, trace } from '@opentelemetry/api';\nimport { TraceState } from './utils/TraceState';\nimport type { Sampler, SamplingResult } from '@opentelemetry/sdk-trace-base';\nimport { SamplingDecision } from '@opentelemetry/sdk-trace-base';\nimport {\n  ATTR_HTTP_REQUEST_METHOD,\n  ATTR_URL_FULL,\n  SEMATTRS_HTTP_METHOD,\n  SEMATTRS_HTTP_URL,\n} from '@opentelemetry/semantic-conventions';\nimport type { Client, SpanAttributes } from '@sentry/core';\nimport {\n  _INTERNAL_safeMathRandom,\n  baggageHeaderToDynamicSamplingContext,\n  debug,\n  hasSpansEnabled,\n  hasSpanStreamingEnabled,\n  parseSampleRate,\n  sampleSpan,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,\n  shouldIgnoreSpan,\n} from '@sentry/core';\nimport {\n  SENTRY_TRACE_STATE_DSC,\n  SENTRY_TRACE_STATE_CHILD_IGNORED,\n  SENTRY_TRACE_STATE_SAMPLE_RAND,\n  SENTRY_TRACE_STATE_SAMPLE_RATE,\n  SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING,\n  SENTRY_TRACE_STATE_SEGMENT_IGNORED,\n  SENTRY_TRACE_STATE_URL,\n} from './constants';\nimport { DEBUG_BUILD } from './debug-build';\nimport { getScopesFromContext } from './utils/contextData';\nimport { getSamplingDecision } from './utils/getSamplingDecision';\nimport { inferSpanData } from './utils/parseSpanDescription';\nimport { setIsSetup } from './utils/setupCheck';\n\n/**\n * A custom OTEL sampler that uses Sentry sampling rates to make its decision\n */\nexport class SentrySampler implements Sampler {\n  private _client: Client;\n  private _isSpanStreaming: boolean;\n\n  public constructor(client: Client) {\n    this._client = client;\n    this._isSpanStreaming = hasSpanStreamingEnabled(client);\n    setIsSetup('SentrySampler');\n  }\n\n  /** @inheritDoc */\n  public shouldSample(\n    context: Context,\n    traceId: string,\n    spanName: string,\n    spanKind: SpanKind,\n    spanAttributes: SpanAttributes,\n    _links: unknown,\n  ): SamplingResult {\n    const options = this._client.getOptions();\n    const { ignoreSpans } = options;\n\n    const parentSpan = getValidSpan(context);\n    const parentContext = parentSpan?.spanContext();\n\n    if (!hasSpansEnabled(options)) {\n      return wrapSamplingDecision({ decision: undefined, context, spanAttributes });\n    }\n\n    // `ATTR_HTTP_REQUEST_METHOD` is the new attribute, but we still support the old one, `SEMATTRS_HTTP_METHOD`, for now.\n    // eslint-disable-next-line deprecation/deprecation\n    const maybeSpanHttpMethod = spanAttributes[SEMATTRS_HTTP_METHOD] || spanAttributes[ATTR_HTTP_REQUEST_METHOD];\n\n    // If we have a http.client span that has no local parent, we never want to sample it\n    // but we want to leave downstream sampling decisions up to the server.\n    // Exception: when span streaming is enabled, we always emit these spans.\n    if (spanKind === SpanKind.CLIENT && maybeSpanHttpMethod && (!parentSpan || parentContext?.isRemote)) {\n      if (!this._isSpanStreaming) {\n        this._client.recordDroppedEvent('no_parent_span', 'span');\n        return wrapSamplingDecision({ decision: undefined, context, spanAttributes });\n      }\n    }\n\n    const parentSampled = parentSpan ? getParentSampled(parentSpan, traceId, spanName) : undefined;\n    const isRootSpan = !parentSpan || parentContext?.isRemote;\n\n    // We only sample based on parameters (like tracesSampleRate or tracesSampler) for root spans (which is done in sampleSpan).\n    // Non-root-spans simply inherit the sampling decision from their parent.\n    if (!isRootSpan) {\n      if (this._isSpanStreaming) {\n        // `ignoreSpans` is only applied at span start for streamed spans.\n        // Static spans/transactions get filtered at transaction end.\n        // Likewise, we only record client outcomes for child spans when streaming\n        if (parentSampled) {\n          if (ignoreSpans?.length) {\n            const { description: inferredChildName, op: childOp } = inferSpanData(spanName, spanAttributes, spanKind);\n            if (\n              shouldIgnoreSpan(\n                {\n                  description: inferredChildName,\n                  op: spanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] ?? childOp,\n                  attributes: spanAttributes,\n                },\n                ignoreSpans,\n              )\n            ) {\n              this._client.recordDroppedEvent('ignored', 'span');\n              return wrapSamplingDecision({\n                decision: SamplingDecision.NOT_RECORD,\n                context,\n                spanAttributes,\n                ignoredChildSpan: true,\n              });\n            }\n          }\n        }\n\n        if (!parentSampled) {\n          const parentSegmentIgnored = parentContext?.traceState?.get(SENTRY_TRACE_STATE_SEGMENT_IGNORED) === '1';\n          this._client.recordDroppedEvent(parentSegmentIgnored ? 'ignored' : 'sample_rate', 'span');\n        }\n      }\n\n      return wrapSamplingDecision({\n        decision: parentSampled ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD,\n        context,\n        spanAttributes,\n      });\n    }\n\n    // We want to pass the inferred name & attributes to the sampler method\n    const {\n      description: inferredSpanName,\n      data: inferredAttributes,\n      op,\n    } = inferSpanData(spanName, spanAttributes, spanKind);\n\n    const mergedAttributes = {\n      ...inferredAttributes,\n      ...spanAttributes,\n    };\n\n    if (op) {\n      mergedAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] = op;\n    }\n\n    if (\n      this._isSpanStreaming &&\n      ignoreSpans?.length &&\n      shouldIgnoreSpan(\n        {\n          description: inferredSpanName,\n          op: mergedAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] ?? op,\n          attributes: mergedAttributes,\n        },\n        ignoreSpans,\n      )\n    ) {\n      this._client.recordDroppedEvent('ignored', 'span');\n      return wrapSamplingDecision({\n        decision: SamplingDecision.NOT_RECORD,\n        context,\n        spanAttributes,\n        ignoredSegmentSpan: true,\n      });\n    }\n\n    const mutableSamplingDecision = { decision: true };\n    this._client.emit(\n      'beforeSampling',\n      {\n        spanAttributes: mergedAttributes,\n        spanName: inferredSpanName,\n        parentSampled: parentSampled,\n        parentContext: parentContext,\n      },\n      mutableSamplingDecision,\n    );\n    if (!mutableSamplingDecision.decision) {\n      return wrapSamplingDecision({ decision: undefined, context, spanAttributes });\n    }\n\n    const { isolationScope } = getScopesFromContext(context) ?? {};\n\n    const dscString = parentContext?.traceState ? parentContext.traceState.get(SENTRY_TRACE_STATE_DSC) : undefined;\n    const dsc = dscString ? baggageHeaderToDynamicSamplingContext(dscString) : undefined;\n\n    const sampleRand = parseSampleRate(dsc?.sample_rand) ?? _INTERNAL_safeMathRandom();\n\n    const [sampled, sampleRate, localSampleRateWasApplied] = sampleSpan(\n      options,\n      {\n        name: inferredSpanName,\n        attributes: mergedAttributes,\n        normalizedRequest: isolationScope?.getScopeData().sdkProcessingMetadata.normalizedRequest,\n        parentSampled,\n        parentSampleRate: parseSampleRate(dsc?.sample_rate),\n      },\n      sampleRand,\n    );\n\n    const method = `${maybeSpanHttpMethod}`.toUpperCase();\n    if (method === 'OPTIONS' || method === 'HEAD') {\n      DEBUG_BUILD && debug.log(`[Tracing] Not sampling span because HTTP method is '${method}' for ${spanName}`);\n\n      return wrapSamplingDecision({\n        decision: SamplingDecision.NOT_RECORD,\n        context,\n        spanAttributes,\n        sampleRand,\n        downstreamTraceSampleRate: 0, // we don't want to sample anything in the downstream trace either\n      });\n    }\n\n    if (\n      !sampled &&\n      // We check for `parentSampled === undefined` because we only want to record client reports for spans that are trace roots (ie. when there was incoming trace)\n      parentSampled === undefined\n    ) {\n      DEBUG_BUILD && debug.log('[Tracing] Discarding root span because its trace was not chosen to be sampled.');\n      this._client.recordDroppedEvent('sample_rate', this._isSpanStreaming ? 'span' : 'transaction');\n    }\n\n    return {\n      ...wrapSamplingDecision({\n        decision: sampled ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD,\n        context,\n        spanAttributes,\n        sampleRand,\n        downstreamTraceSampleRate: localSampleRateWasApplied ? sampleRate : undefined,\n      }),\n      attributes: {\n        // We set the sample rate on the span when a local sample rate was applied to better understand how traces were sampled in Sentry\n        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: localSampleRateWasApplied ? sampleRate : undefined,\n      },\n    };\n  }\n\n  /** Returns the sampler name or short description with the configuration. */\n  public toString(): string {\n    return 'SentrySampler';\n  }\n}\n\nfunction getParentSampled(parentSpan: Span, traceId: string, spanName: string): boolean | undefined {\n  const parentContext = parentSpan.spanContext();\n\n  // Only inherit sample rate if `traceId` is the same\n  // Note for testing: `isSpanContextValid()` checks the format of the traceId/spanId, so we need to pass valid ones\n  if (isSpanContextValid(parentContext) && parentContext.traceId === traceId) {\n    if (parentContext.isRemote) {\n      const parentSampled = getSamplingDecision(parentSpan.spanContext());\n      DEBUG_BUILD &&\n        debug.log(`[Tracing] Inheriting remote parent's sampled decision for ${spanName}: ${parentSampled}`);\n      return parentSampled;\n    }\n\n    const parentSampled = getSamplingDecision(parentContext);\n    DEBUG_BUILD && debug.log(`[Tracing] Inheriting parent's sampled decision for ${spanName}: ${parentSampled}`);\n    return parentSampled;\n  }\n\n  return undefined;\n}\n\n/**\n * Wrap a sampling decision with data that Sentry needs to work properly with it.\n * If you pass `decision: undefined`, it will be treated as `NOT_RECORDING`, but in contrast to passing `NOT_RECORDING`\n * it will not propagate this decision to downstream Sentry SDKs.\n */\nexport function wrapSamplingDecision({\n  decision,\n  context,\n  spanAttributes,\n  sampleRand,\n  downstreamTraceSampleRate,\n  ignoredChildSpan,\n  ignoredSegmentSpan,\n}: {\n  decision: SamplingDecision | undefined;\n  context: Context;\n  spanAttributes: SpanAttributes;\n  sampleRand?: number;\n  downstreamTraceSampleRate?: number;\n  // flags for ignored streamed spans (only set for span streaming)\n  ignoredChildSpan?: boolean;\n  ignoredSegmentSpan?: boolean;\n}): SamplingResult {\n  let traceState = getBaseTraceState(context, spanAttributes);\n\n  // We will override the propagated sample rate downstream when\n  // - the tracesSampleRate is applied\n  // - the tracesSampler is invoked\n  // Since unsampled OTEL spans (NonRecordingSpans) cannot hold attributes we need to store this on the (trace)context.\n  if (downstreamTraceSampleRate !== undefined) {\n    traceState = traceState.set(SENTRY_TRACE_STATE_SAMPLE_RATE, `${downstreamTraceSampleRate}`);\n  }\n\n  if (sampleRand !== undefined) {\n    traceState = traceState.set(SENTRY_TRACE_STATE_SAMPLE_RAND, `${sampleRand}`);\n  }\n\n  if (ignoredChildSpan) {\n    traceState = traceState.set(SENTRY_TRACE_STATE_CHILD_IGNORED, '1');\n  }\n\n  if (ignoredSegmentSpan) {\n    traceState = traceState.set(SENTRY_TRACE_STATE_SEGMENT_IGNORED, '1');\n  }\n\n  // If the decision is undefined, we treat it as NOT_RECORDING, but we don't propagate this decision to downstream SDKs\n  // Which is done by not setting `SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING` traceState\n  if (decision == undefined) {\n    return { decision: SamplingDecision.NOT_RECORD, traceState };\n  }\n\n  if (decision === SamplingDecision.NOT_RECORD) {\n    return { decision, traceState: traceState.set(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING, '1') };\n  }\n\n  return { decision, traceState };\n}\n\nfunction getBaseTraceState(context: Context, spanAttributes: SpanAttributes): TraceStateInterface {\n  const parentSpan = trace.getSpan(context);\n  const parentContext = parentSpan?.spanContext();\n\n  let traceState = parentContext?.traceState || new TraceState();\n\n  // We always keep the URL on the trace state, so we can access it in the propagator\n  // `ATTR_URL_FULL` is the new attribute, but we still support the old one, `ATTR_HTTP_URL`, for now.\n  // eslint-disable-next-line deprecation/deprecation\n  const url = spanAttributes[SEMATTRS_HTTP_URL] || spanAttributes[ATTR_URL_FULL];\n  if (url && typeof url === 'string') {\n    traceState = traceState.set(SENTRY_TRACE_STATE_URL, url);\n  }\n\n  return traceState;\n}\n\n/**\n * If the active span is invalid, we want to ignore it as parent.\n * This aligns with how otel tracers and default samplers handle these cases.\n */\nfunction getValidSpan(context: Context): Span | undefined {\n  const span = trace.getSpan(context);\n  return span && isSpanContextValid(span.spanContext()) ? span : undefined;\n}\n","import type { Attributes, AttributeValue } from '@opentelemetry/api';\nimport { SDK_INFO } from '@opentelemetry/core';\nimport {\n  ATTR_SERVICE_NAME,\n  ATTR_SERVICE_VERSION,\n  ATTR_TELEMETRY_SDK_LANGUAGE,\n  ATTR_TELEMETRY_SDK_NAME,\n  ATTR_TELEMETRY_SDK_VERSION,\n  SEMRESATTRS_SERVICE_NAMESPACE,\n} from '@opentelemetry/semantic-conventions';\nimport { SDK_VERSION } from '@sentry/core';\n\ntype RawResourceAttribute = [string, AttributeValue | undefined];\n\n/**\n * Minimal Resource implementation that satisfies the OpenTelemetry Resource interface\n * used by BasicTracerProvider, without depending on `@opentelemetry/resources`.\n */\nclass SentryResource {\n  private _attributes: Attributes;\n\n  public constructor(attributes: Attributes) {\n    this._attributes = attributes;\n  }\n\n  public get attributes(): Attributes {\n    return this._attributes;\n  }\n\n  public merge(other: SentryResource | null): SentryResource {\n    if (!other) {\n      return this;\n    }\n    return new SentryResource({ ...this._attributes, ...other.attributes });\n  }\n\n  public getRawAttributes(): RawResourceAttribute[] {\n    return Object.entries(this._attributes);\n  }\n}\n\n/**\n * Parses `OTEL_RESOURCE_ATTRIBUTES` env var (comma-separated `key=value` pairs).\n * Values are URL-decoded per the OTel spec.\n */\nfunction parseOtelResourceAttributes(raw: string | undefined): Attributes {\n  if (!raw) {\n    return {};\n  }\n  const result: Attributes = {};\n  for (const pair of raw.split(',')) {\n    const eq = pair.indexOf('=');\n    if (eq === -1) {\n      continue;\n    }\n    const key = pair.substring(0, eq).trim();\n    const value = pair.substring(eq + 1).trim();\n    if (key) {\n      try {\n        result[key] = decodeURIComponent(value);\n      } catch {\n        result[key] = value;\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Returns a Resource for use in Sentry's OpenTelemetry TracerProvider setup.\n *\n * Combines the default OTel SDK telemetry attributes with Sentry-specific\n * service attributes, equivalent to what was previously done via:\n * `defaultResource().merge(resourceFromAttributes({ ... }))`\n *\n * Respects OTEL_SERVICE_NAME and OTEL_RESOURCE_ATTRIBUTES environment variables\n * per the OpenTelemetry specification.\n */\nexport function getSentryResource(serviceNameFallback: string): SentryResource {\n  const env = typeof process !== 'undefined' ? process.env : {};\n  const otelServiceName = env.OTEL_SERVICE_NAME;\n  const otelResourceAttrs = parseOtelResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);\n\n  return new SentryResource({\n    // Lowest priority: Sentry defaults\n    // eslint-disable-next-line deprecation/deprecation\n    [SEMRESATTRS_SERVICE_NAMESPACE]: 'sentry',\n    [ATTR_SERVICE_NAME]: serviceNameFallback,\n    // OTEL_RESOURCE_ATTRIBUTES overrides defaults (including service.name and service.namespace)\n    ...otelResourceAttrs,\n    // OTEL_SERVICE_NAME explicitly overrides service.name\n    ...(otelServiceName ? { [ATTR_SERVICE_NAME]: otelServiceName } : {}),\n    // Highest priority: Sentry SDK telemetry attrs (cannot be overridden by env vars)\n    [ATTR_SERVICE_VERSION]: SDK_VERSION,\n    [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],\n    [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],\n    [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION],\n  });\n}\n"],"names":["context","dynamicSamplingContext","suppressTracing","suppressTracingImpl","scope","inferredStatus","spans","hasGenAiSpans","parentSampled"],"mappings":";;;;;;;;AACO,MAAM,0CAAA,GAA6C,uBAAA;AAGnD,MAAM,2CAAA,GAA8C;;ACGpD,SAAS,gBAAgB,IAAA,EAAwC;AACtE,EAAA,IAAI,kBAAkB,IAAA,EAAM;AAC1B,IAAA,OAAO,IAAA,CAAK,YAAA;AAAA,EACd,CAAA,MAAA,IAAW,uBAAuB,IAAA,EAAM;AACtC,IAAA,OAAQ,KAAK,iBAAA,EAAuD,MAAA;AAAA,EACtE;AAEA,EAAA,OAAO,MAAA;AACT;;ACLO,SAAS,kBACd,IAAA,EAC+D;AAC/D,EAAA,MAAM,QAAA,GAAW,IAAA;AACjB,EAAA,OAAO,CAAC,CAAC,QAAA,CAAS,UAAA,IAAc,OAAO,SAAS,UAAA,KAAe,QAAA;AACjE;AAOO,SAAS,YAA2C,IAAA,EAAuD;AAChH,EAAA,MAAM,QAAA,GAAW,IAAA;AACjB,EAAA,OAAO,OAAO,SAAS,IAAA,KAAS,QAAA;AAClC;AAOO,SAAS,cACd,IAAA,EAC2C;AAC3C,EAAA,MAAM,QAAA,GAAW,IAAA;AACjB,EAAA,OAAO,CAAC,CAAC,QAAA,CAAS,MAAA;AACpB;AAOO,SAAS,YAA2C,IAAA,EAAqD;AAC9G,EAAA,MAAM,QAAA,GAAW,IAAA;AACjB,EAAA,OAAO,CAAC,CAAC,QAAA,CAAS,IAAA;AACpB;AAOO,SAAS,gBACd,IAAA,EAC6C;AAC7C,EAAA,MAAM,QAAA,GAAW,IAAA;AACjB,EAAA,OAAO,CAAC,CAAC,eAAA,CAAgB,QAAQ,CAAA;AACnC;AAOO,SAAS,cACd,IAAA,EAC6C;AAC7C,EAAA,MAAM,QAAA,GAAW,IAAA;AACjB,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,QAAA,CAAS,MAAM,CAAA;AACtC;;ACxDO,SAAS,mBAAmB,IAAA,EAA0D;AAE3F,EAAA,IAAI,CAAC,iBAAA,CAAkB,IAAI,CAAA,EAAG;AAC5B,IAAA,OAAO,EAAC;AAAA,EACV;AAGA,EAAA,MAAM,oBAAqB,IAAA,CAAK,UAAA,CAAW,aAAa,CAAA,IAAK,IAAA,CAAK,WAAW,iBAAiB,CAAA;AAI9F,EAAA,MAAM,IAAA,GAAsC;AAAA,IAC1C,GAAA,EAAK,iBAAA;AAAA;AAAA,IAEL,eAAgB,IAAA,CAAK,UAAA,CAAW,wBAAwB,CAAA,IAAK,IAAA,CAAK,WAAW,oBAAoB;AAAA,GAGnG;AAGA,EAAA,IAAI,CAAC,IAAA,CAAK,aAAa,CAAA,IAAK,KAAK,GAAA,EAAK;AACpC,IAAA,IAAA,CAAK,aAAa,CAAA,GAAI,KAAA;AAAA,EACxB;AAEA,EAAA,IAAI;AACF,IAAA,IAAI,OAAO,sBAAsB,QAAA,EAAU;AACzC,MAAA,MAAM,GAAA,GAAM,SAAS,iBAAiB,CAAA;AAEtC,MAAA,IAAA,CAAK,GAAA,GAAM,sBAAsB,GAAG,CAAA;AAEpC,MAAA,IAAI,IAAI,MAAA,EAAQ;AACd,QAAA,IAAA,CAAK,YAAY,IAAI,GAAA,CAAI,MAAA;AAAA,MAC3B;AACA,MAAA,IAAI,IAAI,IAAA,EAAM;AACZ,QAAA,IAAA,CAAK,eAAe,IAAI,GAAA,CAAI,IAAA;AAAA,MAC9B;AAAA,IACF;AAAA,EACF,CAAA,CAAA,MAAQ;AAAA,EAER;AAEA,EAAA,OAAO,IAAA;AACT;;ACtCO,SAAS,gBAGd,WAAA,EAAwD;AAAA,EAExD,MAAM,4BAA4B,WAAA,CAAoD;AAAA,IAI7E,eAAe,IAAA,EAAa;AACjC,MAAA,KAAA,CAAM,GAAG,IAAI,CAAA;AAAA,IACf;AAAA;AAAA,IAGA,IAAW,MAAA,GAAiB;AAC1B,MAAA,IAAI,KAAK,OAAA,EAAS;AAChB,QAAA,OAAO,IAAA,CAAK,OAAA;AAAA,MACd;AAEA,MAAA,MAAM,IAAA,GAAO,uBAAA;AACb,MAAA,MAAM,OAAA,GAAU,WAAA;AAChB,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,SAAA,CAAU,IAAA,EAAM,OAAO,CAAA;AAC5C,MAAA,IAAA,CAAK,OAAA,GAAU,MAAA;AAEf,MAAA,OAAO,MAAA;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,MAAa,MAAM,OAAA,EAAoC;AACrD,MAAA,MAAM,WAAW,IAAA,CAAK,aAAA;AACtB,MAAA,MAAM,UAAU,UAAA,EAAW;AAC3B,MAAA,OAAO,KAAA,CAAM,MAAM,OAAO,CAAA;AAAA,IAC5B;AAAA;AAGF,EAAA,OAAO,mBAAA;AACT;;AC/CO,SAAS,YAAY,IAAA,EAA8B;AACxD,EAAA,IAAI,WAAA,CAAY,IAAI,CAAA,EAAG;AACrB,IAAA,OAAO,IAAA,CAAK,IAAA;AAAA,EACd;AAEA,EAAA,OAAO,QAAA,CAAS,QAAA;AAClB;;ACdO,MAAM,mBAAA,GAAsB,cAAA;AAC5B,MAAM,qBAAA,GAAwB,SAAA;AAE9B,MAAM,sBAAA,GAAyB,YAAA;AAC/B,MAAM,wCAAA,GAA2C,8BAAA;AACjD,MAAM,sBAAA,GAAyB,YAAA;AAC/B,MAAM,8BAAA,GAAiC,oBAAA;AACvC,MAAM,8BAAA,GAAiC,oBAAA;AAMvC,MAAM,gCAAA,GAAmC,gBAAA;AAQzC,MAAM,kCAAA,GAAqC,wBAAA;AAE3C,MAAM,yBAAA,GAA4B,iBAAiB,eAAe;AAElE,MAAM,uCAAA,GAA0C,iBAAiB,6BAA6B,CAAA;AAE9F,MAAM,iCAAA,GAAoC,iBAAiB,uBAAuB,CAAA;AAElF,MAAM,2CAAA,GAA8C,iBAAiB,iCAAiC,CAAA;;ACzB7G,MAAM,mBAAA,GAAsB,eAAA;AAUrB,SAAS,qBAAqB,OAAA,EAA6C;AAChF,EAAA,OAAO,OAAA,CAAQ,SAAS,yBAAyB,CAAA;AACnD;AAMO,SAAS,kBAAA,CAAmB,SAAkB,MAAA,EAAgC;AACnF,EAAA,OAAO,OAAA,CAAQ,QAAA,CAAS,yBAAA,EAA2B,MAAM,CAAA;AAC3D;AAYO,SAAS,iBAAA,CAAkB,OAAc,OAAA,EAAwB;AACtE,EAAA,wBAAA,CAAyB,KAAA,EAAO,mBAAA,EAAqB,WAAA,CAAY,OAAO,CAAC,CAAA;AAC3E;AAMO,SAAS,oBAAoB,KAAA,EAAmC;AACrE,EAAA,OAAO,YAAA,CAAc,KAAA,CAA2B,mBAAmB,CAAC,CAAA;AACtE;;ACtCO,SAAS,oBAAoB,IAAA,EAA6B;AAC/D,EAAA,IAAI,CAAC,iBAAA,CAAkB,IAAI,CAAA,EAAG;AAC5B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,EAAE,YAAW,GAAI,IAAA;AAIvB,EAAA,MAAM,OAAA,GAAU,UAAA,CAAW,iBAAiB,CAAA,IAAK,WAAW,aAAa,CAAA;AAEzE,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OAAO,kBAAA,CAAmB,OAAA,CAAQ,QAAA,EAAS,EAAG,WAAW,CAAA;AAC3D;;ACdO,SAAS,oBAAoB,WAAA,EAA+C;AACjF,EAAA,MAAM,EAAE,UAAA,EAAY,UAAA,EAAW,GAAI,WAAA;AAEnC,EAAA,MAAM,sBAAsB,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,wCAAwC,MAAM,GAAA,GAAM,KAAA;AAM5G,EAAA,IAAI,UAAA,KAAe,WAAW,OAAA,EAAS;AACrC,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,IAAI,mBAAA,EAAqB;AACvB,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,SAAA,GAAY,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,sBAAsB,CAAA,GAAI,MAAA;AACxE,EAAA,MAAM,GAAA,GAAM,SAAA,GAAY,qCAAA,CAAsC,SAAS,CAAA,GAAI,MAAA;AAE3E,EAAA,IAAI,GAAA,EAAK,YAAY,MAAA,EAAQ;AAC3B,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,IAAI,GAAA,EAAK,YAAY,OAAA,EAAS;AAC5B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OAAO,MAAA;AACT;;ACAO,SAAS,aAAA,CAAc,QAAA,EAAkB,UAAA,EAA4B,IAAA,EAAiC;AAG3G,EAAA,MAAM,UAAA,GAAa,UAAA,CAAW,wBAAwB,CAAA,IAAK,WAAW,oBAAoB,CAAA;AAC1F,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO,yBAAyB,EAAE,UAAA,EAAY,MAAM,QAAA,EAAU,IAAA,IAAQ,UAAU,CAAA;AAAA,EAClF;AAGA,EAAA,MAAM,QAAA,GAAW,UAAA,CAAW,mBAAmB,CAAA,IAAK,WAAW,kBAAkB,CAAA;AACjF,EAAA,MAAM,SAAA,GACJ,OAAO,UAAA,CAAW,4BAA4B,CAAA,KAAM,YACpD,UAAA,CAAW,4BAA4B,CAAA,CAAE,UAAA,CAAW,QAAQ,CAAA;AAI9D,EAAA,IAAI,QAAA,IAAY,CAAC,SAAA,EAAW;AAC1B,IAAA,OAAO,sBAAA,CAAuB,EAAE,UAAA,EAAY,IAAA,EAAM,UAAU,CAAA;AAAA,EAC9D;AAEA,EAAA,MAAM,mBAAA,GAAsB,UAAA,CAAW,gCAAgC,CAAA,KAAM,WAAW,QAAA,GAAW,OAAA;AAInG,EAAA,MAAM,UAAA,GAAa,WAAW,oBAAoB,CAAA;AAClD,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO;AAAA,MACL,GAAG,2BAAA,CAA4B,QAAA,EAAU,UAAA,EAAY,OAAO,CAAA;AAAA,MAC5D,EAAA,EAAI;AAAA,KACN;AAAA,EACF;AAIA,EAAA,MAAM,eAAA,GAAkB,WAAW,yBAAyB,CAAA;AAC5D,EAAA,IAAI,eAAA,EAAiB;AACnB,IAAA,OAAO;AAAA,MACL,GAAG,2BAAA,CAA4B,QAAA,EAAU,UAAA,EAAY,mBAAmB,CAAA;AAAA,MACxE,EAAA,EAAI;AAAA,KACN;AAAA,EACF;AAIA,EAAA,MAAM,WAAA,GAAc,WAAW,qBAAqB,CAAA;AACpD,EAAA,IAAI,WAAA,EAAa;AACf,IAAA,OAAO;AAAA,MACL,GAAG,2BAAA,CAA4B,QAAA,EAAU,UAAA,EAAY,mBAAmB,CAAA;AAAA,MACxE,EAAA,EAAI,YAAY,QAAA;AAAS,KAC3B;AAAA,EACF;AAEA,EAAA,OAAO,EAAE,EAAA,EAAI,MAAA,EAAW,WAAA,EAAa,QAAA,EAAU,QAAQ,QAAA,EAAS;AAClE;AAWO,SAAS,qBAAqB,IAAA,EAAqC;AACxE,EAAA,MAAM,aAAa,iBAAA,CAAkB,IAAI,CAAA,GAAI,IAAA,CAAK,aAAa,EAAC;AAChE,EAAA,MAAM,IAAA,GAAO,WAAA,CAAY,IAAI,CAAA,GAAI,KAAK,IAAA,GAAO,WAAA;AAC7C,EAAA,MAAM,IAAA,GAAO,YAAY,IAAI,CAAA;AAE7B,EAAA,OAAO,aAAA,CAAc,IAAA,EAAM,UAAA,EAAY,IAAI,CAAA;AAC7C;AAEA,SAAS,sBAAA,CAAuB,EAAE,UAAA,EAAY,IAAA,EAAK,EAA8D;AAE/G,EAAA,MAAM,eAAA,GAAkB,WAAW,0CAA0C,CAAA;AAC7E,EAAA,IAAI,OAAO,oBAAoB,QAAA,EAAU;AACvC,IAAA,OAAO;AAAA,MACL,EAAA,EAAI,IAAA;AAAA,MACJ,WAAA,EAAa,eAAA;AAAA,MACb,MAAA,EAAS,UAAA,CAAW,gCAAgC,CAAA,IAA2B;AAAA,KACjF;AAAA,EACF;AAGA,EAAA,IAAI,UAAA,CAAW,gCAAgC,CAAA,KAAM,QAAA,EAAU;AAC7D,IAAA,OAAO,EAAE,EAAA,EAAI,IAAA,EAAM,WAAA,EAAa,IAAA,EAAM,QAAQ,QAAA,EAAS;AAAA,EACzD;AAIA,EAAA,MAAM,SAAA,GAAY,WAAW,qBAAqB,CAAA;AAElD,EAAA,MAAM,WAAA,GAAc,SAAA,GAAY,SAAA,CAAU,QAAA,EAAS,GAAI,IAAA;AAEvD,EAAA,OAAO,EAAE,EAAA,EAAI,IAAA,EAAM,WAAA,EAAa,QAAQ,MAAA,EAAO;AACjD;AAGO,SAAS,yBACd,EAAE,IAAA,EAAM,IAAA,EAAM,UAAA,IACd,UAAA,EACiB;AACjB,EAAA,MAAM,OAAA,GAAU,CAAC,MAAM,CAAA;AAEvB,EAAA,QAAQ,IAAA;AAAM,IACZ,KAAK,QAAA,CAAS,MAAA;AACZ,MAAA,OAAA,CAAQ,KAAK,QAAQ,CAAA;AACrB,MAAA;AAAA,IACF,KAAK,QAAA,CAAS,MAAA;AACZ,MAAA,OAAA,CAAQ,KAAK,QAAQ,CAAA;AACrB,MAAA;AAAA;AAIJ,EAAA,IAAI,UAAA,CAAW,sBAAsB,CAAA,EAAG;AACtC,IAAA,OAAA,CAAQ,KAAK,UAAU,CAAA;AAAA,EACzB;AAEA,EAAA,MAAM,EAAE,SAAS,GAAA,EAAK,KAAA,EAAO,UAAU,QAAA,EAAS,GAAI,eAAA,CAAgB,UAAA,EAAY,IAAI,CAAA;AAEpF,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA,OAAO,EAAE,GAAG,2BAAA,CAA4B,IAAA,EAAM,UAAU,GAAG,EAAA,EAAI,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAA,EAAE;AAAA,EACnF;AAEA,EAAA,MAAM,0BAAA,GAA6B,WAAW,2CAA2C,CAAA;AAGzF,EAAA,MAAM,eAAA,GAAkB,CAAA,EAAG,UAAU,CAAA,CAAA,EAAI,OAAO,CAAA,CAAA;AAIhD,EAAA,MAAM,mBAAA,GAAsB,6BACxB,CAAA,EAAG,eAAe,KAAK,qCAAA,CAAsC,0BAA0B,CAAC,CAAA,CAAA,CAAA,GACxF,eAAA;AAGJ,EAAA,MAAM,cAAA,GAAoC,QAAA,IAAY,OAAA,KAAY,GAAA,GAAM,OAAA,GAAU,KAAA;AAElF,EAAA,MAAM,OAA+B,EAAC;AAEtC,EAAA,IAAI,GAAA,EAAK;AACP,IAAA,IAAA,CAAK,GAAA,GAAM,GAAA;AAAA,EACb;AACA,EAAA,IAAI,KAAA,EAAO;AACT,IAAA,IAAA,CAAK,YAAY,CAAA,GAAI,KAAA;AAAA,EACvB;AACA,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,IAAA,CAAK,eAAe,CAAA,GAAI,QAAA;AAAA,EAC1B;AAIA,EAAA,MAAM,oBAAA,GAAuB,IAAA,KAAS,QAAA,CAAS,MAAA,IAAU,SAAS,QAAA,CAAS,MAAA;AAK3E,EAAA,MAAM,MAAA,GAAS,UAAA,CAAW,gCAAgC,CAAA,IAAK,QAAA;AAC/D,EAAA,MAAM,eAAe,CAAC,CAAA,EAAG,MAAM,CAAA,CAAA,CAAG,WAAW,MAAM,CAAA;AAGnD,EAAA,MAAM,sBAAA,GAAyB,UAAA,CAAW,gCAAgC,CAAA,KAAM,QAAA;AAChF,EAAA,MAAM,cAAA,GAAiB,WAAW,0CAA0C,CAAA;AAE5E,EAAA,MAAM,yBACJ,CAAC,sBAAA,IAA0B,cAAA,IAAkB,IAAA,KAAS,wBAAwB,CAAC,YAAA,CAAA;AAEjF,EAAA,MAAM,EAAE,WAAA,EAAa,MAAA,EAAO,GAAI,sBAAA,GAC5B,EAAE,WAAA,EAAa,mBAAA,EAAqB,MAAA,EAAQ,cAAA,EAAe,GAC3D,2BAAA,CAA4B,MAAM,UAAU,CAAA;AAEhD,EAAA,OAAO;AAAA,IACL,EAAA,EAAI,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAA;AAAA,IACpB,WAAA;AAAA,IACA,MAAA;AAAA,IACA;AAAA,GACF;AACF;AAEA,SAAS,sCAAsC,IAAA,EAA8B;AAC3E,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,IAAI,CAAA,EAAG;AAEvB,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,EAAM,CAAE,IAAA,EAAK;AAGjC,IAAA,IAAI,MAAA,CAAO,UAAU,CAAA,EAAG;AACtB,MAAA,OAAO,MAAA,CAAO,KAAK,IAAI,CAAA;AAAA,IACzB,CAAA,MAAO;AAEL,MAAA,OAAO,CAAA,EAAG,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAC,CAAA,CAAE,IAAA,CAAK,IAAI,CAAC,CAAA,GAAA,EAAM,MAAA,CAAO,MAAA,GAAS,CAAC,CAAA,CAAA;AAAA,IAChE;AAAA,EACF;AAEA,EAAA,OAAO,GAAG,IAAI,CAAA,CAAA;AAChB;AAGO,SAAS,eAAA,CACd,YACA,IAAA,EAOA;AAGA,EAAA,MAAM,UAAA,GAAa,WAAW,oBAAoB,CAAA;AAGlD,EAAA,MAAM,OAAA,GAAU,UAAA,CAAW,iBAAiB,CAAA,IAAK,WAAW,aAAa,CAAA;AAEzE,EAAA,MAAM,SAAA,GAAY,WAAW,eAAe,CAAA;AAE5C,EAAA,MAAM,YAAY,OAAO,OAAA,KAAY,QAAA,GAAW,QAAA,CAAS,OAAO,CAAA,GAAI,MAAA;AACpE,EAAA,MAAM,GAAA,GAAM,SAAA,GAAY,qBAAA,CAAsB,SAAS,CAAA,GAAI,MAAA;AAC3D,EAAA,MAAM,KAAA,GAAQ,WAAW,MAAA,IAAU,MAAA;AACnC,EAAA,MAAM,QAAA,GAAW,WAAW,IAAA,IAAQ,MAAA;AAEpC,EAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,IAAA,OAAO,EAAE,OAAA,EAAS,SAAA,EAAW,KAAK,KAAA,EAAO,QAAA,EAAU,UAAU,IAAA,EAAK;AAAA,EACpE;AAEA,EAAA,IAAI,IAAA,KAAS,QAAA,CAAS,MAAA,IAAU,OAAO,eAAe,QAAA,EAAU;AAC9D,IAAA,OAAO,EAAE,SAAS,wBAAA,CAAyB,UAAU,GAAG,GAAA,EAAK,KAAA,EAAO,QAAA,EAAU,QAAA,EAAU,KAAA,EAAM;AAAA,EAChG;AAEA,EAAA,IAAI,SAAA,EAAW;AACb,IAAA,OAAO,EAAE,OAAA,EAAS,GAAA,EAAK,KAAK,KAAA,EAAO,QAAA,EAAU,UAAU,KAAA,EAAM;AAAA,EAC/D;AAGA,EAAA,IAAI,OAAO,eAAe,QAAA,EAAU;AAClC,IAAA,OAAO,EAAE,SAAS,wBAAA,CAAyB,UAAU,GAAG,GAAA,EAAK,KAAA,EAAO,QAAA,EAAU,QAAA,EAAU,KAAA,EAAM;AAAA,EAChG;AAEA,EAAA,OAAO,EAAE,OAAA,EAAS,MAAA,EAAW,KAAK,KAAA,EAAO,QAAA,EAAU,UAAU,KAAA,EAAM;AACrE;AAcO,SAAS,2BAAA,CACd,YAAA,EACA,UAAA,EACA,cAAA,GAAoC,QAAA,EAIpC;AACA,EAAA,MAAM,MAAA,GAAU,UAAA,CAAW,gCAAgC,CAAA,IAA2B,cAAA;AACtF,EAAA,MAAM,WAAA,GAAc,WAAW,0CAA0C,CAAA;AAEzE,EAAA,IAAI,WAAA,IAAe,OAAO,WAAA,KAAgB,QAAA,EAAU;AAClD,IAAA,OAAO;AAAA,MACL,WAAA;AAAA,MACA;AAAA,KACF;AAAA,EACF;AAEA,EAAA,OAAO,EAAE,WAAA,EAAa,YAAA,EAAc,MAAA,EAAO;AAC7C;;AC/SO,SAAS,wCAAwC,MAAA,EAAsB;AAC5E,EAAA,MAAA,CAAO,EAAA,CAAG,WAAA,EAAa,CAAC,GAAA,EAAK,QAAA,KAAa;AACxC,IAAA,IAAI,CAAC,QAAA,EAAU;AACb,MAAA;AAAA,IACF;AAQA,IAAA,MAAM,QAAA,GAAW,WAAW,QAAQ,CAAA;AACpC,IAAA,MAAM,aAAa,QAAA,CAAS,IAAA;AAC5B,IAAA,MAAM,MAAA,GAAS,WAAW,gCAAgC,CAAA;AAE1D,IAAA,MAAM,EAAE,WAAA,EAAY,GAAI,WAAA,CAAY,QAAQ,CAAA,GAAI,oBAAA,CAAqB,QAAQ,CAAA,GAAI,EAAE,WAAA,EAAa,MAAA,EAAU;AAC1G,IAAA,IAAI,MAAA,KAAW,SAAS,WAAA,EAAa;AACnC,MAAA,GAAA,CAAI,WAAA,GAAc,WAAA;AAAA,IACpB;AAKA,IAAA,IAAI,iBAAgB,EAAG;AACrB,MAAA,MAAM,OAAA,GAAU,mBAAA,CAAoB,QAAA,CAAS,WAAA,EAAa,CAAA;AAC1D,MAAA,GAAA,CAAI,OAAA,GAAU,OAAA,IAAW,MAAA,GAAY,MAAA,GAAY,OAAO,OAAO,CAAA;AAAA,IACjE;AAAA,EACF,CAAC,CAAA;AACH;;ACjCO,SAAS,aAAA,GAAkC;AAChD,EAAA,OAAO,MAAM,aAAA,EAAc;AAC7B;;ACwBO,MAAM,UAAA,CAA0C;AAAA,EAAhD,WAAA,GAAA;AACL,IAAA,IAAA,CAAQ,cAAA,uBAA0C,GAAA,EAAI;AAAA,EAAA;AAAA;AAAA,EAG/C,GAAA,CAAI,KAAa,KAAA,EAA2B;AACjD,IAAA,MAAM,IAAA,GAAO,KAAK,MAAA,EAAO;AACzB,IAAA,IAAI,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,GAAG,CAAA,EAAG;AAChC,MAAA,IAAA,CAAK,cAAA,CAAe,OAAO,GAAG,CAAA;AAAA,IAChC;AACA,IAAA,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AAClC,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA,EAGO,MAAM,GAAA,EAAyB;AACpC,IAAA,MAAM,IAAA,GAAO,KAAK,MAAA,EAAO;AACzB,IAAA,IAAA,CAAK,cAAA,CAAe,OAAO,GAAG,CAAA;AAC9B,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA,EAGO,IAAI,GAAA,EAAiC;AAC1C,IAAA,OAAO,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,GAAG,CAAA;AAAA,EACpC;AAAA;AAAA,EAGO,SAAA,GAAoB;AACzB,IAAA,OAAO,KAAA,CAAM,KAAK,IAAA,CAAK,cAAA,CAAe,MAAM,CAAA,CACzC,OAAA,EAAQ,CACR,GAAA,CAAI,CAAA,GAAA,KAAO,GAAG,GAAG,CAAA,CAAA,EAAI,KAAK,cAAA,CAAe,GAAA,CAAI,GAAG,CAAC,CAAA,CAAE,CAAA,CACnD,IAAA,CAAK,GAAG,CAAA;AAAA,EACb;AAAA,EAEQ,MAAA,GAAqB;AAC3B,IAAA,MAAM,IAAA,GAAO,IAAI,UAAA,EAAW;AAC5B,IAAA,IAAA,CAAK,cAAA,GAAiB,IAAI,GAAA,CAAI,IAAA,CAAK,cAAc,CAAA;AACjD,IAAA,OAAO,IAAA;AAAA,EACT;AACF;;AC9DO,SAAS,cAAA,CAAe;AAAA,EAC7B,GAAA;AAAA,EACA;AACF,CAAA,EAGe;AAEb,EAAA,MAAM,SAAA,GAAY,GAAA,GAAM,2CAAA,CAA4C,GAAG,CAAA,GAAI,MAAA;AAE3E,EAAA,MAAM,cAAA,GAAiB,IAAI,UAAA,EAAW;AAEtC,EAAA,MAAM,oBAAoB,SAAA,GAAY,cAAA,CAAe,GAAA,CAAI,sBAAA,EAAwB,SAAS,CAAA,GAAI,cAAA;AAI9F,EAAA,OAAO,YAAY,KAAA,GAAQ,iBAAA,CAAkB,GAAA,CAAI,wCAAA,EAA0C,GAAG,CAAA,GAAI,iBAAA;AACpG;;ACvBA,MAAM,aAAA,uBAAoB,GAAA,EAA0B;AAG7C,SAAS,uBAAA,GAAkD;AAChE,EAAA,OAAO,KAAA,CAAM,KAAK,aAAa,CAAA;AACjC;AAGO,SAAS,WAAW,OAAA,EAAqC;AAC9D,EAAA,aAAA,CAAc,IAAI,OAAO,CAAA;AAC3B;;ACqBO,MAAM,yBAAyB,oBAAA,CAAqB;AAAA,EAIlD,WAAA,GAAc;AACnB,IAAA,KAAA,EAAM;AACN,IAAA,UAAA,CAAW,kBAAkB,CAAA;AAG7B,IAAA,IAAA,CAAK,qBAAA,GAAwB,IAAI,MAAA,CAAwB,GAAG,CAAA;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA,EAKO,MAAA,CAAOA,QAAAA,EAAkB,OAAA,EAAkB,MAAA,EAA6B;AAC7E,IAAA,IAAI,mBAAA,CAAoBA,QAAO,CAAA,EAAG;AAChC,MAAA,WAAA,IAAe,KAAA,CAAM,IAAI,2EAA2E,CAAA;AACpG,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,UAAA,GAAa,KAAA,CAAM,OAAA,CAAQA,QAAO,CAAA;AACxC,IAAA,MAAM,GAAA,GAAM,UAAA,IAAc,aAAA,CAAc,UAAU,CAAA;AAElD,IAAA,MAAM,EAAE,yBAAyB,oBAAA,EAAqB,GAAI,WAAU,EAAG,UAAA,MAAgB,EAAC;AACxF,IAAA,IAAI,CAAC,0BAAA,CAA2B,GAAA,EAAK,uBAAA,EAAyB,IAAA,CAAK,qBAAqB,CAAA,EAAG;AACzF,MAAA,WAAA,IACE,KAAA,CAAM,GAAA,CAAI,+FAAA,EAAiG,GAAG,CAAA;AAChH,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,qBAAA,GAAwB,mBAAmB,OAAO,CAAA;AACxD,IAAA,MAAM,yBAAA,GAA4B,uBAAuB,OAAO,CAAA;AAEhE,IAAA,IAAI,OAAA,GAAU,YAAY,UAAA,CAAWA,QAAO,KAAK,WAAA,CAAY,aAAA,CAAc,EAAE,CAAA;AAE7E,IAAA,MAAM,EAAE,sBAAA,EAAwB,OAAA,EAAS,QAAQ,OAAA,EAAQ,GAAI,iBAAiBA,QAAO,CAAA;AAErF,IAAA,IAAI,qBAAA,EAAuB;AACzB,MAAA,MAAM,cAAA,GAAiB,mBAAmB,qBAAqB,CAAA;AAE/D,MAAA,IAAI,cAAA,EAAgB;AAClB,QAAA,MAAA,CAAO,OAAA,CAAQ,cAAc,CAAA,CAAE,OAAA,CAAQ,CAAC,CAAC,GAAA,EAAK,KAAK,CAAA,KAAM;AACvD,UAAA,IAAI,CAAC,yBAAA,IAA6B,GAAA,CAAI,UAAA,CAAW,yBAAyB,CAAA,EAAG;AAI3E,YAAA;AAAA,UACF;AACA,UAAA,OAAA,GAAU,OAAA,CAAQ,QAAA,CAAS,GAAA,EAAK,EAAE,OAAO,CAAA;AAAA,QAC3C,CAAC,CAAA;AAAA,MACH;AAAA,IACF;AAEA,IAAA,IAAI,CAAC,6BAA6B,sBAAA,EAAwB;AACxD,MAAA,OAAA,GAAU,MAAA,CAAO,OAAA,CAAQ,sBAAsB,CAAA,CAAE,MAAA,CAAgB,CAAC,CAAA,EAAG,CAAC,MAAA,EAAQ,QAAQ,CAAA,KAAM;AAC1F,QAAA,IAAI,QAAA,EAAU;AACZ,UAAA,OAAO,CAAA,CAAE,QAAA,CAAS,CAAA,EAAG,yBAAyB,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,EAAE,KAAA,EAAO,QAAA,EAAU,CAAA;AAAA,QAChF;AACA,QAAA,OAAO,CAAA;AAAA,MACT,GAAG,OAAO,CAAA;AAAA,IACZ;AAGA,IAAA,IAAI,CAAC,yBAAA,IAA6B,OAAA,IAAW,OAAA,KAAY,eAAA,EAAiB;AACxE,MAAA,MAAA,CAAO,IAAI,OAAA,EAAS,mBAAA,EAAqB,0BAA0B,OAAA,EAAS,MAAA,EAAQ,OAAO,CAAC,CAAA;AAE5F,MAAA,IAAI,oBAAA,EAAsB;AACxB,QAAA,MAAA,CAAO,IAAI,OAAA,EAAS,aAAA,EAAe,0BAA0B,OAAA,EAAS,MAAA,EAAQ,OAAO,CAAC,CAAA;AAAA,MACxF;AAAA,IACF;AAEA,IAAA,KAAA,CAAM,OAAO,WAAA,CAAY,UAAA,CAAWA,UAAS,OAAO,CAAA,EAAG,SAAS,MAAM,CAAA;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA,EAKO,OAAA,CAAQA,QAAAA,EAAkB,OAAA,EAAkB,MAAA,EAAgC;AACjF,IAAA,MAAM,sBAAA,GAAwD,MAAA,CAAO,GAAA,CAAI,OAAA,EAAS,mBAAmB,CAAA;AACrG,IAAA,MAAM,OAAA,GAAU,MAAA,CAAO,GAAA,CAAI,OAAA,EAAS,qBAAqB,CAAA;AAEzD,IAAA,MAAM,WAAA,GAAc,yBAChB,KAAA,CAAM,OAAA,CAAQ,sBAAsB,CAAA,GAClC,sBAAA,CAAuB,CAAC,CAAA,GACxB,sBAAA,GACF,MAAA;AAIJ,IAAA,OAAO,sBAAsB,8BAAA,CAA+BA,QAAAA,EAAS,EAAE,WAAA,EAAa,OAAA,EAAS,CAAC,CAAA;AAAA,EAChG;AAAA;AAAA;AAAA;AAAA,EAKO,MAAA,GAAmB;AACxB,IAAA,OAAO,CAAC,mBAAA,EAAqB,qBAAA,EAAuB,aAAa,CAAA;AAAA,EACnE;AACF;AASO,SAAS,gBAAA,CACdA,QAAAA,EACA,OAAA,GAA8C,EAAC,EAM/C;AACA,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,OAAA,CAAQA,QAAO,CAAA;AAIlC,EAAA,IAAI,IAAA,EAAM,WAAA,EAAY,CAAE,QAAA,EAAU;AAChC,IAAA,MAAM,WAAA,GAAc,KAAK,WAAA,EAAY;AACrC,IAAA,MAAMC,uBAAAA,GAAyB,kCAAkC,IAAI,CAAA;AAErE,IAAA,OAAO;AAAA,MACL,sBAAA,EAAAA,uBAAAA;AAAA,MACA,SAAS,WAAA,CAAY,OAAA;AAAA,MACrB,MAAA,EAAQ,MAAA;AAAA,MACR,OAAA,EAAS,oBAAoB,WAAW;AAAA;AAAA,KAC1C;AAAA,EACF;AAGA,EAAA,IAAI,IAAA,EAAM;AACR,IAAA,MAAM,WAAA,GAAc,KAAK,WAAA,EAAY;AACrC,IAAA,MAAMA,uBAAAA,GAAyB,kCAAkC,IAAI,CAAA;AAErE,IAAA,OAAO;AAAA,MACL,sBAAA,EAAAA,uBAAAA;AAAA,MACA,SAAS,WAAA,CAAY,OAAA;AAAA,MACrB,QAAQ,WAAA,CAAY,MAAA;AAAA,MACpB,OAAA,EAAS,oBAAoB,WAAW;AAAA;AAAA,KAC1C;AAAA,EACF;AAIA,EAAA,MAAM,QAAQ,OAAA,CAAQ,KAAA,IAAS,qBAAqBD,QAAO,CAAA,EAAG,SAAS,eAAA,EAAgB;AACvF,EAAA,MAAM,MAAA,GAAS,OAAA,CAAQ,MAAA,IAAU,SAAA,EAAU;AAE3C,EAAA,MAAM,kBAAA,GAAqB,MAAM,qBAAA,EAAsB;AACvD,EAAA,MAAM,sBAAA,GAAyB,MAAA,GAAS,kCAAA,CAAmC,MAAA,EAAQ,KAAK,CAAA,GAAI,MAAA;AAC5F,EAAA,OAAO;AAAA,IACL,sBAAA;AAAA,IACA,SAAS,kBAAA,CAAmB,OAAA;AAAA,IAC5B,QAAQ,kBAAA,CAAmB,iBAAA;AAAA,IAC3B,SAAS,kBAAA,CAAmB;AAAA,GAC9B;AACF;AAEA,SAAS,8BAAA,CACP,GAAA,EACA,EAAE,WAAA,EAAa,SAAQ,EACd;AACT,EAAA,MAAM,kBAAA,GAAqB,6BAAA,CAA8B,WAAA,EAAa,OAAO,CAAA;AAE7E,EAAA,MAAM,EAAE,OAAA,EAAS,YAAA,EAAc,OAAA,EAAS,KAAI,GAAI,kBAAA;AAEhD,EAAA,MAAM,SAAS,SAAA,EAAU;AACzB,EAAA,MAAM,WAAA,GAAc,sCAAsC,OAAO,CAAA;AAIjE,EAAA,IAAI,CAAC,gBAAiB,MAAA,IAAU,CAAC,oBAAoB,MAAA,EAAQ,WAAA,EAAa,MAAM,CAAA,EAAI;AAClF,IAAA,OAAO,GAAA;AAAA,EACT;AAEA,EAAA,MAAM,cAAc,yBAAA,CAA0B;AAAA,IAC5C,OAAA;AAAA,IACA,MAAA,EAAQ,YAAA;AAAA,IACR,OAAA;AAAA,IACA;AAAA,GACD,CAAA;AAED,EAAA,OAAO,KAAA,CAAM,cAAA,CAAe,GAAA,EAAK,WAAW,CAAA;AAC9C;AAMO,SAAS,yBAAA,CACd,GAAA,EACA,OAAA,EACA,QAAA,EACG;AACH,EAAA,MAAM,kBAAA,GAAqB,qBAAA,CAAsB,8BAAA,CAA+B,GAAA,EAAK,OAAO,CAAC,CAAA;AAE7F,EAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,kBAAA,EAAoB,QAAQ,CAAA;AAClD;AAEA,SAAS,sBAAsB,GAAA,EAAuB;AAEpD,EAAA,MAAM,MAAA,GAAS,qBAAqB,GAAG,CAAA;AACvC,EAAA,MAAM,SAAA,GAAY;AAAA;AAAA;AAAA,IAGhB,OAAO,MAAA,GAAS,MAAA,CAAO,KAAA,GAAQ,eAAA,GAAkB,KAAA,EAAM;AAAA,IACvD,cAAA,EAAgB,MAAA,GAAS,MAAA,CAAO,cAAA,GAAiB,iBAAA;AAAkB,GACrE;AAEA,EAAA,OAAO,kBAAA,CAAmB,KAAK,SAAS,CAAA;AAC1C;AAGA,SAAS,mBAAmB,OAAA,EAAsC;AAChE,EAAA,IAAI;AACF,IAAA,MAAM,OAAA,GAAW,QAA8C,qBAAqB,CAAA;AACpF,IAAA,OAAO,MAAM,OAAA,CAAQ,OAAO,IAAI,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAA,GAAI,OAAA;AAAA,EACtD,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAEA,SAAS,uBAAuB,OAAA,EAAiD;AAC/E,EAAA,IAAI;AACF,IAAA,OAAQ,QAA8C,mBAAmB,CAAA;AAAA,EAC3E,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAWA,SAAS,cAAc,IAAA,EAAgC;AACrD,EAAA,MAAM,QAAA,GAAW,UAAA,CAAW,IAAI,CAAA,CAAE,IAAA;AAGlC,EAAA,MAAM,YAAA,GAAe,QAAA,CAAS,iBAAiB,CAAA,IAAK,SAAS,aAAa,CAAA;AAC1E,EAAA,IAAI,OAAO,iBAAiB,QAAA,EAAU;AACpC,IAAA,OAAO,YAAA;AAAA,EACT;AAGA,EAAA,MAAM,gBAAgB,IAAA,CAAK,WAAA,EAAY,CAAE,UAAA,EAAY,IAAI,sBAAsB,CAAA;AAC/E,EAAA,IAAI,aAAA,EAAe;AACjB,IAAA,OAAO,aAAA;AAAA,EACT;AAEA,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,yBAAA,CAA0B;AAAA,EACjC,MAAA;AAAA,EACA,OAAA;AAAA,EACA,OAAA;AAAA,EACA;AACF,CAAA,EAKgB;AAEd,EAAA,MAAM,aAAa,cAAA,CAAe;AAAA,IAChC,GAAA;AAAA,IACA;AAAA,GACD,CAAA;AAED,EAAA,MAAM,WAAA,GAA2B;AAAA,IAC/B,OAAA;AAAA,IACA,MAAA;AAAA,IACA,QAAA,EAAU,IAAA;AAAA,IACV,UAAA,EAAY,OAAA,GAAU,UAAA,CAAW,OAAA,GAAU,UAAA,CAAW,IAAA;AAAA,IACtD;AAAA,GACF;AAEA,EAAA,OAAO,WAAA;AACT;;ACvRA,SAAS,UAAA,CAAc,OAAA,EAAmC,QAAA,EAA6B,OAAA,EAAqB;AAC1G,EAAA,MAAM,SAAS,SAAA,EAAU;AAEzB,EAAA,MAAM,EAAE,IAAA,EAAM,UAAA,EAAY,gBAAA,EAAiB,GAAI,OAAA;AAG/C,EAAA,MAAM,OAAA,GAAU,qBAAwB,gBAAgB,CAAA;AAExD,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,MAAM,SAAA,GAAY,UAAA,CAAW,OAAA,CAAQ,KAAA,EAAO,QAAQ,gBAAgB,CAAA;AACpE,IAAA,MAAM,wBAAwB,OAAA,CAAQ,YAAA,IAAgB,CAAC,KAAA,CAAM,QAAQ,SAAS,CAAA;AAC9E,IAAA,MAAM,GAAA,GAAM,qBAAA,GAAwBE,iBAAA,CAAgB,SAAS,CAAA,GAAI,SAAA;AAEjE,IAAA,IAAI,qBAAA,EAAuB;AACzB,MAAA,SAAA,EAAU,EAAG,kBAAA,CAAmB,gBAAA,EAAkB,MAAM,CAAA;AAAA,IAC1D;AAEA,IAAA,MAAM,WAAA,GAAc,eAAe,OAAO,CAAA;AAO1C,IAAA,IAAI,CAAC,iBAAgB,EAAG;AACtB,MAAA,MAAM,gBAAgB,mBAAA,CAAoB,GAAG,CAAA,GAAI,GAAA,GAAMA,kBAAgB,GAAG,CAAA;AAE1E,MAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,aAAA,EAAe,MAAM;AACvC,QAAA,OAAO,MAAA,CAAO,eAAA,CAAgB,IAAA,EAAM,WAAA,EAAa,eAAe,CAAA,IAAA,KAAQ;AACtE,UAAA,YAAA,CAAa,IAAI,CAAA;AAMjB,UAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,SAAA,EAAW,MAAM;AACnC,YAAA,OAAO,oBAAA;AAAA,cACL,MAAM,SAAS,IAAI,CAAA;AAAA,cACnB,MAAM;AAEJ,gBAAA,IAAI,UAAA,CAAW,IAAI,CAAA,CAAE,MAAA,KAAW,MAAA,EAAW;AACzC,kBAAA,IAAA,CAAK,SAAA,CAAU,EAAE,IAAA,EAAM,cAAA,CAAe,OAAO,CAAA;AAAA,gBAC/C;AAAA,cACF,CAAA;AAAA,cACA,OAAA,GAAU,MAAM,IAAA,CAAK,GAAA,EAAI,GAAI;AAAA,aAC/B;AAAA,UACF,CAAC,CAAA;AAAA,QACH,CAAC,CAAA;AAAA,MACH,CAAC,CAAA;AAAA,IACH;AAEA,IAAA,OAAO,MAAA,CAAO,eAAA,CAAgB,IAAA,EAAM,WAAA,EAAa,KAAK,CAAA,IAAA,KAAQ;AAC5D,MAAA,YAAA,CAAa,IAAI,CAAA;AACjB,MAAA,OAAO,oBAAA;AAAA,QACL,MAAM,SAAS,IAAI,CAAA;AAAA,QACnB,MAAM;AAEJ,UAAA,IAAI,UAAA,CAAW,IAAI,CAAA,CAAE,MAAA,KAAW,MAAA,EAAW;AACzC,YAAA,IAAA,CAAK,SAAA,CAAU,EAAE,IAAA,EAAM,cAAA,CAAe,OAAO,CAAA;AAAA,UAC/C;AAAA,QACF,CAAA;AAAA,QACA,OAAA,GAAU,MAAM,IAAA,CAAK,GAAA,EAAI,GAAI;AAAA,OAC/B;AAAA,IACF,CAAC,CAAA;AAAA,EACH,CAAC,CAAA;AACH;AAYO,SAAS,SAAA,CAAa,SAAmC,QAAA,EAAgC;AAC9F,EAAA,OAAO,UAAA,CAAW,OAAA,EAAS,QAAA,EAAU,IAAI,CAAA;AAC3C;AAYO,SAAS,eAAA,CACd,SACA,QAAA,EACG;AACH,EAAA,OAAO,UAAA,CAAW,OAAA,EAAS,CAAA,IAAA,KAAQ,QAAA,CAAS,IAAA,EAAM,MAAM,IAAA,CAAK,GAAA,EAAK,CAAA,EAAG,KAAK,CAAA;AAC5E;AAWO,SAAS,kBAAkB,OAAA,EAAyC;AACzE,EAAA,MAAM,SAAS,SAAA,EAAU;AAEzB,EAAA,MAAM,EAAE,IAAA,EAAM,UAAA,EAAY,gBAAA,EAAiB,GAAI,OAAA;AAG/C,EAAA,MAAM,OAAA,GAAU,qBAA2B,gBAAgB,CAAA;AAE3D,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,MAAM,SAAA,GAAY,UAAA,CAAW,OAAA,CAAQ,KAAA,EAAO,QAAQ,gBAAgB,CAAA;AACpE,IAAA,MAAM,wBAAwB,OAAA,CAAQ,YAAA,IAAgB,CAAC,KAAA,CAAM,QAAQ,SAAS,CAAA;AAC9E,IAAA,IAAI,GAAA,GAAM,qBAAA,GAAwBA,iBAAA,CAAgB,SAAS,CAAA,GAAI,SAAA;AAE/D,IAAA,IAAI,qBAAA,EAAuB;AACzB,MAAA,SAAA,EAAU,EAAG,kBAAA,CAAmB,gBAAA,EAAkB,MAAM,CAAA;AAAA,IAC1D;AAEA,IAAA,MAAM,WAAA,GAAc,eAAe,OAAO,CAAA;AAE1C,IAAA,IAAI,CAAC,iBAAgB,EAAG;AACtB,MAAA,GAAA,GAAM,mBAAA,CAAoB,GAAG,CAAA,GAAI,GAAA,GAAMA,kBAAgB,GAAG,CAAA;AAAA,IAC5D;AAEA,IAAA,MAAM,IAAA,GAAO,MAAA,CAAO,SAAA,CAAU,IAAA,EAAM,aAAa,GAAG,CAAA;AACpD,IAAA,YAAA,CAAa,IAAI,CAAA;AACjB,IAAA,OAAO,IAAA;AAAA,EACT,CAAC,CAAA;AACH;AAWO,SAAS,cAAA,CAAkB,MAAmB,QAAA,EAAkC;AACrF,EAAA,MAAM,wBAAA,GAA2B,IAAA,GAAO,KAAA,CAAM,OAAA,CAAQ,OAAA,CAAQ,MAAA,EAAO,EAAG,IAAI,CAAA,GAAI,KAAA,CAAM,UAAA,CAAW,OAAA,CAAQ,QAAQ,CAAA;AACjH,EAAA,OAAO,QAAQ,IAAA,CAAK,wBAAA,EAA0B,MAAM,QAAA,CAAS,eAAA,EAAiB,CAAC,CAAA;AACjF;AAEA,SAAS,SAAA,GAAoB;AAC3B,EAAA,MAAM,SAAS,SAAA,EAAwC;AACvD,EAAA,OAAO,MAAA,EAAQ,MAAA,IAAU,KAAA,CAAM,SAAA,CAAU,yBAAyB,WAAW,CAAA;AAC/E;AAEA,SAAS,eAAe,OAAA,EAAgD;AACtE,EAAA,MAAM,EAAE,SAAA,EAAW,UAAA,EAAY,IAAA,EAAM,EAAA,EAAI,OAAM,GAAI,OAAA;AAGnD,EAAA,MAAM,iBAAiB,OAAO,SAAA,KAAc,QAAA,GAAW,6BAAA,CAA8B,SAAS,CAAA,GAAI,SAAA;AAElG,EAAA,OAAO;AAAA,IACL,YAAY,EAAA,GACR;AAAA,MACE,CAAC,4BAA4B,GAAG,EAAA;AAAA,MAChC,GAAG;AAAA,KACL,GACA,UAAA;AAAA,IACJ,IAAA;AAAA,IACA,KAAA;AAAA,IACA,SAAA,EAAW;AAAA,GACb;AACF;AAEA,SAAS,8BAA8B,SAAA,EAA2B;AAChE,EAAA,MAAM,OAAO,SAAA,GAAY,UAAA;AACzB,EAAA,OAAO,IAAA,GAAO,YAAY,GAAA,GAAO,SAAA;AACnC;AAMA,SAAS,aAAa,IAAA,EAAkB;AACtC,EAAA,MAAM,WAAA,GAAc,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,IAAI,CAAA;AACtC,EAAA,IAAA,CAAK,GAAA,GAAM,CAAC,OAAA,KAAwB;AAClC,IAAA,OAAO,YAAY,OAAO,OAAA,KAAY,WAAW,6BAAA,CAA8B,OAAO,IAAI,OAAO,CAAA;AAAA,EACnG,CAAA;AACF;AAEA,SAAS,UAAA,CAAW,OAA0B,gBAAA,EAAgD;AAC5F,EAAA,MAAM,GAAA,GAAM,mBAAmB,KAAK,CAAA;AACpC,EAAA,MAAM,UAAA,GAAa,KAAA,CAAM,OAAA,CAAQ,GAAG,CAAA;AAIpC,EAAA,IAAI,CAAC,UAAA,EAAY;AACf,IAAA,OAAO,GAAA;AAAA,EACT;AAGA,EAAA,IAAI,CAAC,gBAAA,EAAkB;AACrB,IAAA,OAAO,GAAA;AAAA,EACT;AAOA,EAAA,MAAM,cAAA,GAAiB,KAAA,CAAM,UAAA,CAAW,GAAG,CAAA;AAE3C,EAAA,MAAM,EAAE,MAAA,EAAQ,OAAA,EAAQ,GAAI,WAAW,WAAA,EAAY;AACnD,EAAA,MAAM,OAAA,GAAU,mBAAA,CAAoB,UAAA,CAAW,WAAA,EAAa,CAAA;AAI5D,EAAA,MAAM,QAAA,GAAW,YAAY,UAAU,CAAA;AACvC,EAAA,MAAM,GAAA,GAAM,kCAAkC,QAAQ,CAAA;AAEtD,EAAA,MAAM,aAAa,cAAA,CAAe;AAAA,IAChC,GAAA;AAAA,IACA;AAAA,GACD,CAAA;AAED,EAAA,MAAM,WAAA,GAA2B;AAAA,IAC/B,OAAA;AAAA,IACA,MAAA;AAAA,IACA,QAAA,EAAU,IAAA;AAAA,IACV,UAAA,EAAY,OAAA,GAAU,UAAA,CAAW,OAAA,GAAU,UAAA,CAAW,IAAA;AAAA,IACtD;AAAA,GACF;AAEA,EAAA,MAAM,kBAAA,GAAqB,KAAA,CAAM,cAAA,CAAe,cAAA,EAAgB,WAAW,CAAA;AAE3E,EAAA,OAAO,kBAAA;AACT;AAEA,SAAS,mBAAmB,KAAA,EAAwB;AAClD,EAAA,IAAI,KAAA,EAAO;AACT,IAAA,MAAM,GAAA,GAAM,oBAAoB,KAAK,CAAA;AACrC,IAAA,IAAI,GAAA,EAAK;AACP,MAAA,OAAO,GAAA;AAAA,IACT;AAAA,EACF;AAEA,EAAA,OAAO,QAAQ,MAAA,EAAO;AACxB;AAaO,SAAS,aAAA,CAAiB,SAAkD,QAAA,EAAsB;AACvG,EAAA,OAAO,yBAAA,CAA0B,OAAA,CAAQ,MAAA,EAAO,EAAG,SAAS,QAAQ,CAAA;AACtE;AAUO,SAAS,cAAiB,QAAA,EAAsB;AACrD,EAAA,MAAM,UAAU,eAAA,EAAgB;AAChC,EAAA,MAAM,SAAS,cAAA,EAAe;AAE9B,EAAA,MAAM,WAAA,GAA2B;AAAA,IAC/B,OAAA;AAAA,IACA,MAAA;AAAA,IACA,QAAA,EAAU,IAAA;AAAA,IACV,YAAY,UAAA,CAAW;AAAA,GACzB;AAEA,EAAA,MAAM,eAAe,KAAA,CAAM,cAAA,CAAe,OAAA,CAAQ,MAAA,IAAU,WAAW,CAAA;AAEvE,EAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,YAAA,EAAc,MAAM;AACtC,IAAA,eAAA,GAAkB,qBAAA,CAAsB;AAAA,MACtC,OAAA;AAAA,MACA,YAAY,wBAAA;AAAyB,KACtC,CAAA;AACD,IAAA,OAAO,QAAA,EAAS;AAAA,EAClB,CAAC,CAAA;AACH;AAMO,SAAS,uBAAA,CACd,QACA,KAAA,EACuF;AACvF,EAAA,MAAM,GAAA,GAAM,oBAAoB,KAAK,CAAA;AACrC,EAAA,MAAM,IAAA,GAAO,GAAA,IAAO,KAAA,CAAM,OAAA,CAAQ,GAAG,CAAA;AAErC,EAAA,MAAM,eAAe,IAAA,GAAO,kBAAA,CAAmB,IAAI,CAAA,GAAI,yBAAyB,KAAK,CAAA;AAErF,EAAA,MAAM,yBAAyB,IAAA,GAC3B,iCAAA,CAAkC,IAAI,CAAA,GACtC,kCAAA,CAAmC,QAAQ,KAAK,CAAA;AACpD,EAAA,OAAO,CAAC,wBAAwB,YAAY,CAAA;AAC9C;AAEA,SAAS,qBAAwB,UAAA,EAA4E;AAC3G,EAAA,OAAO,UAAA,KAAe,MAAA,GAClB,CAAC,QAAA,KAAsB;AACrB,IAAA,OAAO,cAAA,CAAe,YAAY,QAAQ,CAAA;AAAA,EAC5C,CAAA,GACA,CAAC,QAAA,KAAsB,QAAA,EAAS;AACtC;;ACnWO,SAAS,gBAAmB,QAAA,EAAsB;AACvD,EAAA,MAAM,GAAA,GAAMC,iBAAA,CAAoB,OAAA,CAAQ,MAAA,EAAQ,CAAA;AAChD,EAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,GAAA,EAAK,QAAQ,CAAA;AACnC;;ACFO,SAAS,uBAAuB,MAAA,EAAsB;AAC3D,EAAA,MAAA,CAAO,EAAA,CAAG,mBAAmB,CAAA,KAAA,KAAS;AACpC,IAAA,MAAM,OAAO,aAAA,EAAc;AAG3B,IAAA,IAAI,CAAC,IAAA,IAAQ,KAAA,CAAM,IAAA,KAAS,aAAA,EAAe;AACzC,MAAA;AAAA,IACF;AAGA,IAAA,KAAA,CAAM,QAAA,GAAW;AAAA,MACf,KAAA,EAAO,mBAAmB,IAAI,CAAA;AAAA,MAC9B,GAAG,KAAA,CAAM;AAAA,KACX;AAEA,IAAA,MAAM,QAAA,GAAW,YAAY,IAAI,CAAA;AAEjC,IAAA,KAAA,CAAM,qBAAA,GAAwB;AAAA,MAC5B,sBAAA,EAAwB,kCAAkC,QAAQ,CAAA;AAAA,MAClE,GAAG,KAAA,CAAM;AAAA,KACX;AAEA,IAAA,OAAO,KAAA;AAAA,EACT,CAAC,CAAA;AACH;;ACdO,SAAS,YAAA,CAAa;AAAA,EAC3B,IAAA;AAAA,EACA,KAAA;AAAA,EACA,MAAA;AAAA,EACA;AACF,CAAA,GAAqF,EAAC,EAAwB;AAC5G,EAAA,IAAI,OAAO,KAAA,IAAS,mBAAA,CAAoB,KAAK,CAAA,KAAM,GAAA,CAAI,QAAQ,MAAA,EAAO;AAEtE,EAAA,IAAI,IAAA,EAAM;AACR,IAAA,MAAM,EAAE,KAAA,EAAAC,MAAAA,EAAM,GAAI,wBAAwB,IAAI,CAAA;AAE9C,IAAA,GAAA,GAAOA,MAAAA,IAAS,mBAAA,CAAoBA,MAAK,CAAA,IAAM,GAAA,CAAI,KAAA,CAAM,OAAA,CAAQ,GAAA,CAAI,OAAA,CAAQ,MAAA,EAAO,EAAG,IAAI,CAAA;AAAA,EAC7F;AAEA,EAAA,MAAM,EAAE,OAAA,EAAS,MAAA,EAAQ,OAAA,EAAS,sBAAA,EAAuB,GAAI,gBAAA,CAAiB,GAAA,EAAK,EAAE,KAAA,EAAO,MAAA,EAAQ,CAAA;AAEpG,EAAA,MAAM,SAAA,GAAiC;AAAA,IACrC,cAAA,EAAgB,yBAAA,CAA0B,OAAA,EAAS,MAAA,EAAQ,OAAO,CAAA;AAAA,IAClE,OAAA,EAAS,4CAA4C,sBAAsB;AAAA,GAC7E;AAEA,EAAA,IAAI,oBAAA,EAAsB;AACxB,IAAA,SAAA,CAAU,WAAA,GAAc,yBAAA,CAA0B,OAAA,EAAS,MAAA,EAAQ,OAAO,CAAA;AAAA,EAC5E;AAEA,EAAA,OAAO,SAAA;AACT;;ACtBO,SAAS,2CAAA,GAAoD;AAClE,EAAA,SAAS,SAAA,GAA2B;AAClC,IAAA,MAAM,GAAA,GAAM,GAAA,CAAI,OAAA,CAAQ,MAAA,EAAO;AAC/B,IAAA,MAAM,MAAA,GAAS,qBAAqB,GAAG,CAAA;AAEvC,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,OAAO,MAAA;AAAA,IACT;AAIA,IAAA,OAAO;AAAA,MACL,OAAO,sBAAA,EAAuB;AAAA,MAC9B,gBAAgB,wBAAA;AAAyB,KAC3C;AAAA,EACF;AAEA,EAAA,SAAS,UAAa,QAAA,EAAkC;AACtD,IAAA,MAAM,GAAA,GAAM,GAAA,CAAI,OAAA,CAAQ,MAAA,EAAO;AAO/B,IAAA,OAAO,GAAA,CAAI,OAAA,CAAQ,IAAA,CAAK,GAAA,EAAK,MAAM;AACjC,MAAA,OAAO,QAAA,CAAS,iBAAiB,CAAA;AAAA,IACnC,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,SAAS,YAAA,CAAgB,OAAc,QAAA,EAAkC;AACvE,IAAA,MAAM,MAAM,mBAAA,CAAoB,KAAK,CAAA,IAAK,GAAA,CAAI,QAAQ,MAAA,EAAO;AAK7D,IAAA,OAAO,GAAA,CAAI,QAAQ,IAAA,CAAK,GAAA,CAAI,SAAS,iCAAA,EAAmC,KAAK,GAAG,MAAM;AACpF,MAAA,OAAO,SAAS,KAAK,CAAA;AAAA,IACvB,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,SAAS,mBAAsB,QAAA,EAA2C;AACxE,IAAA,MAAM,GAAA,GAAM,GAAA,CAAI,OAAA,CAAQ,MAAA,EAAO;AAM/B,IAAA,OAAO,GAAA,CAAI,QAAQ,IAAA,CAAK,GAAA,CAAI,SAAS,uCAAA,EAAyC,IAAI,GAAG,MAAM;AACzF,MAAA,OAAO,QAAA,CAAS,mBAAmB,CAAA;AAAA,IACrC,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,SAAS,qBAAA,CAAyB,gBAAuB,QAAA,EAA2C;AAClG,IAAA,MAAM,GAAA,GAAM,GAAA,CAAI,OAAA,CAAQ,MAAA,EAAO;AAM/B,IAAA,OAAO,GAAA,CAAI,QAAQ,IAAA,CAAK,GAAA,CAAI,SAAS,2CAAA,EAA6C,cAAc,GAAG,MAAM;AACvG,MAAA,OAAO,QAAA,CAAS,mBAAmB,CAAA;AAAA,IACrC,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,SAAS,eAAA,GAAyB;AAChC,IAAA,OAAO,WAAU,CAAE,KAAA;AAAA,EACrB;AAEA,EAAA,SAAS,iBAAA,GAA2B;AAClC,IAAA,OAAO,WAAU,CAAE,cAAA;AAAA,EACrB;AAEA,EAAA,uBAAA,CAAwB;AAAA,IACtB,SAAA;AAAA,IACA,YAAA;AAAA,IACA,qBAAA;AAAA,IACA,kBAAA;AAAA,IACA,eAAA;AAAA,IACA,iBAAA;AAAA,IACA,SAAA;AAAA,IACA,eAAA;AAAA,IACA,iBAAA;AAAA,IACA,aAAA;AAAA,IACA,eAAA;AAAA,IACA,YAAA;AAAA,IACA,aAAA;AAAA,IACA,aAAA;AAAA;AAAA;AAAA,IAGA;AAAA,GACD,CAAA;AACH;;AC1FO,SAAS,4BAAA,CAA6B,SAAkB,aAAA,EAAiC;AAC9F,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,OAAA,CAAQ,OAAO,CAAA;AAClC,EAAA,IAAI,gBAAA;AACJ,EAAA,IAAI,MAAM,WAAA,EAAY,CAAE,YAAY,GAAA,CAAI,gCAAgC,MAAM,GAAA,EAAK;AACjF,IAAA,MAAM,kBAAA,GAAqB,KAAA,CAAM,UAAA,CAAW,OAAO,CAAA;AACnD,IAAA,MAAM,UAAA,GAAa,KAAA,CAAM,OAAA,CAAQ,aAAa,CAAA;AAC9C,IAAA,gBAAA,GAAmB,UAAA,GAAa,KAAA,CAAM,OAAA,CAAQ,kBAAA,EAAoB,UAAU,CAAA,GAAI,kBAAA;AAAA,EAClF,CAAA,MAAO;AACL,IAAA,gBAAA,GAAmB,OAAA;AAAA,EACrB;AAEA,EAAA,MAAM,aAAA,GAAgB,qBAAqB,gBAAgB,CAAA;AAC3D,EAAA,MAAM,YAAA,GAAe,aAAA,EAAe,KAAA,IAAS,eAAA,EAAgB;AAC7D,EAAA,MAAM,qBAAA,GAAwB,aAAA,EAAe,cAAA,IAAkB,iBAAA,EAAkB;AAEjF,EAAA,MAAM,wBAAA,GAA2B,gBAAA,CAAiB,QAAA,CAAS,uCAAuC,CAAA,KAAM,IAAA;AACxG,EAAA,MAAM,KAAA,GAAQ,gBAAA,CAAiB,QAAA,CAAS,iCAAiC,CAAA;AACzE,EAAA,MAAM,cAAA,GAAiB,gBAAA,CAAiB,QAAA,CAAS,2CAA2C,CAAA;AAE5F,EAAA,MAAM,eAAA,GAAkB,KAAA,IAAS,YAAA,CAAa,KAAA,EAAM;AACpD,EAAA,MAAM,iBAAA,GACJ,cAAA,KAAmB,wBAAA,GAA2B,qBAAA,CAAsB,OAAM,GAAI,qBAAA,CAAA;AAChF,EAAA,MAAM,MAAA,GAAS,EAAE,KAAA,EAAO,eAAA,EAAiB,gBAAgB,iBAAA,EAAkB;AAE3E,EAAA,MAAM,IAAA,GAAO,kBAAA,CAAmB,gBAAA,EAAkB,MAAM,CAAA;AAExD,EAAA,MAAM,IAAA,GAAO,KACV,WAAA,CAAY,uCAAuC,EACnD,WAAA,CAAY,iCAAiC,CAAA,CAC7C,WAAA,CAAY,2CAA2C,CAAA;AAE1D,EAAA,iBAAA,CAAkB,iBAAiB,IAAI,CAAA;AAEvC,EAAA,OAAO,IAAA;AACT;;AC5BO,SAAS,wBACd,mBAAA,EACwD;AAAA,EAUxD,MAAM,6BAA6B,mBAAA,CAAoB;AAAA,IAC9C,eAAe,IAAA,EAAiB;AACrC,MAAA,KAAA,CAAM,GAAG,IAAI,CAAA;AACb,MAAA,UAAA,CAAW,sBAAsB,CAAA;AAAA,IACnC;AAAA;AAAA;AAAA;AAAA;AAAA,IAKO,IAAA,CACL,OAAA,EACA,EAAA,EACA,OAAA,EAAA,GACG,IAAA,EACY;AACf,MAAA,MAAM,IAAA,GAAO,4BAAA,CAA6B,OAAA,EAAS,IAAA,CAAK,QAAQ,CAAA;AAChE,MAAA,OAAO,MAAM,IAAA,CAAK,IAAA,EAAM,EAAA,EAAI,OAAA,EAAS,GAAG,IAAI,CAAA;AAAA,IAC9C;AAAA;AAAA;AAAA;AAAA,IAKO,0BAAA,GAAsD;AAC3D,MAAA,OAAO;AAAA;AAAA,QAEL,mBAAmB,IAAA,CAAK,kBAAA;AAAA,QACxB,aAAA,EAAe;AAAA,OACjB;AAAA,IACF;AAAA;AAGF,EAAA,OAAO,oBAAA;AACT;;ACtDO,SAAS,sBAAsB,KAAA,EAAmC;AACvE,EAAA,MAAM,OAAA,uBAAuB,GAAA,EAAsB;AAEnD,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,6BAAA,CAA8B,SAAS,IAAI,CAAA;AAAA,EAC7C;AAEA,EAAA,OAAO,MAAM,IAAA,CAAK,OAAA,EAAS,SAAU,CAAC,GAAA,EAAK,QAAQ,CAAA,EAAG;AACpD,IAAA,OAAO,QAAA;AAAA,EACT,CAAC,CAAA;AACH;AAKO,SAAS,iBAAiB,IAAA,EAAwC;AACvE,EAAA,MAAM,cAAA,GAAiB,IAAA,CAAK,UAAA,CAAW,0CAA0C,CAAA,KAAM,IAAA;AAGvF,EAAA,OAAO,CAAC,cAAA,GAAiB,eAAA,CAAgB,IAAI,CAAA,GAAI,MAAA;AACnD;AAEA,SAAS,6BAAA,CAA8B,SAAkB,IAAA,EAA0B;AACjF,EAAA,MAAM,EAAA,GAAK,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA;AAC9B,EAAA,MAAM,QAAA,GAAW,iBAAiB,IAAI,CAAA;AAEtC,EAAA,IAAI,CAAC,QAAA,EAAU;AACb,IAAA,kBAAA,CAAmB,SAAS,EAAE,EAAA,EAAI,MAAM,QAAA,EAAU,IAAI,CAAA;AACtD,IAAA;AAAA,EACF;AAIA,EAAA,MAAM,UAAA,GAAa,qBAAA,CAAsB,OAAA,EAAS,QAAQ,CAAA;AAC1D,EAAA,MAAM,IAAA,GAAO,kBAAA,CAAmB,OAAA,EAAS,EAAE,EAAA,EAAI,MAAM,UAAA,EAAY,QAAA,EAAU,EAAC,EAAG,CAAA;AAC/E,EAAA,UAAA,CAAW,QAAA,CAAS,KAAK,IAAI,CAAA;AAC/B;AAEA,SAAS,qBAAA,CAAsB,SAAkB,EAAA,EAAsB;AACrE,EAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,EAAE,CAAA;AAE/B,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,OAAO,QAAA;AAAA,EACT;AAEA,EAAA,OAAO,mBAAmB,OAAA,EAAS,EAAE,IAAI,QAAA,EAAU,IAAI,CAAA;AACzD;AAEA,SAAS,kBAAA,CAAmB,SAAkB,QAAA,EAA8B;AAC1E,EAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,QAAA,CAAS,EAAE,CAAA;AAGxC,EAAA,IAAI,UAAU,IAAA,EAAM;AAClB,IAAA,OAAO,QAAA;AAAA,EACT;AAGA,EAAA,IAAI,QAAA,IAAY,CAAC,QAAA,CAAS,IAAA,EAAM;AAC9B,IAAA,QAAA,CAAS,OAAO,QAAA,CAAS,IAAA;AACzB,IAAA,QAAA,CAAS,aAAa,QAAA,CAAS,UAAA;AAC/B,IAAA,OAAO,QAAA;AAAA,EACT;AAGA,EAAA,OAAA,CAAQ,GAAA,CAAI,QAAA,CAAS,EAAA,EAAI,QAAQ,CAAA;AACjC,EAAA,OAAO,QAAA;AACT;;ACvEA,MAAM,0BAAA,GAAoE;AAAA,EACxE,GAAA,EAAK,WAAA;AAAA,EACL,GAAA,EAAK,eAAA;AAAA,EACL,GAAA,EAAK,kBAAA;AAAA,EACL,GAAA,EAAK,mBAAA;AAAA,EACL,GAAA,EAAK,WAAA;AAAA,EACL,GAAA,EAAK,gBAAA;AAAA,EACL,GAAA,EAAK,mBAAA;AAAA,EACL,GAAA,EAAK,oBAAA;AAAA,EACL,GAAA,EAAK,qBAAA;AAAA,EACL,IAAA,EAAM,SAAA;AAAA,EACN,IAAA,EAAM,cAAA;AAAA,EACN,IAAA,EAAM,eAAA;AAAA,EACN,IAAA,EAAM,gBAAA;AAAA,EACN,IAAA,EAAM,aAAA;AAAA,EACN,IAAA,EAAM,WAAA;AAAA,EACN,IAAA,EAAM;AACR,CAAA;AAEA,MAAM,yBAAA,GAA4B,CAAC,OAAA,KAA6B;AAC9D,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,0BAA0B,CAAA,CAAE,SAAS,OAAgC,CAAA;AAC5F,CAAA;AAKO,SAAS,UAAU,IAAA,EAAgC;AACxD,EAAA,MAAM,aAAa,iBAAA,CAAkB,IAAI,CAAA,GAAI,IAAA,CAAK,aAAa,EAAC;AAChE,EAAA,MAAM,MAAA,GAAS,aAAA,CAAc,IAAI,CAAA,GAAI,KAAK,MAAA,GAAS,MAAA;AAEnD,EAAA,IAAI,MAAA,EAAQ;AAEV,IAAA,IAAI,MAAA,CAAO,IAAA,KAAS,cAAA,CAAe,EAAA,EAAI;AACrC,MAAA,OAAO,EAAE,MAAM,cAAA,EAAe;AAAA,IAEhC,CAAA,MAAA,IAAW,MAAA,CAAO,IAAA,KAAS,cAAA,CAAe,KAAA,EAAO;AAC/C,MAAA,IAAI,OAAO,MAAA,CAAO,OAAA,KAAY,WAAA,EAAa;AACzC,QAAA,MAAMC,eAAAA,GAAiB,0BAA0B,UAAU,CAAA;AAC3D,QAAA,IAAIA,eAAAA,EAAgB;AAClB,UAAA,OAAOA,eAAAA;AAAA,QACT;AAAA,MACF;AAEA,MAAA,IAAI,MAAA,CAAO,OAAA,IAAW,yBAAA,CAA0B,MAAA,CAAO,OAAO,CAAA,EAAG;AAC/D,QAAA,OAAO,EAAE,IAAA,EAAM,iBAAA,EAAmB,OAAA,EAAS,OAAO,OAAA,EAAQ;AAAA,MAC5D,CAAA,MAAO;AACL,QAAA,OAAO,EAAE,IAAA,EAAM,iBAAA,EAAmB,OAAA,EAAS,gBAAA,EAAiB;AAAA,MAC9D;AAAA,IACF;AAAA,EACF;AAGA,EAAA,MAAM,cAAA,GAAiB,0BAA0B,UAAU,CAAA;AAE3D,EAAA,IAAI,cAAA,EAAgB;AAClB,IAAA,OAAO,cAAA;AAAA,EACT;AAGA,EAAA,IAAI,MAAA,EAAQ,IAAA,KAAS,cAAA,CAAe,KAAA,EAAO;AACzC,IAAA,OAAO,EAAE,MAAM,cAAA,EAAe;AAAA,EAChC,CAAA,MAAO;AACL,IAAA,OAAO,EAAE,IAAA,EAAM,iBAAA,EAAmB,OAAA,EAAS,eAAA,EAAgB;AAAA,EAC7D;AACF;AAEA,SAAS,0BAA0B,UAAA,EAAoD;AAIrF,EAAA,MAAM,iBAAA,GAAoB,UAAA,CAAW,8BAA8B,CAAA,IAAK,WAAW,yBAAyB,CAAA;AAE5G,EAAA,MAAM,iBAAA,GAAoB,WAAW,6BAA6B,CAAA;AAElE,EAAA,MAAM,cAAA,GACJ,OAAO,iBAAA,KAAsB,QAAA,GACzB,iBAAA,GACA,OAAO,iBAAA,KAAsB,QAAA,GAC3B,QAAA,CAAS,iBAAiB,CAAA,GAC1B,MAAA;AAER,EAAA,IAAI,OAAO,mBAAmB,QAAA,EAAU;AACtC,IAAA,OAAO,0BAA0B,cAAc,CAAA;AAAA,EACjD;AAEA,EAAA,IAAI,OAAO,sBAAsB,QAAA,EAAU;AACzC,IAAA,OAAO,EAAE,IAAA,EAAM,iBAAA,EAAmB,SAAS,0BAAA,CAA2B,iBAAiB,KAAK,eAAA,EAAgB;AAAA,EAC9G;AAEA,EAAA,OAAO,MAAA;AACT;;AC5DA,MAAM,cAAA,GAAiB,GAAA;AACvB,MAAM,eAAA,GAAkB,GAAA;AACxB,MAAM,mBAAA,GAAsB,GAAA;AAUrB,MAAM,kBAAA,CAAmB;AAAA,EAyBvB,YAAY,OAAA,EAGhB;AACD,IAAA,IAAA,CAAK,uBAAA,GAA0B,SAAS,OAAA,IAAW,eAAA;AACnD,IAAA,IAAA,CAAK,uBAAuB,IAAI,KAAA,CAAM,KAAK,uBAAuB,CAAA,CAAE,KAAK,MAAS,CAAA;AAClF,IAAA,IAAA,CAAK,wBAAA,GAA2B,IAAA,CAAK,KAAA,CAAM,qBAAA,KAA0B,GAAI,CAAA;AACzE,IAAA,IAAA,CAAK,mBAAA,uBAA0B,OAAA,EAAQ;AACvC,IAAA,IAAA,CAAK,UAAA,GAAa,IAAI,MAAA,CAAuB,mBAAmB,CAAA;AAChE,IAAA,IAAA,CAAK,eAAA,GAAkB,QAAA,CAAS,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,IAAI,CAAA,EAAG,CAAA,EAAG,EAAE,OAAA,EAAS,GAAA,EAAK,CAAA;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAO,IAAA,EAA0B;AACtC,IAAA,MAAM,mBAAA,GAAsB,IAAA,CAAK,KAAA,CAAM,qBAAA,KAA0B,GAAI,CAAA;AAErE,IAAA,IAAI,IAAA,CAAK,6BAA6B,mBAAA,EAAqB;AACzD,MAAA,IAAI,gBAAA,GAAmB,CAAA;AACvB,MAAA,IAAA,CAAK,oBAAA,CAAqB,OAAA,CAAQ,CAAC,MAAA,EAAQ,CAAA,KAAM;AAC/C,QAAA,IAAI,MAAA,IAAU,MAAA,CAAO,YAAA,IAAgB,mBAAA,GAAsB,KAAK,uBAAA,EAAyB;AACvF,UAAA,gBAAA,IAAoB,OAAO,KAAA,CAAM,IAAA;AACjC,UAAA,IAAA,CAAK,oBAAA,CAAqB,CAAC,CAAA,GAAI,MAAA;AAAA,QACjC;AAAA,MACF,CAAC,CAAA;AACD,MAAA,IAAI,mBAAmB,CAAA,EAAG;AACxB,QAAA,WAAA,IACE,KAAA,CAAM,GAAA;AAAA,UACJ,CAAA,qBAAA,EAAwB,gBAAgB,CAAA,+CAAA,EAAkD,IAAA,CAAK,uBAAuB,CAAA,SAAA;AAAA,SACxH;AAAA,MACJ;AACA,MAAA,IAAA,CAAK,wBAAA,GAA2B,mBAAA;AAAA,IAClC;AAEA,IAAA,MAAM,kBAAA,GAAqB,sBAAsB,IAAA,CAAK,uBAAA;AACtD,IAAA,MAAM,aAAA,GAAgB,IAAA,CAAK,oBAAA,CAAqB,kBAAkB,CAAA,IAAK;AAAA,MACrE,YAAA,EAAc,mBAAA;AAAA,MACd,KAAA,sBAAW,GAAA;AAAI,KACjB;AACA,IAAA,IAAA,CAAK,oBAAA,CAAqB,kBAAkB,CAAA,GAAI,aAAA;AAChD,IAAA,aAAA,CAAc,KAAA,CAAM,IAAI,IAAI,CAAA;AAC5B,IAAA,IAAA,CAAK,mBAAA,CAAoB,GAAA,CAAI,IAAA,EAAM,aAAa,CAAA;AAGhD,IAAA,MAAM,aAAA,GAAgB,iBAAiB,IAAI,CAAA;AAC3C,IAAA,IAAI,CAAC,aAAA,IAAiB,IAAA,CAAK,UAAA,CAAW,GAAA,CAAI,aAAa,CAAA,EAAG;AACxD,MAAA,IAAA,CAAK,eAAA,EAAgB;AAAA,IACvB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,KAAA,GAAc;AACnB,IAAA,MAAM,aAAA,GAAgB,IAAA,CAAK,oBAAA,CAAqB,OAAA,CAAQ,CAAA,MAAA,KAAW,MAAA,GAAS,KAAA,CAAM,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA,GAAI,EAAG,CAAA;AAE1G,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,UAAA,CAAW,aAAa,CAAA;AAE/C,IAAA,MAAM,gBAAgB,SAAA,CAAU,IAAA;AAChC,IAAA,MAAM,sBAAA,GAAyB,cAAc,MAAA,GAAS,aAAA;AACtD,IAAA,WAAA,IACE,KAAA,CAAM,GAAA;AAAA,MACJ,CAAA,sBAAA,EAAyB,aAAa,CAAA,QAAA,EAAW,sBAAsB,CAAA,mDAAA;AAAA,KACzE;AAEF,IAAA,KAAA,MAAW,QAAQ,SAAA,EAAW;AAC5B,MAAA,IAAA,CAAK,WAAW,GAAA,CAAI,IAAA,CAAK,WAAA,EAAY,CAAE,QAAQ,CAAC,CAAA;AAChD,MAAA,MAAM,WAAA,GAAc,IAAA,CAAK,mBAAA,CAAoB,GAAA,CAAI,IAAI,CAAA;AACrD,MAAA,IAAI,WAAA,EAAa;AACf,QAAA,WAAA,CAAY,KAAA,CAAM,OAAO,IAAI,CAAA;AAAA,MAC/B;AAAA,IACF;AAKA,IAAA,IAAA,CAAK,gBAAgB,MAAA,EAAO;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,KAAA,GAAc;AACnB,IAAA,IAAA,CAAK,oBAAA,GAAuB,IAAA,CAAK,oBAAA,CAAqB,IAAA,CAAK,MAAS,CAAA;AACpE,IAAA,IAAA,CAAK,WAAW,KAAA,EAAM;AACtB,IAAA,IAAA,CAAK,gBAAgB,MAAA,EAAO;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWQ,WAAW,KAAA,EAA0C;AAC3D,IAAA,MAAM,OAAA,GAAU,sBAAsB,KAAK,CAAA;AAC3C,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAkB;AAExC,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,sBAAA,CAAuB,OAAO,CAAA;AAErD,IAAA,KAAA,MAAW,QAAQ,SAAA,EAAW;AAC5B,MAAA,MAAM,OAAO,IAAA,CAAK,IAAA;AAClB,MAAA,SAAA,CAAU,IAAI,IAAI,CAAA;AAClB,MAAA,MAAM,gBAAA,GAAmB,6BAA6B,IAAI,CAAA;AAG1D,MAAA,IAAI,IAAA,CAAK,cAAc,IAAA,CAAK,UAAA,CAAW,IAAI,IAAA,CAAK,UAAA,CAAW,EAAE,CAAA,EAAG;AAC9D,QAAA,MAAM,SAAA,GAAY,gBAAA,CAAiB,QAAA,EAAU,KAAA,EAAO,IAAA;AACpD,QAAA,IAAI,SAAA,EAAW;AACb,UAAA,SAAA,CAAU,iCAAiC,CAAA,GAAI,IAAA;AAAA,QACjD;AAAA,MACF;AAGA,MAAA,MAAMC,MAAAA,GAAQ,gBAAA,CAAiB,KAAA,IAAS,EAAC;AAEzC,MAAA,IAAI,aAAA,GAAgB,KAAA;AACpB,MAAA,KAAA,MAAW,KAAA,IAAS,KAAK,QAAA,EAAU;AACjC,QAAA,IAAI,8BAAA,CAA+B,KAAA,EAAOA,MAAAA,EAAO,SAAS,CAAA,EAAG;AAC3D,UAAA,aAAA,GAAgB,IAAA;AAAA,QAClB;AAAA,MACF;AAIA,MAAA,gBAAA,CAAiB,QACfA,MAAAA,CAAM,MAAA,GAAS,cAAA,GACXA,MAAAA,CAAM,KAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,kBAAkB,CAAA,CAAE,eAAe,EAAE,KAAA,CAAM,CAAA,EAAG,cAAc,CAAA,GACnFA,MAAAA;AAEN,MAAA,IAAI,aAAA,EAAe;AACjB,QAAA,gBAAA,CAAiB,qBAAA,GAAwB;AAAA,UACvC,GAAG,gBAAA,CAAiB,qBAAA;AAAA,UACpB,aAAA,EAAe;AAAA,SACjB;AAAA,MACF;AAEA,MAAA,MAAM,YAAA,GAAe,yBAAA,CAA0B,IAAA,CAAK,MAAM,CAAA;AAC1D,MAAA,IAAI,YAAA,EAAc;AAChB,QAAA,gBAAA,CAAiB,YAAA,GAAe,YAAA;AAAA,MAClC;AAEA,MAAA,YAAA,CAAa,gBAAgB,CAAA;AAAA,IAC/B;AAEA,IAAA,OAAO,SAAA;AAAA,EACT;AAAA;AAAA,EAGQ,wCAAwC,IAAA,EAA2C;AACzF,IAAA,OAAO,CAAC,CAAC,IAAA,CAAK,IAAA,KAAS,CAAC,IAAA,CAAK,UAAA,IAAc,CAAC,CAAC,IAAA,CAAK,UAAA,CAAW,GAAA,CAAI,IAAA,CAAK,WAAW,EAAE,CAAA,CAAA;AAAA,EACrF;AAAA;AAAA,EAGQ,uBAAuB,KAAA,EAAwC;AAGrE,IAAA,OAAO,MAAM,MAAA,CAAO,CAAC,SAAoC,IAAA,CAAK,uCAAA,CAAwC,IAAI,CAAC,CAAA;AAAA,EAC7G;AACF;AAEA,SAAS,UAAU,IAAA,EAAsF;AACvG,EAAA,MAAM,aAAa,IAAA,CAAK,UAAA;AAExB,EAAA,MAAM,MAAA,GAAS,WAAW,gCAAgC,CAAA;AAC1D,EAAA,MAAM,EAAA,GAAK,WAAW,4BAA4B,CAAA;AAClD,EAAA,MAAM,MAAA,GAAS,WAAW,gCAAgC,CAAA;AAE1D,EAAA,OAAO,EAAE,MAAA,EAAQ,EAAA,EAAI,MAAA,EAAO;AAC9B;AAGO,SAAS,6BAA6B,IAAA,EAAsC;AACjF,EAAA,MAAM,EAAE,IAAI,WAAA,EAAa,IAAA,EAAM,SAAS,QAAA,EAAU,MAAA,EAAO,GAAI,WAAA,CAAY,IAAI,CAAA;AAC7E,EAAA,MAAM,kBAAA,GAAqB,wBAAwB,IAAuB,CAAA;AAE1E,EAAA,MAAM,UAAA,GAAa,IAAA,CAAK,UAAA,CAAW,qCAAqC,CAAA;AAExE,EAAA,MAAM,UAAA,GAA6B;AAAA,IACjC,CAAC,gCAAgC,GAAG,MAAA;AAAA,IACpC,CAAC,qCAAqC,GAAG,UAAA;AAAA,IACzC,CAAC,4BAA4B,GAAG,EAAA;AAAA,IAChC,CAAC,gCAAgC,GAAG,MAAA;AAAA,IACpC,GAAG,IAAA;AAAA,IACH,GAAG,sBAAA,CAAuB,IAAA,CAAK,UAAU;AAAA,GAC3C;AAEA,EAAA,MAAM,EAAE,OAAM,GAAI,IAAA;AAClB,EAAA,MAAM,EAAE,OAAA,EAAS,QAAA,EAAU,QAAQ,OAAA,EAAQ,GAAI,KAAK,WAAA,EAAY;AAOhE,EAAA,MAAM,cAAA,GAAiB,gBAAgB,IAAI,CAAA;AAE3C,EAAA,MAAM,MAAA,GAAS,UAAU,IAAI,CAAA;AAE7B,EAAA,MAAM,YAAA,GAA6B;AAAA,IACjC,cAAA;AAAA,IACA,OAAA;AAAA,IACA,QAAA;AAAA,IACA,IAAA,EAAM,UAAA;AAAA,IACN,MAAA;AAAA,IACA,EAAA;AAAA,IACA,MAAA,EAAQ,iBAAiB,MAAM,CAAA;AAAA;AAAA,IAC/B,KAAA,EAAO,4BAA4B,KAAK;AAAA,GAC1C;AAEA,EAAA,MAAM,UAAA,GAAa,WAAW,8BAA8B,CAAA;AAC5D,EAAA,MAAM,eAAA,GAAkB,OAAO,UAAA,KAAe,QAAA,GAAW,EAAE,UAAU,EAAE,WAAA,EAAa,UAAA,EAAW,EAAE,GAAI,MAAA;AAErG,EAAA,MAAM,gBAAA,GAAqC;AAAA,IACzC,QAAA,EAAU;AAAA,MACR,KAAA,EAAO,YAAA;AAAA,MACP,IAAA,EAAM;AAAA,QACJ,QAAA,EAAU,KAAK,QAAA,CAAS;AAAA,OAC1B;AAAA,MACA,GAAG;AAAA,KACL;AAAA,IACA,OAAO,EAAC;AAAA,IACR,eAAA,EAAiB,sBAAA,CAAuB,IAAA,CAAK,SAAS,CAAA;AAAA,IACtD,SAAA,EAAW,sBAAA,CAAuB,IAAA,CAAK,OAAO,CAAA;AAAA,IAC9C,WAAA,EAAa,WAAA;AAAA,IACb,IAAA,EAAM,aAAA;AAAA,IACN,qBAAA,EAAuB;AAAA,MACrB,mBAAmB,kBAAA,CAAmB,KAAA;AAAA,MACtC,4BAA4B,kBAAA,CAAmB,cAAA;AAAA,MAC/C,UAAA;AAAA,MACA,sBAAA,EAAwB,kCAAkC,IAAuB;AAAA,KACnF;AAAA,IACA,GAAI,MAAA,IAAU;AAAA,MACZ,gBAAA,EAAkB;AAAA,QAChB;AAAA;AACF;AACF,GACF;AAEA,EAAA,OAAO,gBAAA;AACT;AAKA,SAAS,8BAAA,CAA+B,IAAA,EAAgB,KAAA,EAAmB,SAAA,EAAuC;AAChH,EAAA,MAAM,OAAO,IAAA,CAAK,IAAA;AAElB,EAAA,IAAI,IAAA,EAAM;AACR,IAAA,SAAA,CAAU,IAAI,IAAI,CAAA;AAAA,EACpB;AAEA,EAAA,MAAM,aAAa,CAAC,IAAA;AAGpB,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,IAAIC,cAAAA,GAAgB,KAAA;AACpB,IAAA,IAAA,CAAK,QAAA,CAAS,QAAQ,CAAA,KAAA,KAAS;AAC7B,MAAA,IAAI,8BAAA,CAA+B,KAAA,EAAO,KAAA,EAAO,SAAS,CAAA,EAAG;AAC3D,QAAAA,cAAAA,GAAgB,IAAA;AAAA,MAClB;AAAA,IACF,CAAC,CAAA;AACD,IAAA,OAAOA,cAAAA;AAAA,EACT;AAEA,EAAA,MAAM,OAAA,GAAU,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA;AACnC,EAAA,MAAM,QAAA,GAAW,IAAA,CAAK,WAAA,EAAY,CAAE,OAAA;AACpC,EAAA,MAAM,YAAA,GAAe,gBAAgB,IAAI,CAAA;AAEzC,EAAA,MAAM,EAAE,UAAA,EAAY,SAAA,EAAW,OAAA,EAAS,OAAM,GAAI,IAAA;AAElD,EAAA,MAAM,EAAE,IAAI,WAAA,EAAa,IAAA,EAAM,SAAS,QAAA,EAAS,GAAI,YAAY,IAAI,CAAA;AACrE,EAAA,MAAM,OAAA,GAAU;AAAA,IACd,CAAC,gCAAgC,GAAG,MAAA;AAAA,IACpC,CAAC,4BAA4B,GAAG,EAAA;AAAA,IAChC,GAAG,uBAAuB,UAAU,CAAA;AAAA,IACpC,GAAG;AAAA,GACL;AAEA,EAAA,MAAM,MAAA,GAAS,UAAU,IAAI,CAAA;AAE7B,EAAA,MAAM,QAAA,GAAqB;AAAA,IACzB,OAAA;AAAA,IACA,QAAA;AAAA,IACA,IAAA,EAAM,OAAA;AAAA,IACN,WAAA;AAAA,IACA,cAAA,EAAgB,YAAA;AAAA,IAChB,eAAA,EAAiB,uBAAuB,SAAS,CAAA;AAAA;AAAA,IAEjD,SAAA,EAAW,sBAAA,CAAuB,OAAO,CAAA,IAAK,MAAA;AAAA,IAC9C,MAAA,EAAQ,iBAAiB,MAAM,CAAA;AAAA;AAAA,IAC/B,EAAA;AAAA,IACA,MAAA;AAAA,IACA,YAAA,EAAc,yBAAA,CAA0B,IAAA,CAAK,MAAM,CAAA;AAAA,IACnD,KAAA,EAAO,4BAA4B,KAAK;AAAA,GAC1C;AAEA,EAAA,KAAA,CAAM,KAAK,QAAQ,CAAA;AAEnB,EAAA,IAAI,aAAA,GAAgB,CAAC,CAAC,EAAA,EAAI,WAAW,SAAS,CAAA;AAC9C,EAAA,IAAA,CAAK,QAAA,CAAS,QAAQ,CAAA,KAAA,KAAS;AAC7B,IAAA,IAAI,8BAAA,CAA+B,KAAA,EAAO,KAAA,EAAO,SAAS,CAAA,EAAG;AAC3D,MAAA,aAAA,GAAgB,IAAA;AAAA,IAClB;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,aAAA;AACT;AAEA,SAAS,YAAY,IAAA,EAMnB;AACA,EAAA,MAAM,EAAE,IAAI,SAAA,EAAW,MAAA,EAAQ,eAAe,MAAA,EAAO,GAAI,UAAU,IAAI,CAAA;AACvE,EAAA,MAAM,EAAE,EAAA,EAAI,UAAA,EAAY,WAAA,EAAa,MAAA,EAAQ,gBAAgB,IAAA,EAAM,YAAA,EAAa,GAAI,oBAAA,CAAqB,IAAI,CAAA;AAE7G,EAAA,MAAM,KAAK,SAAA,IAAa,UAAA;AACxB,EAAA,MAAM,SAAS,aAAA,IAAiB,cAAA;AAEhC,EAAA,MAAM,OAAO,EAAE,GAAG,cAAc,GAAG,OAAA,CAAQ,IAAI,CAAA,EAAE;AAEjD,EAAA,OAAO;AAAA,IACL,EAAA;AAAA,IACA,WAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,IACA;AAAA,GACF;AACF;AAMA,SAAS,uBAAuB,IAAA,EAAwD;AACtF,EAAA,MAAM,WAAA,GAAc,EAAE,GAAG,IAAA,EAAK;AAG9B,EAAA,OAAO,YAAY,qCAAqC,CAAA;AACxD,EAAA,OAAO,YAAY,0CAA0C,CAAA;AAC7D,EAAA,OAAO,YAAY,0CAA0C,CAAA;AAG7D,EAAA,OAAO,WAAA;AACT;AAEA,SAAS,QAAQ,IAAA,EAA6C;AAC5D,EAAA,MAAM,aAAa,IAAA,CAAK,UAAA;AACxB,EAAA,MAAM,OAAgC,EAAC;AAEvC,EAAA,IAAI,IAAA,CAAK,IAAA,KAAS,QAAA,CAAS,QAAA,EAAU;AACnC,IAAA,IAAA,CAAK,WAAW,CAAA,GAAI,QAAA,CAAS,IAAA,CAAK,IAAI,CAAA;AAAA,EACxC;AAGA,EAAA,MAAM,4BAAA,GAA+B,WAAW,yBAAyB,CAAA;AACzE,EAAA,IAAI,4BAAA,EAA8B;AAChC,IAAA,IAAA,CAAK,8BAA8B,CAAA,GAAI,4BAAA;AAAA,EACzC;AAEA,EAAA,MAAM,WAAA,GAAc,mBAAmB,IAAI,CAAA;AAE3C,EAAA,IAAI,YAAY,GAAA,EAAK;AACnB,IAAA,IAAA,CAAK,MAAM,WAAA,CAAY,GAAA;AAAA,EACzB;AAEA,EAAA,IAAI,WAAA,CAAY,YAAY,CAAA,EAAG;AAC7B,IAAA,IAAA,CAAK,YAAY,CAAA,GAAI,WAAA,CAAY,YAAY,CAAA,CAAE,MAAM,CAAC,CAAA;AAAA,EACxD;AACA,EAAA,IAAI,WAAA,CAAY,eAAe,CAAA,EAAG;AAChC,IAAA,IAAA,CAAK,eAAe,CAAA,GAAI,WAAA,CAAY,eAAe,CAAA,CAAE,MAAM,CAAC,CAAA;AAAA,EAC9D;AAEA,EAAA,OAAO,IAAA;AACT;;AC1bO,MAAM,mBAAA,CAAsD;AAAA,EAG1D,YAAY,OAAA,EAAgC;AACjD,IAAA,UAAA,CAAW,qBAAqB,CAAA;AAChC,IAAA,IAAA,CAAK,SAAA,GAAY,IAAI,kBAAA,CAAmB,OAAO,CAAA;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,UAAA,GAA4B;AACvC,IAAA,IAAA,CAAK,UAAU,KAAA,EAAM;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,QAAA,GAA0B;AACrC,IAAA,IAAA,CAAK,UAAU,KAAA,EAAM;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKO,OAAA,CAAQ,MAAY,aAAA,EAA8B;AAEvD,IAAA,MAAM,UAAA,GAAa,KAAA,CAAM,OAAA,CAAQ,aAAa,CAAA;AAE9C,IAAA,IAAI,MAAA,GAAS,qBAAqB,aAAa,CAAA;AAG/C,IAAA,IAAI,UAAA,IAAc,CAAC,UAAA,CAAW,WAAA,GAAc,QAAA,EAAU;AACpD,MAAA,kBAAA,CAAmB,YAAY,IAAI,CAAA;AAAA,IACrC;AAGA,IAAA,IAAI,UAAA,EAAY,WAAA,EAAY,CAAE,QAAA,EAAU;AACtC,MAAA,IAAA,CAAK,YAAA,CAAa,4CAA4C,IAAI,CAAA;AAAA,IACpE;AAIA,IAAA,IAAI,kBAAkB,YAAA,EAAc;AAClC,MAAA,MAAA,GAAS;AAAA,QACP,OAAO,sBAAA,EAAuB;AAAA,QAC9B,gBAAgB,wBAAA;AAAyB,OAC3C;AAAA,IACF;AAGA,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,uBAAA,CAAwB,IAAA,EAAM,MAAA,CAAO,KAAA,EAAO,MAAA,CAAO,cAAc,CAAA;AAAA,IACnE;AAEA,IAAA,YAAA,CAAa,IAAI,CAAA;AAEjB,IAAA,MAAM,SAAS,SAAA,EAAU;AACzB,IAAA,MAAA,EAAQ,IAAA,CAAK,aAAa,IAAI,CAAA;AAAA,EAChC;AAAA;AAAA,EAGO,MAAM,IAAA,EAAiC;AAC5C,IAAA,UAAA,CAAW,IAAI,CAAA;AAEf,IAAA,MAAM,SAAS,SAAA,EAAU;AACzB,IAAA,MAAA,EAAQ,IAAA,CAAK,WAAW,IAAI,CAAA;AAE5B,IAAA,IAAI,MAAA,IAAU,uBAAA,CAAwB,MAAM,CAAA,EAAG;AAC7C,MAAA,MAAA,CAAO,IAAA,CAAK,gBAAgB,IAAI,CAAA;AAAA,IAClC,CAAA,MAAO;AACL,MAAA,IAAA,CAAK,SAAA,CAAU,OAAO,IAAI,CAAA;AAAA,IAC5B;AAAA,EACF;AACF;;ACpDO,MAAM,aAAA,CAAiC;AAAA,EAIrC,YAAY,MAAA,EAAgB;AACjC,IAAA,IAAA,CAAK,OAAA,GAAU,MAAA;AACf,IAAA,IAAA,CAAK,gBAAA,GAAmB,wBAAwB,MAAM,CAAA;AACtD,IAAA,UAAA,CAAW,eAAe,CAAA;AAAA,EAC5B;AAAA;AAAA,EAGO,aACL,OAAA,EACA,OAAA,EACA,QAAA,EACA,QAAA,EACA,gBACA,MAAA,EACgB;AAChB,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,OAAA,CAAQ,UAAA,EAAW;AACxC,IAAA,MAAM,EAAE,aAAY,GAAI,OAAA;AAExB,IAAA,MAAM,UAAA,GAAa,aAAa,OAAO,CAAA;AACvC,IAAA,MAAM,aAAA,GAAgB,YAAY,WAAA,EAAY;AAE9C,IAAA,IAAI,CAAC,eAAA,CAAgB,OAAO,CAAA,EAAG;AAC7B,MAAA,OAAO,qBAAqB,EAAE,QAAA,EAAU,MAAA,EAAW,OAAA,EAAS,gBAAgB,CAAA;AAAA,IAC9E;AAIA,IAAA,MAAM,mBAAA,GAAsB,cAAA,CAAe,oBAAoB,CAAA,IAAK,eAAe,wBAAwB,CAAA;AAK3G,IAAA,IAAI,aAAa,QAAA,CAAS,MAAA,IAAU,wBAAwB,CAAC,UAAA,IAAc,eAAe,QAAA,CAAA,EAAW;AACnG,MAAA,IAAI,CAAC,KAAK,gBAAA,EAAkB;AAC1B,QAAA,IAAA,CAAK,OAAA,CAAQ,kBAAA,CAAmB,gBAAA,EAAkB,MAAM,CAAA;AACxD,QAAA,OAAO,qBAAqB,EAAE,QAAA,EAAU,MAAA,EAAW,OAAA,EAAS,gBAAgB,CAAA;AAAA,MAC9E;AAAA,IACF;AAEA,IAAA,MAAM,gBAAgB,UAAA,GAAa,gBAAA,CAAiB,UAAA,EAAY,OAAA,EAAS,QAAQ,CAAA,GAAI,MAAA;AACrF,IAAA,MAAM,UAAA,GAAa,CAAC,UAAA,IAAc,aAAA,EAAe,QAAA;AAIjD,IAAA,IAAI,CAAC,UAAA,EAAY;AACf,MAAA,IAAI,KAAK,gBAAA,EAAkB;AAIzB,QAAA,IAAI,aAAA,EAAe;AACjB,UAAA,IAAI,aAAa,MAAA,EAAQ;AACvB,YAAA,MAAM,EAAE,aAAa,iBAAA,EAAmB,EAAA,EAAI,SAAQ,GAAI,aAAA,CAAc,QAAA,EAAU,cAAA,EAAgB,QAAQ,CAAA;AACxG,YAAA,IACE,gBAAA;AAAA,cACE;AAAA,gBACE,WAAA,EAAa,iBAAA;AAAA,gBACb,EAAA,EAAI,cAAA,CAAe,4BAA4B,CAAA,IAAK,OAAA;AAAA,gBACpD,UAAA,EAAY;AAAA,eACd;AAAA,cACA;AAAA,aACF,EACA;AACA,cAAA,IAAA,CAAK,OAAA,CAAQ,kBAAA,CAAmB,SAAA,EAAW,MAAM,CAAA;AACjD,cAAA,OAAO,oBAAA,CAAqB;AAAA,gBAC1B,UAAU,gBAAA,CAAiB,UAAA;AAAA,gBAC3B,OAAA;AAAA,gBACA,cAAA;AAAA,gBACA,gBAAA,EAAkB;AAAA,eACnB,CAAA;AAAA,YACH;AAAA,UACF;AAAA,QACF;AAEA,QAAA,IAAI,CAAC,aAAA,EAAe;AAClB,UAAA,MAAM,oBAAA,GAAuB,aAAA,EAAe,UAAA,EAAY,GAAA,CAAI,kCAAkC,CAAA,KAAM,GAAA;AACpG,UAAA,IAAA,CAAK,OAAA,CAAQ,kBAAA,CAAmB,oBAAA,GAAuB,SAAA,GAAY,eAAe,MAAM,CAAA;AAAA,QAC1F;AAAA,MACF;AAEA,MAAA,OAAO,oBAAA,CAAqB;AAAA,QAC1B,QAAA,EAAU,aAAA,GAAgB,gBAAA,CAAiB,kBAAA,GAAqB,gBAAA,CAAiB,UAAA;AAAA,QACjF,OAAA;AAAA,QACA;AAAA,OACD,CAAA;AAAA,IACH;AAGA,IAAA,MAAM;AAAA,MACJ,WAAA,EAAa,gBAAA;AAAA,MACb,IAAA,EAAM,kBAAA;AAAA,MACN;AAAA,KACF,GAAI,aAAA,CAAc,QAAA,EAAU,cAAA,EAAgB,QAAQ,CAAA;AAEpD,IAAA,MAAM,gBAAA,GAAmB;AAAA,MACvB,GAAG,kBAAA;AAAA,MACH,GAAG;AAAA,KACL;AAEA,IAAA,IAAI,EAAA,EAAI;AACN,MAAA,gBAAA,CAAiB,4BAA4B,CAAA,GAAI,EAAA;AAAA,IACnD;AAEA,IAAA,IACE,IAAA,CAAK,gBAAA,IACL,WAAA,EAAa,MAAA,IACb,gBAAA;AAAA,MACE;AAAA,QACE,WAAA,EAAa,gBAAA;AAAA,QACb,EAAA,EAAI,gBAAA,CAAiB,4BAA4B,CAAA,IAAK,EAAA;AAAA,QACtD,UAAA,EAAY;AAAA,OACd;AAAA,MACA;AAAA,KACF,EACA;AACA,MAAA,IAAA,CAAK,OAAA,CAAQ,kBAAA,CAAmB,SAAA,EAAW,MAAM,CAAA;AACjD,MAAA,OAAO,oBAAA,CAAqB;AAAA,QAC1B,UAAU,gBAAA,CAAiB,UAAA;AAAA,QAC3B,OAAA;AAAA,QACA,cAAA;AAAA,QACA,kBAAA,EAAoB;AAAA,OACrB,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,uBAAA,GAA0B,EAAE,QAAA,EAAU,IAAA,EAAK;AACjD,IAAA,IAAA,CAAK,OAAA,CAAQ,IAAA;AAAA,MACX,gBAAA;AAAA,MACA;AAAA,QACE,cAAA,EAAgB,gBAAA;AAAA,QAChB,QAAA,EAAU,gBAAA;AAAA,QACV,aAAA;AAAA,QACA;AAAA,OACF;AAAA,MACA;AAAA,KACF;AACA,IAAA,IAAI,CAAC,wBAAwB,QAAA,EAAU;AACrC,MAAA,OAAO,qBAAqB,EAAE,QAAA,EAAU,MAAA,EAAW,OAAA,EAAS,gBAAgB,CAAA;AAAA,IAC9E;AAEA,IAAA,MAAM,EAAE,cAAA,EAAe,GAAI,oBAAA,CAAqB,OAAO,KAAK,EAAC;AAE7D,IAAA,MAAM,YAAY,aAAA,EAAe,UAAA,GAAa,cAAc,UAAA,CAAW,GAAA,CAAI,sBAAsB,CAAA,GAAI,MAAA;AACrG,IAAA,MAAM,GAAA,GAAM,SAAA,GAAY,qCAAA,CAAsC,SAAS,CAAA,GAAI,MAAA;AAE3E,IAAA,MAAM,UAAA,GAAa,eAAA,CAAgB,GAAA,EAAK,WAAW,KAAK,wBAAA,EAAyB;AAEjF,IAAA,MAAM,CAAC,OAAA,EAAS,UAAA,EAAY,yBAAyB,CAAA,GAAI,UAAA;AAAA,MACvD,OAAA;AAAA,MACA;AAAA,QACE,IAAA,EAAM,gBAAA;AAAA,QACN,UAAA,EAAY,gBAAA;AAAA,QACZ,iBAAA,EAAmB,cAAA,EAAgB,YAAA,EAAa,CAAE,qBAAA,CAAsB,iBAAA;AAAA,QACxE,aAAA;AAAA,QACA,gBAAA,EAAkB,eAAA,CAAgB,GAAA,EAAK,WAAW;AAAA,OACpD;AAAA,MACA;AAAA,KACF;AAEA,IAAA,MAAM,MAAA,GAAS,CAAA,EAAG,mBAAmB,CAAA,CAAA,CAAG,WAAA,EAAY;AACpD,IAAA,IAAI,MAAA,KAAW,SAAA,IAAa,MAAA,KAAW,MAAA,EAAQ;AAC7C,MAAA,WAAA,IAAe,MAAM,GAAA,CAAI,CAAA,oDAAA,EAAuD,MAAM,CAAA,MAAA,EAAS,QAAQ,CAAA,CAAE,CAAA;AAEzG,MAAA,OAAO,oBAAA,CAAqB;AAAA,QAC1B,UAAU,gBAAA,CAAiB,UAAA;AAAA,QAC3B,OAAA;AAAA,QACA,cAAA;AAAA,QACA,UAAA;AAAA,QACA,yBAAA,EAA2B;AAAA;AAAA,OAC5B,CAAA;AAAA,IACH;AAEA,IAAA,IACE,CAAC,OAAA;AAAA,IAED,kBAAkB,MAAA,EAClB;AACA,MAAA,WAAA,IAAe,KAAA,CAAM,IAAI,gFAAgF,CAAA;AACzG,MAAA,IAAA,CAAK,QAAQ,kBAAA,CAAmB,aAAA,EAAe,IAAA,CAAK,gBAAA,GAAmB,SAAS,aAAa,CAAA;AAAA,IAC/F;AAEA,IAAA,OAAO;AAAA,MACL,GAAG,oBAAA,CAAqB;AAAA,QACtB,QAAA,EAAU,OAAA,GAAU,gBAAA,CAAiB,kBAAA,GAAqB,gBAAA,CAAiB,UAAA;AAAA,QAC3E,OAAA;AAAA,QACA,cAAA;AAAA,QACA,UAAA;AAAA,QACA,yBAAA,EAA2B,4BAA4B,UAAA,GAAa;AAAA,OACrE,CAAA;AAAA,MACD,UAAA,EAAY;AAAA;AAAA,QAEV,CAAC,qCAAqC,GAAG,yBAAA,GAA4B,UAAA,GAAa;AAAA;AACpF,KACF;AAAA,EACF;AAAA;AAAA,EAGO,QAAA,GAAmB;AACxB,IAAA,OAAO,eAAA;AAAA,EACT;AACF;AAEA,SAAS,gBAAA,CAAiB,UAAA,EAAkB,OAAA,EAAiB,QAAA,EAAuC;AAClG,EAAA,MAAM,aAAA,GAAgB,WAAW,WAAA,EAAY;AAI7C,EAAA,IAAI,kBAAA,CAAmB,aAAa,CAAA,IAAK,aAAA,CAAc,YAAY,OAAA,EAAS;AAC1E,IAAA,IAAI,cAAc,QAAA,EAAU;AAC1B,MAAA,MAAMC,cAAAA,GAAgB,mBAAA,CAAoB,UAAA,CAAW,WAAA,EAAa,CAAA;AAClE,MAAA,WAAA,IACE,MAAM,GAAA,CAAI,CAAA,0DAAA,EAA6D,QAAQ,CAAA,EAAA,EAAKA,cAAa,CAAA,CAAE,CAAA;AACrG,MAAA,OAAOA,cAAAA;AAAA,IACT;AAEA,IAAA,MAAM,aAAA,GAAgB,oBAAoB,aAAa,CAAA;AACvD,IAAA,WAAA,IAAe,MAAM,GAAA,CAAI,CAAA,mDAAA,EAAsD,QAAQ,CAAA,EAAA,EAAK,aAAa,CAAA,CAAE,CAAA;AAC3G,IAAA,OAAO,aAAA;AAAA,EACT;AAEA,EAAA,OAAO,MAAA;AACT;AAOO,SAAS,oBAAA,CAAqB;AAAA,EACnC,QAAA;AAAA,EACA,OAAA;AAAA,EACA,cAAA;AAAA,EACA,UAAA;AAAA,EACA,yBAAA;AAAA,EACA,gBAAA;AAAA,EACA;AACF,CAAA,EASmB;AACjB,EAAA,IAAI,UAAA,GAAa,iBAAA,CAAkB,OAAA,EAAS,cAAc,CAAA;AAM1D,EAAA,IAAI,8BAA8B,MAAA,EAAW;AAC3C,IAAA,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,8BAAA,EAAgC,CAAA,EAAG,yBAAyB,CAAA,CAAE,CAAA;AAAA,EAC5F;AAEA,EAAA,IAAI,eAAe,MAAA,EAAW;AAC5B,IAAA,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,8BAAA,EAAgC,CAAA,EAAG,UAAU,CAAA,CAAE,CAAA;AAAA,EAC7E;AAEA,EAAA,IAAI,gBAAA,EAAkB;AACpB,IAAA,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,gCAAA,EAAkC,GAAG,CAAA;AAAA,EACnE;AAEA,EAAA,IAAI,kBAAA,EAAoB;AACtB,IAAA,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,kCAAA,EAAoC,GAAG,CAAA;AAAA,EACrE;AAIA,EAAA,IAAI,YAAY,MAAA,EAAW;AACzB,IAAA,OAAO,EAAE,QAAA,EAAU,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAW;AAAA,EAC7D;AAEA,EAAA,IAAI,QAAA,KAAa,iBAAiB,UAAA,EAAY;AAC5C,IAAA,OAAO,EAAE,QAAA,EAAU,UAAA,EAAY,WAAW,GAAA,CAAI,wCAAA,EAA0C,GAAG,CAAA,EAAE;AAAA,EAC/F;AAEA,EAAA,OAAO,EAAE,UAAU,UAAA,EAAW;AAChC;AAEA,SAAS,iBAAA,CAAkB,SAAkB,cAAA,EAAqD;AAChG,EAAA,MAAM,UAAA,GAAa,KAAA,CAAM,OAAA,CAAQ,OAAO,CAAA;AACxC,EAAA,MAAM,aAAA,GAAgB,YAAY,WAAA,EAAY;AAE9C,EAAA,IAAI,UAAA,GAAa,aAAA,EAAe,UAAA,IAAc,IAAI,UAAA,EAAW;AAK7D,EAAA,MAAM,GAAA,GAAM,cAAA,CAAe,iBAAiB,CAAA,IAAK,eAAe,aAAa,CAAA;AAC7E,EAAA,IAAI,GAAA,IAAO,OAAO,GAAA,KAAQ,QAAA,EAAU;AAClC,IAAA,UAAA,GAAa,UAAA,CAAW,GAAA,CAAI,sBAAA,EAAwB,GAAG,CAAA;AAAA,EACzD;AAEA,EAAA,OAAO,UAAA;AACT;AAMA,SAAS,aAAa,OAAA,EAAoC;AACxD,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,OAAA,CAAQ,OAAO,CAAA;AAClC,EAAA,OAAO,QAAQ,kBAAA,CAAmB,IAAA,CAAK,WAAA,EAAa,IAAI,IAAA,GAAO,MAAA;AACjE;;AC5UA,MAAM,cAAA,CAAe;AAAA,EAGZ,YAAY,UAAA,EAAwB;AACzC,IAAA,IAAA,CAAK,WAAA,GAAc,UAAA;AAAA,EACrB;AAAA,EAEA,IAAW,UAAA,GAAyB;AAClC,IAAA,OAAO,IAAA,CAAK,WAAA;AAAA,EACd;AAAA,EAEO,MAAM,KAAA,EAA8C;AACzD,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,OAAO,IAAA;AAAA,IACT;AACA,IAAA,OAAO,IAAI,eAAe,EAAE,GAAG,KAAK,WAAA,EAAa,GAAG,KAAA,CAAM,UAAA,EAAY,CAAA;AAAA,EACxE;AAAA,EAEO,gBAAA,GAA2C;AAChD,IAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,IAAA,CAAK,WAAW,CAAA;AAAA,EACxC;AACF;AAMA,SAAS,4BAA4B,GAAA,EAAqC;AACxE,EAAA,IAAI,CAAC,GAAA,EAAK;AACR,IAAA,OAAO,EAAC;AAAA,EACV;AACA,EAAA,MAAM,SAAqB,EAAC;AAC5B,EAAA,KAAA,MAAW,IAAA,IAAQ,GAAA,CAAI,KAAA,CAAM,GAAG,CAAA,EAAG;AACjC,IAAA,MAAM,EAAA,GAAK,IAAA,CAAK,OAAA,CAAQ,GAAG,CAAA;AAC3B,IAAA,IAAI,OAAO,EAAA,EAAI;AACb,MAAA;AAAA,IACF;AACA,IAAA,MAAM,MAAM,IAAA,CAAK,SAAA,CAAU,CAAA,EAAG,EAAE,EAAE,IAAA,EAAK;AACvC,IAAA,MAAM,QAAQ,IAAA,CAAK,SAAA,CAAU,EAAA,GAAK,CAAC,EAAE,IAAA,EAAK;AAC1C,IAAA,IAAI,GAAA,EAAK;AACP,MAAA,IAAI;AACF,QAAA,MAAA,CAAO,GAAG,CAAA,GAAI,kBAAA,CAAmB,KAAK,CAAA;AAAA,MACxC,CAAA,CAAA,MAAQ;AACN,QAAA,MAAA,CAAO,GAAG,CAAA,GAAI,KAAA;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AACA,EAAA,OAAO,MAAA;AACT;AAYO,SAAS,kBAAkB,mBAAA,EAA6C;AAC7E,EAAA,MAAM,MAAM,OAAO,OAAA,KAAY,WAAA,GAAc,OAAA,CAAQ,MAAM,EAAC;AAC5D,EAAA,MAAM,kBAAkB,GAAA,CAAI,iBAAA;AAC5B,EAAA,MAAM,iBAAA,GAAoB,2BAAA,CAA4B,GAAA,CAAI,wBAAwB,CAAA;AAElF,EAAA,OAAO,IAAI,cAAA,CAAe;AAAA;AAAA;AAAA,IAGxB,CAAC,6BAA6B,GAAG,QAAA;AAAA,IACjC,CAAC,iBAAiB,GAAG,mBAAA;AAAA;AAAA,IAErB,GAAG,iBAAA;AAAA;AAAA,IAEH,GAAI,kBAAkB,EAAE,CAAC,iBAAiB,GAAG,eAAA,KAAoB,EAAC;AAAA;AAAA,IAElE,CAAC,oBAAoB,GAAG,WAAA;AAAA,IACxB,CAAC,2BAA2B,GAAG,QAAA,CAAS,2BAA2B,CAAA;AAAA,IACnE,CAAC,uBAAuB,GAAG,QAAA,CAAS,uBAAuB,CAAA;AAAA,IAC3D,CAAC,0BAA0B,GAAG,QAAA,CAAS,0BAA0B;AAAA,GAClE,CAAA;AACH;;;;"}