{"version":3,"file":"4lbgKLcd.js","sources":["../../../../../../../node_modules/.pnpm/@sentry+utils@8.39.0/node_modules/@sentry/utils/build/esm/dsn.js","../../../../../../../node_modules/.pnpm/@sentry+utils@8.39.0/node_modules/@sentry/utils/build/esm/envelope.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/tracing/utils.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/tracing/sentryNonRecordingSpan.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/utils/handleCallbackErrors.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/tracing/logSpans.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/utils/parseSampleRate.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/tracing/sampling.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/envelope.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/tracing/sentrySpan.js","../../../../../../../node_modules/.pnpm/@sentry+core@8.39.0/node_modules/@sentry/core/build/esm/tracing/trace.js"],"sourcesContent":["import { DEBUG_BUILD } from './debug-build.js';\nimport { consoleSandbox, logger } from './logger.js';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string\n */\nfunction dsnFromString(str) {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(`Invalid Sentry Dsn: ${str}`);\n    });\n    return undefined;\n  }\n\n  const [protocol, publicKey, pass = '', host = '', port = '', lastPath = ''] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() ;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn) {\n  if (!DEBUG_BUILD) {\n    return true;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  const hasMissingRequiredComponent = requiredComponents.find(component => {\n    if (!dsn[component]) {\n      logger.error(`Invalid Sentry Dsn: ${component} missing`);\n      return true;\n    }\n    return false;\n  });\n\n  if (hasMissingRequiredComponent) {\n    return false;\n  }\n\n  if (!projectId.match(/^\\d+$/)) {\n    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nfunction makeDsn(from) {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","import { dsnToString } from './dsn.js';\nimport { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n *\n * If the callback returns true, the rest of the items will be skipped.\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  const envelopeItems = envelope[1];\n\n  for (const envelopeItem of envelopeItems) {\n    const envelopeItemType = envelopeItem[0].type;\n    const result = callback(envelopeItem, envelopeItemType);\n\n    if (result) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nfunction envelopeContainsItemType(envelope, types) {\n  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8 array.\n */\nfunction encodeUTF8(input) {\n  return GLOBAL_OBJ.__SENTRY__ && GLOBAL_OBJ.__SENTRY__.encodePolyfill\n    ? GLOBAL_OBJ.__SENTRY__.encodePolyfill(input)\n    : new TextEncoder().encode(input);\n}\n\n/**\n * Decode a UTF8 array to string.\n */\nfunction decodeUTF8(input) {\n  return GLOBAL_OBJ.__SENTRY__ && GLOBAL_OBJ.__SENTRY__.decodePolyfill\n    ? GLOBAL_OBJ.__SENTRY__.decodePolyfill(input)\n    : new TextDecoder().decode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope) {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next) : next);\n    }\n  }\n\n  for (const item of items) {\n    const [itemHeaders, payload] = item;\n\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.stringify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  const merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Parses an envelope\n */\nfunction parseEnvelope(env) {\n  let buffer = typeof env === 'string' ? encodeUTF8(env) : env;\n\n  function readBinary(length) {\n    const bin = buffer.subarray(0, length);\n    // Replace the buffer with the remaining data excluding trailing newline\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson() {\n    let i = buffer.indexOf(0xa);\n    // If we couldn't find a newline, we must have found the end of the buffer\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(decodeUTF8(readBinary(i))) ;\n  }\n\n  const envelopeHeader = readJson();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = [];\n\n  while (buffer.length) {\n    const itemHeader = readJson();\n    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n\n/**\n * Creates envelope item for a single span\n */\nfunction createSpanEnvelopeItem(spanJson) {\n  const spanHeaders = {\n    type: 'span',\n  };\n\n  return [spanHeaders, spanJson];\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(attachment) {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n  profile: 'profile',\n  profile_chunk: 'profile',\n  replay_event: 'replay',\n  replay_recording: 'replay',\n  check_in: 'monitor',\n  feedback: 'feedback',\n  span: 'span',\n  statsd: 'metric_bucket',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\n/** Extracts the minimal SDK info from the metadata or an events */\nfunction getSdkMetadataForEnvelopeHeader(metadataOrEvent) {\n  if (!metadataOrEvent || !metadataOrEvent.sdk) {\n    return;\n  }\n  const { name, version } = metadataOrEvent.sdk;\n  return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n    ...(dynamicSamplingContext && {\n      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n    }),\n  };\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, createSpanEnvelopeItem, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { addNonEnumerableProperty } from '@sentry/utils';\nexport { stripUrlQueryAndFragment } from '@sentry/utils';\n\nconst SCOPE_ON_START_SPAN_FIELD = '_sentryScope';\nconst ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';\n\n/** Store the scope & isolation scope for a span, which can the be used when it is finished. */\nfunction setCapturedScopesOnSpan(span, scope, isolationScope) {\n  if (span) {\n    addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);\n    addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);\n  }\n}\n\n/**\n * Grabs the scope and isolation scope off a span that were active when the span was started.\n */\nfunction getCapturedScopesOnSpan(span) {\n  return {\n    scope: (span )[SCOPE_ON_START_SPAN_FIELD],\n    isolationScope: (span )[ISOLATION_SCOPE_ON_START_SPAN_FIELD],\n  };\n}\n\nexport { getCapturedScopesOnSpan, setCapturedScopesOnSpan };\n//# sourceMappingURL=utils.js.map\n","import { uuid4 } from '@sentry/utils';\nimport { TRACE_FLAG_NONE } from '../utils/spanUtils.js';\n\n/**\n * A Sentry Span that is non-recording, meaning it will not be sent to Sentry.\n */\nclass SentryNonRecordingSpan  {\n\n   constructor(spanContext = {}) {\n    this._traceId = spanContext.traceId || uuid4();\n    this._spanId = spanContext.spanId || uuid4().substring(16);\n  }\n\n  /** @inheritdoc */\n   spanContext() {\n    return {\n      spanId: this._spanId,\n      traceId: this._traceId,\n      traceFlags: TRACE_FLAG_NONE,\n    };\n  }\n\n  /** @inheritdoc */\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n   end(_timestamp) {}\n\n  /** @inheritdoc */\n   setAttribute(_key, _value) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   setAttributes(_values) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   setStatus(_status) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   updateName(_name) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   isRecording() {\n    return false;\n  }\n\n  /** @inheritdoc */\n   addEvent(\n    _name,\n    _attributesOrStartTime,\n    _startTime,\n  ) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLink(_link) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLinks(_links) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   recordException(_exception, _time) {\n    // noop\n  }\n}\n\nexport { SentryNonRecordingSpan };\n//# sourceMappingURL=sentryNonRecordingSpan.js.map\n","import { isThenable } from '@sentry/utils';\n\n/**\n * Wrap a callback function with error handling.\n * If an error is thrown, it will be passed to the `onError` callback and re-thrown.\n *\n * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.\n *\n * If an `onFinally` callback is provided, this will be called when the callback has finished\n * - so if it returns a promise, once the promise resolved/rejected,\n * else once the callback has finished executing.\n * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.\n */\nfunction handleCallbackErrors\n\n(\n  fn,\n  onError,\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onFinally = () => {},\n) {\n  let maybePromiseResult;\n  try {\n    maybePromiseResult = fn();\n  } catch (e) {\n    onError(e);\n    onFinally();\n    throw e;\n  }\n\n  return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally);\n}\n\n/**\n * Maybe handle a promise rejection.\n * This expects to be given a value that _may_ be a promise, or any other value.\n * If it is a promise, and it rejects, it will call the `onError` callback.\n * Other than this, it will generally return the given value as-is.\n */\nfunction maybeHandlePromiseRejection(\n  value,\n  onError,\n  onFinally,\n) {\n  if (isThenable(value)) {\n    // @ts-expect-error - the isThenable check returns the \"wrong\" type here\n    return value.then(\n      res => {\n        onFinally();\n        return res;\n      },\n      e => {\n        onError(e);\n        onFinally();\n        throw e;\n      },\n    );\n  }\n\n  onFinally();\n  return value;\n}\n\nexport { handleCallbackErrors };\n//# sourceMappingURL=handleCallbackErrors.js.map\n","import { logger } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { spanToJSON, spanIsSampled, getRootSpan } from '../utils/spanUtils.js';\n\n/**\n * Print a log message for a started span.\n */\nfunction logSpanStart(span) {\n  if (!DEBUG_BUILD) return;\n\n  const { description = '< unknown name >', op = '< unknown op >', parent_span_id: parentSpanId } = spanToJSON(span);\n  const { spanId } = span.spanContext();\n\n  const sampled = spanIsSampled(span);\n  const rootSpan = getRootSpan(span);\n  const isRootSpan = rootSpan === span;\n\n  const header = `[Tracing] Starting ${sampled ? 'sampled' : 'unsampled'} ${isRootSpan ? 'root ' : ''}span`;\n\n  const infoParts = [`op: ${op}`, `name: ${description}`, `ID: ${spanId}`];\n\n  if (parentSpanId) {\n    infoParts.push(`parent ID: ${parentSpanId}`);\n  }\n\n  if (!isRootSpan) {\n    const { op, description } = spanToJSON(rootSpan);\n    infoParts.push(`root ID: ${rootSpan.spanContext().spanId}`);\n    if (op) {\n      infoParts.push(`root op: ${op}`);\n    }\n    if (description) {\n      infoParts.push(`root description: ${description}`);\n    }\n  }\n\n  logger.log(`${header}\n  ${infoParts.join('\\n  ')}`);\n}\n\n/**\n * Print a log message for an ended span.\n */\nfunction logSpanEnd(span) {\n  if (!DEBUG_BUILD) return;\n\n  const { description = '< unknown name >', op = '< unknown op >' } = spanToJSON(span);\n  const { spanId } = span.spanContext();\n  const rootSpan = getRootSpan(span);\n  const isRootSpan = rootSpan === span;\n\n  const msg = `[Tracing] Finishing \"${op}\" ${isRootSpan ? 'root ' : ''}span \"${description}\" with ID ${spanId}`;\n  logger.log(msg);\n}\n\nexport { logSpanEnd, logSpanStart };\n//# sourceMappingURL=logSpans.js.map\n","import { logger } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\n\n/**\n * Parse a sample rate from a given value.\n * This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).\n * If a string is passed, we try to convert it to a number.\n *\n * Any invalid sample rate will return `undefined`.\n */\nfunction parseSampleRate(sampleRate) {\n  if (typeof sampleRate === 'boolean') {\n    return Number(sampleRate);\n  }\n\n  const rate = typeof sampleRate === 'string' ? parseFloat(sampleRate) : sampleRate;\n  if (typeof rate !== 'number' || isNaN(rate) || rate < 0 || rate > 1) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          sampleRate,\n        )} of type ${JSON.stringify(typeof sampleRate)}.`,\n      );\n    return undefined;\n  }\n\n  return rate;\n}\n\nexport { parseSampleRate };\n//# sourceMappingURL=parseSampleRate.js.map\n","import { logger } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { parseSampleRate } from '../utils/parseSampleRate.js';\n\n/**\n * Makes a sampling decision for the given options.\n *\n * Called every time a root span is created. Only root spans which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n */\nfunction sampleSpan(\n  options,\n  samplingContext,\n) {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    return [false];\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` nor `enableTracing` were defined, so one of these should\n  // work; prefer the hook if so\n  let sampleRate;\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n  } else if (typeof options.tracesSampleRate !== 'undefined') {\n    sampleRate = options.tracesSampleRate;\n  } else {\n    // When `enableTracing === true`, we use a sample rate of 100%\n    sampleRate = 1;\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get.\n  // (The only valid values are booleans or numbers between 0 and 1.)\n  const parsedSampleRate = parseSampleRate(sampleRate);\n\n  if (parsedSampleRate === undefined) {\n    DEBUG_BUILD && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    return [false];\n  }\n\n  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n  if (!parsedSampleRate) {\n    DEBUG_BUILD &&\n      logger.log(\n        `[Tracing] Discarding transaction because ${\n          typeof options.tracesSampler === 'function'\n            ? 'tracesSampler returned 0 or false'\n            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'\n        }`,\n      );\n    return [false, parsedSampleRate];\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  const shouldSample = Math.random() < parsedSampleRate;\n\n  // if we're not going to keep it, we're done\n  if (!shouldSample) {\n    DEBUG_BUILD &&\n      logger.log(\n        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(\n          sampleRate,\n        )})`,\n      );\n    return [false, parsedSampleRate];\n  }\n\n  return [true, parsedSampleRate];\n}\n\nexport { sampleSpan };\n//# sourceMappingURL=sampling.js.map\n","import { getSdkMetadataForEnvelopeHeader, dsnToString, createEnvelope, createEventEnvelopeHeaders, createSpanEnvelopeItem } from '@sentry/utils';\nimport { getDynamicSamplingContextFromSpan } from './tracing/dynamicSamplingContext.js';\nimport { spanToJSON } from './utils/spanUtils.js';\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nfunction createSessionEnvelope(\n  session,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  const envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const envelopeItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session.toJSON()];\n\n  return createEnvelope(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nfunction createEventEnvelope(\n  event,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n\n  /*\n    Note: Due to TS, event.type may be `replay_event`, theoretically.\n    In practice, we never call `createEventEnvelope` with `replay_event` type,\n    and we'd have to adjust a looot of types to make this work properly.\n    We want to avoid casting this around, as that could lead to bugs (e.g. when we add another type)\n    So the safe choice is to really guard against the replay_event type here.\n  */\n  const eventType = event.type && event.type !== 'replay_event' ? event.type : 'event';\n\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  const eventItem = [{ type: eventType }, event];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\n/**\n * Create envelope from Span item.\n *\n * Takes an optional client and runs spans through `beforeSendSpan` if available.\n */\nfunction createSpanEnvelope(spans, client) {\n  function dscHasRequiredProps(dsc) {\n    return !!dsc.trace_id && !!dsc.public_key;\n  }\n\n  // For the moment we'll obtain the DSC from the first span in the array\n  // This might need to be changed if we permit sending multiple spans from\n  // different segments in one envelope\n  const dsc = getDynamicSamplingContextFromSpan(spans[0]);\n\n  const dsn = client && client.getDsn();\n  const tunnel = client && client.getOptions().tunnel;\n\n  const headers = {\n    sent_at: new Date().toISOString(),\n    ...(dscHasRequiredProps(dsc) && { trace: dsc }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const beforeSendSpan = client && client.getOptions().beforeSendSpan;\n  const convertToSpanJSON = beforeSendSpan\n    ? (span) => beforeSendSpan(spanToJSON(span) )\n    : (span) => spanToJSON(span);\n\n  const items = [];\n  for (const span of spans) {\n    const spanJson = convertToSpanJSON(span);\n    if (spanJson) {\n      items.push(createSpanEnvelopeItem(spanJson));\n    }\n  }\n\n  return createEnvelope(headers, items);\n}\n\nexport { createEventEnvelope, createSessionEnvelope, createSpanEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { uuid4, timestampInSeconds, dropUndefinedKeys, logger } from '@sentry/utils';\nimport { getClient, getCurrentScope } from '../currentScopes.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { createSpanEnvelope } from '../envelope.js';\nimport { getMetricSummaryJsonForSpan } from '../metrics/metric-summary.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_PROFILE_ID, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME } from '../semanticAttributes.js';\nimport { TRACE_FLAG_SAMPLED, TRACE_FLAG_NONE, spanTimeInputToSeconds, getStatusMessage, getRootSpan, spanToJSON, getSpanDescendants, spanToTransactionTraceContext } from '../utils/spanUtils.js';\nimport { getDynamicSamplingContextFromSpan } from './dynamicSamplingContext.js';\nimport { logSpanEnd } from './logSpans.js';\nimport { timedEventsToMeasurements } from './measurement.js';\nimport { getCapturedScopesOnSpan } from './utils.js';\n\nconst MAX_SPAN_COUNT = 1000;\n\n/**\n * Span contains all data about a span\n */\nclass SentrySpan  {\n\n  /** Epoch timestamp in seconds when the span started. */\n\n  /** Epoch timestamp in seconds when the span ended. */\n\n  /** Internal keeper of the status */\n\n  /** The timed events added to this span. */\n\n  /** if true, treat span as a standalone span (not part of a transaction) */\n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startSpan()`\n   * or other span methods.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n   constructor(spanContext = {}) {\n    this._traceId = spanContext.traceId || uuid4();\n    this._spanId = spanContext.spanId || uuid4().substring(16);\n    this._startTime = spanContext.startTimestamp || timestampInSeconds();\n\n    this._attributes = {};\n    this.setAttributes({\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'manual',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: spanContext.op,\n      ...spanContext.attributes,\n    });\n\n    this._name = spanContext.name;\n\n    if (spanContext.parentSpanId) {\n      this._parentSpanId = spanContext.parentSpanId;\n    }\n    // We want to include booleans as well here\n    if ('sampled' in spanContext) {\n      this._sampled = spanContext.sampled;\n    }\n    if (spanContext.endTimestamp) {\n      this._endTime = spanContext.endTimestamp;\n    }\n\n    this._events = [];\n\n    this._isStandaloneSpan = spanContext.isStandalone;\n\n    // If the span is already ended, ensure we finalize the span immediately\n    if (this._endTime) {\n      this._onSpanEnded();\n    }\n  }\n\n  /**\n   * This should generally not be used,\n   * but it is needed for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLink(_link) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but it is needed for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLinks(_links) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but it is needed for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   recordException(_exception, _time) {\n    // noop\n  }\n\n  /** @inheritdoc */\n   spanContext() {\n    const { _spanId: spanId, _traceId: traceId, _sampled: sampled } = this;\n    return {\n      spanId,\n      traceId,\n      traceFlags: sampled ? TRACE_FLAG_SAMPLED : TRACE_FLAG_NONE,\n    };\n  }\n\n  /** @inheritdoc */\n   setAttribute(key, value) {\n    if (value === undefined) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._attributes[key];\n    } else {\n      this._attributes[key] = value;\n    }\n\n    return this;\n  }\n\n  /** @inheritdoc */\n   setAttributes(attributes) {\n    Object.keys(attributes).forEach(key => this.setAttribute(key, attributes[key]));\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for browser tracing where we want to adjust the start time afterwards.\n   * USE THIS WITH CAUTION!\n   *\n   * @hidden\n   * @internal\n   */\n   updateStartTime(timeInput) {\n    this._startTime = spanTimeInputToSeconds(timeInput);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setStatus(value) {\n    this._status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   updateName(name) {\n    this._name = name;\n    this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'custom');\n    return this;\n  }\n\n  /** @inheritdoc */\n   end(endTimestamp) {\n    // If already ended, skip\n    if (this._endTime) {\n      return;\n    }\n\n    this._endTime = spanTimeInputToSeconds(endTimestamp);\n    logSpanEnd(this);\n\n    this._onSpanEnded();\n  }\n\n  /**\n   * Get JSON representation of this span.\n   *\n   * @hidden\n   * @internal This method is purely for internal purposes and should not be used outside\n   * of SDK code. If you need to get a JSON representation of a span,\n   * use `spanToJSON(span)` instead.\n   */\n   getSpanJSON() {\n    return dropUndefinedKeys({\n      data: this._attributes,\n      description: this._name,\n      op: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],\n      parent_span_id: this._parentSpanId,\n      span_id: this._spanId,\n      start_timestamp: this._startTime,\n      status: getStatusMessage(this._status),\n      timestamp: this._endTime,\n      trace_id: this._traceId,\n      origin: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] ,\n      _metrics_summary: getMetricSummaryJsonForSpan(this),\n      profile_id: this._attributes[SEMANTIC_ATTRIBUTE_PROFILE_ID] ,\n      exclusive_time: this._attributes[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] ,\n      measurements: timedEventsToMeasurements(this._events),\n      is_segment: (this._isStandaloneSpan && getRootSpan(this) === this) || undefined,\n      segment_id: this._isStandaloneSpan ? getRootSpan(this).spanContext().spanId : undefined,\n    });\n  }\n\n  /** @inheritdoc */\n   isRecording() {\n    return !this._endTime && !!this._sampled;\n  }\n\n  /**\n   * @inheritdoc\n   */\n   addEvent(\n    name,\n    attributesOrStartTime,\n    startTime,\n  ) {\n    DEBUG_BUILD && logger.log('[Tracing] Adding an event to span:', name);\n\n    const time = isSpanTimeInput(attributesOrStartTime) ? attributesOrStartTime : startTime || timestampInSeconds();\n    const attributes = isSpanTimeInput(attributesOrStartTime) ? {} : attributesOrStartTime || {};\n\n    const event = {\n      name,\n      time: spanTimeInputToSeconds(time),\n      attributes,\n    };\n\n    this._events.push(event);\n\n    return this;\n  }\n\n  /**\n   * This method should generally not be used,\n   * but for now we need a way to publicly check if the `_isStandaloneSpan` flag is set.\n   * USE THIS WITH CAUTION!\n   * @internal\n   * @hidden\n   * @experimental\n   */\n   isStandaloneSpan() {\n    return !!this._isStandaloneSpan;\n  }\n\n  /** Emit `spanEnd` when the span is ended. */\n   _onSpanEnded() {\n    const client = getClient();\n    if (client) {\n      client.emit('spanEnd', this);\n    }\n\n    // A segment span is basically the root span of a local span tree.\n    // So for now, this is either what we previously refer to as the root span,\n    // or a standalone span.\n    const isSegmentSpan = this._isStandaloneSpan || this === getRootSpan(this);\n\n    if (!isSegmentSpan) {\n      return;\n    }\n\n    // if this is a standalone span, we send it immediately\n    if (this._isStandaloneSpan) {\n      if (this._sampled) {\n        sendSpanEnvelope(createSpanEnvelope([this], client));\n      } else {\n        DEBUG_BUILD &&\n          logger.log('[Tracing] Discarding standalone span because its trace was not chosen to be sampled.');\n        if (client) {\n          client.recordDroppedEvent('sample_rate', 'span');\n        }\n      }\n      return;\n    }\n\n    const transactionEvent = this._convertSpanToTransaction();\n    if (transactionEvent) {\n      const scope = getCapturedScopesOnSpan(this).scope || getCurrentScope();\n      scope.captureEvent(transactionEvent);\n    }\n  }\n\n  /**\n   * Finish the transaction & prepare the event to send to Sentry.\n   */\n   _convertSpanToTransaction() {\n    // We can only convert finished spans\n    if (!isFullFinishedSpan(spanToJSON(this))) {\n      return undefined;\n    }\n\n    if (!this._name) {\n      DEBUG_BUILD && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this._name = '<unlabeled transaction>';\n    }\n\n    const { scope: capturedSpanScope, isolationScope: capturedSpanIsolationScope } = getCapturedScopesOnSpan(this);\n    const scope = capturedSpanScope || getCurrentScope();\n    const client = scope.getClient() || getClient();\n\n    if (this._sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      DEBUG_BUILD && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      if (client) {\n        client.recordDroppedEvent('sample_rate', 'transaction');\n      }\n\n      return undefined;\n    }\n\n    // The transaction span itself as well as any potential standalone spans should be filtered out\n    const finishedSpans = getSpanDescendants(this).filter(span => span !== this && !isStandaloneSpan(span));\n\n    const spans = finishedSpans.map(span => spanToJSON(span)).filter(isFullFinishedSpan);\n\n    const source = this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] ;\n\n    const transaction = {\n      contexts: {\n        trace: spanToTransactionTraceContext(this),\n      },\n      spans:\n        // spans.sort() mutates the array, but `spans` is already a copy so we can safely do this here\n        // we do not use spans anymore after this point\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      start_timestamp: this._startTime,\n      timestamp: this._endTime,\n      transaction: this._name,\n      type: 'transaction',\n      sdkProcessingMetadata: {\n        capturedSpanScope,\n        capturedSpanIsolationScope,\n        ...dropUndefinedKeys({\n          dynamicSamplingContext: getDynamicSamplingContextFromSpan(this),\n        }),\n      },\n      _metrics_summary: getMetricSummaryJsonForSpan(this),\n      ...(source && {\n        transaction_info: {\n          source,\n        },\n      }),\n    };\n\n    const measurements = timedEventsToMeasurements(this._events);\n    const hasMeasurements = measurements && Object.keys(measurements).length;\n\n    if (hasMeasurements) {\n      DEBUG_BUILD &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction event',\n          JSON.stringify(measurements, undefined, 2),\n        );\n      transaction.measurements = measurements;\n    }\n\n    return transaction;\n  }\n}\n\nfunction isSpanTimeInput(value) {\n  return (value && typeof value === 'number') || value instanceof Date || Array.isArray(value);\n}\n\n// We want to filter out any incomplete SpanJSON objects\nfunction isFullFinishedSpan(input) {\n  return !!input.start_timestamp && !!input.timestamp && !!input.span_id && !!input.trace_id;\n}\n\n/** `SentrySpan`s can be sent as a standalone span rather than belonging to a transaction */\nfunction isStandaloneSpan(span) {\n  return span instanceof SentrySpan && span.isStandaloneSpan();\n}\n\n/**\n * Sends a `SpanEnvelope`.\n *\n * Note: If the envelope's spans are dropped, e.g. via `beforeSendSpan`,\n * the envelope will not be sent either.\n */\nfunction sendSpanEnvelope(envelope) {\n  const client = getClient();\n  if (!client) {\n    return;\n  }\n\n  const spanItems = envelope[1];\n  if (!spanItems || spanItems.length === 0) {\n    client.recordDroppedEvent('before_send', 'span');\n    return;\n  }\n\n  // sendEnvelope should not throw\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  client.sendEnvelope(envelope);\n}\n\nexport { SentrySpan };\n//# sourceMappingURL=sentrySpan.js.map\n","import { propagationContextFromHeaders, generatePropagationContext, logger } from '@sentry/utils';\nimport { getMainCarrier } from '../carrier.js';\nimport { withScope, getCurrentScope, getIsolationScope, getClient } from '../currentScopes.js';\nimport { getAsyncContextStrategy } from '../asyncContext/index.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '../semanticAttributes.js';\nimport { handleCallbackErrors } from '../utils/handleCallbackErrors.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { _setSpanForScope, _getSpanForScope } from '../utils/spanOnScope.js';\nimport { spanToJSON, addChildSpanToSpan, spanIsSampled, spanTimeInputToSeconds, getRootSpan } from '../utils/spanUtils.js';\nimport { getDynamicSamplingContextFromSpan, freezeDscOnSpan } from './dynamicSamplingContext.js';\nimport { logSpanStart } from './logSpans.js';\nimport { sampleSpan } from './sampling.js';\nimport { SentryNonRecordingSpan } from './sentryNonRecordingSpan.js';\nimport { SentrySpan } from './sentrySpan.js';\nimport { SPAN_STATUS_ERROR } from './spanstatus.js';\nimport { setCapturedScopesOnSpan } from './utils.js';\n\nconst SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';\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 */\nfunction startSpan(options, callback) {\n  const acs = getAcs();\n  if (acs.startSpan) {\n    return acs.startSpan(options, callback);\n  }\n\n  const spanArguments = parseSentrySpanArguments(options);\n  const { forceTransaction, parentSpan: customParentSpan } = options;\n\n  return withScope(options.scope, () => {\n    // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n    const wrapper = getActiveSpanWrapper(customParentSpan);\n\n    return wrapper(() => {\n      const scope = getCurrentScope();\n      const parentSpan = getParentSpan(scope);\n\n      const shouldSkipSpan = options.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan\n        ? new SentryNonRecordingSpan()\n        : createChildOrRootSpan({\n            parentSpan,\n            spanArguments,\n            forceTransaction,\n            scope,\n          });\n\n      _setSpanForScope(scope, activeSpan);\n\n      return handleCallbackErrors(\n        () => callback(activeSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet, and the span is not yet finished\n          const { status } = spanToJSON(activeSpan);\n          if (activeSpan.isRecording() && (!status || status === 'ok')) {\n            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n          }\n        },\n        () => activeSpan.end(),\n      );\n    });\n  });\n}\n\n/**\n * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span\n * after the function is done automatically. You'll have to call `span.end()` 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 */\nfunction startSpanManual(options, callback) {\n  const acs = getAcs();\n  if (acs.startSpanManual) {\n    return acs.startSpanManual(options, callback);\n  }\n\n  const spanArguments = parseSentrySpanArguments(options);\n  const { forceTransaction, parentSpan: customParentSpan } = options;\n\n  return withScope(options.scope, () => {\n    // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n    const wrapper = getActiveSpanWrapper(customParentSpan);\n\n    return wrapper(() => {\n      const scope = getCurrentScope();\n      const parentSpan = getParentSpan(scope);\n\n      const shouldSkipSpan = options.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan\n        ? new SentryNonRecordingSpan()\n        : createChildOrRootSpan({\n            parentSpan,\n            spanArguments,\n            forceTransaction,\n            scope,\n          });\n\n      _setSpanForScope(scope, activeSpan);\n\n      function finishAndSetSpan() {\n        activeSpan.end();\n      }\n\n      return handleCallbackErrors(\n        () => callback(activeSpan, finishAndSetSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet, and the span is not yet finished\n          const { status } = spanToJSON(activeSpan);\n          if (activeSpan.isRecording() && (!status || status === 'ok')) {\n            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n          }\n        },\n      );\n    });\n  });\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 */\nfunction startInactiveSpan(options) {\n  const acs = getAcs();\n  if (acs.startInactiveSpan) {\n    return acs.startInactiveSpan(options);\n  }\n\n  const spanArguments = parseSentrySpanArguments(options);\n  const { forceTransaction, parentSpan: customParentSpan } = options;\n\n  // If `options.scope` is defined, we use this as as a wrapper,\n  // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n  const wrapper = options.scope\n    ? (callback) => withScope(options.scope, callback)\n    : customParentSpan !== undefined\n      ? (callback) => withActiveSpan(customParentSpan, callback)\n      : (callback) => callback();\n\n  return wrapper(() => {\n    const scope = getCurrentScope();\n    const parentSpan = getParentSpan(scope);\n\n    const shouldSkipSpan = options.onlyIfParent && !parentSpan;\n\n    if (shouldSkipSpan) {\n      return new SentryNonRecordingSpan();\n    }\n\n    return createChildOrRootSpan({\n      parentSpan,\n      spanArguments,\n      forceTransaction,\n      scope,\n    });\n  });\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 */\nconst continueTrace = (\n  {\n    sentryTrace,\n    baggage,\n  }\n\n,\n  callback,\n) => {\n  return withScope(scope => {\n    const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n    scope.setPropagationContext(propagationContext);\n    return callback();\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 not be attached to a parent span.\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 */\nfunction withActiveSpan(span, callback) {\n  const acs = getAcs();\n  if (acs.withActiveSpan) {\n    return acs.withActiveSpan(span, callback);\n  }\n\n  return withScope(scope => {\n    _setSpanForScope(scope, span || undefined);\n    return callback(scope);\n  });\n}\n\n/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */\nfunction suppressTracing(callback) {\n  const acs = getAcs();\n\n  if (acs.suppressTracing) {\n    return acs.suppressTracing(callback);\n  }\n\n  return withScope(scope => {\n    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });\n    return callback();\n  });\n}\n\n/**\n * Starts a new trace for the duration of the provided callback. Spans started within the\n * callback will be part of the new trace instead of a potentially previously started trace.\n *\n * Important: Only use this function if you want to override the default trace lifetime and\n * propagation mechanism of the SDK for the duration and scope of the provided callback.\n * The newly created trace will also be the root of a new distributed trace, for example if\n * you make http requests within the callback.\n * This function might be useful if the operation you want to instrument should not be part\n * of a potentially ongoing trace.\n *\n * Default behavior:\n * - Server-side: A new trace is started for each incoming request.\n * - Browser: A new trace is started for each page our route. Navigating to a new route\n *            or page will automatically create a new trace.\n */\nfunction startNewTrace(callback) {\n  return withScope(scope => {\n    scope.setPropagationContext(generatePropagationContext());\n    DEBUG_BUILD && logger.info(`Starting a new trace with id ${scope.getPropagationContext().traceId}`);\n    return withActiveSpan(null, callback);\n  });\n}\n\nfunction createChildOrRootSpan({\n  parentSpan,\n  spanArguments,\n  forceTransaction,\n  scope,\n}\n\n) {\n  if (!hasTracingEnabled()) {\n    return new SentryNonRecordingSpan();\n  }\n\n  const isolationScope = getIsolationScope();\n\n  let span;\n  if (parentSpan && !forceTransaction) {\n    span = _startChildSpan(parentSpan, scope, spanArguments);\n    addChildSpanToSpan(parentSpan, span);\n  } else if (parentSpan) {\n    // If we forced a transaction but have a parent span, make sure to continue from the parent span, not the scope\n    const dsc = getDynamicSamplingContextFromSpan(parentSpan);\n    const { traceId, spanId: parentSpanId } = parentSpan.spanContext();\n    const parentSampled = spanIsSampled(parentSpan);\n\n    span = _startRootSpan(\n      {\n        traceId,\n        parentSpanId,\n        ...spanArguments,\n      },\n      scope,\n      parentSampled,\n    );\n\n    freezeDscOnSpan(span, dsc);\n  } else {\n    const {\n      traceId,\n      dsc,\n      parentSpanId,\n      sampled: parentSampled,\n    } = {\n      ...isolationScope.getPropagationContext(),\n      ...scope.getPropagationContext(),\n    };\n\n    span = _startRootSpan(\n      {\n        traceId,\n        parentSpanId,\n        ...spanArguments,\n      },\n      scope,\n      parentSampled,\n    );\n\n    if (dsc) {\n      freezeDscOnSpan(span, dsc);\n    }\n  }\n\n  logSpanStart(span);\n\n  setCapturedScopesOnSpan(span, scope, isolationScope);\n\n  return span;\n}\n\n/**\n * This converts StartSpanOptions to SentrySpanArguments.\n * For the most part (for now) we accept the same options,\n * but some of them need to be transformed.\n */\nfunction parseSentrySpanArguments(options) {\n  const exp = options.experimental || {};\n  const initialCtx = {\n    isStandalone: exp.standalone,\n    ...options,\n  };\n\n  if (options.startTime) {\n    const ctx = { ...initialCtx };\n    ctx.startTimestamp = spanTimeInputToSeconds(options.startTime);\n    delete ctx.startTime;\n    return ctx;\n  }\n\n  return initialCtx;\n}\n\nfunction getAcs() {\n  const carrier = getMainCarrier();\n  return getAsyncContextStrategy(carrier);\n}\n\nfunction _startRootSpan(spanArguments, scope, parentSampled) {\n  const client = getClient();\n  const options = (client && client.getOptions()) || {};\n\n  const { name = '', attributes } = spanArguments;\n  const [sampled, sampleRate] = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY]\n    ? [false]\n    : sampleSpan(options, {\n        name,\n        parentSampled,\n        attributes,\n        transactionContext: {\n          name,\n          parentSampled,\n        },\n      });\n\n  const rootSpan = new SentrySpan({\n    ...spanArguments,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',\n      ...spanArguments.attributes,\n    },\n    sampled,\n  });\n  if (sampleRate !== undefined) {\n    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);\n  }\n\n  if (client) {\n    client.emit('spanStart', rootSpan);\n  }\n\n  return rootSpan;\n}\n\n/**\n * Creates a new `Span` while setting the current `Span.id` as `parentSpanId`.\n * This inherits the sampling decision from the parent span.\n */\nfunction _startChildSpan(parentSpan, scope, spanArguments) {\n  const { spanId, traceId } = parentSpan.spanContext();\n  const sampled = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] ? false : spanIsSampled(parentSpan);\n\n  const childSpan = sampled\n    ? new SentrySpan({\n        ...spanArguments,\n        parentSpanId: spanId,\n        traceId,\n        sampled,\n      })\n    : new SentryNonRecordingSpan({ traceId });\n\n  addChildSpanToSpan(parentSpan, childSpan);\n\n  const client = getClient();\n  if (client) {\n    client.emit('spanStart', childSpan);\n    // If it has an endTimestamp, it's already ended\n    if (spanArguments.endTimestamp) {\n      client.emit('spanEnd', childSpan);\n    }\n  }\n\n  return childSpan;\n}\n\nfunction getParentSpan(scope) {\n  const span = _getSpanForScope(scope) ;\n\n  if (!span) {\n    return undefined;\n  }\n\n  const client = getClient();\n  const options = client ? client.getOptions() : {};\n  if (options.parentSpanIsAlwaysRootSpan) {\n    return getRootSpan(span) ;\n  }\n\n  return span;\n}\n\nfunction getActiveSpanWrapper(parentSpan) {\n  return parentSpan !== undefined\n    ? (callback) => {\n        return withActiveSpan(parentSpan, callback);\n      }\n    : (callback) => callback();\n}\n\nexport { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, suppressTracing, withActiveSpan };\n//# sourceMappingURL=trace.js.map\n"],"names":["DSN_REGEX","isValidProtocol","protocol","dsnToString","dsn","withPassword","host","path","pass","port","projectId","publicKey","dsnFromString","str","match","consoleSandbox","lastPath","split","projectMatch","dsnFromComponents","components","validateDsn","DEBUG_BUILD","component","logger","makeDsn","from","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","envelopeItemType","encodeUTF8","input","GLOBAL_OBJ","serializeEnvelope","envHeaders","parts","append","next","item","itemHeaders","payload","stringifiedPayload","normalize","concatBuffers","buffers","totalLength","acc","buf","merged","offset","buffer","createSpanEnvelopeItem","spanJson","createAttachmentEnvelopeItem","attachment","dropUndefinedKeys","ITEM_TYPE_TO_DATA_CATEGORY_MAP","envelopeItemTypeToDataCategory","type","getSdkMetadataForEnvelopeHeader","metadataOrEvent","name","version","createEventEnvelopeHeaders","event","sdkInfo","tunnel","dynamicSamplingContext","SCOPE_ON_START_SPAN_FIELD","ISOLATION_SCOPE_ON_START_SPAN_FIELD","setCapturedScopesOnSpan","span","scope","isolationScope","addNonEnumerableProperty","getCapturedScopesOnSpan","SentryNonRecordingSpan","spanContext","uuid4","TRACE_FLAG_NONE","_timestamp","_key","_value","_values","_status","_name","_attributesOrStartTime","_startTime","_link","_links","_exception","_time","handleCallbackErrors","fn","onError","onFinally","maybePromiseResult","e","maybeHandlePromiseRejection","value","isThenable","res","logSpanStart","description","op","parentSpanId","spanToJSON","spanId","sampled","spanIsSampled","rootSpan","getRootSpan","isRootSpan","header","infoParts","logSpanEnd","msg","parseSampleRate","sampleRate","rate","sampleSpan","options","samplingContext","hasTracingEnabled","parsedSampleRate","enhanceEventWithSdkInfo","createSessionEnvelope","session","metadata","envelopeHeaders","createEventEnvelope","eventType","createSpanEnvelope","spans","client","dscHasRequiredProps","dsc","getDynamicSamplingContextFromSpan","beforeSendSpan","convertToSpanJSON","MAX_SPAN_COUNT","SentrySpan","timestampInSeconds","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_OP","traceId","TRACE_FLAG_SAMPLED","key","attributes","timeInput","spanTimeInputToSeconds","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","endTimestamp","getStatusMessage","getMetricSummaryJsonForSpan","SEMANTIC_ATTRIBUTE_PROFILE_ID","SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME","timedEventsToMeasurements","attributesOrStartTime","startTime","time","isSpanTimeInput","getClient","sendSpanEnvelope","transactionEvent","getCurrentScope","isFullFinishedSpan","capturedSpanScope","capturedSpanIsolationScope","getSpanDescendants","isStandaloneSpan","source","transaction","spanToTransactionTraceContext","a","b","measurements","spanItems","SUPPRESS_TRACING_KEY","startSpan","acs","getAcs","spanArguments","parseSentrySpanArguments","forceTransaction","customParentSpan","withScope","getActiveSpanWrapper","parentSpan","getParentSpan","activeSpan","createChildOrRootSpan","_setSpanForScope","status","SPAN_STATUS_ERROR","startInactiveSpan","withActiveSpan","getIsolationScope","_startChildSpan","addChildSpanToSpan","parentSampled","_startRootSpan","freezeDscOnSpan","initialCtx","ctx","carrier","getMainCarrier","getAsyncContextStrategy","SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE","childSpan","_getSpanForScope"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10]}